?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* SolutionParser.cs: Identify and emit warning for a
[mcs.git] / mcs / statement.cs
blob12bd6b6977dee2cb219ee6bb34f6c54440036f05
1 //
2 // statement.cs: Statement representation for the IL tree.
3 //
4 // Author:
5 // Miguel de Icaza (miguel@ximian.com)
6 // Martin Baulig (martin@ximian.com)
7 // Marek Safar (marek.safar@seznam.cz)
8 //
9 // Copyright 2001, 2002, 2003 Ximian, Inc.
10 // Copyright 2003, 2004 Novell, Inc.
11 //
12
13 using System;
14 using System.Text;
15 using System.Reflection;
16 using System.Reflection.Emit;
17 using System.Diagnostics;
18 using System.Collections.Generic;
19
20 namespace Mono.CSharp {
21
22 public abstract class Statement {
23 public Location loc;
24
25 /// <summary>
26 /// Resolves the statement, true means that all sub-statements
27 /// did resolve ok.
28 // </summary>
29 public virtual bool Resolve (BlockContext ec)
30 {
31 return true;
32 }
33
34 /// <summary>
35 /// We already know that the statement is unreachable, but we still
36 /// need to resolve it to catch errors.
37 /// </summary>
38 public virtual bool ResolveUnreachable (BlockContext ec, bool warn)
39 {
40 //
41 // This conflicts with csc's way of doing this, but IMHO it's
42 // the right thing to do.
43 //
44 // If something is unreachable, we still check whether it's
45 // correct. This means that you cannot use unassigned variables
46 // in unreachable code, for instance.
47 //
48
49 if (warn)
50 ec.Report.Warning (162, 2, loc, "Unreachable code detected");
51
52 ec.StartFlowBranching (FlowBranching.BranchingType.Block, loc);
53 bool ok = Resolve (ec);
54 ec.KillFlowBranching ();
55
56 return ok;
57 }
58
59 /// <summary>
60 /// Return value indicates whether all code paths emitted return.
61 /// </summary>
62 protected abstract void DoEmit (EmitContext ec);
63
64 public virtual void Emit (EmitContext ec)
65 {
66 ec.Mark (loc);
67 DoEmit (ec);
68 }
69
70 //
71 // This routine must be overrided in derived classes and make copies
72 // of all the data that might be modified if resolved
73 //
74 protected abstract void CloneTo (CloneContext clonectx, Statement target);
75
76 public Statement Clone (CloneContext clonectx)
77 {
78 Statement s = (Statement) this.MemberwiseClone ();
79 CloneTo (clonectx, s);
80 return s;
81 }
82
83 public virtual Expression CreateExpressionTree (ResolveContext ec)
84 {
85 ec.Report.Error (834, loc, "A lambda expression with statement body cannot be converted to an expresion tree");
86 return null;
87 }
88
89 public Statement PerformClone ()
90 {
91 CloneContext clonectx = new CloneContext ();
92
93 return Clone (clonectx);
94 }
95
96 public abstract void MutateHoistedGenericType (AnonymousMethodStorey storey);
97 }
98
99 public sealed class EmptyStatement : Statement
100 {
101 public EmptyStatement (Location loc)
102 {
103 this.loc = loc;
104 }
105
106 public override bool Resolve (BlockContext ec)
107 {
108 return true;
109 }
110
111 public override bool ResolveUnreachable (BlockContext ec, bool warn)
112 {
113 return true;
114 }
115
116 public override void Emit (EmitContext ec)
117 {
118 }
119
120 protected override void DoEmit (EmitContext ec)
121 {
122 throw new NotSupportedException ();
123 }
124
125 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
126 {
127 }
128
129 protected override void CloneTo (CloneContext clonectx, Statement target)
130 {
131 // nothing needed.
132 }
133 }
134
135 public class If : Statement {
136 Expression expr;
137 public Statement TrueStatement;
138 public Statement FalseStatement;
139
140 bool is_true_ret;
141
142 public If (Expression bool_expr, Statement true_statement, Location l)
143 : this (bool_expr, true_statement, null, l)
144 {
145 }
146
147 public If (Expression bool_expr,
148 Statement true_statement,
149 Statement false_statement,
150 Location l)
151 {
152 this.expr = bool_expr;
153 TrueStatement = true_statement;
154 FalseStatement = false_statement;
155 loc = l;
156 }
157
158 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
159 {
160 expr.MutateHoistedGenericType (storey);
161 TrueStatement.MutateHoistedGenericType (storey);
162 if (FalseStatement != null)
163 FalseStatement.MutateHoistedGenericType (storey);
164 }
165
166 public override bool Resolve (BlockContext ec)
167 {
168 bool ok = true;
169
170 Report.Debug (1, "START IF BLOCK", loc);
171
172 expr = expr.Resolve (ec);
173 if (expr == null) {
174 ok = false;
175 } else {
176 //
177 // Dead code elimination
178 //
179 if (expr is Constant) {
180 bool take = !((Constant) expr).IsDefaultValue;
181
182 if (take) {
183 if (!TrueStatement.Resolve (ec))
184 return false;
185
186 if ((FalseStatement != null) &&
187 !FalseStatement.ResolveUnreachable (ec, true))
188 return false;
189 FalseStatement = null;
190 } else {
191 if (!TrueStatement.ResolveUnreachable (ec, true))
192 return false;
193 TrueStatement = null;
194
195 if ((FalseStatement != null) &&
196 !FalseStatement.Resolve (ec))
197 return false;
198 }
199
200 return true;
201 }
202 }
203
204 ec.StartFlowBranching (FlowBranching.BranchingType.Conditional, loc);
205
206 ok &= TrueStatement.Resolve (ec);
207
208 is_true_ret = ec.CurrentBranching.CurrentUsageVector.IsUnreachable;
209
210 ec.CurrentBranching.CreateSibling ();
211
212 if (FalseStatement != null)
213 ok &= FalseStatement.Resolve (ec);
214
215 ec.EndFlowBranching ();
216
217 Report.Debug (1, "END IF BLOCK", loc);
218
219 return ok;
220 }
221
222 protected override void DoEmit (EmitContext ec)
223 {
224 ILGenerator ig = ec.ig;
225 Label false_target = ig.DefineLabel ();
226 Label end;
227
228 //
229 // If we're a boolean constant, Resolve() already
230 // eliminated dead code for us.
231 //
232 Constant c = expr as Constant;
233 if (c != null){
234 c.EmitSideEffect (ec);
235
236 if (!c.IsDefaultValue)
237 TrueStatement.Emit (ec);
238 else if (FalseStatement != null)
239 FalseStatement.Emit (ec);
240
241 return;
242 }
243
244 expr.EmitBranchable (ec, false_target, false);
245
246 TrueStatement.Emit (ec);
247
248 if (FalseStatement != null){
249 bool branch_emitted = false;
250
251 end = ig.DefineLabel ();
252 if (!is_true_ret){
253 ig.Emit (OpCodes.Br, end);
254 branch_emitted = true;
255 }
256
257 ig.MarkLabel (false_target);
258 FalseStatement.Emit (ec);
259
260 if (branch_emitted)
261 ig.MarkLabel (end);
262 } else {
263 ig.MarkLabel (false_target);
264 }
265 }
266
267 protected override void CloneTo (CloneContext clonectx, Statement t)
268 {
269 If target = (If) t;
270
271 target.expr = expr.Clone (clonectx);
272 target.TrueStatement = TrueStatement.Clone (clonectx);
273 if (FalseStatement != null)
274 target.FalseStatement = FalseStatement.Clone (clonectx);
275 }
276 }
277
278 public class Do : Statement {
279 public Expression expr;
280 public Statement EmbeddedStatement;
281
282 public Do (Statement statement, BooleanExpression bool_expr, Location l)
283 {
284 expr = bool_expr;
285 EmbeddedStatement = statement;
286 loc = l;
287 }
288
289 public override bool Resolve (BlockContext ec)
290 {
291 bool ok = true;
292
293 ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc);
294
295 bool was_unreachable = ec.CurrentBranching.CurrentUsageVector.IsUnreachable;
296
297 ec.StartFlowBranching (FlowBranching.BranchingType.Embedded, loc);
298 if (!EmbeddedStatement.Resolve (ec))
299 ok = false;
300 ec.EndFlowBranching ();
301
302 if (ec.CurrentBranching.CurrentUsageVector.IsUnreachable && !was_unreachable)
303 ec.Report.Warning (162, 2, expr.Location, "Unreachable code detected");
304
305 expr = expr.Resolve (ec);
306 if (expr == null)
307 ok = false;
308 else if (expr is Constant){
309 bool infinite = !((Constant) expr).IsDefaultValue;
310 if (infinite)
311 ec.CurrentBranching.CurrentUsageVector.Goto ();
312 }
313
314 ec.EndFlowBranching ();
315
316 return ok;
317 }
318
319 protected override void DoEmit (EmitContext ec)
320 {
321 ILGenerator ig = ec.ig;
322 Label loop = ig.DefineLabel ();
323 Label old_begin = ec.LoopBegin;
324 Label old_end = ec.LoopEnd;
325
326 ec.LoopBegin = ig.DefineLabel ();
327 ec.LoopEnd = ig.DefineLabel ();
328
329 ig.MarkLabel (loop);
330 EmbeddedStatement.Emit (ec);
331 ig.MarkLabel (ec.LoopBegin);
332
333 //
334 // Dead code elimination
335 //
336 if (expr is Constant){
337 bool res = !((Constant) expr).IsDefaultValue;
338
339 expr.EmitSideEffect (ec);
340 if (res)
341 ec.ig.Emit (OpCodes.Br, loop);
342 } else
343 expr.EmitBranchable (ec, loop, true);
344
345 ig.MarkLabel (ec.LoopEnd);
346
347 ec.LoopBegin = old_begin;
348 ec.LoopEnd = old_end;
349 }
350
351 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
352 {
353 expr.MutateHoistedGenericType (storey);
354 EmbeddedStatement.MutateHoistedGenericType (storey);
355 }
356
357 protected override void CloneTo (CloneContext clonectx, Statement t)
358 {
359 Do target = (Do) t;
360
361 target.EmbeddedStatement = EmbeddedStatement.Clone (clonectx);
362 target.expr = expr.Clone (clonectx);
363 }
364 }
365
366 public class While : Statement {
367 public Expression expr;
368 public Statement Statement;
369 bool infinite, empty;
370
371 public While (BooleanExpression bool_expr, Statement statement, Location l)
372 {
373 this.expr = bool_expr;
374 Statement = statement;
375 loc = l;
376 }
377
378 public override bool Resolve (BlockContext ec)
379 {
380 bool ok = true;
381
382 expr = expr.Resolve (ec);
383 if (expr == null)
384 ok = false;
385
386 //
387 // Inform whether we are infinite or not
388 //
389 if (expr is Constant){
390 bool value = !((Constant) expr).IsDefaultValue;
391
392 if (value == false){
393 if (!Statement.ResolveUnreachable (ec, true))
394 return false;
395 empty = true;
396 return true;
397 } else
398 infinite = true;
399 }
400
401 ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc);
402 if (!infinite)
403 ec.CurrentBranching.CreateSibling ();
404
405 ec.StartFlowBranching (FlowBranching.BranchingType.Embedded, loc);
406 if (!Statement.Resolve (ec))
407 ok = false;
408 ec.EndFlowBranching ();
409
410 // There's no direct control flow from the end of the embedded statement to the end of the loop
411 ec.CurrentBranching.CurrentUsageVector.Goto ();
412
413 ec.EndFlowBranching ();
414
415 return ok;
416 }
417
418 protected override void DoEmit (EmitContext ec)
419 {
420 if (empty) {
421 expr.EmitSideEffect (ec);
422 return;
423 }
424
425 ILGenerator ig = ec.ig;
426 Label old_begin = ec.LoopBegin;
427 Label old_end = ec.LoopEnd;
428
429 ec.LoopBegin = ig.DefineLabel ();
430 ec.LoopEnd = ig.DefineLabel ();
431
432 //
433 // Inform whether we are infinite or not
434 //
435 if (expr is Constant){
436 // expr is 'true', since the 'empty' case above handles the 'false' case
437 ig.MarkLabel (ec.LoopBegin);
438 expr.EmitSideEffect (ec);
439 Statement.Emit (ec);
440 ig.Emit (OpCodes.Br, ec.LoopBegin);
441
442 //
443 // Inform that we are infinite (ie, `we return'), only
444 // if we do not `break' inside the code.
445 //
446 ig.MarkLabel (ec.LoopEnd);
447 } else {
448 Label while_loop = ig.DefineLabel ();
449
450 ig.Emit (OpCodes.Br, ec.LoopBegin);
451 ig.MarkLabel (while_loop);
452
453 Statement.Emit (ec);
454
455 ig.MarkLabel (ec.LoopBegin);
456 ec.Mark (loc);
457
458 expr.EmitBranchable (ec, while_loop, true);
459
460 ig.MarkLabel (ec.LoopEnd);
461 }
462
463 ec.LoopBegin = old_begin;
464 ec.LoopEnd = old_end;
465 }
466
467 public override void Emit (EmitContext ec)
468 {
469 DoEmit (ec);
470 }
471
472 protected override void CloneTo (CloneContext clonectx, Statement t)
473 {
474 While target = (While) t;
475
476 target.expr = expr.Clone (clonectx);
477 target.Statement = Statement.Clone (clonectx);
478 }
479
480 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
481 {
482 expr.MutateHoistedGenericType (storey);
483 Statement.MutateHoistedGenericType (storey);
484 }
485 }
486
487 public class For : Statement {
488 Expression Test;
489 Statement InitStatement;
490 Statement Increment;
491 public Statement Statement;
492 bool infinite, empty;
493
494 public For (Statement init_statement,
495 BooleanExpression test,
496 Statement increment,
497 Statement statement,
498 Location l)
499 {
500 InitStatement = init_statement;
501 Test = test;
502 Increment = increment;
503 Statement = statement;
504 loc = l;
505 }
506
507 public override bool Resolve (BlockContext ec)
508 {
509 bool ok = true;
510
511 if (InitStatement != null){
512 if (!InitStatement.Resolve (ec))
513 ok = false;
514 }
515
516 if (Test != null){
517 Test = Test.Resolve (ec);
518 if (Test == null)
519 ok = false;
520 else if (Test is Constant){
521 bool value = !((Constant) Test).IsDefaultValue;
522
523 if (value == false){
524 if (!Statement.ResolveUnreachable (ec, true))
525 return false;
526 if ((Increment != null) &&
527 !Increment.ResolveUnreachable (ec, false))
528 return false;
529 empty = true;
530 return true;
531 } else
532 infinite = true;
533 }
534 } else
535 infinite = true;
536
537 ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc);
538 if (!infinite)
539 ec.CurrentBranching.CreateSibling ();
540
541 bool was_unreachable = ec.CurrentBranching.CurrentUsageVector.IsUnreachable;
542
543 ec.StartFlowBranching (FlowBranching.BranchingType.Embedded, loc);
544 if (!Statement.Resolve (ec))
545 ok = false;
546 ec.EndFlowBranching ();
547
548 if (Increment != null){
549 if (ec.CurrentBranching.CurrentUsageVector.IsUnreachable) {
550 if (!Increment.ResolveUnreachable (ec, !was_unreachable))
551 ok = false;
552 } else {
553 if (!Increment.Resolve (ec))
554 ok = false;
555 }
556 }
557
558 // There's no direct control flow from the end of the embedded statement to the end of the loop
559 ec.CurrentBranching.CurrentUsageVector.Goto ();
560
561 ec.EndFlowBranching ();
562
563 return ok;
564 }
565
566 protected override void DoEmit (EmitContext ec)
567 {
568 if (InitStatement != null)
569 InitStatement.Emit (ec);
570
571 if (empty) {
572 Test.EmitSideEffect (ec);
573 return;
574 }
575
576 ILGenerator ig = ec.ig;
577 Label old_begin = ec.LoopBegin;
578 Label old_end = ec.LoopEnd;
579 Label loop = ig.DefineLabel ();
580 Label test = ig.DefineLabel ();
581
582 ec.LoopBegin = ig.DefineLabel ();
583 ec.LoopEnd = ig.DefineLabel ();
584
585 ig.Emit (OpCodes.Br, test);
586 ig.MarkLabel (loop);
587 Statement.Emit (ec);
588
589 ig.MarkLabel (ec.LoopBegin);
590 Increment.Emit (ec);
591
592 ig.MarkLabel (test);
593 //
594 // If test is null, there is no test, and we are just
595 // an infinite loop
596 //
597 if (Test != null){
598 //
599 // The Resolve code already catches the case for
600 // Test == Constant (false) so we know that
601 // this is true
602 //
603 if (Test is Constant) {
604 Test.EmitSideEffect (ec);
605 ig.Emit (OpCodes.Br, loop);
606 } else {
607 Test.EmitBranchable (ec, loop, true);
608 }
609
610 } else
611 ig.Emit (OpCodes.Br, loop);
612 ig.MarkLabel (ec.LoopEnd);
613
614 ec.LoopBegin = old_begin;
615 ec.LoopEnd = old_end;
616 }
617
618 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
619 {
620 if (InitStatement != null)
621 InitStatement.MutateHoistedGenericType (storey);
622 if (Test != null)
623 Test.MutateHoistedGenericType (storey);
624 if (Increment != null)
625 Increment.MutateHoistedGenericType (storey);
626
627 Statement.MutateHoistedGenericType (storey);
628 }
629
630 protected override void CloneTo (CloneContext clonectx, Statement t)
631 {
632 For target = (For) t;
633
634 if (InitStatement != null)
635 target.InitStatement = InitStatement.Clone (clonectx);
636 if (Test != null)
637 target.Test = Test.Clone (clonectx);
638 if (Increment != null)
639 target.Increment = Increment.Clone (clonectx);
640 target.Statement = Statement.Clone (clonectx);
641 }
642 }
643
644 public class StatementExpression : Statement {
645 ExpressionStatement expr;
646
647 public StatementExpression (ExpressionStatement expr)
648 {
649 this.expr = expr;
650 loc = expr.Location;
651 }
652
653 public override bool Resolve (BlockContext ec)
654 {
655 expr = expr.ResolveStatement (ec);
656 return expr != null;
657 }
658
659 protected override void DoEmit (EmitContext ec)
660 {
661 expr.EmitStatement (ec);
662 }
663
664 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
665 {
666 expr.MutateHoistedGenericType (storey);
667 }
668
669 public override string ToString ()
670 {
671 return "StatementExpression (" + expr + ")";
672 }
673
674 protected override void CloneTo (CloneContext clonectx, Statement t)
675 {
676 StatementExpression target = (StatementExpression) t;
677
678 target.expr = (ExpressionStatement) expr.Clone (clonectx);
679 }
680 }
681
682 // A 'return' or a 'yield break'
683 public abstract class ExitStatement : Statement
684 {
685 protected bool unwind_protect;
686 protected abstract bool DoResolve (BlockContext ec);
687
688 public virtual void Error_FinallyClause (Report Report)
689 {
690 Report.Error (157, loc, "Control cannot leave the body of a finally clause");
691 }
692
693 public sealed override bool Resolve (BlockContext ec)
694 {
695 if (!DoResolve (ec))
696 return false;
697
698 unwind_protect = ec.CurrentBranching.AddReturnOrigin (ec.CurrentBranching.CurrentUsageVector, this);
699 if (unwind_protect)
700 ec.NeedReturnLabel ();
701 ec.CurrentBranching.CurrentUsageVector.Goto ();
702 return true;
703 }
704 }
705
706 /// <summary>
707 /// Implements the return statement
708 /// </summary>
709 public class Return : ExitStatement {
710 protected Expression Expr;
711 public Return (Expression expr, Location l)
712 {
713 Expr = expr;
714 loc = l;
715 }
716
717 protected override bool DoResolve (BlockContext ec)
718 {
719 if (Expr == null) {
720 if (ec.ReturnType == TypeManager.void_type)
721 return true;
722
723 ec.Report.Error (126, loc,
724 "An object of a type convertible to `{0}' is required for the return statement",
725 TypeManager.CSharpName (ec.ReturnType));
726 return false;
727 }
728
729 if (ec.CurrentBlock.Toplevel.IsIterator) {
730 ec.Report.Error (1622, loc, "Cannot return a value from iterators. Use the yield return " +
731 "statement to return a value, or yield break to end the iteration");
732 }
733
734 AnonymousExpression am = ec.CurrentAnonymousMethod;
735 if (am == null && ec.ReturnType == TypeManager.void_type) {
736 ec.Report.Error (127, loc, "`{0}': A return keyword must not be followed by any expression when method returns void",
737 ec.GetSignatureForError ());
738 }
739
740 Expr = Expr.Resolve (ec);
741 if (Expr == null)
742 return false;
743
744 if (ec.HasSet (ResolveContext.Options.InferReturnType)) {
745 ec.ReturnTypeInference.AddCommonTypeBound (Expr.Type);
746 return true;
747 }
748
749 if (Expr.Type != ec.ReturnType) {
750 Expr = Convert.ImplicitConversionRequired (ec, Expr, ec.ReturnType, loc);
751
752 if (Expr == null) {
753 if (am != null) {
754 ec.Report.Error (1662, loc,
755 "Cannot convert `{0}' to delegate type `{1}' because some of the return types in the block are not implicitly convertible to the delegate return type",
756 am.ContainerType, am.GetSignatureForError ());
757 }
758 return false;
759 }
760 }
761
762 return true;
763 }
764
765 protected override void DoEmit (EmitContext ec)
766 {
767 if (Expr != null) {
768 Expr.Emit (ec);
769
770 if (unwind_protect)
771 ec.ig.Emit (OpCodes.Stloc, ec.TemporaryReturn ());
772 }
773
774 if (unwind_protect)
775 ec.ig.Emit (OpCodes.Leave, ec.ReturnLabel);
776 else
777 ec.ig.Emit (OpCodes.Ret);
778 }
779
780 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
781 {
782 if (Expr != null)
783 Expr.MutateHoistedGenericType (storey);
784 }
785
786 protected override void CloneTo (CloneContext clonectx, Statement t)
787 {
788 Return target = (Return) t;
789 // It's null for simple return;
790 if (Expr != null)
791 target.Expr = Expr.Clone (clonectx);
792 }
793 }
794
795 public class Goto : Statement {
796 string target;
797 LabeledStatement label;
798 bool unwind_protect;
799
800 public override bool Resolve (BlockContext ec)
801 {
802 unwind_protect = ec.CurrentBranching.AddGotoOrigin (ec.CurrentBranching.CurrentUsageVector, this);
803 ec.CurrentBranching.CurrentUsageVector.Goto ();
804 return true;
805 }
806
807 public Goto (string label, Location l)
808 {
809 loc = l;
810 target = label;
811 }
812
813 public string Target {
814 get { return target; }
815 }
816
817 public void SetResolvedTarget (LabeledStatement label)
818 {
819 this.label = label;
820 label.AddReference ();
821 }
822
823 protected override void CloneTo (CloneContext clonectx, Statement target)
824 {
825 // Nothing to clone
826 }
827
828 protected override void DoEmit (EmitContext ec)
829 {
830 if (label == null)
831 throw new InternalErrorException ("goto emitted before target resolved");
832 Label l = label.LabelTarget (ec);
833 ec.ig.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, l);
834 }
835
836 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
837 {
838 }
839 }
840
841 public class LabeledStatement : Statement {
842 string name;
843 bool defined;
844 bool referenced;
845 Label label;
846 ILGenerator ig;
847
848 FlowBranching.UsageVector vectors;
849
850 public LabeledStatement (string name, Location l)
851 {
852 this.name = name;
853 this.loc = l;
854 }
855
856 public Label LabelTarget (EmitContext ec)
857 {
858 if (defined)
859 return label;
860 ig = ec.ig;
861 label = ec.ig.DefineLabel ();
862 defined = true;
863
864 return label;
865 }
866
867 public string Name {
868 get { return name; }
869 }
870
871 public bool IsDefined {
872 get { return defined; }
873 }
874
875 public bool HasBeenReferenced {
876 get { return referenced; }
877 }
878
879 public FlowBranching.UsageVector JumpOrigins {
880 get { return vectors; }
881 }
882
883 public void AddUsageVector (FlowBranching.UsageVector vector)
884 {
885 vector = vector.Clone ();
886 vector.Next = vectors;
887 vectors = vector;
888 }
889
890 protected override void CloneTo (CloneContext clonectx, Statement target)
891 {
892 // nothing to clone
893 }
894
895 public override bool Resolve (BlockContext ec)
896 {
897 // this flow-branching will be terminated when the surrounding block ends
898 ec.StartFlowBranching (this);
899 return true;
900 }
901
902 protected override void DoEmit (EmitContext ec)
903 {
904 if (ig != null && ig != ec.ig)
905 throw new InternalErrorException ("cannot happen");
906 LabelTarget (ec);
907 ec.ig.MarkLabel (label);
908 }
909
910 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
911 {
912 }
913
914 public void AddReference ()
915 {
916 referenced = true;
917 }
918 }
919
920
921 /// <summary>
922 /// `goto default' statement
923 /// </summary>
924 public class GotoDefault : Statement {
925
926 public GotoDefault (Location l)
927 {
928 loc = l;
929 }
930
931 protected override void CloneTo (CloneContext clonectx, Statement target)
932 {
933 // nothing to clone
934 }
935
936 public override bool Resolve (BlockContext ec)
937 {
938 ec.CurrentBranching.CurrentUsageVector.Goto ();
939
940 if (ec.Switch == null) {
941 ec.Report.Error (153, loc, "A goto case is only valid inside a switch statement");
942 return false;
943 }
944
945 if (!ec.Switch.GotDefault) {
946 FlowBranchingBlock.Error_UnknownLabel (loc, "default", ec.Report);
947 return false;
948 }
949
950 return true;
951 }
952
953 protected override void DoEmit (EmitContext ec)
954 {
955 ec.ig.Emit (OpCodes.Br, ec.Switch.DefaultTarget);
956 }
957
958 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
959 {
960 }
961 }
962
963 /// <summary>
964 /// `goto case' statement
965 /// </summary>
966 public class GotoCase : Statement {
967 Expression expr;
968 SwitchLabel sl;
969
970 public GotoCase (Expression e, Location l)
971 {
972 expr = e;
973 loc = l;
974 }
975
976 public override bool Resolve (BlockContext ec)
977 {
978 if (ec.Switch == null){
979 ec.Report.Error (153, loc, "A goto case is only valid inside a switch statement");
980 return false;
981 }
982
983 ec.CurrentBranching.CurrentUsageVector.Goto ();
984
985 expr = expr.Resolve (ec);
986 if (expr == null)
987 return false;
988
989 Constant c = expr as Constant;
990 if (c == null) {
991 ec.Report.Error (150, expr.Location, "A constant value is expected");
992 return false;
993 }
994
995 Type type = ec.Switch.SwitchType;
996 Constant res = c.TryReduce (ec, type, c.Location);
997 if (res == null) {
998 c.Error_ValueCannotBeConverted (ec, loc, type, true);
999 return false;
1000 }
1001
1002 if (!Convert.ImplicitStandardConversionExists (c, type))
1003 ec.Report.Warning (469, 2, loc,
1004 "The `goto case' value is not implicitly convertible to type `{0}'",
1005 TypeManager.CSharpName (type));
1006
1007 object val = res.GetValue ();
1008 if (val == null)
1009 val = SwitchLabel.NullStringCase;
1010
1011 if (!ec.Switch.Elements.TryGetValue (val, out sl)) {
1012 FlowBranchingBlock.Error_UnknownLabel (loc, "case " +
1013 (c.GetValue () == null ? "null" : val.ToString ()), ec.Report);
1014 return false;
1015 }
1016
1017 return true;
1018 }
1019
1020 protected override void DoEmit (EmitContext ec)
1021 {
1022 ec.ig.Emit (OpCodes.Br, sl.GetILLabelCode (ec));
1023 }
1024
1025 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
1026 {
1027 expr.MutateHoistedGenericType (storey);
1028 }
1029
1030 protected override void CloneTo (CloneContext clonectx, Statement t)
1031 {
1032 GotoCase target = (GotoCase) t;
1033
1034 target.expr = expr.Clone (clonectx);
1035 }
1036 }
1037
1038 public class Throw : Statement {
1039 Expression expr;
1040
1041 public Throw (Expression expr, Location l)
1042 {
1043 this.expr = expr;
1044 loc = l;
1045 }
1046
1047 public override bool Resolve (BlockContext ec)
1048 {
1049 if (expr == null) {
1050 ec.CurrentBranching.CurrentUsageVector.Goto ();
1051 return ec.CurrentBranching.CheckRethrow (loc);
1052 }
1053
1054 expr = expr.Resolve (ec, ResolveFlags.Type | ResolveFlags.VariableOrValue);
1055 ec.CurrentBranching.CurrentUsageVector.Goto ();
1056
1057 if (expr == null)
1058 return false;
1059
1060 if (Convert.ImplicitConversionExists (ec, expr, TypeManager.exception_type))
1061 expr = Convert.ImplicitConversion (ec, expr, TypeManager.exception_type, loc);
1062 else
1063 ec.Report.Error (155, expr.Location, "The type caught or thrown must be derived from System.Exception");
1064
1065 return true;
1066 }
1067
1068 protected override void DoEmit (EmitContext ec)
1069 {
1070 if (expr == null)
1071 ec.ig.Emit (OpCodes.Rethrow);
1072 else {
1073 expr.Emit (ec);
1074
1075 ec.ig.Emit (OpCodes.Throw);
1076 }
1077 }
1078
1079 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
1080 {
1081 if (expr != null)
1082 expr.MutateHoistedGenericType (storey);
1083 }
1084
1085 protected override void CloneTo (CloneContext clonectx, Statement t)
1086 {
1087 Throw target = (Throw) t;
1088
1089 if (expr != null)
1090 target.expr = expr.Clone (clonectx);
1091 }
1092 }
1093
1094 public class Break : Statement {
1095
1096 public Break (Location l)
1097 {
1098 loc = l;
1099 }
1100
1101 bool unwind_protect;
1102
1103 public override bool Resolve (BlockContext ec)
1104 {
1105 unwind_protect = ec.CurrentBranching.AddBreakOrigin (ec.CurrentBranching.CurrentUsageVector, loc);
1106 ec.CurrentBranching.CurrentUsageVector.Goto ();
1107 return true;
1108 }
1109
1110 protected override void DoEmit (EmitContext ec)
1111 {
1112 ec.ig.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, ec.LoopEnd);
1113 }
1114
1115 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
1116 {
1117 }
1118
1119 protected override void CloneTo (CloneContext clonectx, Statement t)
1120 {
1121 // nothing needed
1122 }
1123 }
1124
1125 public class Continue : Statement {
1126
1127 public Continue (Location l)
1128 {
1129 loc = l;
1130 }
1131
1132 bool unwind_protect;
1133
1134 public override bool Resolve (BlockContext ec)
1135 {
1136 unwind_protect = ec.CurrentBranching.AddContinueOrigin (ec.CurrentBranching.CurrentUsageVector, loc);
1137 ec.CurrentBranching.CurrentUsageVector.Goto ();
1138 return true;
1139 }
1140
1141 protected override void DoEmit (EmitContext ec)
1142 {
1143 ec.ig.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, ec.LoopBegin);
1144 }
1145
1146 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
1147 {
1148 }
1149
1150 protected override void CloneTo (CloneContext clonectx, Statement t)
1151 {
1152 // nothing needed.
1153 }
1154 }
1155
1156 public interface ILocalVariable
1157 {
1158 void Emit (EmitContext ec);
1159 void EmitAssign (EmitContext ec);
1160 void EmitAddressOf (EmitContext ec);
1161 }
1162
1163 public interface IKnownVariable {
1164 Block Block { get; }
1165 Location Location { get; }
1166 }
1167
1168 //
1169 // The information about a user-perceived local variable
1170 //
1171 public class LocalInfo : IKnownVariable, ILocalVariable {
1172 public readonly FullNamedExpression Type;
1173
1174 public Type VariableType;
1175 public readonly string Name;
1176 public readonly Location Location;
1177 public readonly Block Block;
1178
1179 public VariableInfo VariableInfo;
1180 HoistedVariable hoisted_variant;
1181
1182 [Flags]
1183 enum Flags : byte {
1184 Used = 1,
1185 ReadOnly = 2,
1186 Pinned = 4,
1187 IsThis = 8,
1188 AddressTaken = 32,
1189 CompilerGenerated = 64,
1190 IsConstant = 128
1191 }
1192
1193 public enum ReadOnlyContext: byte {
1194 Using,
1195 Foreach,
1196 Fixed
1197 }
1198
1199 Flags flags;
1200 ReadOnlyContext ro_context;
1201 LocalBuilder builder;
1202
1203 public LocalInfo (FullNamedExpression type, string name, Block block, Location l)
1204 {
1205 Type = type;
1206 Name = name;
1207 Block = block;
1208 Location = l;
1209 }
1210
1211 public LocalInfo (DeclSpace ds, Block block, Location l)
1212 {
1213 VariableType = ds.IsGeneric ? ds.CurrentType : ds.TypeBuilder;
1214 Block = block;
1215 Location = l;
1216 }
1217
1218 public void ResolveVariable (EmitContext ec)
1219 {
1220 if (HoistedVariant != null)
1221 return;
1222
1223 if (builder == null) {
1224 builder = ec.ig.DeclareLocal (TypeManager.TypeToReflectionType (VariableType), Pinned);
1225 }
1226 }
1227
1228 public void Emit (EmitContext ec)
1229 {
1230 ec.ig.Emit (OpCodes.Ldloc, builder);
1231 }
1232
1233 public void EmitAssign (EmitContext ec)
1234 {
1235 ec.ig.Emit (OpCodes.Stloc, builder);
1236 }
1237
1238 public void EmitAddressOf (EmitContext ec)
1239 {
1240 ec.ig.Emit (OpCodes.Ldloca, builder);
1241 }
1242
1243 public void EmitSymbolInfo (EmitContext ec)
1244 {
1245 if (builder != null)
1246 ec.DefineLocalVariable (Name, builder);
1247 }
1248
1249 //
1250 // Hoisted local variable variant
1251 //
1252 public HoistedVariable HoistedVariant {
1253 get {
1254 return hoisted_variant;
1255 }
1256 set {
1257 hoisted_variant = value;
1258 }
1259 }
1260
1261 public bool IsThisAssigned (BlockContext ec, Block block)
1262 {
1263 if (VariableInfo == null)
1264 throw new Exception ();
1265
1266 if (!ec.DoFlowAnalysis || ec.CurrentBranching.IsAssigned (VariableInfo))
1267 return true;
1268
1269 return VariableInfo.TypeInfo.IsFullyInitialized (ec, VariableInfo, block.StartLocation);
1270 }
1271
1272 public bool IsAssigned (BlockContext ec)
1273 {
1274 if (VariableInfo == null)
1275 throw new Exception ();
1276
1277 return !ec.DoFlowAnalysis || ec.CurrentBranching.IsAssigned (VariableInfo);
1278 }
1279
1280 public bool Resolve (ResolveContext ec)
1281 {
1282 if (VariableType != null)
1283 return true;
1284
1285 TypeExpr texpr = Type.ResolveAsContextualType (ec, false);
1286 if (texpr == null)
1287 return false;
1288
1289 VariableType = texpr.Type;
1290
1291 if (TypeManager.IsGenericParameter (VariableType))
1292 return true;
1293
1294 if (VariableType.IsAbstract && VariableType.IsSealed) {
1295 FieldBase.Error_VariableOfStaticClass (Location, Name, VariableType, ec.Report);
1296 return false;
1297 }
1298
1299 if (VariableType.IsPointer && !ec.IsUnsafe)
1300 Expression.UnsafeError (ec, Location);
1301
1302 return true;
1303 }
1304
1305 public bool IsConstant {
1306 get { return (flags & Flags.IsConstant) != 0; }
1307 set { flags |= Flags.IsConstant; }
1308 }
1309
1310 public bool AddressTaken {
1311 get { return (flags & Flags.AddressTaken) != 0; }
1312 set { flags |= Flags.AddressTaken; }
1313 }
1314
1315 public bool CompilerGenerated {
1316 get { return (flags & Flags.CompilerGenerated) != 0; }
1317 set { flags |= Flags.CompilerGenerated; }
1318 }
1319
1320 public override string ToString ()
1321 {
1322 return String.Format ("LocalInfo ({0},{1},{2},{3})",
1323 Name, Type, VariableInfo, Location);
1324 }
1325
1326 public bool Used {
1327 get { return (flags & Flags.Used) != 0; }
1328 set { flags = value ? (flags | Flags.Used) : (unchecked (flags & ~Flags.Used)); }
1329 }
1330
1331 public bool ReadOnly {
1332 get { return (flags & Flags.ReadOnly) != 0; }
1333 }
1334
1335 public void SetReadOnlyContext (ReadOnlyContext context)
1336 {
1337 flags |= Flags.ReadOnly;
1338 ro_context = context;
1339 }
1340
1341 public string GetReadOnlyContext ()
1342 {
1343 if (!ReadOnly)
1344 throw new InternalErrorException ("Variable is not readonly");
1345
1346 switch (ro_context) {
1347 case ReadOnlyContext.Fixed:
1348 return "fixed variable";
1349 case ReadOnlyContext.Foreach:
1350 return "foreach iteration variable";
1351 case ReadOnlyContext.Using:
1352 return "using variable";
1353 }
1354 throw new NotImplementedException ();
1355 }
1356
1357 //
1358 // Whether the variable is pinned, if Pinned the variable has been
1359 // allocated in a pinned slot with DeclareLocal.
1360 //
1361 public bool Pinned {
1362 get { return (flags & Flags.Pinned) != 0; }
1363 set { flags = value ? (flags | Flags.Pinned) : (flags & ~Flags.Pinned); }
1364 }
1365
1366 public bool IsThis {
1367 get { return (flags & Flags.IsThis) != 0; }
1368 set { flags = value ? (flags | Flags.IsThis) : (flags & ~Flags.IsThis); }
1369 }
1370
1371 Block IKnownVariable.Block {
1372 get { return Block; }
1373 }
1374
1375 Location IKnownVariable.Location {
1376 get { return Location; }
1377 }
1378
1379 public LocalInfo Clone (CloneContext clonectx)
1380 {
1381 //
1382 // Variables in anonymous block are not resolved yet
1383 //
1384 if (VariableType == null)
1385 return new LocalInfo ((FullNamedExpression) Type.Clone (clonectx), Name, clonectx.LookupBlock (Block), Location);
1386
1387 //
1388 // Variables in method block are resolved
1389 //
1390 LocalInfo li = new LocalInfo (null, Name, clonectx.LookupBlock (Block), Location);
1391 li.VariableType = VariableType;
1392 return li;
1393 }
1394 }
1395
1396 /// <summary>
1397 /// Block represents a C# block.
1398 /// </summary>
1399 ///
1400 /// <remarks>
1401 /// This class is used in a number of places: either to represent
1402 /// explicit blocks that the programmer places or implicit blocks.
1403 ///
1404 /// Implicit blocks are used as labels or to introduce variable
1405 /// declarations.
1406 ///
1407 /// Top-level blocks derive from Block, and they are called ToplevelBlock
1408 /// they contain extra information that is not necessary on normal blocks.
1409 /// </remarks>
1410 public class Block : Statement {
1411 public Block Parent;
1412 public Location StartLocation;
1413 public Location EndLocation = Location.Null;
1414
1415 public ExplicitBlock Explicit;
1416 public ToplevelBlock Toplevel; // TODO: Use Explicit
1417
1418 [Flags]
1419 public enum Flags
1420 {
1421 Unchecked = 1,
1422 BlockUsed = 2,
1423 VariablesInitialized = 4,
1424 HasRet = 8,
1425 Unsafe = 16,
1426 IsIterator = 32,
1427 HasCapturedVariable = 64,
1428 HasCapturedThis = 1 << 7,
1429 IsExpressionTree = 1 << 8
1430 }
1431
1432 protected Flags flags;
1433
1434 public bool Unchecked {
1435 get { return (flags & Flags.Unchecked) != 0; }
1436 set { flags = value ? flags | Flags.Unchecked : flags & ~Flags.Unchecked; }
1437 }
1438
1439 public bool Unsafe {
1440 get { return (flags & Flags.Unsafe) != 0; }
1441 set { flags |= Flags.Unsafe; }
1442 }
1443
1444 //
1445 // The statements in this block
1446 //
1447 protected List<Statement> statements;
1448
1449 //
1450 // An array of Blocks. We keep track of children just
1451 // to generate the local variable declarations.
1452 //
1453 // Statements and child statements are handled through the
1454 // statements.
1455 //
1456 List<Block> children;
1457
1458 //
1459 // Labels. (label, block) pairs.
1460 //
1461 protected Dictionary<string, LabeledStatement> labels;
1462
1463 //
1464 // Keeps track of (name, type) pairs
1465 //
1466 Dictionary<string, LocalInfo> variables;
1467
1468 //
1469 // Keeps track of constants
1470 Dictionary<string, Expression> constants;
1471
1472 //
1473 // Temporary variables.
1474 //
1475 List<LocalInfo> temporary_variables;
1476
1477 //
1478 // If this is a switch section, the enclosing switch block.
1479 //
1480 Block switch_block;
1481
1482 protected List<Statement> scope_initializers;
1483
1484 List<ToplevelBlock> anonymous_children;
1485
1486 protected static int id;
1487
1488 int this_id;
1489
1490 int assignable_slots;
1491 bool unreachable_shown;
1492 bool unreachable;
1493
1494 public Block (Block parent)
1495 : this (parent, (Flags) 0, Location.Null, Location.Null)
1496 { }
1497
1498 public Block (Block parent, Flags flags)
1499 : this (parent, flags, Location.Null, Location.Null)
1500 { }
1501
1502 public Block (Block parent, Location start, Location end)
1503 : this (parent, (Flags) 0, start, end)
1504 { }
1505
1506 //
1507 // Useful when TopLevel block is downgraded to normal block
1508 //
1509 public Block (ToplevelBlock parent, ToplevelBlock source)
1510 : this (parent, source.flags, source.StartLocation, source.EndLocation)
1511 {
1512 statements = source.statements;
1513 children = source.children;
1514 labels = source.labels;
1515 variables = source.variables;
1516 constants = source.constants;
1517 switch_block = source.switch_block;
1518 }
1519
1520 public Block (Block parent, Flags flags, Location start, Location end)
1521 {
1522 if (parent != null) {
1523 parent.AddChild (this);
1524
1525 // the appropriate constructors will fixup these fields
1526 Toplevel = parent.Toplevel;
1527 Explicit = parent.Explicit;
1528 }
1529
1530 this.Parent = parent;
1531 this.flags = flags;
1532 this.StartLocation = start;
1533 this.EndLocation = end;
1534 this.loc = start;
1535 this_id = id++;
1536 statements = new List<Statement> (4);
1537 }
1538
1539 public Block CreateSwitchBlock (Location start)
1540 {
1541 // FIXME: should this be implicit?
1542 Block new_block = new ExplicitBlock (this, start, start);
1543 new_block.switch_block = this;
1544 return new_block;
1545 }
1546
1547 public int ID {
1548 get { return this_id; }
1549 }
1550
1551 public IDictionary<string, LocalInfo> Variables {
1552 get {
1553 if (variables == null)
1554 variables = new Dictionary<string, LocalInfo> ();
1555 return variables;
1556 }
1557 }
1558
1559 void AddChild (Block b)
1560 {
1561 if (children == null)
1562 children = new List<Block> (1);
1563
1564 children.Add (b);
1565 }
1566
1567 public void SetEndLocation (Location loc)
1568 {
1569 EndLocation = loc;
1570 }
1571
1572 protected void Error_158 (string name, Location loc)
1573 {
1574 Toplevel.Report.Error (158, loc, "The label `{0}' shadows another label " +
1575 "by the same name in a contained scope", name);
1576 }
1577
1578 /// <summary>
1579 /// Adds a label to the current block.
1580 /// </summary>
1581 ///
1582 /// <returns>
1583 /// false if the name already exists in this block. true
1584 /// otherwise.
1585 /// </returns>
1586 ///
1587 public bool AddLabel (LabeledStatement target)
1588 {
1589 if (switch_block != null)
1590 return switch_block.AddLabel (target);
1591
1592 string name = target.Name;
1593
1594 Block cur = this;
1595 while (cur != null) {
1596 LabeledStatement s = cur.DoLookupLabel (name);
1597 if (s != null) {
1598 Toplevel.Report.SymbolRelatedToPreviousError (s.loc, s.Name);
1599 Toplevel.Report.Error (140, target.loc, "The label `{0}' is a duplicate", name);
1600 return false;
1601 }
1602
1603 if (this == Explicit)
1604 break;
1605
1606 cur = cur.Parent;
1607 }
1608
1609 while (cur != null) {
1610 if (cur.DoLookupLabel (name) != null) {
1611 Error_158 (name, target.loc);
1612 return false;
1613 }
1614
1615 if (children != null) {
1616 foreach (Block b in children) {
1617 LabeledStatement s = b.DoLookupLabel (name);
1618 if (s == null)
1619 continue;
1620
1621 Toplevel.Report.SymbolRelatedToPreviousError (s.loc, s.Name);
1622 Error_158 (name, target.loc);
1623 return false;
1624 }
1625 }
1626
1627 cur = cur.Parent;
1628 }
1629
1630 Toplevel.CheckError158 (name, target.loc);
1631
1632 if (labels == null)
1633 labels = new Dictionary<string, LabeledStatement> ();
1634
1635 labels.Add (name, target);
1636 return true;
1637 }
1638
1639 public LabeledStatement LookupLabel (string name)
1640 {
1641 LabeledStatement s = DoLookupLabel (name);
1642 if (s != null)
1643 return s;
1644
1645 if (children == null)
1646 return null;
1647
1648 foreach (Block child in children) {
1649 if (Explicit != child.Explicit)
1650 continue;
1651
1652 s = child.LookupLabel (name);
1653 if (s != null)
1654 return s;
1655 }
1656
1657 return null;
1658 }
1659
1660 LabeledStatement DoLookupLabel (string name)
1661 {
1662 if (switch_block != null)
1663 return switch_block.LookupLabel (name);
1664
1665 if (labels != null)
1666 if (labels.ContainsKey (name))
1667 return labels [name];
1668
1669 return null;
1670 }
1671
1672 public bool CheckInvariantMeaningInBlock (string name, Expression e, Location loc)
1673 {
1674 Block b = this;
1675 IKnownVariable kvi = b.Explicit.GetKnownVariable (name);
1676 while (kvi == null) {
1677 b = b.Explicit.Parent;
1678 if (b == null)
1679 return true;
1680 kvi = b.Explicit.GetKnownVariable (name);
1681 }
1682
1683 if (kvi.Block == b)
1684 return true;
1685
1686 // Is kvi.Block nested inside 'b'
1687 if (b.Explicit != kvi.Block.Explicit) {
1688 //
1689 // If a variable by the same name it defined in a nested block of this
1690 // block, we violate the invariant meaning in a block.
1691 //
1692 if (b == this) {
1693 Toplevel.Report.SymbolRelatedToPreviousError (kvi.Location, name);
1694 Toplevel.Report.Error (135, loc, "`{0}' conflicts with a declaration in a child block", name);
1695 return false;
1696 }
1697
1698 //
1699 // It's ok if the definition is in a nested subblock of b, but not
1700 // nested inside this block -- a definition in a sibling block
1701 // should not affect us.
1702 //
1703 return true;
1704 }
1705
1706 //
1707 // Block 'b' and kvi.Block are the same textual block.
1708 // However, different variables are extant.
1709 //
1710 // Check if the variable is in scope in both blocks. We use
1711 // an indirect check that depends on AddVariable doing its
1712 // part in maintaining the invariant-meaning-in-block property.
1713 //
1714 if (e is VariableReference || (e is Constant && b.GetLocalInfo (name) != null))
1715 return true;
1716
1717 if (this is ToplevelBlock) {
1718 Toplevel.Report.SymbolRelatedToPreviousError (kvi.Location, name);
1719 e.Error_VariableIsUsedBeforeItIsDeclared (Toplevel.Report, name);
1720 return false;
1721 }
1722
1723 //
1724 // Even though we detected the error when the name is used, we
1725 // treat it as if the variable declaration was in error.
1726 //
1727 Toplevel.Report.SymbolRelatedToPreviousError (loc, name);
1728 Error_AlreadyDeclared (kvi.Location, name, "parent or current");
1729 return false;
1730 }
1731
1732 protected virtual bool CheckParentConflictName (ToplevelBlock block, string name, Location l)
1733 {
1734 LocalInfo vi = GetLocalInfo (name);
1735 if (vi != null) {
1736 block.Report.SymbolRelatedToPreviousError (vi.Location, name);
1737 if (Explicit == vi.Block.Explicit) {
1738 Error_AlreadyDeclared (l, name, null);
1739 } else {
1740 Error_AlreadyDeclared (l, name, this is ToplevelBlock ?
1741 "parent or current" : "parent");
1742 }
1743 return false;
1744 }
1745
1746 if (block != null) {
1747 Expression e = block.GetParameterReference (name, Location.Null);
1748 if (e != null) {
1749 ParameterReference pr = e as ParameterReference;
1750 if (this is Linq.QueryBlock && (pr != null && pr.Parameter is Linq.QueryBlock.ImplicitQueryParameter || e is MemberAccess))
1751 Error_AlreadyDeclared (loc, name);
1752 else
1753 Error_AlreadyDeclared (loc, name, "parent or current");
1754 return false;
1755 }
1756 }
1757
1758 return true;
1759 }
1760
1761 public LocalInfo AddVariable (Expression type, string name, Location l)
1762 {
1763 if (!CheckParentConflictName (Toplevel, name, l))
1764 return null;
1765
1766 if (Toplevel.GenericMethod != null) {
1767 foreach (TypeParameter tp in Toplevel.GenericMethod.CurrentTypeParameters) {
1768 if (tp.Name == name) {
1769 Toplevel.Report.SymbolRelatedToPreviousError (tp);
1770 Error_AlreadyDeclaredTypeParameter (Toplevel.Report, loc, name, "local variable");
1771 return null;
1772 }
1773 }
1774 }
1775
1776 IKnownVariable kvi = Explicit.GetKnownVariable (name);
1777 if (kvi != null) {
1778 Toplevel.Report.SymbolRelatedToPreviousError (kvi.Location, name);
1779 Error_AlreadyDeclared (l, name, "child");
1780 return null;
1781 }
1782
1783 LocalInfo vi = new LocalInfo ((FullNamedExpression) type, name, this, l);
1784 AddVariable (vi);
1785
1786 if ((flags & Flags.VariablesInitialized) != 0)
1787 throw new InternalErrorException ("block has already been resolved");
1788
1789 return vi;
1790 }
1791
1792 protected virtual void AddVariable (LocalInfo li)
1793 {
1794 Variables.Add (li.Name, li);
1795 Explicit.AddKnownVariable (li.Name, li);
1796 }
1797
1798 protected virtual void Error_AlreadyDeclared (Location loc, string var, string reason)
1799 {
1800 if (reason == null) {
1801 Error_AlreadyDeclared (loc, var);
1802 return;
1803 }
1804
1805 Toplevel.Report.Error (136, loc, "A local variable named `{0}' cannot be declared " +
1806 "in this scope because it would give a different meaning " +
1807 "to `{0}', which is already used in a `{1}' scope " +
1808 "to denote something else", var, reason);
1809 }
1810
1811 protected virtual void Error_AlreadyDeclared (Location loc, string name)
1812 {
1813 Toplevel.Report.Error (128, loc,
1814 "A local variable named `{0}' is already defined in this scope", name);
1815 }
1816
1817 public virtual void Error_AlreadyDeclaredTypeParameter (Report r, Location loc, string name, string conflict)
1818 {
1819 r.Error (412, loc, "The type parameter name `{0}' is the same as `{1}'",
1820 name, conflict);
1821 }
1822
1823 public bool AddConstant (Expression type, string name, Expression value, Location l)
1824 {
1825 if (AddVariable (type, name, l) == null)
1826 return false;
1827
1828 if (constants == null)
1829 constants = new Dictionary<string, Expression> ();
1830
1831 constants.Add (name, value);
1832
1833 // A block is considered used if we perform an initialization in a local declaration, even if it is constant.
1834 Use ();
1835 return true;
1836 }
1837
1838 static int next_temp_id = 0;
1839
1840 public LocalInfo AddTemporaryVariable (TypeExpr te, Location loc)
1841 {
1842 Report.Debug (64, "ADD TEMPORARY", this, Toplevel, loc);
1843
1844 if (temporary_variables == null)
1845 temporary_variables = new List<LocalInfo> ();
1846
1847 int id = ++next_temp_id;
1848 string name = "$s_" + id.ToString ();
1849
1850 LocalInfo li = new LocalInfo (te, name, this, loc);
1851 li.CompilerGenerated = true;
1852 temporary_variables.Add (li);
1853 return li;
1854 }
1855
1856 public LocalInfo GetLocalInfo (string name)
1857 {
1858 LocalInfo ret;
1859 for (Block b = this; b != null; b = b.Parent) {
1860 if (b.variables != null) {
1861 if (b.variables.TryGetValue (name, out ret))
1862 return ret;
1863 }
1864 }
1865
1866 return null;
1867 }
1868
1869 public Expression GetVariableType (string name)
1870 {
1871 LocalInfo vi = GetLocalInfo (name);
1872 return vi == null ? null : vi.Type;
1873 }
1874
1875 public Expression GetConstantExpression (string name)
1876 {
1877 Expression ret;
1878 for (Block b = this; b != null; b = b.Parent) {
1879 if (b.constants != null) {
1880 if (b.constants.TryGetValue (name, out ret))
1881 return ret;
1882 }
1883 }
1884 return null;
1885 }
1886
1887 //
1888 // It should be used by expressions which require to
1889 // register a statement during resolve process.
1890 //
1891 public void AddScopeStatement (Statement s)
1892 {
1893 if (scope_initializers == null)
1894 scope_initializers = new List<Statement> ();
1895
1896 scope_initializers.Add (s);
1897 }
1898
1899 public void AddStatement (Statement s)
1900 {
1901 statements.Add (s);
1902 flags |= Flags.BlockUsed;
1903 }
1904
1905 public bool Used {
1906 get { return (flags & Flags.BlockUsed) != 0; }
1907 }
1908
1909 public void Use ()
1910 {
1911 flags |= Flags.BlockUsed;
1912 }
1913
1914 public bool HasRet {
1915 get { return (flags & Flags.HasRet) != 0; }
1916 }
1917
1918 public int AssignableSlots {
1919 get {
1920 // TODO: Re-enable
1921 // if ((flags & Flags.VariablesInitialized) == 0)
1922 // throw new Exception ("Variables have not been initialized yet");
1923 return assignable_slots;
1924 }
1925 }
1926
1927 public IList<ToplevelBlock> AnonymousChildren {
1928 get { return anonymous_children; }
1929 }
1930
1931 public void AddAnonymousChild (ToplevelBlock b)
1932 {
1933 if (anonymous_children == null)
1934 anonymous_children = new List<ToplevelBlock> ();
1935
1936 anonymous_children.Add (b);
1937 }
1938
1939 void DoResolveConstants (BlockContext ec)
1940 {
1941 if (constants == null)
1942 return;
1943
1944 if (variables == null)
1945 throw new InternalErrorException ("cannot happen");
1946
1947 foreach (var de in variables) {
1948 string name = de.Key;
1949 LocalInfo vi = de.Value;
1950 Type variable_type = vi.VariableType;
1951
1952 if (variable_type == null) {
1953 if (vi.Type is VarExpr)
1954 ec.Report.Error (822, vi.Type.Location, "An implicitly typed local variable cannot be a constant");
1955
1956 continue;
1957 }
1958
1959 Expression cv;
1960 if (!constants.TryGetValue (name, out cv))
1961 continue;
1962
1963 // Don't let 'const int Foo = Foo;' succeed.
1964 // Removing the name from 'constants' ensures that we get a LocalVariableReference below,
1965 // which in turn causes the 'must be constant' error to be triggered.
1966 constants.Remove (name);
1967
1968 if (!Const.IsConstantTypeValid (variable_type)) {
1969 Const.Error_InvalidConstantType (variable_type, loc, ec.Report);
1970 continue;
1971 }
1972
1973 ec.CurrentBlock = this;
1974 Expression e;
1975 using (ec.With (ResolveContext.Options.ConstantCheckState, (flags & Flags.Unchecked) == 0)) {
1976 e = cv.Resolve (ec);
1977 }
1978 if (e == null)
1979 continue;
1980
1981 Constant ce = e as Constant;
1982 if (ce == null) {
1983 e.Error_ExpressionMustBeConstant (ec, vi.Location, name);
1984 continue;
1985 }
1986
1987 e = ce.ConvertImplicitly (ec, variable_type);
1988 if (e == null) {
1989 if (TypeManager.IsReferenceType (variable_type))
1990 ce.Error_ConstantCanBeInitializedWithNullOnly (ec, variable_type, vi.Location, vi.Name);
1991 else
1992 ce.Error_ValueCannotBeConverted (ec, vi.Location, variable_type, false);
1993 continue;
1994 }
1995
1996 constants.Add (name, e);
1997 vi.IsConstant = true;
1998 }
1999 }
2000
2001 protected void ResolveMeta (BlockContext ec, int offset)
2002 {
2003 Report.Debug (64, "BLOCK RESOLVE META", this, Parent);
2004
2005 // If some parent block was unsafe, we remain unsafe even if this block
2006 // isn't explicitly marked as such.
2007 using (ec.With (ResolveContext.Options.UnsafeScope, ec.IsUnsafe | Unsafe)) {
2008 flags |= Flags.VariablesInitialized;
2009
2010 if (variables != null) {
2011 foreach (LocalInfo li in variables.Values) {
2012 if (!li.Resolve (ec))
2013 continue;
2014 li.VariableInfo = new VariableInfo (li, offset);
2015 offset += li.VariableInfo.Length;
2016 }
2017 }
2018 assignable_slots = offset;
2019
2020 DoResolveConstants (ec);
2021
2022 if (children == null)
2023 return;
2024 foreach (Block b in children)
2025 b.ResolveMeta (ec, offset);
2026 }
2027 }
2028
2029 //
2030 // Emits the local variable declarations for a block
2031 //
2032 public virtual void EmitMeta (EmitContext ec)
2033 {
2034 if (variables != null){
2035 foreach (LocalInfo vi in variables.Values)
2036 vi.ResolveVariable (ec);
2037 }
2038
2039 if (temporary_variables != null) {
2040 for (int i = 0; i < temporary_variables.Count; i++)
2041 ((LocalInfo)temporary_variables[i]).ResolveVariable(ec);
2042 }
2043
2044 if (children != null) {
2045 for (int i = 0; i < children.Count; i++)
2046 ((Block)children[i]).EmitMeta(ec);
2047 }
2048 }
2049
2050 void UsageWarning (BlockContext ec)
2051 {
2052 if (variables == null || ec.Report.WarningLevel < 3)
2053 return;
2054
2055 foreach (var de in variables) {
2056 LocalInfo vi = de.Value;
2057
2058 if (!vi.Used) {
2059 string name = de.Key;
2060
2061 // vi.VariableInfo can be null for 'catch' variables
2062 if (vi.VariableInfo != null && vi.VariableInfo.IsEverAssigned)
2063 ec.Report.Warning (219, 3, vi.Location, "The variable `{0}' is assigned but its value is never used", name);
2064 else
2065 ec.Report.Warning (168, 3, vi.Location, "The variable `{0}' is declared but never used", name);
2066 }
2067 }
2068 }
2069
2070 static void CheckPossibleMistakenEmptyStatement (BlockContext ec, Statement s)
2071 {
2072 Statement body;
2073
2074 // Some statements are wrapped by a Block. Since
2075 // others' internal could be changed, here I treat
2076 // them as possibly wrapped by Block equally.
2077 Block b = s as Block;
2078 if (b != null && b.statements.Count == 1)
2079 s = (Statement) b.statements [0];
2080
2081 if (s is Lock)
2082 body = ((Lock) s).Statement;
2083 else if (s is For)
2084 body = ((For) s).Statement;
2085 else if (s is Foreach)
2086 body = ((Foreach) s).Statement;
2087 else if (s is While)
2088 body = ((While) s).Statement;
2089 else if (s is Fixed)
2090 body = ((Fixed) s).Statement;
2091 else if (s is Using)
2092 body = ((Using) s).EmbeddedStatement;
2093 else if (s is UsingTemporary)
2094 body = ((UsingTemporary) s).Statement;
2095 else
2096 return;
2097
2098 if (body == null || body is EmptyStatement)
2099 ec.Report.Warning (642, 3, s.loc, "Possible mistaken empty statement");
2100 }
2101
2102 public override bool Resolve (BlockContext ec)
2103 {
2104 Block prev_block = ec.CurrentBlock;
2105 bool ok = true;
2106
2107 int errors = ec.Report.Errors;
2108
2109 ec.CurrentBlock = this;
2110 ec.StartFlowBranching (this);
2111
2112 Report.Debug (4, "RESOLVE BLOCK", StartLocation, ec.CurrentBranching);
2113
2114 //
2115 // Compiler generated scope statements
2116 //
2117 if (scope_initializers != null) {
2118 foreach (Statement s in scope_initializers)
2119 s.Resolve (ec);
2120 }
2121
2122 //
2123 // This flag is used to notate nested statements as unreachable from the beginning of this block.
2124 // For the purposes of this resolution, it doesn't matter that the whole block is unreachable
2125 // from the beginning of the function. The outer Resolve() that detected the unreachability is
2126 // responsible for handling the situation.
2127 //
2128 int statement_count = statements.Count;
2129 for (int ix = 0; ix < statement_count; ix++){
2130 Statement s = statements [ix];
2131 // Check possible empty statement (CS0642)
2132 if (ix + 1 < statement_count && ec.Report.WarningLevel >= 3 &&
2133 statements [ix + 1] is ExplicitBlock)
2134 CheckPossibleMistakenEmptyStatement (ec, s);
2135
2136 //
2137 // Warn if we detect unreachable code.
2138 //
2139 if (unreachable) {
2140 if (s is EmptyStatement)
2141 continue;
2142
2143 if (!unreachable_shown && !(s is LabeledStatement)) {
2144 ec.Report.Warning (162, 2, s.loc, "Unreachable code detected");
2145 unreachable_shown = true;
2146 }
2147
2148 Block c_block = s as Block;
2149 if (c_block != null)
2150 c_block.unreachable = c_block.unreachable_shown = true;
2151 }
2152
2153 //
2154 // Note that we're not using ResolveUnreachable() for unreachable
2155 // statements here. ResolveUnreachable() creates a temporary
2156 // flow branching and kills it afterwards. This leads to problems
2157 // if you have two unreachable statements where the first one
2158 // assigns a variable and the second one tries to access it.
2159 //
2160
2161 if (!s.Resolve (ec)) {
2162 ok = false;
2163 if (ec.IsInProbingMode)
2164 break;
2165
2166 statements [ix] = new EmptyStatement (s.loc);
2167 continue;
2168 }
2169
2170 if (unreachable && !(s is LabeledStatement) && !(s is Block))
2171 statements [ix] = new EmptyStatement (s.loc);
2172
2173 unreachable = ec.CurrentBranching.CurrentUsageVector.IsUnreachable;
2174 if (unreachable && s is LabeledStatement)
2175 throw new InternalErrorException ("should not happen");
2176 }
2177
2178 Report.Debug (4, "RESOLVE BLOCK DONE", StartLocation,
2179 ec.CurrentBranching, statement_count);
2180
2181 while (ec.CurrentBranching is FlowBranchingLabeled)
2182 ec.EndFlowBranching ();
2183
2184 bool flow_unreachable = ec.EndFlowBranching ();
2185
2186 ec.CurrentBlock = prev_block;
2187
2188 if (flow_unreachable)
2189 flags |= Flags.HasRet;
2190
2191 // If we're a non-static `struct' constructor which doesn't have an
2192 // initializer, then we must initialize all of the struct's fields.
2193 if (this == Toplevel && !Toplevel.IsThisAssigned (ec) && !flow_unreachable)
2194 ok = false;
2195
2196 if ((labels != null) && (ec.Report.WarningLevel >= 2)) {
2197 foreach (LabeledStatement label in labels.Values)
2198 if (!label.HasBeenReferenced)
2199 ec.Report.Warning (164, 2, label.loc, "This label has not been referenced");
2200 }
2201
2202 if (ok && errors == ec.Report.Errors)
2203 UsageWarning (ec);
2204
2205 return ok;
2206 }
2207
2208 public override bool ResolveUnreachable (BlockContext ec, bool warn)
2209 {
2210 unreachable_shown = true;
2211 unreachable = true;
2212
2213 if (warn)
2214 ec.Report.Warning (162, 2, loc, "Unreachable code detected");
2215
2216 ec.StartFlowBranching (FlowBranching.BranchingType.Block, loc);
2217 bool ok = Resolve (ec);
2218 ec.KillFlowBranching ();
2219
2220 return ok;
2221 }
2222
2223 protected override void DoEmit (EmitContext ec)
2224 {
2225 for (int ix = 0; ix < statements.Count; ix++){
2226 Statement s = (Statement) statements [ix];
2227 s.Emit (ec);
2228 }
2229 }
2230
2231 public override void Emit (EmitContext ec)
2232 {
2233 if (scope_initializers != null)
2234 EmitScopeInitializers (ec);
2235
2236 ec.Mark (StartLocation);
2237 DoEmit (ec);
2238
2239 if (SymbolWriter.HasSymbolWriter)
2240 EmitSymbolInfo (ec);
2241 }
2242
2243 protected void EmitScopeInitializers (EmitContext ec)
2244 {
2245 SymbolWriter.OpenCompilerGeneratedBlock (ec.ig);
2246
2247 using (ec.With (EmitContext.Options.OmitDebugInfo, true)) {
2248 foreach (Statement s in scope_initializers)
2249 s.Emit (ec);
2250 }
2251
2252 SymbolWriter.CloseCompilerGeneratedBlock (ec.ig);
2253 }
2254
2255 protected virtual void EmitSymbolInfo (EmitContext ec)
2256 {
2257 if (variables != null) {
2258 foreach (LocalInfo vi in variables.Values) {
2259 vi.EmitSymbolInfo (ec);
2260 }
2261 }
2262 }
2263
2264 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
2265 {
2266 MutateVariables (storey);
2267
2268 if (scope_initializers != null) {
2269 foreach (Statement s in scope_initializers)
2270 s.MutateHoistedGenericType (storey);
2271 }
2272
2273 foreach (Statement s in statements)
2274 s.MutateHoistedGenericType (storey);
2275 }
2276
2277 void MutateVariables (AnonymousMethodStorey storey)
2278 {
2279 if (variables != null) {
2280 foreach (LocalInfo vi in variables.Values) {
2281 vi.VariableType = storey.MutateType (vi.VariableType);
2282 }
2283 }
2284
2285 if (temporary_variables != null) {
2286 foreach (LocalInfo vi in temporary_variables)
2287 vi.VariableType = storey.MutateType (vi.VariableType);
2288 }
2289 }
2290
2291 public override string ToString ()
2292 {
2293 return String.Format ("{0} ({1}:{2})", GetType (),ID, StartLocation);
2294 }
2295
2296 protected override void CloneTo (CloneContext clonectx, Statement t)
2297 {
2298 Block target = (Block) t;
2299
2300 clonectx.AddBlockMap (this, target);
2301
2302 //target.Toplevel = (ToplevelBlock) clonectx.LookupBlock (Toplevel);
2303 target.Explicit = (ExplicitBlock) clonectx.LookupBlock (Explicit);
2304 if (Parent != null)
2305 target.Parent = clonectx.RemapBlockCopy (Parent);
2306
2307 if (variables != null){
2308 target.variables = new Dictionary<string, LocalInfo> ();
2309
2310 foreach (var de in variables){
2311 LocalInfo newlocal = de.Value.Clone (clonectx);
2312 target.variables [de.Key] = newlocal;
2313 clonectx.AddVariableMap (de.Value, newlocal);
2314 }
2315 }
2316
2317 target.statements = new List<Statement> (statements.Count);
2318 foreach (Statement s in statements)
2319 target.statements.Add (s.Clone (clonectx));
2320
2321 if (target.children != null){
2322 target.children = new List<Block> (children.Count);
2323 foreach (Block b in children){
2324 target.children.Add (clonectx.LookupBlock (b));
2325 }
2326 }
2327
2328 //
2329 // TODO: labels, switch_block, constants (?), anonymous_children
2330 //
2331 }
2332 }
2333
2334 public class ExplicitBlock : Block
2335 {
2336 Dictionary<string, IKnownVariable> known_variables;
2337 protected AnonymousMethodStorey am_storey;
2338
2339 public ExplicitBlock (Block parent, Location start, Location end)
2340 : this (parent, (Flags) 0, start, end)
2341 {
2342 }
2343
2344 public ExplicitBlock (Block parent, Flags flags, Location start, Location end)
2345 : base (parent, flags, start, end)
2346 {
2347 this.Explicit = this;
2348 }
2349
2350 // <summary>
2351 // Marks a variable with name @name as being used in this or a child block.
2352 // If a variable name has been used in a child block, it's illegal to
2353 // declare a variable with the same name in the current block.
2354 // </summary>
2355 internal void AddKnownVariable (string name, IKnownVariable info)
2356 {
2357 if (known_variables == null)
2358 known_variables = new Dictionary<string, IKnownVariable> ();
2359
2360 known_variables [name] = info;
2361
2362 if (Parent != null)
2363 Parent.Explicit.AddKnownVariable (name, info);
2364 }
2365
2366 public AnonymousMethodStorey AnonymousMethodStorey {
2367 get { return am_storey; }
2368 }
2369
2370 //
2371 // Creates anonymous method storey in current block
2372 //
2373 public AnonymousMethodStorey CreateAnonymousMethodStorey (ResolveContext ec)
2374 {
2375 //
2376 // When referencing a variable in iterator storey from children anonymous method
2377 //
2378 if (Toplevel.am_storey is IteratorStorey) {
2379 return Toplevel.am_storey;
2380 }
2381
2382 //
2383 // An iterator has only 1 storey block
2384 //
2385 if (ec.CurrentIterator != null)
2386 return ec.CurrentIterator.Storey;
2387
2388 if (am_storey == null) {
2389 MemberBase mc = ec.MemberContext as MemberBase;
2390 GenericMethod gm = mc == null ? null : mc.GenericMethod;
2391
2392 //
2393 // Creates anonymous method storey for this block
2394 //
2395 am_storey = new AnonymousMethodStorey (this, ec.CurrentTypeDefinition, mc, gm, "AnonStorey");
2396 }
2397
2398 return am_storey;
2399 }
2400
2401 public override void Emit (EmitContext ec)
2402 {
2403 if (am_storey != null)
2404 am_storey.EmitStoreyInstantiation (ec);
2405
2406 bool emit_debug_info = SymbolWriter.HasSymbolWriter && Parent != null && !(am_storey is IteratorStorey);
2407 if (emit_debug_info)
2408 ec.BeginScope ();
2409
2410 base.Emit (ec);
2411
2412 if (emit_debug_info)
2413 ec.EndScope ();
2414 }
2415
2416 public override void EmitMeta (EmitContext ec)
2417 {
2418 //
2419 // Creates anonymous method storey
2420 //
2421 if (am_storey != null) {
2422 if (ec.CurrentAnonymousMethod != null && ec.CurrentAnonymousMethod.Storey != null) {
2423 //
2424 // Creates parent storey reference when hoisted this is accessible
2425 //
2426 if (am_storey.OriginalSourceBlock.Explicit.HasCapturedThis) {
2427 ExplicitBlock parent = Toplevel.Parent.Explicit;
2428
2429 //
2430 // Hoisted this exists in top-level parent storey only
2431 //
2432 while (parent.am_storey == null || parent.am_storey.Parent is AnonymousMethodStorey)
2433 parent = parent.Parent.Explicit;
2434
2435 am_storey.AddParentStoreyReference (parent.am_storey);
2436 }
2437
2438 am_storey.ChangeParentStorey (ec.CurrentAnonymousMethod.Storey);
2439 }
2440
2441 am_storey.DefineType ();
2442 am_storey.ResolveType ();
2443 am_storey.Define ();
2444 am_storey.Parent.PartialContainer.AddCompilerGeneratedClass (am_storey);
2445
2446 var ref_blocks = am_storey.ReferencesFromChildrenBlock;
2447 if (ref_blocks != null) {
2448 foreach (ExplicitBlock ref_block in ref_blocks) {
2449 for (ExplicitBlock b = ref_block.Explicit; b != this; b = b.Parent.Explicit) {
2450 if (b.am_storey != null) {
2451 b.am_storey.AddParentStoreyReference (am_storey);
2452
2453 // Stop propagation inside same top block
2454 if (b.Toplevel == Toplevel)
2455 break;
2456
2457 b = b.Toplevel;
2458 }
2459 b.HasCapturedVariable = true;
2460 }
2461 }
2462 }
2463 }
2464
2465 base.EmitMeta (ec);
2466 }
2467
2468 internal IKnownVariable GetKnownVariable (string name)
2469 {
2470 if (known_variables == null)
2471 return null;
2472
2473 IKnownVariable kw;
2474 if (!known_variables.TryGetValue (name, out kw))
2475 return null;
2476
2477 return kw;
2478 }
2479
2480 public bool HasCapturedThis
2481 {
2482 set { flags = value ? flags | Flags.HasCapturedThis : flags & ~Flags.HasCapturedThis; }
2483 get { return (flags & Flags.HasCapturedThis) != 0; }
2484 }
2485
2486 public bool HasCapturedVariable
2487 {
2488 set { flags = value ? flags | Flags.HasCapturedVariable : flags & ~Flags.HasCapturedVariable; }
2489 get { return (flags & Flags.HasCapturedVariable) != 0; }
2490 }
2491
2492 protected override void CloneTo (CloneContext clonectx, Statement t)
2493 {
2494 ExplicitBlock target = (ExplicitBlock) t;
2495 target.known_variables = null;
2496 base.CloneTo (clonectx, t);
2497 }
2498 }
2499
2500 public class ToplevelParameterInfo : IKnownVariable {
2501 public readonly ToplevelBlock Block;
2502 public readonly int Index;
2503 public VariableInfo VariableInfo;
2504
2505 Block IKnownVariable.Block {
2506 get { return Block; }
2507 }
2508 public Parameter Parameter {
2509 get { return Block.Parameters [Index]; }
2510 }
2511
2512 public Type ParameterType {
2513 get { return Block.Parameters.Types [Index]; }
2514 }
2515
2516 public Location Location {
2517 get { return Parameter.Location; }
2518 }
2519
2520 public ToplevelParameterInfo (ToplevelBlock block, int idx)
2521 {
2522 this.Block = block;
2523 this.Index = idx;
2524 }
2525 }
2526
2527 //
2528 // A toplevel block contains extra information, the split is done
2529 // only to separate information that would otherwise bloat the more
2530 // lightweight Block.
2531 //
2532 // In particular, this was introduced when the support for Anonymous
2533 // Methods was implemented.
2534 //
2535 public class ToplevelBlock : ExplicitBlock
2536 {
2537 //
2538 // Block is converted to an expression
2539 //
2540 sealed class BlockScopeExpression : Expression
2541 {
2542 Expression child;
2543 readonly ToplevelBlock block;
2544
2545 public BlockScopeExpression (Expression child, ToplevelBlock block)
2546 {
2547 this.child = child;
2548 this.block = block;
2549 }
2550
2551 public override Expression CreateExpressionTree (ResolveContext ec)
2552 {
2553 throw new NotSupportedException ();
2554 }
2555
2556 protected override Expression DoResolve (ResolveContext ec)
2557 {
2558 if (child == null)
2559 return null;
2560
2561 child = child.Resolve (ec);
2562 if (child == null)
2563 return null;
2564
2565 eclass = child.eclass;
2566 type = child.Type;
2567 return this;
2568 }
2569
2570 public override void Emit (EmitContext ec)
2571 {
2572 block.EmitMeta (ec);
2573 block.EmitScopeInitializers (ec);
2574 child.Emit (ec);
2575 }
2576
2577 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
2578 {
2579 type = storey.MutateType (type);
2580 child.MutateHoistedGenericType (storey);
2581 block.MutateHoistedGenericType (storey);
2582 }
2583 }
2584
2585 GenericMethod generic;
2586 protected ParametersCompiled parameters;
2587 ToplevelParameterInfo[] parameter_info;
2588 LocalInfo this_variable;
2589 bool resolved;
2590 bool unreachable;
2591 CompilerContext compiler;
2592
2593 public HoistedVariable HoistedThisVariable;
2594
2595 public bool Resolved {
2596 get {
2597 return resolved;
2598 }
2599 }
2600
2601 //
2602 // The parameters for the block.
2603 //
2604 public ParametersCompiled Parameters {
2605 get { return parameters; }
2606 }
2607
2608 public Report Report {
2609 get { return compiler.Report; }
2610 }
2611
2612 public GenericMethod GenericMethod {
2613 get { return generic; }
2614 }
2615
2616 public ToplevelBlock Container {
2617 get { return Parent == null ? null : Parent.Toplevel; }
2618 }
2619
2620 public ToplevelBlock (CompilerContext ctx, Block parent, ParametersCompiled parameters, Location start) :
2621 this (ctx, parent, (Flags) 0, parameters, start)
2622 {
2623 }
2624
2625 public ToplevelBlock (CompilerContext ctx, Block parent, ParametersCompiled parameters, GenericMethod generic, Location start) :
2626 this (ctx, parent, parameters, start)
2627 {
2628 this.generic = generic;
2629 }
2630
2631 public ToplevelBlock (CompilerContext ctx, ParametersCompiled parameters, Location start) :
2632 this (ctx, null, (Flags) 0, parameters, start)
2633 {
2634 }
2635
2636 ToplevelBlock (CompilerContext ctx, Flags flags, ParametersCompiled parameters, Location start) :
2637 this (ctx, null, flags, parameters, start)
2638 {
2639 }
2640
2641 // We use 'Parent' to hook up to the containing block, but don't want to register the current block as a child.
2642 // So, we use a two-stage setup -- first pass a null parent to the base constructor, and then override 'Parent'.
2643 public ToplevelBlock (CompilerContext ctx, Block parent, Flags flags, ParametersCompiled parameters, Location start) :
2644 base (null, flags, start, Location.Null)
2645 {
2646 this.compiler = ctx;
2647 this.Toplevel = this;
2648
2649 this.parameters = parameters;
2650 this.Parent = parent;
2651 if (parent != null)
2652 parent.AddAnonymousChild (this);
2653
2654 if (!this.parameters.IsEmpty)
2655 ProcessParameters ();
2656 }
2657
2658 public ToplevelBlock (CompilerContext ctx, Location loc)
2659 : this (ctx, null, (Flags) 0, ParametersCompiled.EmptyReadOnlyParameters, loc)
2660 {
2661 }
2662
2663 protected override void CloneTo (CloneContext clonectx, Statement t)
2664 {
2665 ToplevelBlock target = (ToplevelBlock) t;
2666 base.CloneTo (clonectx, t);
2667
2668 if (parameters.Count != 0)
2669 target.parameter_info = new ToplevelParameterInfo [parameters.Count];
2670 for (int i = 0; i < parameters.Count; ++i)
2671 target.parameter_info [i] = new ToplevelParameterInfo (target, i);
2672 }
2673
2674 public bool CheckError158 (string name, Location loc)
2675 {
2676 if (AnonymousChildren != null) {
2677 foreach (ToplevelBlock child in AnonymousChildren) {
2678 if (!child.CheckError158 (name, loc))
2679 return false;
2680 }
2681 }
2682
2683 for (ToplevelBlock c = Container; c != null; c = c.Container) {
2684 if (!c.DoCheckError158 (name, loc))
2685 return false;
2686 }
2687
2688 return true;
2689 }
2690
2691 void ProcessParameters ()
2692 {
2693 int n = parameters.Count;
2694 parameter_info = new ToplevelParameterInfo [n];
2695 ToplevelBlock top_parent = Parent == null ? null : Parent.Toplevel;
2696 for (int i = 0; i < n; ++i) {
2697 parameter_info [i] = new ToplevelParameterInfo (this, i);
2698
2699 Parameter p = parameters [i];
2700 if (p == null)
2701 continue;
2702
2703 string name = p.Name;
2704 if (CheckParentConflictName (top_parent, name, loc))
2705 AddKnownVariable (name, parameter_info [i]);
2706 }
2707
2708 // mark this block as "used" so that we create local declarations in a sub-block
2709 // FIXME: This appears to uncover a lot of bugs
2710 //this.Use ();
2711 }
2712
2713 bool DoCheckError158 (string name, Location loc)
2714 {
2715 LabeledStatement s = LookupLabel (name);
2716 if (s != null) {
2717 Report.SymbolRelatedToPreviousError (s.loc, s.Name);
2718 Error_158 (name, loc);
2719 return false;
2720 }
2721
2722 return true;
2723 }
2724
2725 public override Expression CreateExpressionTree (ResolveContext ec)
2726 {
2727 if (statements.Count == 1) {
2728 Expression expr = ((Statement) statements[0]).CreateExpressionTree (ec);
2729 if (scope_initializers != null)
2730 expr = new BlockScopeExpression (expr, this);
2731
2732 return expr;
2733 }
2734
2735 return base.CreateExpressionTree (ec);
2736 }
2737
2738 //
2739 // Reformats this block to be top-level iterator block
2740 //
2741 public IteratorStorey ChangeToIterator (Iterator iterator, ToplevelBlock source)
2742 {
2743 IsIterator = true;
2744
2745 // Creates block with original statements
2746 AddStatement (new IteratorStatement (iterator, new Block (this, source)));
2747
2748 source.statements = new List<Statement> (1);
2749 source.AddStatement (new Return (iterator, iterator.Location));
2750 source.IsIterator = false;
2751
2752 IteratorStorey iterator_storey = new IteratorStorey (iterator);
2753 source.am_storey = iterator_storey;
2754 return iterator_storey;
2755 }
2756
2757 //
2758 // Returns a parameter reference expression for the given name,
2759 // or null if there is no such parameter
2760 //
2761 public Expression GetParameterReference (string name, Location loc)
2762 {
2763 for (ToplevelBlock t = this; t != null; t = t.Container) {
2764 Expression expr = t.GetParameterReferenceExpression (name, loc);
2765 if (expr != null)
2766 return expr;
2767 }
2768
2769 return null;
2770 }
2771
2772 protected virtual Expression GetParameterReferenceExpression (string name, Location loc)
2773 {
2774 int idx = parameters.GetParameterIndexByName (name);
2775 return idx < 0 ?
2776 null : new ParameterReference (parameter_info [idx], loc);
2777 }
2778
2779 // <summary>
2780 // Returns the "this" instance variable of this block.
2781 // See AddThisVariable() for more information.
2782 // </summary>
2783 public LocalInfo ThisVariable {
2784 get { return this_variable; }
2785 }
2786
2787 // <summary>
2788 // This is used by non-static `struct' constructors which do not have an
2789 // initializer - in this case, the constructor must initialize all of the
2790 // struct's fields. To do this, we add a "this" variable and use the flow
2791 // analysis code to ensure that it's been fully initialized before control
2792 // leaves the constructor.
2793 // </summary>
2794 public LocalInfo AddThisVariable (DeclSpace ds, Location l)
2795 {
2796 if (this_variable == null) {
2797 this_variable = new LocalInfo (ds, this, l);
2798 this_variable.Used = true;
2799 this_variable.IsThis = true;
2800
2801 Variables.Add ("this", this_variable);
2802 }
2803
2804 return this_variable;
2805 }
2806
2807 public bool IsIterator {
2808 get { return (flags & Flags.IsIterator) != 0; }
2809 set { flags = value ? flags | Flags.IsIterator : flags & ~Flags.IsIterator; }
2810 }
2811
2812 //
2813 // Block has been converted to expression tree
2814 //
2815 public bool IsExpressionTree {
2816 get { return (flags & Flags.IsExpressionTree) != 0; }
2817 }
2818
2819 public bool IsThisAssigned (BlockContext ec)
2820 {
2821 return this_variable == null || this_variable.IsThisAssigned (ec, this);
2822 }
2823
2824 public bool Resolve (FlowBranching parent, BlockContext rc, ParametersCompiled ip, IMethodData md)
2825 {
2826 if (resolved)
2827 return true;
2828
2829 resolved = true;
2830
2831 if (rc.HasSet (ResolveContext.Options.ExpressionTreeConversion))
2832 flags |= Flags.IsExpressionTree;
2833
2834 try {
2835 if (!ResolveMeta (rc, ip))
2836 return false;
2837
2838 using (rc.With (ResolveContext.Options.DoFlowAnalysis, true)) {
2839 FlowBranchingToplevel top_level = rc.StartFlowBranching (this, parent);
2840
2841 if (!Resolve (rc))
2842 return false;
2843
2844 unreachable = top_level.End ();
2845 }
2846 } catch (Exception) {
2847 #if PRODUCTION
2848 if (rc.CurrentBlock != null) {
2849 ec.Report.Error (584, rc.CurrentBlock.StartLocation, "Internal compiler error: Phase Resolve");
2850 } else {
2851 ec.Report.Error (587, "Internal compiler error: Phase Resolve");
2852 }
2853 #endif
2854 throw;
2855 }
2856
2857 if (rc.ReturnType != TypeManager.void_type && !unreachable) {
2858 if (rc.CurrentAnonymousMethod == null) {
2859 rc.Report.Error (161, md.Location, "`{0}': not all code paths return a value", md.GetSignatureForError ());
2860 return false;
2861 } else if (!rc.CurrentAnonymousMethod.IsIterator) {
2862 rc.Report.Error (1643, rc.CurrentAnonymousMethod.Location, "Not all code paths return a value in anonymous method of type `{0}'",
2863 rc.CurrentAnonymousMethod.GetSignatureForError ());
2864 return false;
2865 }
2866 }
2867
2868 return true;
2869 }
2870
2871 bool ResolveMeta (BlockContext ec, ParametersCompiled ip)
2872 {
2873 int errors = ec.Report.Errors;
2874 int orig_count = parameters.Count;
2875
2876 if (ip != null)
2877 parameters = ip;
2878
2879 // Assert: orig_count != parameter.Count => orig_count == 0
2880 if (orig_count != 0 && orig_count != parameters.Count)
2881 throw new InternalErrorException ("parameter information mismatch");
2882
2883 int offset = Parent == null ? 0 : Parent.AssignableSlots;
2884
2885 for (int i = 0; i < orig_count; ++i) {
2886 Parameter.Modifier mod = parameters.FixedParameters [i].ModFlags;
2887
2888 if ((mod & Parameter.Modifier.OUT) != Parameter.Modifier.OUT)
2889 continue;
2890
2891 VariableInfo vi = new VariableInfo (ip, i, offset);
2892 parameter_info [i].VariableInfo = vi;
2893 offset += vi.Length;
2894 }
2895
2896 ResolveMeta (ec, offset);
2897
2898 return ec.Report.Errors == errors;
2899 }
2900
2901 // <summary>
2902 // Check whether all `out' parameters have been assigned.
2903 // </summary>
2904 public void CheckOutParameters (FlowBranching.UsageVector vector, Location loc)
2905 {
2906 if (vector.IsUnreachable)
2907 return;
2908
2909 int n = parameter_info == null ? 0 : parameter_info.Length;
2910
2911 for (int i = 0; i < n; i++) {
2912 VariableInfo var = parameter_info [i].VariableInfo;
2913
2914 if (var == null)
2915 continue;
2916
2917 if (vector.IsAssigned (var, false))
2918 continue;
2919
2920 Report.Error (177, loc, "The out parameter `{0}' must be assigned to before control leaves the current method",
2921 var.Name);
2922 }
2923 }
2924
2925 public override void Emit (EmitContext ec)
2926 {
2927 if (Report.Errors > 0)
2928 return;
2929
2930 #if PRODUCTION
2931 try {
2932 #endif
2933 EmitMeta (ec);
2934
2935 if (ec.HasReturnLabel)
2936 ec.ReturnLabel = ec.ig.DefineLabel ();
2937
2938 base.Emit (ec);
2939
2940 ec.Mark (EndLocation);
2941
2942 if (ec.HasReturnLabel)
2943 ec.ig.MarkLabel (ec.ReturnLabel);
2944
2945 if (ec.return_value != null) {
2946 ec.ig.Emit (OpCodes.Ldloc, ec.return_value);
2947 ec.ig.Emit (OpCodes.Ret);
2948 } else {
2949 //
2950 // If `HasReturnLabel' is set, then we already emitted a
2951 // jump to the end of the method, so we must emit a `ret'
2952 // there.
2953 //
2954 // Unfortunately, System.Reflection.Emit automatically emits
2955 // a leave to the end of a finally block. This is a problem
2956 // if no code is following the try/finally block since we may
2957 // jump to a point after the end of the method.
2958 // As a workaround, we're always creating a return label in
2959 // this case.
2960 //
2961
2962 if (ec.HasReturnLabel || !unreachable) {
2963 if (ec.ReturnType != TypeManager.void_type)
2964 ec.ig.Emit (OpCodes.Ldloc, ec.TemporaryReturn ());
2965 ec.ig.Emit (OpCodes.Ret);
2966 }
2967 }
2968
2969 #if PRODUCTION
2970 } catch (Exception e){
2971 Console.WriteLine ("Exception caught by the compiler while emitting:");
2972 Console.WriteLine (" Block that caused the problem begin at: " + block.loc);
2973
2974 Console.WriteLine (e.GetType ().FullName + ": " + e.Message);
2975 throw;
2976 }
2977 #endif
2978 }
2979
2980 public override void EmitMeta (EmitContext ec)
2981 {
2982 parameters.ResolveVariable ();
2983
2984 // Avoid declaring an IL variable for this_variable since it is not accessed
2985 // from the generated IL
2986 if (this_variable != null)
2987 Variables.Remove ("this");
2988 base.EmitMeta (ec);
2989 }
2990
2991 protected override void EmitSymbolInfo (EmitContext ec)
2992 {
2993 AnonymousExpression ae = ec.CurrentAnonymousMethod;
2994 if ((ae != null) && (ae.Storey != null))
2995 SymbolWriter.DefineScopeVariable (ae.Storey.ID);
2996
2997 base.EmitSymbolInfo (ec);
2998 }
2999 }
3000
3001 public class SwitchLabel {
3002 Expression label;
3003 object converted;
3004 Location loc;
3005
3006 Label il_label;
3007 bool il_label_set;
3008 Label il_label_code;
3009 bool il_label_code_set;
3010
3011 public static readonly object NullStringCase = new object ();
3012
3013 //
3014 // if expr == null, then it is the default case.
3015 //
3016 public SwitchLabel (Expression expr, Location l)
3017 {
3018 label = expr;
3019 loc = l;
3020 }
3021
3022 public Expression Label {
3023 get {
3024 return label;
3025 }
3026 }
3027
3028 public Location Location {
3029 get { return loc; }
3030 }
3031
3032 public object Converted {
3033 get {
3034 return converted;
3035 }
3036 }
3037
3038 public Label GetILLabel (EmitContext ec)
3039 {
3040 if (!il_label_set){
3041 il_label = ec.ig.DefineLabel ();
3042 il_label_set = true;
3043 }
3044 return il_label;
3045 }
3046
3047 public Label GetILLabelCode (EmitContext ec)
3048 {
3049 if (!il_label_code_set){
3050 il_label_code = ec.ig.DefineLabel ();
3051 il_label_code_set = true;
3052 }
3053 return il_label_code;
3054 }
3055
3056 //
3057 // Resolves the expression, reduces it to a literal if possible
3058 // and then converts it to the requested type.
3059 //
3060 public bool ResolveAndReduce (ResolveContext ec, Type required_type, bool allow_nullable)
3061 {
3062 Expression e = label.Resolve (ec);
3063
3064 if (e == null)
3065 return false;
3066
3067 Constant c = e as Constant;
3068 if (c == null){
3069 ec.Report.Error (150, loc, "A constant value is expected");
3070 return false;
3071 }
3072
3073 if (required_type == TypeManager.string_type && c.GetValue () == null) {
3074 converted = NullStringCase;
3075 return true;
3076 }
3077
3078 if (allow_nullable && c.GetValue () == null) {
3079 converted = NullStringCase;
3080 return true;
3081 }
3082
3083 c = c.ImplicitConversionRequired (ec, required_type, loc);
3084 if (c == null)
3085 return false;
3086
3087 converted = c.GetValue ();
3088 return true;
3089 }
3090
3091 public void Error_AlreadyOccurs (ResolveContext ec, Type switch_type, SwitchLabel collision_with)
3092 {
3093 string label;
3094 if (converted == null)
3095 label = "default";
3096 else if (converted == NullStringCase)
3097 label = "null";
3098 else
3099 label = converted.ToString ();
3100
3101 ec.Report.SymbolRelatedToPreviousError (collision_with.loc, null);
3102 ec.Report.Error (152, loc, "The label `case {0}:' already occurs in this switch statement", label);
3103 }
3104
3105 public SwitchLabel Clone (CloneContext clonectx)
3106 {
3107 return new SwitchLabel (label.Clone (clonectx), loc);
3108 }
3109 }
3110
3111 public class SwitchSection {
3112 // An array of SwitchLabels.
3113 public readonly List<SwitchLabel> Labels;
3114 public readonly Block Block;
3115
3116 public SwitchSection (List<SwitchLabel> labels, Block block)
3117 {
3118 Labels = labels;
3119 Block = block;
3120 }
3121
3122 public SwitchSection Clone (CloneContext clonectx)
3123 {
3124 var cloned_labels = new List<SwitchLabel> ();
3125
3126 foreach (SwitchLabel sl in cloned_labels)
3127 cloned_labels.Add (sl.Clone (clonectx));
3128
3129 return new SwitchSection (cloned_labels, clonectx.LookupBlock (Block));
3130 }
3131 }
3132
3133 public class Switch : Statement {
3134 public List<SwitchSection> Sections;
3135 public Expression Expr;
3136
3137 /// <summary>
3138 /// Maps constants whose type type SwitchType to their SwitchLabels.
3139 /// </summary>
3140 public IDictionary<object, SwitchLabel> Elements;
3141
3142 /// <summary>
3143 /// The governing switch type
3144 /// </summary>
3145 public Type SwitchType;
3146
3147 //
3148 // Computed
3149 //
3150 Label default_target;
3151 Label null_target;
3152 Expression new_expr;
3153 bool is_constant;
3154 bool has_null_case;
3155 SwitchSection constant_section;
3156 SwitchSection default_section;
3157
3158 ExpressionStatement string_dictionary;
3159 FieldExpr switch_cache_field;
3160 static int unique_counter;
3161
3162 //
3163 // Nullable Types support
3164 //
3165 Nullable.Unwrap unwrap;
3166
3167 protected bool HaveUnwrap {
3168 get { return unwrap != null; }
3169 }
3170
3171 //
3172 // The types allowed to be implicitly cast from
3173 // on the governing type
3174 //
3175 static Type [] allowed_types;
3176
3177 public Switch (Expression e, List<SwitchSection> sects, Location l)
3178 {
3179 Expr = e;
3180 Sections = sects;
3181 loc = l;
3182 }
3183
3184 public bool GotDefault {
3185 get {
3186 return default_section != null;
3187 }
3188 }
3189
3190 public Label DefaultTarget {
3191 get {
3192 return default_target;
3193 }
3194 }
3195
3196 //
3197 // Determines the governing type for a switch. The returned
3198 // expression might be the expression from the switch, or an
3199 // expression that includes any potential conversions to the
3200 // integral types or to string.
3201 //
3202 Expression SwitchGoverningType (ResolveContext ec, Expression expr)
3203 {
3204 Type t = expr.Type;
3205
3206 if (t == TypeManager.byte_type ||
3207 t == TypeManager.sbyte_type ||
3208 t == TypeManager.ushort_type ||
3209 t == TypeManager.short_type ||
3210 t == TypeManager.uint32_type ||
3211 t == TypeManager.int32_type ||
3212 t == TypeManager.uint64_type ||
3213 t == TypeManager.int64_type ||
3214 t == TypeManager.char_type ||
3215 t == TypeManager.string_type ||
3216 t == TypeManager.bool_type ||
3217 TypeManager.IsEnumType (t))
3218 return expr;
3219
3220 if (allowed_types == null){
3221 allowed_types = new Type [] {
3222 TypeManager.sbyte_type,
3223 TypeManager.byte_type,
3224 TypeManager.short_type,
3225 TypeManager.ushort_type,
3226 TypeManager.int32_type,
3227 TypeManager.uint32_type,
3228 TypeManager.int64_type,
3229 TypeManager.uint64_type,
3230 TypeManager.char_type,
3231 TypeManager.string_type
3232 };
3233 }
3234
3235 //
3236 // Try to find a *user* defined implicit conversion.
3237 //
3238 // If there is no implicit conversion, or if there are multiple
3239 // conversions, we have to report an error
3240 //
3241 Expression converted = null;
3242 foreach (Type tt in allowed_types){
3243 Expression e;
3244
3245 e = Convert.ImplicitUserConversion (ec, expr, tt, loc);
3246 if (e == null)
3247 continue;
3248
3249 //
3250 // Ignore over-worked ImplicitUserConversions that do
3251 // an implicit conversion in addition to the user conversion.
3252 //
3253 if (!(e is UserCast))
3254 continue;
3255
3256 if (converted != null){
3257 ec.Report.ExtraInformation (loc, "(Ambiguous implicit user defined conversion in previous ");
3258 return null;
3259 }
3260
3261 converted = e;
3262 }
3263 return converted;
3264 }
3265
3266 //
3267 // Performs the basic sanity checks on the switch statement
3268 // (looks for duplicate keys and non-constant expressions).
3269 //
3270 // It also returns a hashtable with the keys that we will later
3271 // use to compute the switch tables
3272 //
3273 bool CheckSwitch (ResolveContext ec)
3274 {
3275 bool error = false;
3276 Elements = new Dictionary<object, SwitchLabel> ();
3277
3278 foreach (SwitchSection ss in Sections){
3279 foreach (SwitchLabel sl in ss.Labels){
3280 if (sl.Label == null){
3281 if (default_section != null){
3282 sl.Error_AlreadyOccurs (ec, SwitchType, (SwitchLabel)default_section.Labels [0]);
3283 error = true;
3284 }
3285 default_section = ss;
3286 continue;
3287 }
3288
3289 if (!sl.ResolveAndReduce (ec, SwitchType, HaveUnwrap)) {
3290 error = true;
3291 continue;
3292 }
3293
3294 object key = sl.Converted;
3295 if (key == SwitchLabel.NullStringCase)
3296 has_null_case = true;
3297
3298 try {
3299 Elements.Add (key, sl);
3300 } catch (ArgumentException) {
3301 sl.Error_AlreadyOccurs (ec, SwitchType, Elements [key]);
3302 error = true;
3303 }
3304 }
3305 }
3306 return !error;
3307 }
3308
3309 void EmitObjectInteger (ILGenerator ig, object k)
3310 {
3311 if (k is int)
3312 IntConstant.EmitInt (ig, (int) k);
3313 else if (k is Constant) {
3314 EmitObjectInteger (ig, ((Constant) k).GetValue ());
3315 }
3316 else if (k is uint)
3317 IntConstant.EmitInt (ig, unchecked ((int) (uint) k));
3318 else if (k is long)
3319 {
3320 if ((long) k >= int.MinValue && (long) k <= int.MaxValue)
3321 {
3322 IntConstant.EmitInt (ig, (int) (long) k);
3323 ig.Emit (OpCodes.Conv_I8);
3324 }
3325 else
3326 LongConstant.EmitLong (ig, (long) k);
3327 }
3328 else if (k is ulong)
3329 {
3330 ulong ul = (ulong) k;
3331 if (ul < (1L<<32))
3332 {
3333 IntConstant.EmitInt (ig, unchecked ((int) ul));
3334 ig.Emit (OpCodes.Conv_U8);
3335 }
3336 else
3337 {
3338 LongConstant.EmitLong (ig, unchecked ((long) ul));
3339 }
3340 }
3341 else if (k is char)
3342 IntConstant.EmitInt (ig, (int) ((char) k));
3343 else if (k is sbyte)
3344 IntConstant.EmitInt (ig, (int) ((sbyte) k));
3345 else if (k is byte)
3346 IntConstant.EmitInt (ig, (int) ((byte) k));
3347 else if (k is short)
3348 IntConstant.EmitInt (ig, (int) ((short) k));
3349 else if (k is ushort)
3350 IntConstant.EmitInt (ig, (int) ((ushort) k));
3351 else if (k is bool)
3352 IntConstant.EmitInt (ig, ((bool) k) ? 1 : 0);
3353 else
3354 throw new Exception ("Unhandled case");
3355 }
3356
3357 // structure used to hold blocks of keys while calculating table switch
3358 class KeyBlock : IComparable
3359 {
3360 public KeyBlock (long _first)
3361 {
3362 first = last = _first;
3363 }
3364 public long first;
3365 public long last;
3366 public List<object> element_keys;
3367 // how many items are in the bucket
3368 public int Size = 1;
3369 public int Length
3370 {
3371 get { return (int) (last - first + 1); }
3372 }
3373 public static long TotalLength (KeyBlock kb_first, KeyBlock kb_last)
3374 {
3375 return kb_last.last - kb_first.first + 1;
3376 }
3377 public int CompareTo (object obj)
3378 {
3379 KeyBlock kb = (KeyBlock) obj;
3380 int nLength = Length;
3381 int nLengthOther = kb.Length;
3382 if (nLengthOther == nLength)
3383 return (int) (kb.first - first);
3384 return nLength - nLengthOther;
3385 }
3386 }
3387
3388 /// <summary>
3389 /// This method emits code for a lookup-based switch statement (non-string)
3390 /// Basically it groups the cases into blocks that are at least half full,
3391 /// and then spits out individual lookup opcodes for each block.
3392 /// It emits the longest blocks first, and short blocks are just
3393 /// handled with direct compares.
3394 /// </summary>
3395 /// <param name="ec"></param>
3396 /// <param name="val"></param>
3397 /// <returns></returns>
3398 void TableSwitchEmit (EmitContext ec, Expression val)
3399 {
3400 int element_count = Elements.Count;
3401 object [] element_keys = new object [element_count];
3402 Elements.Keys.CopyTo (element_keys, 0);
3403 Array.Sort (element_keys);
3404
3405 // initialize the block list with one element per key
3406 var key_blocks = new List<KeyBlock> (element_count);
3407 foreach (object key in element_keys)
3408 key_blocks.Add (new KeyBlock (System.Convert.ToInt64 (key)));
3409
3410 KeyBlock current_kb;
3411 // iteratively merge the blocks while they are at least half full
3412 // there's probably a really cool way to do this with a tree...
3413 while (key_blocks.Count > 1)
3414 {
3415 var key_blocks_new = new List<KeyBlock> ();
3416 current_kb = (KeyBlock) key_blocks [0];
3417 for (int ikb = 1; ikb < key_blocks.Count; ikb++)
3418 {
3419 KeyBlock kb = (KeyBlock) key_blocks [ikb];
3420 if ((current_kb.Size + kb.Size) * 2 >= KeyBlock.TotalLength (current_kb, kb))
3421 {
3422 // merge blocks
3423 current_kb.last = kb.last;
3424 current_kb.Size += kb.Size;
3425 }
3426 else
3427 {
3428 // start a new block
3429 key_blocks_new.Add (current_kb);
3430 current_kb = kb;
3431 }
3432 }
3433 key_blocks_new.Add (current_kb);
3434 if (key_blocks.Count == key_blocks_new.Count)
3435 break;
3436 key_blocks = key_blocks_new;
3437 }
3438
3439 // initialize the key lists
3440 foreach (KeyBlock kb in key_blocks)
3441 kb.element_keys = new List<object> ();
3442
3443 // fill the key lists
3444 int iBlockCurr = 0;
3445 if (key_blocks.Count > 0) {
3446 current_kb = (KeyBlock) key_blocks [0];
3447 foreach (object key in element_keys)
3448 {
3449 bool next_block = (key is UInt64) ? (ulong) key > (ulong) current_kb.last :
3450 System.Convert.ToInt64 (key) > current_kb.last;
3451 if (next_block)
3452 current_kb = (KeyBlock) key_blocks [++iBlockCurr];
3453 current_kb.element_keys.Add (key);
3454 }
3455 }
3456
3457 // sort the blocks so we can tackle the largest ones first
3458 key_blocks.Sort ();
3459
3460 // okay now we can start...
3461 ILGenerator ig = ec.ig;
3462 Label lbl_end = ig.DefineLabel (); // at the end ;-)
3463 Label lbl_default = default_target;
3464
3465 Type type_keys = null;
3466 if (element_keys.Length > 0)
3467 type_keys = element_keys [0].GetType (); // used for conversions
3468
3469 Type compare_type;
3470
3471 if (TypeManager.IsEnumType (SwitchType))
3472 compare_type = TypeManager.GetEnumUnderlyingType (SwitchType);
3473 else
3474 compare_type = SwitchType;
3475
3476 for (int iBlock = key_blocks.Count - 1; iBlock >= 0; --iBlock)
3477 {
3478 KeyBlock kb = ((KeyBlock) key_blocks [iBlock]);
3479 lbl_default = (iBlock == 0) ? default_target : ig.DefineLabel ();
3480 if (kb.Length <= 2)
3481 {
3482 foreach (object key in kb.element_keys) {
3483 SwitchLabel sl = (SwitchLabel) Elements [key];
3484 if (key is int && (int) key == 0) {
3485 val.EmitBranchable (ec, sl.GetILLabel (ec), false);
3486 } else {
3487 val.Emit (ec);
3488 EmitObjectInteger (ig, key);
3489 ig.Emit (OpCodes.Beq, sl.GetILLabel (ec));
3490 }
3491 }
3492 }
3493 else
3494 {
3495 // TODO: if all the keys in the block are the same and there are
3496 // no gaps/defaults then just use a range-check.
3497 if (compare_type == TypeManager.int64_type ||
3498 compare_type == TypeManager.uint64_type)
3499 {
3500 // TODO: optimize constant/I4 cases
3501
3502 // check block range (could be > 2^31)
3503 val.Emit (ec);
3504 EmitObjectInteger (ig, System.Convert.ChangeType (kb.first, type_keys));
3505 ig.Emit (OpCodes.Blt, lbl_default);
3506 val.Emit (ec);
3507 EmitObjectInteger (ig, System.Convert.ChangeType (kb.last, type_keys));
3508 ig.Emit (OpCodes.Bgt, lbl_default);
3509
3510 // normalize range
3511 val.Emit (ec);
3512 if (kb.first != 0)
3513 {
3514 EmitObjectInteger (ig, System.Convert.ChangeType (kb.first, type_keys));
3515 ig.Emit (OpCodes.Sub);
3516 }
3517 ig.Emit (OpCodes.Conv_I4); // assumes < 2^31 labels!
3518 }
3519 else
3520 {
3521 // normalize range
3522 val.Emit (ec);
3523 int first = (int) kb.first;
3524 if (first > 0)
3525 {
3526 IntConstant.EmitInt (ig, first);
3527 ig.Emit (OpCodes.Sub);
3528 }
3529 else if (first < 0)
3530 {
3531 IntConstant.EmitInt (ig, -first);
3532 ig.Emit (OpCodes.Add);
3533 }
3534 }
3535
3536 // first, build the list of labels for the switch
3537 int iKey = 0;
3538 int cJumps = kb.Length;
3539 Label [] switch_labels = new Label [cJumps];
3540 for (int iJump = 0; iJump < cJumps; iJump++)
3541 {
3542 object key = kb.element_keys [iKey];
3543 if (System.Convert.ToInt64 (key) == kb.first + iJump)
3544 {
3545 SwitchLabel sl = (SwitchLabel) Elements [key];
3546 switch_labels [iJump] = sl.GetILLabel (ec);
3547 iKey++;
3548 }
3549 else
3550 switch_labels [iJump] = lbl_default;
3551 }
3552 // emit the switch opcode
3553 ig.Emit (OpCodes.Switch, switch_labels);
3554 }
3555
3556 // mark the default for this block
3557 if (iBlock != 0)
3558 ig.MarkLabel (lbl_default);
3559 }
3560
3561 // TODO: find the default case and emit it here,
3562 // to prevent having to do the following jump.
3563 // make sure to mark other labels in the default section
3564
3565 // the last default just goes to the end
3566 if (element_keys.Length > 0)
3567 ig.Emit (OpCodes.Br, lbl_default);
3568
3569 // now emit the code for the sections
3570 bool found_default = false;
3571
3572 foreach (SwitchSection ss in Sections) {
3573 foreach (SwitchLabel sl in ss.Labels) {
3574 if (sl.Converted == SwitchLabel.NullStringCase) {
3575 ig.MarkLabel (null_target);
3576 } else if (sl.Label == null) {
3577 ig.MarkLabel (lbl_default);
3578 found_default = true;
3579 if (!has_null_case)
3580 ig.MarkLabel (null_target);
3581 }
3582 ig.MarkLabel (sl.GetILLabel (ec));
3583 ig.MarkLabel (sl.GetILLabelCode (ec));
3584 }
3585 ss.Block.Emit (ec);
3586 }
3587
3588 if (!found_default) {
3589 ig.MarkLabel (lbl_default);
3590 if (!has_null_case) {
3591 ig.MarkLabel (null_target);
3592 }
3593 }
3594
3595 ig.MarkLabel (lbl_end);
3596 }
3597
3598 SwitchSection FindSection (SwitchLabel label)
3599 {
3600 foreach (SwitchSection ss in Sections){
3601 foreach (SwitchLabel sl in ss.Labels){
3602 if (label == sl)
3603 return ss;
3604 }
3605 }
3606
3607 return null;
3608 }
3609
3610 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
3611 {
3612 foreach (SwitchSection ss in Sections)
3613 ss.Block.MutateHoistedGenericType (storey);
3614 }
3615
3616 public static void Reset ()
3617 {
3618 unique_counter = 0;
3619 allowed_types = null;
3620 }
3621
3622 public override bool Resolve (BlockContext ec)
3623 {
3624 Expr = Expr.Resolve (ec);
3625 if (Expr == null)
3626 return false;
3627
3628 new_expr = SwitchGoverningType (ec, Expr);
3629
3630 if ((new_expr == null) && TypeManager.IsNullableType (Expr.Type)) {
3631 unwrap = Nullable.Unwrap.Create (Expr, false);
3632 if (unwrap == null)
3633 return false;
3634
3635 new_expr = SwitchGoverningType (ec, unwrap);
3636 }
3637
3638 if (new_expr == null){
3639 ec.Report.Error (151, loc,
3640 "A switch expression of type `{0}' cannot be converted to an integral type, bool, char, string, enum or nullable type",
3641 TypeManager.CSharpName (Expr.Type));
3642 return false;
3643 }
3644
3645 // Validate switch.
3646 SwitchType = new_expr.Type;
3647
3648 if (RootContext.Version == LanguageVersion.ISO_1 && SwitchType == TypeManager.bool_type) {
3649 ec.Report.FeatureIsNotAvailable (loc, "switch expression of boolean type");
3650 return false;
3651 }
3652
3653 if (!CheckSwitch (ec))
3654 return false;
3655
3656 if (HaveUnwrap)
3657 Elements.Remove (SwitchLabel.NullStringCase);
3658
3659 Switch old_switch = ec.Switch;
3660 ec.Switch = this;
3661 ec.Switch.SwitchType = SwitchType;
3662
3663 Report.Debug (1, "START OF SWITCH BLOCK", loc, ec.CurrentBranching);
3664 ec.StartFlowBranching (FlowBranching.BranchingType.Switch, loc);
3665
3666 var constant = new_expr as Constant;
3667 if (constant != null) {
3668 is_constant = true;
3669 object key = constant.GetValue ();
3670 SwitchLabel label;
3671 if (Elements.TryGetValue (key, out label))
3672 constant_section = FindSection (label);
3673
3674 if (constant_section == null)
3675 constant_section = default_section;
3676 }
3677
3678 bool first = true;
3679 bool ok = true;
3680 foreach (SwitchSection ss in Sections){
3681 if (!first)
3682 ec.CurrentBranching.CreateSibling (
3683 null, FlowBranching.SiblingType.SwitchSection);
3684 else
3685 first = false;
3686
3687 if (is_constant && (ss != constant_section)) {
3688 // If we're a constant switch, we're only emitting
3689 // one single section - mark all the others as
3690 // unreachable.
3691 ec.CurrentBranching.CurrentUsageVector.Goto ();
3692 if (!ss.Block.ResolveUnreachable (ec, true)) {
3693 ok = false;
3694 }
3695 } else {
3696 if (!ss.Block.Resolve (ec))
3697 ok = false;
3698 }
3699 }
3700
3701 if (default_section == null)
3702 ec.CurrentBranching.CreateSibling (
3703 null, FlowBranching.SiblingType.SwitchSection);
3704
3705 ec.EndFlowBranching ();
3706 ec.Switch = old_switch;
3707
3708 Report.Debug (1, "END OF SWITCH BLOCK", loc, ec.CurrentBranching);
3709
3710 if (!ok)
3711 return false;
3712
3713 if (SwitchType == TypeManager.string_type && !is_constant) {
3714 // TODO: Optimize single case, and single+default case
3715 ResolveStringSwitchMap (ec);
3716 }
3717
3718 return true;
3719 }
3720
3721 void ResolveStringSwitchMap (ResolveContext ec)
3722 {
3723 FullNamedExpression string_dictionary_type;
3724 if (TypeManager.generic_ienumerable_type != null) {
3725 MemberAccess system_collections_generic = new MemberAccess (new MemberAccess (
3726 new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Collections", loc), "Generic", loc);
3727
3728 string_dictionary_type = new MemberAccess (system_collections_generic, "Dictionary",
3729 new TypeArguments (
3730 new TypeExpression (TypeManager.string_type, loc),
3731 new TypeExpression (TypeManager.int32_type, loc)), loc);
3732 } else {
3733 MemberAccess system_collections_generic = new MemberAccess (
3734 new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Collections", loc);
3735
3736 string_dictionary_type = new MemberAccess (system_collections_generic, "Hashtable", loc);
3737 }
3738
3739 Field field = new Field (ec.CurrentTypeDefinition, string_dictionary_type,
3740 Modifiers.STATIC | Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED,
3741 new MemberName (CompilerGeneratedClass.MakeName (null, "f", "switch$map", unique_counter++), loc), null);
3742 if (!field.Define ())
3743 return;
3744 ec.CurrentTypeDefinition.PartialContainer.AddField (field);
3745
3746 var init = new List<Expression> ();
3747 int counter = 0;
3748 Elements.Clear ();
3749 string value = null;
3750 foreach (SwitchSection section in Sections) {
3751 int last_count = init.Count;
3752 foreach (SwitchLabel sl in section.Labels) {
3753 if (sl.Label == null || sl.Converted == SwitchLabel.NullStringCase)
3754 continue;
3755
3756 value = (string) sl.Converted;
3757 var init_args = new List<Expression> (2);
3758 init_args.Add (new StringLiteral (value, sl.Location));
3759 init_args.Add (new IntConstant (counter, loc));
3760 init.Add (new CollectionElementInitializer (init_args, loc));
3761 }
3762
3763 //
3764 // Don't add empty sections
3765 //
3766 if (last_count == init.Count)
3767 continue;
3768
3769 Elements.Add (counter, section.Labels [0]);
3770 ++counter;
3771 }
3772
3773 Arguments args = new Arguments (1);
3774 args.Add (new Argument (new IntConstant (init.Count, loc)));
3775 Expression initializer = new NewInitialize (string_dictionary_type, args,
3776 new CollectionOrObjectInitializers (init, loc), loc);
3777
3778 switch_cache_field = new FieldExpr (field, loc);
3779 string_dictionary = new SimpleAssign (switch_cache_field, initializer.Resolve (ec));
3780 }
3781
3782 void DoEmitStringSwitch (LocalTemporary value, EmitContext ec)
3783 {
3784 ILGenerator ig = ec.ig;
3785 Label l_initialized = ig.DefineLabel ();
3786
3787 //
3788 // Skip initialization when value is null
3789 //
3790 value.EmitBranchable (ec, null_target, false);
3791
3792 //
3793 // Check if string dictionary is initialized and initialize
3794 //
3795 switch_cache_field.EmitBranchable (ec, l_initialized, true);
3796 string_dictionary.EmitStatement (ec);
3797 ig.MarkLabel (l_initialized);
3798
3799 LocalTemporary string_switch_variable = new LocalTemporary (TypeManager.int32_type);
3800
3801 ResolveContext rc = new ResolveContext (ec.MemberContext);
3802
3803 if (TypeManager.generic_ienumerable_type != null) {
3804 Arguments get_value_args = new Arguments (2);
3805 get_value_args.Add (new Argument (value));
3806 get_value_args.Add (new Argument (string_switch_variable, Argument.AType.Out));
3807 Expression get_item = new Invocation (new MemberAccess (switch_cache_field, "TryGetValue", loc), get_value_args).Resolve (rc);
3808 if (get_item == null)
3809 return;
3810
3811 //
3812 // A value was not found, go to default case
3813 //
3814 get_item.EmitBranchable (ec, default_target, false);
3815 } else {
3816 Arguments get_value_args = new Arguments (1);
3817 get_value_args.Add (new Argument (value));
3818
3819 Expression get_item = new IndexerAccess (new ElementAccess (switch_cache_field, get_value_args), loc).Resolve (rc);
3820 if (get_item == null)
3821 return;
3822
3823 LocalTemporary get_item_object = new LocalTemporary (TypeManager.object_type);
3824 get_item_object.EmitAssign (ec, get_item, true, false);
3825 ec.ig.Emit (OpCodes.Brfalse, default_target);
3826
3827 ExpressionStatement get_item_int = (ExpressionStatement) new SimpleAssign (string_switch_variable,
3828 new Cast (new TypeExpression (TypeManager.int32_type, loc), get_item_object, loc)).Resolve (rc);
3829
3830 get_item_int.EmitStatement (ec);
3831 get_item_object.Release (ec);
3832 }
3833
3834 TableSwitchEmit (ec, string_switch_variable);
3835 string_switch_variable.Release (ec);
3836 }
3837
3838 protected override void DoEmit (EmitContext ec)
3839 {
3840 ILGenerator ig = ec.ig;
3841
3842 default_target = ig.DefineLabel ();
3843 null_target = ig.DefineLabel ();
3844
3845 // Store variable for comparission purposes
3846 // TODO: Don't duplicate non-captured VariableReference
3847 LocalTemporary value;
3848 if (HaveUnwrap) {
3849 value = new LocalTemporary (SwitchType);
3850 unwrap.EmitCheck (ec);
3851 ig.Emit (OpCodes.Brfalse, null_target);
3852 new_expr.Emit (ec);
3853 value.Store (ec);
3854 } else if (!is_constant) {
3855 value = new LocalTemporary (SwitchType);
3856 new_expr.Emit (ec);
3857 value.Store (ec);
3858 } else
3859 value = null;
3860
3861 //
3862 // Setup the codegen context
3863 //
3864 Label old_end = ec.LoopEnd;
3865 Switch old_switch = ec.Switch;
3866
3867 ec.LoopEnd = ig.DefineLabel ();
3868 ec.Switch = this;
3869
3870 // Emit Code.
3871 if (is_constant) {
3872 if (constant_section != null)
3873 constant_section.Block.Emit (ec);
3874 } else if (string_dictionary != null) {
3875 DoEmitStringSwitch (value, ec);
3876 } else {
3877 TableSwitchEmit (ec, value);
3878 }
3879
3880 if (value != null)
3881 value.Release (ec);
3882
3883 // Restore context state.
3884 ig.MarkLabel (ec.LoopEnd);
3885
3886 //
3887 // Restore the previous context
3888 //
3889 ec.LoopEnd = old_end;
3890 ec.Switch = old_switch;
3891 }
3892
3893 protected override void CloneTo (CloneContext clonectx, Statement t)
3894 {
3895 Switch target = (Switch) t;
3896
3897 target.Expr = Expr.Clone (clonectx);
3898 target.Sections = new List<SwitchSection> ();
3899 foreach (SwitchSection ss in Sections){
3900 target.Sections.Add (ss.Clone (clonectx));
3901 }
3902 }
3903 }
3904
3905 // A place where execution can restart in an iterator
3906 public abstract class ResumableStatement : Statement
3907 {
3908 bool prepared;
3909 protected Label resume_point;
3910
3911 public Label PrepareForEmit (EmitContext ec)
3912 {
3913 if (!prepared) {
3914 prepared = true;
3915 resume_point = ec.ig.DefineLabel ();
3916 }
3917 return resume_point;
3918 }
3919
3920 public virtual Label PrepareForDispose (EmitContext ec, Label end)
3921 {
3922 return end;
3923 }
3924 public virtual void EmitForDispose (EmitContext ec, Iterator iterator, Label end, bool have_dispatcher)
3925 {
3926 }
3927 }
3928
3929 // Base class for statements that are implemented in terms of try...finally
3930 public abstract class ExceptionStatement : ResumableStatement
3931 {
3932 bool code_follows;
3933 Iterator iter;
3934 List<ResumableStatement> resume_points;
3935 int first_resume_pc;
3936
3937 protected abstract void EmitPreTryBody (EmitContext ec);
3938 protected abstract void EmitTryBody (EmitContext ec);
3939 protected abstract void EmitFinallyBody (EmitContext ec);
3940
3941 protected sealed override void DoEmit (EmitContext ec)
3942 {
3943 ILGenerator ig = ec.ig;
3944
3945 EmitPreTryBody (ec);
3946
3947 if (resume_points != null) {
3948 IntConstant.EmitInt (ig, (int) Iterator.State.Running);
3949 ig.Emit (OpCodes.Stloc, iter.CurrentPC);
3950 }
3951
3952 ig.BeginExceptionBlock ();
3953
3954 if (resume_points != null) {
3955 ig.MarkLabel (resume_point);
3956
3957 // For normal control flow, we want to fall-through the Switch
3958 // So, we use CurrentPC rather than the $PC field, and initialize it to an outside value above
3959 ig.Emit (OpCodes.Ldloc, iter.CurrentPC);
3960 IntConstant.EmitInt (ig, first_resume_pc);
3961 ig.Emit (OpCodes.Sub);
3962
3963 Label [] labels = new Label [resume_points.Count];
3964 for (int i = 0; i < resume_points.Count; ++i)
3965 labels [i] = ((ResumableStatement) resume_points [i]).PrepareForEmit (ec);
3966 ig.Emit (OpCodes.Switch, labels);
3967 }
3968
3969 EmitTryBody (ec);
3970
3971 ig.BeginFinallyBlock ();
3972
3973 Label start_finally = ec.ig.DefineLabel ();
3974 if (resume_points != null) {
3975 ig.Emit (OpCodes.Ldloc, iter.SkipFinally);
3976 ig.Emit (OpCodes.Brfalse_S, start_finally);
3977 ig.Emit (OpCodes.Endfinally);
3978 }
3979
3980 ig.MarkLabel (start_finally);
3981 EmitFinallyBody (ec);
3982
3983 ig.EndExceptionBlock ();
3984 }
3985
3986 public void SomeCodeFollows ()
3987 {
3988 code_follows = true;
3989 }
3990
3991 public override bool Resolve (BlockContext ec)
3992 {
3993 // System.Reflection.Emit automatically emits a 'leave' at the end of a try clause
3994 // So, ensure there's some IL code after this statement.
3995 if (!code_follows && resume_points == null && ec.CurrentBranching.CurrentUsageVector.IsUnreachable)
3996 ec.NeedReturnLabel ();
3997
3998 iter = ec.CurrentIterator;
3999 return true;
4000 }
4001
4002 public void AddResumePoint (ResumableStatement stmt, int pc)
4003 {
4004 if (resume_points == null) {
4005 resume_points = new List<ResumableStatement> ();
4006 first_resume_pc = pc;
4007 }
4008
4009 if (pc != first_resume_pc + resume_points.Count)
4010 throw new InternalErrorException ("missed an intervening AddResumePoint?");
4011
4012 resume_points.Add (stmt);
4013 }
4014
4015 Label dispose_try_block;
4016 bool prepared_for_dispose, emitted_dispose;
4017 public override Label PrepareForDispose (EmitContext ec, Label end)
4018 {
4019 if (!prepared_for_dispose) {
4020 prepared_for_dispose = true;
4021 dispose_try_block = ec.ig.DefineLabel ();
4022 }
4023 return dispose_try_block;
4024 }
4025
4026 public override void EmitForDispose (EmitContext ec, Iterator iterator, Label end, bool have_dispatcher)
4027 {
4028 if (emitted_dispose)
4029 return;
4030
4031 emitted_dispose = true;
4032
4033 ILGenerator ig = ec.ig;
4034
4035 Label end_of_try = ig.DefineLabel ();
4036
4037 // Ensure that the only way we can get into this code is through a dispatcher
4038 if (have_dispatcher)
4039 ig.Emit (OpCodes.Br, end);
4040
4041 ig.BeginExceptionBlock ();
4042
4043 ig.MarkLabel (dispose_try_block);
4044
4045 Label [] labels = null;
4046 for (int i = 0; i < resume_points.Count; ++i) {
4047 ResumableStatement s = (ResumableStatement) resume_points [i];
4048 Label ret = s.PrepareForDispose (ec, end_of_try);
4049 if (ret.Equals (end_of_try) && labels == null)
4050 continue;
4051 if (labels == null) {
4052 labels = new Label [resume_points.Count];
4053 for (int j = 0; j < i; ++j)
4054 labels [j] = end_of_try;
4055 }
4056 labels [i] = ret;
4057 }
4058
4059 if (labels != null) {
4060 int j;
4061 for (j = 1; j < labels.Length; ++j)
4062 if (!labels [0].Equals (labels [j]))
4063 break;
4064 bool emit_dispatcher = j < labels.Length;
4065
4066 if (emit_dispatcher) {
4067 //SymbolWriter.StartIteratorDispatcher (ec.ig);
4068 ig.Emit (OpCodes.Ldloc, iterator.CurrentPC);
4069 IntConstant.EmitInt (ig, first_resume_pc);
4070 ig.Emit (OpCodes.Sub);
4071 ig.Emit (OpCodes.Switch, labels);
4072 //SymbolWriter.EndIteratorDispatcher (ec.ig);
4073 }
4074
4075 foreach (ResumableStatement s in resume_points)
4076 s.EmitForDispose (ec, iterator, end_of_try, emit_dispatcher);
4077 }
4078
4079 ig.MarkLabel (end_of_try);
4080
4081 ig.BeginFinallyBlock ();
4082
4083 EmitFinallyBody (ec);
4084
4085 ig.EndExceptionBlock ();
4086 }
4087 }
4088
4089 public class Lock : ExceptionStatement {
4090 Expression expr;
4091 public Statement Statement;
4092 TemporaryVariable temp;
4093
4094 public Lock (Expression expr, Statement stmt, Location l)
4095 {
4096 this.expr = expr;
4097 Statement = stmt;
4098 loc = l;
4099 }
4100
4101 public override bool Resolve (BlockContext ec)
4102 {
4103 expr = expr.Resolve (ec);
4104 if (expr == null)
4105 return false;
4106
4107 if (!TypeManager.IsReferenceType (expr.Type)){
4108 ec.Report.Error (185, loc,
4109 "`{0}' is not a reference type as required by the lock statement",
4110 TypeManager.CSharpName (expr.Type));
4111 return false;
4112 }
4113
4114 ec.StartFlowBranching (this);
4115 bool ok = Statement.Resolve (ec);
4116 ec.EndFlowBranching ();
4117
4118 ok &= base.Resolve (ec);
4119
4120 // Avoid creating libraries that reference the internal
4121 // mcs NullType:
4122 Type t = expr.Type;
4123 if (t == TypeManager.null_type)
4124 t = TypeManager.object_type;
4125
4126 temp = new TemporaryVariable (t, loc);
4127 temp.Resolve (ec);
4128
4129 if (TypeManager.void_monitor_enter_object == null || TypeManager.void_monitor_exit_object == null) {
4130 Type monitor_type = TypeManager.CoreLookupType (ec.Compiler, "System.Threading", "Monitor", MemberKind.Class, true);
4131 TypeManager.void_monitor_enter_object = TypeManager.GetPredefinedMethod (
4132 monitor_type, "Enter", loc, TypeManager.object_type);
4133 TypeManager.void_monitor_exit_object = TypeManager.GetPredefinedMethod (
4134 monitor_type, "Exit", loc, TypeManager.object_type);
4135 }
4136
4137 return ok;
4138 }
4139
4140 protected override void EmitPreTryBody (EmitContext ec)
4141 {
4142 ILGenerator ig = ec.ig;
4143
4144 temp.EmitAssign (ec, expr);
4145 temp.Emit (ec);
4146 ig.Emit (OpCodes.Call, (MethodInfo) TypeManager.void_monitor_enter_object.MetaInfo);
4147 }
4148
4149 protected override void EmitTryBody (EmitContext ec)
4150 {
4151 Statement.Emit (ec);
4152 }
4153
4154 protected override void EmitFinallyBody (EmitContext ec)
4155 {
4156 temp.Emit (ec);
4157 ec.ig.Emit (OpCodes.Call, (MethodInfo) TypeManager.void_monitor_exit_object.MetaInfo);
4158 }
4159
4160 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4161 {
4162 expr.MutateHoistedGenericType (storey);
4163 temp.MutateHoistedGenericType (storey);
4164 Statement.MutateHoistedGenericType (storey);
4165 }
4166
4167 protected override void CloneTo (CloneContext clonectx, Statement t)
4168 {
4169 Lock target = (Lock) t;
4170
4171 target.expr = expr.Clone (clonectx);
4172 target.Statement = Statement.Clone (clonectx);
4173 }
4174 }
4175
4176 public class Unchecked : Statement {
4177 public Block Block;
4178
4179 public Unchecked (Block b)
4180 {
4181 Block = b;
4182 b.Unchecked = true;
4183 }
4184
4185 public override bool Resolve (BlockContext ec)
4186 {
4187 using (ec.With (ResolveContext.Options.AllCheckStateFlags, false))
4188 return Block.Resolve (ec);
4189 }
4190
4191 protected override void DoEmit (EmitContext ec)
4192 {
4193 using (ec.With (EmitContext.Options.AllCheckStateFlags, false))
4194 Block.Emit (ec);
4195 }
4196
4197 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4198 {
4199 Block.MutateHoistedGenericType (storey);
4200 }
4201
4202 protected override void CloneTo (CloneContext clonectx, Statement t)
4203 {
4204 Unchecked target = (Unchecked) t;
4205
4206 target.Block = clonectx.LookupBlock (Block);
4207 }
4208 }
4209
4210 public class Checked : Statement {
4211 public Block Block;
4212
4213 public Checked (Block b)
4214 {
4215 Block = b;
4216 b.Unchecked = false;
4217 }
4218
4219 public override bool Resolve (BlockContext ec)
4220 {
4221 using (ec.With (ResolveContext.Options.AllCheckStateFlags, true))
4222 return Block.Resolve (ec);
4223 }
4224
4225 protected override void DoEmit (EmitContext ec)
4226 {
4227 using (ec.With (EmitContext.Options.AllCheckStateFlags, true))
4228 Block.Emit (ec);
4229 }
4230
4231 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4232 {
4233 Block.MutateHoistedGenericType (storey);
4234 }
4235
4236 protected override void CloneTo (CloneContext clonectx, Statement t)
4237 {
4238 Checked target = (Checked) t;
4239
4240 target.Block = clonectx.LookupBlock (Block);
4241 }
4242 }
4243
4244 public class Unsafe : Statement {
4245 public Block Block;
4246
4247 public Unsafe (Block b)
4248 {
4249 Block = b;
4250 Block.Unsafe = true;
4251 loc = b.StartLocation;
4252 }
4253
4254 public override bool Resolve (BlockContext ec)
4255 {
4256 if (ec.CurrentIterator != null)
4257 ec.Report.Error (1629, loc, "Unsafe code may not appear in iterators");
4258
4259 using (ec.Set (ResolveContext.Options.UnsafeScope))
4260 return Block.Resolve (ec);
4261 }
4262
4263 protected override void DoEmit (EmitContext ec)
4264 {
4265 Block.Emit (ec);
4266 }
4267
4268 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4269 {
4270 Block.MutateHoistedGenericType (storey);
4271 }
4272
4273 protected override void CloneTo (CloneContext clonectx, Statement t)
4274 {
4275 Unsafe target = (Unsafe) t;
4276
4277 target.Block = clonectx.LookupBlock (Block);
4278 }
4279 }
4280
4281 //
4282 // Fixed statement
4283 //
4284 class Fixed : Statement {
4285 Expression type;
4286 List<KeyValuePair<LocalInfo, Expression>> declarators;
4287 Statement statement;
4288 Type expr_type;
4289 Emitter[] data;
4290 bool has_ret;
4291
4292 abstract class Emitter
4293 {
4294 protected LocalInfo vi;
4295 protected Expression converted;
4296
4297 protected Emitter (Expression expr, LocalInfo li)
4298 {
4299 converted = expr;
4300 vi = li;
4301 }
4302
4303 public abstract void Emit (EmitContext ec);
4304 public abstract void EmitExit (EmitContext ec);
4305 }
4306
4307 class ExpressionEmitter : Emitter {
4308 public ExpressionEmitter (Expression converted, LocalInfo li) :
4309 base (converted, li)
4310 {
4311 }
4312
4313 public override void Emit (EmitContext ec) {
4314 //
4315 // Store pointer in pinned location
4316 //
4317 converted.Emit (ec);
4318 vi.EmitAssign (ec);
4319 }
4320
4321 public override void EmitExit (EmitContext ec)
4322 {
4323 ec.ig.Emit (OpCodes.Ldc_I4_0);
4324 ec.ig.Emit (OpCodes.Conv_U);
4325 vi.EmitAssign (ec);
4326 }
4327 }
4328
4329 class StringEmitter : Emitter
4330 {
4331 LocalInfo pinned_string;
4332
4333 public StringEmitter (Expression expr, LocalInfo li, Location loc):
4334 base (expr, li)
4335 {
4336 pinned_string = new LocalInfo (new TypeExpression (TypeManager.string_type, loc), null, null, loc);
4337 pinned_string.Pinned = true;
4338 }
4339
4340 public StringEmitter Resolve (ResolveContext rc)
4341 {
4342 pinned_string.Resolve (rc);
4343
4344 if (TypeManager.int_get_offset_to_string_data == null) {
4345 TypeManager.int_get_offset_to_string_data = TypeManager.GetPredefinedProperty (
4346 TypeManager.runtime_helpers_type, "OffsetToStringData", pinned_string.Location, TypeManager.int32_type);
4347 }
4348
4349 return this;
4350 }
4351
4352 public override void Emit (EmitContext ec)
4353 {
4354 pinned_string.ResolveVariable (ec);
4355
4356 converted.Emit (ec);
4357 pinned_string.EmitAssign (ec);
4358
4359 // TODO: Should use Binary::Add
4360 pinned_string.Emit (ec);
4361 ec.ig.Emit (OpCodes.Conv_I);
4362
4363 PropertyExpr pe = new PropertyExpr (pinned_string.VariableType, TypeManager.int_get_offset_to_string_data, pinned_string.Location);
4364 //pe.InstanceExpression = pinned_string;
4365 pe.Resolve (new ResolveContext (ec.MemberContext)).Emit (ec);
4366
4367 ec.ig.Emit (OpCodes.Add);
4368 vi.EmitAssign (ec);
4369 }
4370
4371 public override void EmitExit (EmitContext ec)
4372 {
4373 ec.ig.Emit (OpCodes.Ldnull);
4374 pinned_string.EmitAssign (ec);
4375 }
4376 }
4377
4378 public Fixed (Expression type, List<KeyValuePair<LocalInfo, Expression>> decls, Statement stmt, Location l)
4379 {
4380 this.type = type;
4381 declarators = decls;
4382 statement = stmt;
4383 loc = l;
4384 }
4385
4386 public Statement Statement {
4387 get { return statement; }
4388 }
4389
4390 public override bool Resolve (BlockContext ec)
4391 {
4392 if (!ec.IsUnsafe){
4393 Expression.UnsafeError (ec, loc);
4394 return false;
4395 }
4396
4397 TypeExpr texpr = type.ResolveAsContextualType (ec, false);
4398 if (texpr == null) {
4399 if (type is VarExpr)
4400 ec.Report.Error (821, type.Location, "A fixed statement cannot use an implicitly typed local variable");
4401
4402 return false;
4403 }
4404
4405 expr_type = texpr.Type;
4406
4407 data = new Emitter [declarators.Count];
4408
4409 if (!expr_type.IsPointer){
4410 ec.Report.Error (209, loc, "The type of locals declared in a fixed statement must be a pointer type");
4411 return false;
4412 }
4413
4414 int i = 0;
4415 foreach (var p in declarators){
4416 LocalInfo vi = p.Key;
4417 Expression e = p.Value;
4418
4419 vi.VariableInfo.SetAssigned (ec);
4420 vi.SetReadOnlyContext (LocalInfo.ReadOnlyContext.Fixed);
4421
4422 //
4423 // The rules for the possible declarators are pretty wise,
4424 // but the production on the grammar is more concise.
4425 //
4426 // So we have to enforce these rules here.
4427 //
4428 // We do not resolve before doing the case 1 test,
4429 // because the grammar is explicit in that the token &
4430 // is present, so we need to test for this particular case.
4431 //
4432
4433 if (e is Cast){
4434 ec.Report.Error (254, loc, "The right hand side of a fixed statement assignment may not be a cast expression");
4435 return false;
4436 }
4437
4438 using (ec.Set (ResolveContext.Options.FixedInitializerScope)) {
4439 e = e.Resolve (ec);
4440 }
4441
4442 if (e == null)
4443 return false;
4444
4445 //
4446 // Case 2: Array
4447 //
4448 if (e.Type.IsArray){
4449 Type array_type = TypeManager.GetElementType (e.Type);
4450
4451 //
4452 // Provided that array_type is unmanaged,
4453 //
4454 if (!TypeManager.VerifyUnmanaged (ec.Compiler, array_type, loc))
4455 return false;
4456
4457 //
4458 // and T* is implicitly convertible to the
4459 // pointer type given in the fixed statement.
4460 //
4461 ArrayPtr array_ptr = new ArrayPtr (e, array_type, loc);
4462
4463 Expression converted = Convert.ImplicitConversionRequired (
4464 ec, array_ptr, vi.VariableType, loc);
4465 if (converted == null)
4466 return false;
4467
4468 //
4469 // fixed (T* e_ptr = (e == null || e.Length == 0) ? null : converted [0])
4470 //
4471 converted = new Conditional (new BooleanExpression (new Binary (Binary.Operator.LogicalOr,
4472 new Binary (Binary.Operator.Equality, e, new NullLiteral (loc), loc),
4473 new Binary (Binary.Operator.Equality, new MemberAccess (e, "Length"), new IntConstant (0, loc), loc), loc)),
4474 new NullPointer (loc),
4475 converted);
4476
4477 converted = converted.Resolve (ec);
4478
4479 data [i] = new ExpressionEmitter (converted, vi);
4480 i++;
4481
4482 continue;
4483 }
4484
4485 //
4486 // Case 3: string
4487 //
4488 if (e.Type == TypeManager.string_type){
4489 data [i] = new StringEmitter (e, vi, loc).Resolve (ec);
4490 i++;
4491 continue;
4492 }
4493
4494 // Case 4: fixed buffer
4495 if (e is FixedBufferPtr) {
4496 data [i++] = new ExpressionEmitter (e, vi);
4497 continue;
4498 }
4499
4500 //
4501 // Case 1: & object.
4502 //
4503 Unary u = e as Unary;
4504 if (u != null && u.Oper == Unary.Operator.AddressOf) {
4505 IVariableReference vr = u.Expr as IVariableReference;
4506 if (vr == null || !vr.IsFixed) {
4507 data [i] = new ExpressionEmitter (e, vi);
4508 }
4509 }
4510
4511 if (data [i++] == null)
4512 ec.Report.Error (213, vi.Location, "You cannot use the fixed statement to take the address of an already fixed expression");
4513
4514 e = Convert.ImplicitConversionRequired (ec, e, expr_type, loc);
4515 }
4516
4517 ec.StartFlowBranching (FlowBranching.BranchingType.Conditional, loc);
4518 bool ok = statement.Resolve (ec);
4519 bool flow_unreachable = ec.EndFlowBranching ();
4520 has_ret = flow_unreachable;
4521
4522 return ok;
4523 }
4524
4525 protected override void DoEmit (EmitContext ec)
4526 {
4527 for (int i = 0; i < data.Length; i++) {
4528 data [i].Emit (ec);
4529 }
4530
4531 statement.Emit (ec);
4532
4533 if (has_ret)
4534 return;
4535
4536 //
4537 // Clear the pinned variable
4538 //
4539 for (int i = 0; i < data.Length; i++) {
4540 data [i].EmitExit (ec);
4541 }
4542 }
4543
4544 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4545 {
4546 // Fixed statement cannot be used inside anonymous methods or lambdas
4547 throw new NotSupportedException ();
4548 }
4549
4550 protected override void CloneTo (CloneContext clonectx, Statement t)
4551 {
4552 Fixed target = (Fixed) t;
4553
4554 target.type = type.Clone (clonectx);
4555 target.declarators = new List<KeyValuePair<LocalInfo, Expression>> (declarators.Count);
4556 foreach (var p in declarators) {
4557 target.declarators.Add (new KeyValuePair<LocalInfo, Expression> (
4558 clonectx.LookupVariable (p.Key), p.Value.Clone (clonectx)));
4559 }
4560
4561 target.statement = statement.Clone (clonectx);
4562 }
4563 }
4564
4565 public class Catch : Statement {
4566 public readonly string Name;
4567 public Block Block;
4568 public Block VarBlock;
4569
4570 Expression type_expr;
4571 Type type;
4572
4573 public Catch (Expression type, string name, Block block, Block var_block, Location l)
4574 {
4575 type_expr = type;
4576 Name = name;
4577 Block = block;
4578 VarBlock = var_block;
4579 loc = l;
4580 }
4581
4582 public Type CatchType {
4583 get {
4584 return type;
4585 }
4586 }
4587
4588 public bool IsGeneral {
4589 get {
4590 return type_expr == null;
4591 }
4592 }
4593
4594 protected override void DoEmit (EmitContext ec)
4595 {
4596 ILGenerator ig = ec.ig;
4597
4598 if (CatchType != null)
4599 ig.BeginCatchBlock (CatchType);
4600 else
4601 ig.BeginCatchBlock (TypeManager.object_type);
4602
4603 if (VarBlock != null)
4604 VarBlock.Emit (ec);
4605
4606 if (Name != null) {
4607 // TODO: Move to resolve
4608 LocalVariableReference lvr = new LocalVariableReference (Block, Name, loc);
4609 lvr.Resolve (new ResolveContext (ec.MemberContext));
4610
4611 // Only to make verifier happy
4612 if (TypeManager.IsGenericParameter (lvr.Type))
4613 ig.Emit (OpCodes.Unbox_Any, lvr.Type);
4614
4615 Expression source;
4616 if (lvr.IsHoisted) {
4617 LocalTemporary lt = new LocalTemporary (lvr.Type);
4618 lt.Store (ec);
4619 source = lt;
4620 } else {
4621 // Variable is at the top of the stack
4622 source = EmptyExpression.Null;
4623 }
4624
4625 lvr.EmitAssign (ec, source, false, false);
4626 } else
4627 ig.Emit (OpCodes.Pop);
4628
4629 Block.Emit (ec);
4630 }
4631
4632 public override bool Resolve (BlockContext ec)
4633 {
4634 using (ec.With (ResolveContext.Options.CatchScope, true)) {
4635 if (type_expr != null) {
4636 TypeExpr te = type_expr.ResolveAsTypeTerminal (ec, false);
4637 if (te == null)
4638 return false;
4639
4640 type = te.Type;
4641
4642 if (type != TypeManager.exception_type && !TypeManager.IsSubclassOf (type, TypeManager.exception_type)){
4643 ec.Report.Error (155, loc, "The type caught or thrown must be derived from System.Exception");
4644 return false;
4645 }
4646 } else
4647 type = null;
4648
4649 if (!Block.Resolve (ec))
4650 return false;
4651
4652 // Even though VarBlock surrounds 'Block' we resolve it later, so that we can correctly
4653 // emit the "unused variable" warnings.
4654 if (VarBlock != null)
4655 return VarBlock.Resolve (ec);
4656
4657 return true;
4658 }
4659 }
4660
4661 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4662 {
4663 if (type != null)
4664 type = storey.MutateType (type);
4665 if (VarBlock != null)
4666 VarBlock.MutateHoistedGenericType (storey);
4667 Block.MutateHoistedGenericType (storey);
4668 }
4669
4670 protected override void CloneTo (CloneContext clonectx, Statement t)
4671 {
4672 Catch target = (Catch) t;
4673
4674 if (type_expr != null)
4675 target.type_expr = type_expr.Clone (clonectx);
4676 if (VarBlock != null)
4677 target.VarBlock = clonectx.LookupBlock (VarBlock);
4678 target.Block = clonectx.LookupBlock (Block);
4679 }
4680 }
4681
4682 public class TryFinally : ExceptionStatement {
4683 Statement stmt;
4684 Block fini;
4685
4686 public TryFinally (Statement stmt, Block fini, Location l)
4687 {
4688 this.stmt = stmt;
4689 this.fini = fini;
4690 loc = l;
4691 }
4692
4693 public override bool Resolve (BlockContext ec)
4694 {
4695 bool ok = true;
4696
4697 ec.StartFlowBranching (this);
4698
4699 if (!stmt.Resolve (ec))
4700 ok = false;
4701
4702 if (ok)
4703 ec.CurrentBranching.CreateSibling (fini, FlowBranching.SiblingType.Finally);
4704 using (ec.With (ResolveContext.Options.FinallyScope, true)) {
4705 if (!fini.Resolve (ec))
4706 ok = false;
4707 }
4708
4709 ec.EndFlowBranching ();
4710
4711 ok &= base.Resolve (ec);
4712
4713 return ok;
4714 }
4715
4716 protected override void EmitPreTryBody (EmitContext ec)
4717 {
4718 }
4719
4720 protected override void EmitTryBody (EmitContext ec)
4721 {
4722 stmt.Emit (ec);
4723 }
4724
4725 protected override void EmitFinallyBody (EmitContext ec)
4726 {
4727 fini.Emit (ec);
4728 }
4729
4730 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4731 {
4732 stmt.MutateHoistedGenericType (storey);
4733 fini.MutateHoistedGenericType (storey);
4734 }
4735
4736 protected override void CloneTo (CloneContext clonectx, Statement t)
4737 {
4738 TryFinally target = (TryFinally) t;
4739
4740 target.stmt = (Statement) stmt.Clone (clonectx);
4741 if (fini != null)
4742 target.fini = clonectx.LookupBlock (fini);
4743 }
4744 }
4745
4746 public class TryCatch : Statement {
4747 public Block Block;
4748 public List<Catch> Specific;
4749 public Catch General;
4750 bool inside_try_finally, code_follows;
4751
4752 public TryCatch (Block block, List<Catch> catch_clauses, Location l, bool inside_try_finally)
4753 {
4754 this.Block = block;
4755 this.Specific = catch_clauses;
4756 this.inside_try_finally = inside_try_finally;
4757
4758 Catch c = catch_clauses [0];
4759 if (c.IsGeneral) {
4760 this.General = c;
4761 catch_clauses.RemoveAt (0);
4762 }
4763
4764 loc = l;
4765 }
4766
4767 public override bool Resolve (BlockContext ec)
4768 {
4769 bool ok = true;
4770
4771 ec.StartFlowBranching (this);
4772
4773 if (!Block.Resolve (ec))
4774 ok = false;
4775
4776 Type[] prev_catches = new Type [Specific.Count];
4777 int last_index = 0;
4778 foreach (Catch c in Specific){
4779 ec.CurrentBranching.CreateSibling (c.Block, FlowBranching.SiblingType.Catch);
4780
4781 if (c.Name != null) {
4782 LocalInfo vi = c.Block.GetLocalInfo (c.Name);
4783 if (vi == null)
4784 throw new Exception ();
4785
4786 vi.VariableInfo = null;
4787 }
4788
4789 if (!c.Resolve (ec)) {
4790 ok = false;
4791 continue;
4792 }
4793
4794 Type resolved_type = c.CatchType;
4795 for (int ii = 0; ii < last_index; ++ii) {
4796 if (resolved_type == prev_catches [ii] || TypeManager.IsSubclassOf (resolved_type, prev_catches [ii])) {
4797 ec.Report.Error (160, c.loc,
4798 "A previous catch clause already catches all exceptions of this or a super type `{0}'",
4799 TypeManager.CSharpName (prev_catches [ii]));
4800 ok = false;
4801 }
4802 }
4803
4804 prev_catches [last_index++] = resolved_type;
4805 }
4806
4807 if (General != null) {
4808 if (CodeGen.Assembly.WrapNonExceptionThrows) {
4809 foreach (Catch c in Specific){
4810 if (c.CatchType == TypeManager.exception_type && PredefinedAttributes.Get.RuntimeCompatibility.IsDefined) {
4811 ec.Report.Warning (1058, 1, c.loc, "A previous catch clause already catches all exceptions. All non-exceptions thrown will be wrapped in a `System.Runtime.CompilerServices.RuntimeWrappedException'");
4812 }
4813 }
4814 }
4815
4816 ec.CurrentBranching.CreateSibling (General.Block, FlowBranching.SiblingType.Catch);
4817
4818 if (!General.Resolve (ec))
4819 ok = false;
4820 }
4821
4822 ec.EndFlowBranching ();
4823
4824 // System.Reflection.Emit automatically emits a 'leave' at the end of a try/catch clause
4825 // So, ensure there's some IL code after this statement
4826 if (!inside_try_finally && !code_follows && ec.CurrentBranching.CurrentUsageVector.IsUnreachable)
4827 ec.NeedReturnLabel ();
4828
4829 return ok;
4830 }
4831
4832 public void SomeCodeFollows ()
4833 {
4834 code_follows = true;
4835 }
4836
4837 protected override void DoEmit (EmitContext ec)
4838 {
4839 ILGenerator ig = ec.ig;
4840
4841 if (!inside_try_finally)
4842 ig.BeginExceptionBlock ();
4843
4844 Block.Emit (ec);
4845
4846 foreach (Catch c in Specific)
4847 c.Emit (ec);
4848
4849 if (General != null)
4850 General.Emit (ec);
4851
4852 if (!inside_try_finally)
4853 ig.EndExceptionBlock ();
4854 }
4855
4856 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4857 {
4858 Block.MutateHoistedGenericType (storey);
4859
4860 if (General != null)
4861 General.MutateHoistedGenericType (storey);
4862 if (Specific != null) {
4863 foreach (Catch c in Specific)
4864 c.MutateHoistedGenericType (storey);
4865 }
4866 }
4867
4868 protected override void CloneTo (CloneContext clonectx, Statement t)
4869 {
4870 TryCatch target = (TryCatch) t;
4871
4872 target.Block = clonectx.LookupBlock (Block);
4873 if (General != null)
4874 target.General = (Catch) General.Clone (clonectx);
4875 if (Specific != null){
4876 target.Specific = new List<Catch> ();
4877 foreach (Catch c in Specific)
4878 target.Specific.Add ((Catch) c.Clone (clonectx));
4879 }
4880 }
4881 }
4882
4883 // FIXME: Why is it almost exact copy of Using ??
4884 public class UsingTemporary : ExceptionStatement {
4885 TemporaryVariable local_copy;
4886 public Statement Statement;
4887 Expression expr;
4888 Type expr_type;
4889
4890 public UsingTemporary (Expression expr, Statement stmt, Location l)
4891 {
4892 this.expr = expr;
4893 Statement = stmt;
4894 loc = l;
4895 }
4896
4897 public override bool Resolve (BlockContext ec)
4898 {
4899 expr = expr.Resolve (ec);
4900 if (expr == null)
4901 return false;
4902
4903 expr_type = expr.Type;
4904
4905 if (!TypeManager.ImplementsInterface (expr_type, TypeManager.idisposable_type) &&
4906 Convert.ImplicitConversion (ec, expr, TypeManager.idisposable_type, loc) == null) {
4907 if (!TypeManager.IsDynamicType (expr_type)) {
4908 Using.Error_IsNotConvertibleToIDisposable (ec, expr);
4909 return false;
4910 }
4911
4912 expr = Convert.ImplicitConversionRequired (ec, expr, TypeManager.idisposable_type, loc);
4913 expr_type = expr.Type;
4914 }
4915
4916 local_copy = new TemporaryVariable (expr_type, loc);
4917 local_copy.Resolve (ec);
4918
4919 ec.StartFlowBranching (this);
4920
4921 bool ok = Statement.Resolve (ec);
4922
4923 ec.EndFlowBranching ();
4924
4925 ok &= base.Resolve (ec);
4926
4927 if (TypeManager.void_dispose_void == null) {
4928 TypeManager.void_dispose_void = TypeManager.GetPredefinedMethod (
4929 TypeManager.idisposable_type, "Dispose", loc, Type.EmptyTypes);
4930 }
4931
4932 return ok;
4933 }
4934
4935 protected override void EmitPreTryBody (EmitContext ec)
4936 {
4937 local_copy.EmitAssign (ec, expr);
4938 }
4939
4940 protected override void EmitTryBody (EmitContext ec)
4941 {
4942 Statement.Emit (ec);
4943 }
4944
4945 protected override void EmitFinallyBody (EmitContext ec)
4946 {
4947 ILGenerator ig = ec.ig;
4948 if (!TypeManager.IsStruct (expr_type)) {
4949 Label skip = ig.DefineLabel ();
4950 local_copy.Emit (ec);
4951 ig.Emit (OpCodes.Brfalse, skip);
4952 local_copy.Emit (ec);
4953 ig.Emit (OpCodes.Callvirt, (MethodInfo) TypeManager.void_dispose_void.MetaInfo);
4954 ig.MarkLabel (skip);
4955 return;
4956 }
4957
4958 Expression ml = Expression.MemberLookup (RootContext.ToplevelTypes.Compiler,
4959 ec.CurrentType, TypeManager.idisposable_type, expr_type,
4960 "Dispose", Location.Null);
4961
4962 if (!(ml is MethodGroupExpr)) {
4963 local_copy.Emit (ec);
4964 ig.Emit (OpCodes.Box, expr_type);
4965 ig.Emit (OpCodes.Callvirt, (MethodInfo) TypeManager.void_dispose_void.MetaInfo);
4966 return;
4967 }
4968
4969 MethodSpec mi = null;
4970
4971 foreach (var mk in ((MethodGroupExpr) ml).Methods) {
4972 if (mk.Parameters.IsEmpty) {
4973 mi = mk;
4974 break;
4975 }
4976 }
4977
4978 if (mi == null) {
4979 ec.Report.Error(-100, Mono.CSharp.Location.Null, "Internal error: No Dispose method which takes 0 parameters.");
4980 return;
4981 }
4982
4983 local_copy.AddressOf (ec, AddressOp.Load);
4984 ig.Emit (OpCodes.Call, (MethodInfo) mi.MetaInfo);
4985 }
4986
4987 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4988 {
4989 expr_type = storey.MutateType (expr_type);
4990 local_copy.MutateHoistedGenericType (storey);
4991 Statement.MutateHoistedGenericType (storey);
4992 }
4993
4994 protected override void CloneTo (CloneContext clonectx, Statement t)
4995 {
4996 UsingTemporary target = (UsingTemporary) t;
4997
4998 target.expr = expr.Clone (clonectx);
4999 target.Statement = Statement.Clone (clonectx);
5000 }
5001 }
5002
5003 public class Using : ExceptionStatement {
5004 Statement stmt;
5005 public Statement EmbeddedStatement {
5006 get { return stmt is Using ? ((Using) stmt).EmbeddedStatement : stmt; }
5007 }
5008
5009 Expression var;
5010 Expression init;
5011
5012 ExpressionStatement assign;
5013
5014 public Using (Expression var, Expression init, Statement stmt, Location l)
5015 {
5016 this.var = var;
5017 this.init = init;
5018 this.stmt = stmt;
5019 loc = l;
5020 }
5021
5022 static public void Error_IsNotConvertibleToIDisposable (BlockContext ec, Expression expr)
5023 {
5024 ec.Report.SymbolRelatedToPreviousError (expr.Type);
5025 ec.Report.Error (1674, expr.Location, "`{0}': type used in a using statement must be implicitly convertible to `System.IDisposable'",
5026 TypeManager.CSharpName (expr.Type));
5027 }
5028
5029 protected override void EmitPreTryBody (EmitContext ec)
5030 {
5031 assign.EmitStatement (ec);
5032 }
5033
5034 protected override void EmitTryBody (EmitContext ec)
5035 {
5036 stmt.Emit (ec);
5037 }
5038
5039 protected override void EmitFinallyBody (EmitContext ec)
5040 {
5041 ILGenerator ig = ec.ig;
5042 Label skip = ig.DefineLabel ();
5043
5044 bool emit_null_check = !TypeManager.IsValueType (var.Type);
5045 if (emit_null_check) {
5046 var.Emit (ec);
5047 ig.Emit (OpCodes.Brfalse, skip);
5048 }
5049
5050 Invocation.EmitCall (ec, false, var, TypeManager.void_dispose_void, null, loc);
5051
5052 if (emit_null_check)
5053 ig.MarkLabel (skip);
5054 }
5055
5056 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5057 {
5058 assign.MutateHoistedGenericType (storey);
5059 var.MutateHoistedGenericType (storey);
5060 stmt.MutateHoistedGenericType (storey);
5061 }
5062
5063 public override bool Resolve (BlockContext ec)
5064 {
5065 if (!ResolveVariable (ec))
5066 return false;
5067
5068 ec.StartFlowBranching (this);
5069
5070 bool ok = stmt.Resolve (ec);
5071
5072 ec.EndFlowBranching ();
5073
5074 ok &= base.Resolve (ec);
5075
5076 if (TypeManager.void_dispose_void == null) {
5077 TypeManager.void_dispose_void = TypeManager.GetPredefinedMethod (
5078 TypeManager.idisposable_type, "Dispose", loc, Type.EmptyTypes);
5079 }
5080
5081 return ok;
5082 }
5083
5084 bool ResolveVariable (BlockContext ec)
5085 {
5086 assign = new SimpleAssign (var, init, loc);
5087 assign = assign.ResolveStatement (ec);
5088 if (assign == null)
5089 return false;
5090
5091 if (assign.Type == TypeManager.idisposable_type ||
5092 TypeManager.ImplementsInterface (assign.Type, TypeManager.idisposable_type)) {
5093 return true;
5094 }
5095
5096 Expression e = Convert.ImplicitConversionStandard (ec, assign, TypeManager.idisposable_type, var.Location);
5097 if (e == null) {
5098 if (TypeManager.IsDynamicType (assign.Type)) {
5099 e = Convert.ImplicitConversionRequired (ec, assign, TypeManager.idisposable_type, loc);
5100 var = new TemporaryVariable (e.Type, loc);
5101 assign = new SimpleAssign (var, e, loc).ResolveStatement (ec);
5102 return true;
5103 }
5104
5105 Error_IsNotConvertibleToIDisposable (ec, var);
5106 return false;
5107 }
5108
5109 throw new NotImplementedException ("covariance?");
5110 }
5111
5112 protected override void CloneTo (CloneContext clonectx, Statement t)
5113 {
5114 Using target = (Using) t;
5115
5116 target.var = var.Clone (clonectx);
5117 target.init = init.Clone (clonectx);
5118 target.stmt = stmt.Clone (clonectx);
5119 }
5120 }
5121
5122 /// <summary>
5123 /// Implementation of the foreach C# statement
5124 /// </summary>
5125 public class Foreach : Statement {
5126
5127 sealed class ArrayForeach : Statement
5128 {
5129 class ArrayCounter : TemporaryVariable
5130 {
5131 StatementExpression increment;
5132
5133 public ArrayCounter (Location loc)
5134 : base (TypeManager.int32_type, loc)
5135 {
5136 }
5137
5138 public void ResolveIncrement (BlockContext ec)
5139 {
5140 increment = new StatementExpression (new UnaryMutator (UnaryMutator.Mode.PostIncrement, this, loc));
5141 increment.Resolve (ec);
5142 }
5143
5144 public void EmitIncrement (EmitContext ec)
5145 {
5146 increment.Emit (ec);
5147 }
5148 }
5149
5150 readonly Foreach for_each;
5151 readonly Statement statement;
5152
5153 Expression conv;
5154 TemporaryVariable[] lengths;
5155 Expression [] length_exprs;
5156 ArrayCounter[] counter;
5157
5158 TemporaryVariable copy;
5159 Expression access;
5160
5161 public ArrayForeach (Foreach @foreach, int rank)
5162 {
5163 for_each = @foreach;
5164 statement = for_each.statement;
5165 loc = @foreach.loc;
5166
5167 counter = new ArrayCounter [rank];
5168 length_exprs = new Expression [rank];
5169
5170 //
5171 // Only use temporary length variables when dealing with
5172 // multi-dimensional arrays
5173 //
5174 if (rank > 1)
5175 lengths = new TemporaryVariable [rank];
5176 }
5177
5178 protected override void CloneTo (CloneContext clonectx, Statement target)
5179 {
5180 throw new NotImplementedException ();
5181 }
5182
5183 public override bool Resolve (BlockContext ec)
5184 {
5185 copy = new TemporaryVariable (for_each.expr.Type, loc);
5186 copy.Resolve (ec);
5187
5188 int rank = length_exprs.Length;
5189 Arguments list = new Arguments (rank);
5190 for (int i = 0; i < rank; i++) {
5191 counter [i] = new ArrayCounter (loc);
5192 counter [i].ResolveIncrement (ec);
5193
5194 if (rank == 1) {
5195 length_exprs [i] = new MemberAccess (copy, "Length").Resolve (ec);
5196 } else {
5197 lengths [i] = new TemporaryVariable (TypeManager.int32_type, loc);
5198 lengths [i].Resolve (ec);
5199
5200 Arguments args = new Arguments (1);
5201 args.Add (new Argument (new IntConstant (i, loc)));
5202 length_exprs [i] = new Invocation (new MemberAccess (copy, "GetLength"), args).Resolve (ec);
5203 }
5204
5205 list.Add (new Argument (counter [i]));
5206 }
5207
5208 access = new ElementAccess (copy, list).Resolve (ec);
5209 if (access == null)
5210 return false;
5211
5212 Expression var_type = for_each.type;
5213 VarExpr ve = var_type as VarExpr;
5214 if (ve != null) {
5215 // Infer implicitly typed local variable from foreach array type
5216 var_type = new TypeExpression (access.Type, ve.Location);
5217 }
5218
5219 var_type = var_type.ResolveAsTypeTerminal (ec, false);
5220 if (var_type == null)
5221 return false;
5222
5223 conv = Convert.ExplicitConversion (ec, access, var_type.Type, loc);
5224 if (conv == null)
5225 return false;
5226
5227 bool ok = true;
5228
5229 ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc);
5230 ec.CurrentBranching.CreateSibling ();
5231
5232 for_each.variable = for_each.variable.ResolveLValue (ec, conv);
5233 if (for_each.variable == null)
5234 ok = false;
5235
5236 ec.StartFlowBranching (FlowBranching.BranchingType.Embedded, loc);
5237 if (!statement.Resolve (ec))
5238 ok = false;
5239 ec.EndFlowBranching ();
5240
5241 // There's no direct control flow from the end of the embedded statement to the end of the loop
5242 ec.CurrentBranching.CurrentUsageVector.Goto ();
5243
5244 ec.EndFlowBranching ();
5245
5246 return ok;
5247 }
5248
5249 protected override void DoEmit (EmitContext ec)
5250 {
5251 ILGenerator ig = ec.ig;
5252
5253 copy.EmitAssign (ec, for_each.expr);
5254
5255 int rank = length_exprs.Length;
5256 Label[] test = new Label [rank];
5257 Label[] loop = new Label [rank];
5258
5259 for (int i = 0; i < rank; i++) {
5260 test [i] = ig.DefineLabel ();
5261 loop [i] = ig.DefineLabel ();
5262
5263 if (lengths != null)
5264 lengths [i].EmitAssign (ec, length_exprs [i]);
5265 }
5266
5267 IntConstant zero = new IntConstant (0, loc);
5268 for (int i = 0; i < rank; i++) {
5269 counter [i].EmitAssign (ec, zero);
5270
5271 ig.Emit (OpCodes.Br, test [i]);
5272 ig.MarkLabel (loop [i]);
5273 }
5274
5275 ((IAssignMethod) for_each.variable).EmitAssign (ec, conv, false, false);
5276
5277 statement.Emit (ec);
5278
5279 ig.MarkLabel (ec.LoopBegin);
5280
5281 for (int i = rank - 1; i >= 0; i--){
5282 counter [i].EmitIncrement (ec);
5283
5284 ig.MarkLabel (test [i]);
5285 counter [i].Emit (ec);
5286
5287 if (lengths != null)
5288 lengths [i].Emit (ec);
5289 else
5290 length_exprs [i].Emit (ec);
5291
5292 ig.Emit (OpCodes.Blt, loop [i]);
5293 }
5294
5295 ig.MarkLabel (ec.LoopEnd);
5296 }
5297
5298 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5299 {
5300 for_each.expr.MutateHoistedGenericType (storey);
5301
5302 copy.MutateHoistedGenericType (storey);
5303 conv.MutateHoistedGenericType (storey);
5304 statement.MutateHoistedGenericType (storey);
5305
5306 for (int i = 0; i < counter.Length; i++) {
5307 counter [i].MutateHoistedGenericType (storey);
5308 if (lengths != null)
5309 lengths [i].MutateHoistedGenericType (storey);
5310 }
5311 }
5312 }
5313
5314 sealed class CollectionForeach : Statement
5315 {
5316 class CollectionForeachStatement : Statement
5317 {
5318 Type type;
5319 Expression variable, current, conv;
5320 Statement statement;
5321 Assign assign;
5322
5323 public CollectionForeachStatement (Type type, Expression variable,
5324 Expression current, Statement statement,
5325 Location loc)
5326 {
5327 this.type = type;
5328 this.variable = variable;
5329 this.current = current;
5330 this.statement = statement;
5331 this.loc = loc;
5332 }
5333
5334 protected override void CloneTo (CloneContext clonectx, Statement target)
5335 {
5336 throw new NotImplementedException ();
5337 }
5338
5339 public override bool Resolve (BlockContext ec)
5340 {
5341 current = current.Resolve (ec);
5342 if (current == null)
5343 return false;
5344
5345 conv = Convert.ExplicitConversion (ec, current, type, loc);
5346 if (conv == null)
5347 return false;
5348
5349 assign = new SimpleAssign (variable, conv, loc);
5350 if (assign.Resolve (ec) == null)
5351 return false;
5352
5353 if (!statement.Resolve (ec))
5354 return false;
5355
5356 return true;
5357 }
5358
5359 protected override void DoEmit (EmitContext ec)
5360 {
5361 assign.EmitStatement (ec);
5362 statement.Emit (ec);
5363 }
5364
5365 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5366 {
5367 assign.MutateHoistedGenericType (storey);
5368 statement.MutateHoistedGenericType (storey);
5369 }
5370 }
5371
5372 Expression variable, expr;
5373 Statement statement;
5374
5375 TemporaryVariable enumerator;
5376 Expression init;
5377 Statement loop;
5378 Statement wrapper;
5379
5380 MethodGroupExpr get_enumerator;
5381 PropertyExpr get_current;
5382 MethodSpec move_next;
5383 Expression var_type;
5384 Type enumerator_type;
5385 bool enumerator_found;
5386
5387 public CollectionForeach (Expression var_type, Expression var,
5388 Expression expr, Statement stmt, Location l)
5389 {
5390 this.var_type = var_type;
5391 this.variable = var;
5392 this.expr = expr;
5393 statement = stmt;
5394 loc = l;
5395 }
5396
5397 protected override void CloneTo (CloneContext clonectx, Statement target)
5398 {
5399 throw new NotImplementedException ();
5400 }
5401
5402 bool GetEnumeratorFilter (ResolveContext ec, MethodSpec mi)
5403 {
5404 Type return_type = mi.ReturnType;
5405
5406 //
5407 // Ok, we can access it, now make sure that we can do something
5408 // with this `GetEnumerator'
5409 //
5410
5411 if (return_type == TypeManager.ienumerator_type ||
5412 TypeManager.ImplementsInterface (return_type, TypeManager.ienumerator_type)) {
5413 //
5414 // If it is not an interface, lets try to find the methods ourselves.
5415 // For example, if we have:
5416 // public class Foo : IEnumerator { public bool MoveNext () {} public int Current { get {}}}
5417 // We can avoid the iface call. This is a runtime perf boost.
5418 // even bigger if we have a ValueType, because we avoid the cost
5419 // of boxing.
5420 //
5421 // We have to make sure that both methods exist for us to take
5422 // this path. If one of the methods does not exist, we will just
5423 // use the interface. Sadly, this complex if statement is the only
5424 // way I could do this without a goto
5425 //
5426
5427 if (TypeManager.bool_movenext_void == null) {
5428 TypeManager.bool_movenext_void = TypeManager.GetPredefinedMethod (
5429 TypeManager.ienumerator_type, "MoveNext", loc, Type.EmptyTypes);
5430 }
5431
5432 if (TypeManager.ienumerator_getcurrent == null) {
5433 TypeManager.ienumerator_getcurrent = TypeManager.GetPredefinedProperty (
5434 TypeManager.ienumerator_type, "Current", loc, TypeManager.object_type);
5435 }
5436
5437 //
5438 // Prefer a generic enumerator over a non-generic one.
5439 //
5440 if (return_type.IsInterface && TypeManager.IsGenericType (return_type)) {
5441 enumerator_type = return_type;
5442 if (!FetchGetCurrent (ec, return_type))
5443 get_current = new PropertyExpr (
5444 ec.CurrentType, TypeManager.ienumerator_getcurrent, loc);
5445 if (!FetchMoveNext (return_type))
5446 move_next = TypeManager.bool_movenext_void;
5447 return true;
5448 }
5449
5450 if (return_type.IsInterface ||
5451 !FetchMoveNext (return_type) ||
5452 !FetchGetCurrent (ec, return_type)) {
5453 enumerator_type = return_type;
5454 move_next = TypeManager.bool_movenext_void;
5455 get_current = new PropertyExpr (
5456 ec.CurrentType, TypeManager.ienumerator_getcurrent, loc);
5457 return true;
5458 }
5459 } else {
5460 //
5461 // Ok, so they dont return an IEnumerable, we will have to
5462 // find if they support the GetEnumerator pattern.
5463 //
5464
5465 if (TypeManager.HasElementType (return_type) || !FetchMoveNext (return_type) || !FetchGetCurrent (ec, return_type)) {
5466 ec.Report.Error (202, loc, "foreach statement requires that the return type `{0}' of `{1}' must have a suitable public MoveNext method and public Current property",
5467 TypeManager.CSharpName (return_type), TypeManager.CSharpSignature (mi));
5468 return false;
5469 }
5470 }
5471
5472 enumerator_type = return_type;
5473
5474 return true;
5475 }
5476
5477 //
5478 // Retrieves a `public bool MoveNext ()' method from the Type `t'
5479 //
5480 bool FetchMoveNext (Type t)
5481 {
5482 MemberInfo[] move_next_list = TypeManager.MemberLookup (null, null, t,
5483 MemberTypes.Method,
5484 BindingFlags.Public | BindingFlags.Instance,
5485 "MoveNext", null);
5486
5487 if (move_next_list == null)
5488 return false;
5489
5490 foreach (MemberInfo m in move_next_list){
5491 MethodInfo mi = (MethodInfo) m;
5492
5493 if ((TypeManager.GetParameterData (mi).Count == 0) &&
5494 TypeManager.TypeToCoreType (mi.ReturnType) == TypeManager.bool_type) {
5495 move_next = Import.CreateMethod (mi);
5496 return true;
5497 }
5498 }
5499
5500 return false;
5501 }
5502
5503 //
5504 // Retrieves a `public T get_Current ()' method from the Type `t'
5505 //
5506 bool FetchGetCurrent (ResolveContext ec, Type t)
5507 {
5508 PropertyExpr pe = Expression.MemberLookup (ec.Compiler,
5509 ec.CurrentType, t, "Current", MemberTypes.Property,
5510 Expression.AllBindingFlags, loc) as PropertyExpr;
5511 if (pe == null)
5512 return false;
5513
5514 get_current = pe;
5515 return true;
5516 }
5517
5518 void Error_Enumerator (BlockContext ec)
5519 {
5520 if (enumerator_found) {
5521 return;
5522 }
5523
5524 ec.Report.Error (1579, loc,
5525 "foreach statement cannot operate on variables of type `{0}' because it does not contain a definition for `GetEnumerator' or is not accessible",
5526 TypeManager.CSharpName (expr.Type));
5527 }
5528
5529 bool IsOverride (MethodSpec ms)
5530 {
5531 MethodInfo m = (MethodInfo) ms.MetaInfo;
5532 m = (MethodInfo) TypeManager.DropGenericMethodArguments (m);
5533
5534 if (!m.IsVirtual || ((m.Attributes & MethodAttributes.NewSlot) != 0))
5535 return false;
5536 if (m is MethodBuilder)
5537 return true;
5538
5539 MethodInfo base_method = m.GetBaseDefinition ();
5540 return base_method != m;
5541 }
5542
5543 bool TryType (ResolveContext ec, Type t)
5544 {
5545 MethodGroupExpr mg = Expression.MemberLookup (ec.Compiler,
5546 ec.CurrentType, t, "GetEnumerator", MemberTypes.Method,
5547 Expression.AllBindingFlags, loc) as MethodGroupExpr;
5548 if (mg == null)
5549 return false;
5550
5551 MethodSpec result = null;
5552 MethodSpec tmp_move_next = null;
5553 PropertyExpr tmp_get_cur = null;
5554 Type tmp_enumerator_type = enumerator_type;
5555 foreach (var mi in mg.Methods) {
5556 if (!mi.Parameters.IsEmpty)
5557 continue;
5558
5559 // Check whether GetEnumerator is public
5560 if ((mi.MetaInfo.Attributes & MethodAttributes.Public) != MethodAttributes.Public)
5561 continue;
5562
5563 if (IsOverride (mi))
5564 continue;
5565
5566 enumerator_found = true;
5567
5568 if (!GetEnumeratorFilter (ec, mi))
5569 continue;
5570
5571 if (result != null) {
5572 if (TypeManager.IsGenericType (result.ReturnType)) {
5573 if (!TypeManager.IsGenericType (mi.ReturnType))
5574 continue;
5575
5576 MethodBase mb = TypeManager.DropGenericMethodArguments (mi);
5577 ec.Report.SymbolRelatedToPreviousError (t);
5578 ec.Report.Error(1640, loc, "foreach statement cannot operate on variables of type `{0}' " +
5579 "because it contains multiple implementation of `{1}'. Try casting to a specific implementation",
5580 TypeManager.CSharpName (t), TypeManager.CSharpSignature (mb));
5581 return false;
5582 }
5583
5584 // Always prefer generics enumerators
5585 if (!TypeManager.IsGenericType (mi.ReturnType)) {
5586 if (TypeManager.ImplementsInterface (mi.DeclaringType, result.DeclaringType) ||
5587 TypeManager.ImplementsInterface (result.DeclaringType, mi.DeclaringType))
5588 continue;
5589
5590 ec.Report.SymbolRelatedToPreviousError (result.MetaInfo);
5591 ec.Report.SymbolRelatedToPreviousError (mi.MetaInfo);
5592 ec.Report.Warning (278, 2, loc, "`{0}' contains ambiguous implementation of `{1}' pattern. Method `{2}' is ambiguous with method `{3}'",
5593 TypeManager.CSharpName (t), "enumerable", TypeManager.CSharpSignature (result.MetaInfo), TypeManager.CSharpSignature (mi.MetaInfo));
5594 return false;
5595 }
5596 }
5597 result = mi;
5598 tmp_move_next = move_next;
5599 tmp_get_cur = get_current;
5600 tmp_enumerator_type = enumerator_type;
5601 if (mi.DeclaringType == t)
5602 break;
5603 }
5604
5605 if (result != null) {
5606 move_next = tmp_move_next;
5607 get_current = tmp_get_cur;
5608 enumerator_type = tmp_enumerator_type;
5609 var mi = new [] { result };
5610 get_enumerator = new MethodGroupExpr (mi, enumerator_type, loc);
5611
5612 if (t != expr.Type) {
5613 expr = Convert.ExplicitConversion (
5614 ec, expr, t, loc);
5615 if (expr == null)
5616 throw new InternalErrorException ();
5617 }
5618
5619 get_enumerator.InstanceExpression = expr;
5620 get_enumerator.IsBase = t != expr.Type;
5621
5622 return true;
5623 }
5624
5625 return false;
5626 }
5627
5628 bool ProbeCollectionType (ResolveContext ec, Type t)
5629 {
5630 int errors = ec.Report.Errors;
5631 for (Type tt = t; tt != null && tt != TypeManager.object_type;){
5632 if (TryType (ec, tt))
5633 return true;
5634 tt = tt.BaseType;
5635 }
5636
5637 if (ec.Report.Errors > errors)
5638 return false;
5639
5640 //
5641 // Now try to find the method in the interfaces
5642 //
5643 Type [] ifaces = TypeManager.GetInterfaces (t);
5644 foreach (Type i in ifaces){
5645 if (TryType (ec, i))
5646 return true;
5647 }
5648
5649 return false;
5650 }
5651
5652 public override bool Resolve (BlockContext ec)
5653 {
5654 enumerator_type = TypeManager.ienumerator_type;
5655
5656 bool is_dynamic = TypeManager.IsDynamicType (expr.Type);
5657 if (is_dynamic)
5658 expr = Convert.ImplicitConversionRequired (ec, expr, TypeManager.ienumerable_type, loc);
5659
5660 if (!ProbeCollectionType (ec, expr.Type)) {
5661 Error_Enumerator (ec);
5662 return false;
5663 }
5664
5665 VarExpr ve = var_type as VarExpr;
5666 if (ve != null) {
5667 // Infer implicitly typed local variable from foreach enumerable type
5668 var_type = new TypeExpression (
5669 is_dynamic ? InternalType.Dynamic : get_current.PropertyInfo.PropertyType,
5670 var_type.Location);
5671 }
5672
5673 var_type = var_type.ResolveAsTypeTerminal (ec, false);
5674 if (var_type == null)
5675 return false;
5676
5677 enumerator = new TemporaryVariable (enumerator_type, loc);
5678 enumerator.Resolve (ec);
5679
5680 init = new Invocation (get_enumerator, null);
5681 init = init.Resolve (ec);
5682 if (init == null)
5683 return false;
5684
5685 Expression move_next_expr;
5686 {
5687 var mi = new [] { move_next };
5688 MethodGroupExpr mg = new MethodGroupExpr (mi, var_type.Type, loc);
5689 mg.InstanceExpression = enumerator;
5690
5691 move_next_expr = new Invocation (mg, null);
5692 }
5693
5694 get_current.InstanceExpression = enumerator;
5695
5696 Statement block = new CollectionForeachStatement (
5697 var_type.Type, variable, get_current, statement, loc);
5698
5699 loop = new While (new BooleanExpression (move_next_expr), block, loc);
5700
5701
5702 bool implements_idisposable = TypeManager.ImplementsInterface (enumerator_type, TypeManager.idisposable_type);
5703 if (implements_idisposable || !enumerator_type.IsSealed) {
5704 wrapper = new DisposableWrapper (this, implements_idisposable);
5705 } else {
5706 wrapper = new NonDisposableWrapper (this);
5707 }
5708
5709 return wrapper.Resolve (ec);
5710 }
5711
5712 protected override void DoEmit (EmitContext ec)
5713 {
5714 wrapper.Emit (ec);
5715 }
5716
5717 class NonDisposableWrapper : Statement {
5718 CollectionForeach parent;
5719
5720 internal NonDisposableWrapper (CollectionForeach parent)
5721 {
5722 this.parent = parent;
5723 }
5724
5725 protected override void CloneTo (CloneContext clonectx, Statement target)
5726 {
5727 throw new NotSupportedException ();
5728 }
5729
5730 public override bool Resolve (BlockContext ec)
5731 {
5732 return parent.ResolveLoop (ec);
5733 }
5734
5735 protected override void DoEmit (EmitContext ec)
5736 {
5737 parent.EmitLoopInit (ec);
5738 parent.EmitLoopBody (ec);
5739 }
5740
5741 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5742 {
5743 throw new NotSupportedException ();
5744 }
5745 }
5746
5747 sealed class DisposableWrapper : ExceptionStatement
5748 {
5749 CollectionForeach parent;
5750 bool implements_idisposable;
5751
5752 internal DisposableWrapper (CollectionForeach parent, bool implements)
5753 {
5754 this.parent = parent;
5755 this.implements_idisposable = implements;
5756 }
5757
5758 protected override void CloneTo (CloneContext clonectx, Statement target)
5759 {
5760 throw new NotSupportedException ();
5761 }
5762
5763 public override bool Resolve (BlockContext ec)
5764 {
5765 bool ok = true;
5766
5767 ec.StartFlowBranching (this);
5768
5769 if (!parent.ResolveLoop (ec))
5770 ok = false;
5771
5772 ec.EndFlowBranching ();
5773
5774 ok &= base.Resolve (ec);
5775
5776 if (TypeManager.void_dispose_void == null) {
5777 TypeManager.void_dispose_void = TypeManager.GetPredefinedMethod (
5778 TypeManager.idisposable_type, "Dispose", loc, Type.EmptyTypes);
5779 }
5780 return ok;
5781 }
5782
5783 protected override void EmitPreTryBody (EmitContext ec)
5784 {
5785 parent.EmitLoopInit (ec);
5786 }
5787
5788 protected override void EmitTryBody (EmitContext ec)
5789 {
5790 parent.EmitLoopBody (ec);
5791 }
5792
5793 protected override void EmitFinallyBody (EmitContext ec)
5794 {
5795 Expression instance = parent.enumerator;
5796 if (!TypeManager.IsValueType (parent.enumerator_type)) {
5797 ILGenerator ig = ec.ig;
5798
5799 parent.enumerator.Emit (ec);
5800
5801 Label call_dispose = ig.DefineLabel ();
5802
5803 if (!implements_idisposable) {
5804 ec.ig.Emit (OpCodes.Isinst, TypeManager.idisposable_type);
5805 LocalTemporary temp = new LocalTemporary (TypeManager.idisposable_type);
5806 temp.Store (ec);
5807 temp.Emit (ec);
5808 instance = temp;
5809 }
5810
5811 ig.Emit (OpCodes.Brtrue_S, call_dispose);
5812
5813 // using 'endfinally' to empty the evaluation stack
5814 ig.Emit (OpCodes.Endfinally);
5815 ig.MarkLabel (call_dispose);
5816 }
5817
5818 Invocation.EmitCall (ec, false, instance, TypeManager.void_dispose_void, null, loc);
5819 }
5820
5821 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5822 {
5823 throw new NotSupportedException ();
5824 }
5825 }
5826
5827 bool ResolveLoop (BlockContext ec)
5828 {
5829 return loop.Resolve (ec);
5830 }
5831
5832 void EmitLoopInit (EmitContext ec)
5833 {
5834 enumerator.EmitAssign (ec, init);
5835 }
5836
5837 void EmitLoopBody (EmitContext ec)
5838 {
5839 loop.Emit (ec);
5840 }
5841
5842 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5843 {
5844 enumerator_type = storey.MutateType (enumerator_type);
5845 init.MutateHoistedGenericType (storey);
5846 loop.MutateHoistedGenericType (storey);
5847 }
5848 }
5849
5850 Expression type;
5851 Expression variable;
5852 Expression expr;
5853 Statement statement;
5854
5855 public Foreach (Expression type, LocalVariableReference var, Expression expr,
5856 Statement stmt, Location l)
5857 {
5858 this.type = type;
5859 this.variable = var;
5860 this.expr = expr;
5861 statement = stmt;
5862 loc = l;
5863 }
5864
5865 public Statement Statement {
5866 get { return statement; }
5867 }
5868
5869 public override bool Resolve (BlockContext ec)
5870 {
5871 expr = expr.Resolve (ec);
5872 if (expr == null)
5873 return false;
5874
5875 if (expr.IsNull) {
5876 ec.Report.Error (186, loc, "Use of null is not valid in this context");
5877 return false;
5878 }
5879
5880 if (expr.Type == TypeManager.string_type) {
5881 statement = new ArrayForeach (this, 1);
5882 } else if (expr.Type.IsArray) {
5883 statement = new ArrayForeach (this, expr.Type.GetArrayRank ());
5884 } else {
5885 if (expr.eclass == ExprClass.MethodGroup || expr is AnonymousMethodExpression) {
5886 ec.Report.Error (446, expr.Location, "Foreach statement cannot operate on a `{0}'",
5887 expr.ExprClassName);
5888 return false;
5889 }
5890
5891 statement = new CollectionForeach (type, variable, expr, statement, loc);
5892 }
5893
5894 return statement.Resolve (ec);
5895 }
5896
5897 protected override void DoEmit (EmitContext ec)
5898 {
5899 ILGenerator ig = ec.ig;
5900
5901 Label old_begin = ec.LoopBegin, old_end = ec.LoopEnd;
5902 ec.LoopBegin = ig.DefineLabel ();
5903 ec.LoopEnd = ig.DefineLabel ();
5904
5905 statement.Emit (ec);
5906
5907 ec.LoopBegin = old_begin;
5908 ec.LoopEnd = old_end;
5909 }
5910
5911 protected override void CloneTo (CloneContext clonectx, Statement t)
5912 {
5913 Foreach target = (Foreach) t;
5914
5915 target.type = type.Clone (clonectx);
5916 target.variable = variable.Clone (clonectx);
5917 target.expr = expr.Clone (clonectx);
5918 target.statement = statement.Clone (clonectx);
5919 }
5920
5921 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5922 {
5923 statement.MutateHoistedGenericType (storey);
5924 }
5925 }
5926 }
git-svn mirror of mcs