| blob | c8b77c1adc11d47aabcf6bb0564ca12f3461f35f |
1 //
2 // statement.cs: Statement representation for the IL tree.
3 //
4 // Authors:
5 // Miguel de Icaza (miguel@ximian.com)
6 // Martin Baulig (martin@ximian.com)
7 // Marek Safar (marek.safar@gmail.com)
8 //
9 // Copyright 2001, 2002, 2003 Ximian, Inc.
10 // Copyright 2003, 2004 Novell, Inc.
11 // Copyright 2011 Xamarin Inc.
12 //
17 #if STATIC
19 #else
21 #endif
32 }
33 }
35 /// <summary>
36 /// Resolves the statement, true means that all sub-statements
37 /// did resolve ok.
38 /// </summary>
40 {
42 }
44 /// <summary>
45 /// Return value indicates whether all code paths emitted return.
46 /// </summary>
50 {
56 }
57 }
59 //
60 // This routine must be overrided in derived classes and make copies
61 // of all the data that might be modified if resolved
62 //
66 {
70 }
73 {
74 ec.Report.Error (834, loc, "A lambda expression with statement body cannot be converted to an expresion tree");
76 }
79 {
81 }
83 //
84 // Return value indicates whether statement has unreachable end
85 //
89 {
94 }
96 //
97 // Special handling cases
98 //
101 }
112 }
115 {
120 }
123 {
127 }
133 }
134 }
135 }
138 {
140 }
141 }
144 {
146 {
148 }
151 {
153 }
156 {
157 }
160 {
162 }
165 {
167 }
170 {
171 // nothing needed.
172 }
175 {
177 }
178 }
181 Expression expr;
189 {
190 }
193 Statement true_statement,
194 Statement false_statement,
195 Location l)
196 {
201 }
206 }
207 }
210 {
217 }
220 }
223 {
225 Label end;
227 //
228 // If we're a boolean constant, Resolve() already
229 // eliminated dead code for us.
230 //
241 }
254 }
263 }
264 }
267 {
287 else
291 }
299 }
312 else
314 }
317 }
320 {
334 }
337 }
349 }
352 {
359 }
362 {
364 }
365 }
368 {
372 public Do (Statement statement, BooleanExpression bool_expr, Location doLocation, Location whileLocation)
374 {
378 }
382 }
385 {
391 }
394 {
406 // Mark start of while condition
409 //
410 // Dead code elimination
411 //
420 }
426 }
429 {
443 }
446 }
449 {
457 }
463 }
466 }
469 {
474 }
477 {
479 }
482 {
484 }
487 {
489 }
490 }
493 {
500 {
503 }
506 {
517 }
521 }
524 {
528 }
536 //
537 // Inform whether we are infinite or not
538 //
540 // expr is 'true', since the 'empty' case above handles the 'false' case
550 //
551 // Inform that we are infinite (ie, `we return'), only
552 // if we do not `break' inside the code.
553 //
571 }
575 }
578 {
587 //
588 // Special case infinite while with breaks
589 //
593 }
601 }
604 {
610 //
611 // Special case unreachable while body
612 //
616 }
620 //
621 // When infinite while end is unreachable via break anything what follows is unreachable too
622 //
627 }
630 {
635 }
638 {
640 }
643 {
651 }
654 {
656 }
657 }
660 {
666 {
668 }
672 }
676 }
680 }
683 {
694 }
695 }
698 }
701 }
704 {
707 DefiniteAssignmentBitSet da_false;
714 }
720 //
721 // Special case infinite for with breaks
722 //
726 }
734 }
737 {
745 }
747 //
748 // When infinite for end is unreachable via break anything what follows is unreachable too
749 //
752 }
755 }
758 {
765 }
785 //
786 // If test is null, there is no test, and we are just
787 // an infinite loop
788 //
792 //
793 // The Resolve code already catches the case for
794 // Test == Constant (false) so we know that
795 // this is true
796 //
802 }
810 }
813 {
823 }
826 {
828 }
831 {
839 }
842 {
844 }
847 {
849 }
850 }
853 {
855 {
857 }
859 public Statement Statement { get; set; }
862 {
871 }
873 //
874 // Needed by possibly infinite loops statements (for, while) and switch statment
875 //
877 {
878 }
881 {
882 }
885 {
886 }
887 }
890 {
891 ExpressionStatement expr;
894 {
897 }
900 {
903 }
908 }
909 }
912 {
915 }
918 {
920 }
923 {
926 }
929 {
932 }
935 {
938 }
941 {
943 }
944 }
947 {
948 Expression expr;
951 {
954 }
959 }
960 }
963 {
966 }
969 {
971 }
974 {
976 }
979 {
983 }
986 {
988 }
989 }
991 //
992 // Simple version of statement list not requiring a block
993 //
995 {
999 {
1001 }
1003 #region Properties
1007 }
1008 }
1009 #endregion
1012 {
1014 }
1017 {
1022 }
1025 {
1028 }
1031 {
1036 }
1039 {
1047 }
1050 {
1056 }
1059 {
1061 }
1062 }
1064 //
1065 // For statements which require special handling when inside try or catch block
1066 //
1068 {
1072 protected abstract bool IsLocalExit { get; }
1075 {
1079 //
1080 // We are inside finally scope but is it the scope we are exiting
1081 //
1088 }
1092 }
1093 }
1094 }
1096 unwind_protect = bc.HasAny (ResolveContext.Options.TryScope | ResolveContext.Options.CatchScope);
1098 }
1101 {
1106 fc.TryFinally.RegisterForControlExitCheck (new DefiniteAssignmentBitSet (fc.DefiniteAssignment));
1109 }
1112 }
1113 }
1115 /// <summary>
1116 /// Implements the return statement
1117 /// </summary>
1119 {
1120 Expression expr;
1124 {
1127 }
1129 #region Properties
1134 }
1137 }
1138 }
1143 }
1144 }
1146 #endregion
1149 {
1156 //
1157 // Return must not be followed by an expression when
1158 // the method return type is Task
1159 //
1164 //
1165 // Extra trick not to emit ret/leave inside awaiter body
1166 //
1169 }
1171 if (s_return_type.IsGenericTask || (s_return_type.Arity == 1 && s_return_type.IsCustomTaskType ()))
1173 }
1181 }
1184 }
1196 }
1201 }
1212 else
1215 }
1219 "Anonymous function or lambda expression converted to a void returning delegate cannot return a value");
1221 }
1229 "Async lambda expression or anonymous method converted to a `Task' cannot return a value. Consider returning `Task<T>'");
1232 "`{0}': A return keyword must not be followed by an expression when async method returns `Task'. Consider using `Task<T>' return type",
1234 }
1236 }
1238 //
1239 // The return type is actually Task<T> type argument
1240 //
1241 if (expr.Type == async_type && async_type.TypeArguments [0] != ec.Module.PredefinedTypes.Task.TypeSpec) {
1247 }
1248 }
1252 "Anonymous function or lambda expression converted to a void returning delegate cannot return a value");
1254 }
1261 }
1263 //
1264 // Try to optimize simple lambda. Only when optimizations are enabled not to cause
1265 // unexpected debugging experience
1266 //
1269 }
1270 }
1271 }
1272 }
1278 ec.Report.Error (8149, loc, "By-reference returns can only be used in methods that return by reference");
1280 }
1286 ec.Report.Error (8150, loc, "By-reference return is required when method returns by reference");
1288 }
1293 ec.Report.Error (8151, loc, "The return by reference expression must be of type `{0}' because this method returns by reference",
1296 }
1304 "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",
1306 }
1308 }
1309 }
1310 }
1313 }
1316 {
1324 //
1325 // It's null for await without async
1326 //
1328 //
1329 // Special case hoisted return value (happens in try/finally scenario)
1330 //
1333 }
1343 }
1347 }
1354 }
1362 }
1363 }
1366 {
1374 }
1377 {
1379 "Cannot return a value from iterators. Use the yield return statement to return a value, or yield break to end the iteration");
1380 }
1383 {
1389 }
1392 }
1395 {
1397 // It's null for simple return;
1400 }
1403 {
1405 }
1406 }
1409 {
1411 LabeledStatement label;
1412 TryFinally try_finally;
1415 {
1418 }
1421 get { return target; }
1422 }
1427 }
1428 }
1431 {
1436 }
1443 }
1446 {
1447 bc.Report.Error (159, loc, "The label `{0}:' could not be found within the scope of the goto statement",
1448 label);
1449 }
1452 {
1453 // Goto to unreachable label
1462 }
1465 {
1476 }
1479 }
1482 }
1485 {
1486 // Nothing to clone
1487 }
1490 {
1491 // This should only happen for goto from try block to unrechable label
1500 }
1503 }
1506 {
1513 }
1516 }
1519 {
1521 }
1522 }
1528 Label label;
1529 Block block;
1532 {
1536 }
1539 {
1546 }
1551 }
1552 }
1555 get { return name; }
1556 }
1559 {
1563 }
1566 {
1568 }
1571 {
1574 }
1577 {
1580 }
1583 }
1586 {
1593 }
1596 {
1604 }
1607 {
1609 }
1610 }
1613 /// <summary>
1614 /// `goto default' statement
1615 /// </summary>
1617 {
1620 {
1621 }
1624 {
1628 }
1634 }
1637 {
1639 }
1642 {
1648 }
1649 }
1652 }
1655 {
1657 }
1658 }
1660 /// <summary>
1661 /// `goto case' statement
1662 /// </summary>
1664 {
1665 Expression expr;
1669 {
1671 }
1676 }
1677 }
1679 public SwitchLabel Label { get; set; }
1682 {
1686 }
1691 }
1693 Constant res;
1702 }
1709 }
1716 }
1719 {
1721 }
1724 {
1728 }
1731 {
1737 }
1738 }
1741 }
1744 {
1746 }
1747 }
1750 {
1755 {
1757 }
1760 {
1761 // Nothing to clone
1762 }
1765 {
1768 unwind_protect = bc.HasAny (ResolveContext.Options.TryScope | ResolveContext.Options.CatchScope);
1772 }
1775 {
1777 }
1780 {
1783 }
1786 {
1788 }
1789 }
1792 Expression expr;
1795 {
1798 }
1803 }
1804 }
1807 {
1812 rc.Report.Error (155, expr.Location, "The type caught or thrown must be derived from System.Exception");
1814 }
1817 }
1820 {
1823 ec.Report.Error (156, loc, "A throw statement with no arguments is not allowed outside of a catch clause");
1828 "A throw statement with no arguments is not allowed inside of a finally clause nested inside of the innermost catch clause");
1830 }
1831 }
1832 }
1835 }
1845 }
1848 {
1856 }
1861 }
1866 }
1867 }
1870 {
1875 }
1878 {
1881 }
1884 {
1889 }
1892 {
1894 }
1895 }
1898 {
1901 {
1902 }
1905 {
1907 }
1910 {
1915 l = TryFinally.EmitRedirectedJump (ec, async_body, l, enclosing_loop.Statement as Block, unwind_protect);
1916 }
1919 }
1922 {
1925 }
1928 {
1931 }
1934 {
1941 }
1942 }
1945 {
1948 {
1949 }
1952 {
1954 }
1958 {
1963 l = TryFinally.EmitRedirectedJump (ec, async_body, l, enclosing_loop.Statement as Block, unwind_protect);
1964 }
1967 }
1970 {
1973 }
1976 {
1983 }
1984 }
1987 {
1991 {
1993 }
1998 }
1999 }
2002 {
2003 // nothing needed.
2004 }
2007 {
2011 }
2015 // Don't need to do extra checks for simple statements loops
2018 }
2021 }
2022 }
2024 public interface ILocalVariable
2025 {
2029 }
2031 public interface INamedBlockVariable
2032 {
2033 Block Block { get; }
2035 bool IsDeclared { get; }
2036 bool IsParameter { get; }
2037 Location Location { get; }
2038 }
2040 public class BlockVariableDeclarator
2041 {
2042 LocalVariable li;
2043 Expression initializer;
2046 {
2052 }
2054 #region Properties
2059 }
2060 }
2065 }
2068 }
2069 }
2071 #endregion
2074 {
2080 }
2081 }
2084 {
2085 Expression initializer;
2089 TypeSpec type;
2092 {
2096 }
2099 {
2101 }
2103 #region Properties
2108 }
2109 }
2114 }
2117 }
2118 }
2123 }
2124 }
2129 }
2130 }
2132 #endregion
2135 {
2140 }
2143 {
2149 Field f = new Field (container, new TypeExpression (li.Type, li.Location), Modifiers.PUBLIC | Modifiers.STATIC,
2157 }
2160 {
2162 }
2165 {
2169 //
2170 // C# 3.0 introduced contextual keywords (var) which behaves like a type if type with
2171 // same name exists or as a keyword when no type was found
2172 //
2180 }
2185 }
2188 bc.Report.Error (818, loc, "An implicitly typed local variable declarator must include an initializer");
2190 }
2193 bc.Report.Error (819, loc, "An implicitly typed local variable declaration cannot include multiple declarators");
2195 }
2202 // Set error type to indicate the var was placed correctly but could
2203 // not be infered
2204 //
2205 // var a = missing ();
2206 //
2208 }
2209 }
2218 }
2219 }
2225 }
2227 bool eval_global = bc.Module.Compiler.Settings.StatementMode && bc.CurrentBlock is ToplevelBlock;
2232 }
2237 bc.Report.Error (8172, loc, "Cannot initialize a by-reference variable `{0}' with a value", li.Name);
2239 }
2245 }
2249 bc.Report.Error (8171, loc, "Cannot initialize a by-value variable `{0}' with a reference expression", li.Name);
2251 }
2252 }
2255 // li.Variable.DefinitelyAssigned
2256 }
2265 }
2269 // d.Variable.DefinitelyAssigned
2270 }
2271 }
2272 }
2275 }
2277 protected virtual Expression ResolveInitializer (BlockContext bc, LocalVariable li, Expression initializer)
2278 {
2279 var a = new SimpleAssign (li.CreateReferenceExpression (bc, li.Location), initializer, li.Location);
2281 }
2284 {
2286 }
2289 {
2301 }
2302 }
2303 }
2304 }
2307 {
2315 }
2316 }
2319 }
2322 {
2325 }
2328 {
2341 }
2342 }
2345 {
2347 }
2348 }
2351 {
2354 {
2355 }
2358 {
2362 // Nothing to emit, not even sequence point
2363 }
2365 protected override Expression ResolveInitializer (BlockContext bc, LocalVariable li, Expression initializer)
2366 {
2371 Constant c;
2374 else
2380 }
2385 initializer.Error_ConstantCanBeInitializedWithNullOnly (bc, li.Type, initializer.Location, li.Name);
2386 else
2390 }
2394 }
2397 {
2399 }
2400 }
2402 //
2403 // The information about a user-perceived local variable
2404 //
2406 {
2408 public enum Flags
2409 {
2424 }
2426 TypeSpec type;
2430 Flags flags;
2431 Constant const_value;
2434 HoistedVariable hoisted_variant;
2436 LocalBuilder builder;
2439 {
2443 }
2447 {
2449 }
2451 //
2452 // Used by variable declarators
2453 //
2456 {
2457 }
2459 #region Properties
2464 }
2465 }
2470 }
2471 }
2476 }
2479 }
2480 }
2482 //
2483 // Hoisted local variable variant
2484 //
2488 }
2491 }
2492 }
2497 }
2498 }
2503 }
2504 }
2511 }
2512 }
2517 }
2518 }
2523 }
2526 }
2527 }
2532 }
2533 }
2538 }
2539 }
2544 }
2547 }
2548 }
2553 }
2554 }
2559 }
2560 }
2565 }
2566 }
2571 }
2572 }
2577 }
2580 }
2581 }
2583 #endregion
2586 {
2589 // Missing flow analysis or wrong variable flags
2590 throw new InternalErrorException ("VariableInfo is null and the variable `{0}' is not used", name);
2591 }
2594 ec.Report.Warning (219, 3, Location, "The variable `{0}' is assigned but its value is never used", Name);
2595 else
2597 }
2606 // To avoid Used warning duplicates
2608 }
2613 builder = ec.DeclareLocal (ReferenceContainer.MakeType (ec.Module, ((PointerContainer) Type).Element), IsFixed);
2615 //
2616 // All fixed variabled are pinned, a slot has to be alocated
2617 //
2619 }
2623 }
2625 public static LocalVariable CreateCompilerGenerated (TypeSpec type, Block block, Location loc, bool writeToSymbolFile = false, Flags additionalFlags = 0)
2626 {
2627 LocalVariable li = new LocalVariable (block, GetCompilerGeneratedName (block), Flags.CompilerGenerated | Flags.Used | additionalFlags, loc);
2633 }
2636 {
2640 }
2643 }
2646 {
2647 // TODO: Need something better for temporary variables
2652 }
2655 {
2656 // TODO: Need something better for temporary variables
2661 }
2664 {
2665 // TODO: Need something better for temporary variables
2671 else
2673 }
2676 {
2677 // HACK: Debugger depends on the name semantics
2679 }
2682 {
2690 }
2693 }
2696 {
2704 }
2707 {
2709 }
2712 {
2713 //
2714 // No need to run assignment analysis for these guys
2715 //
2720 }
2722 //
2723 // Mark the variables as referenced in the user code
2724 //
2726 {
2728 }
2731 {
2733 }
2736 {
2738 }
2741 {
2743 }
2744 }
2746 /// <summary>
2747 /// Block represents a C# block.
2748 /// </summary>
2749 ///
2750 /// <remarks>
2751 /// This class is used in a number of places: either to represent
2752 /// explicit blocks that the programmer places or implicit blocks.
2753 ///
2754 /// Implicit blocks are used as labels or to introduce variable
2755 /// declarations.
2756 ///
2757 /// Top-level blocks derive from Block, and they are called ToplevelBlock
2758 /// they contain extra information that is not necessary on normal blocks.
2759 /// </remarks>
2762 public enum Flags
2763 {
2781 }
2792 //
2793 // The statements in this block
2794 //
2801 Block original;
2803 #if DEBUG
2809 #endif
2811 // int assignable_slots;
2815 {
2816 }
2819 {
2821 // the appropriate constructors will fixup these fields
2824 }
2834 }
2836 #region Properties
2841 }
2844 }
2845 }
2848 get { return (flags & Flags.CompilerGenerated) != 0; }
2849 set { flags = value ? flags | Flags.CompilerGenerated : flags & ~Flags.CompilerGenerated; }
2850 }
2856 }
2857 }
2862 }
2863 }
2866 get { return (flags & Flags.Unchecked) != 0; }
2867 set { flags = value ? flags | Flags.Unchecked : flags & ~Flags.Unchecked; }
2868 }
2871 get { return (flags & Flags.Unsafe) != 0; }
2872 set { flags |= Flags.Unsafe; }
2873 }
2876 get { return statements; }
2877 }
2879 #endregion
2882 {
2884 }
2887 {
2889 }
2892 {
2894 }
2896 public virtual void AddLocalName (string name, INamedBlockVariable li, bool canShadowChildrenBlockName = false)
2897 {
2899 }
2901 public virtual void Error_AlreadyDeclared (string name, INamedBlockVariable variable, string reason)
2902 {
2906 }
2909 "A local variable named `{0}' cannot be declared in this scope because it would give a different meaning " +
2912 }
2915 {
2922 }
2923 }
2926 {
2929 name);
2930 }
2932 //
2933 // It should be used by expressions which require to
2934 // register a statement during resolve process.
2935 //
2937 {
2941 //
2942 // Simple recursive helper, when resolve scope initializer another
2943 // new scope initializer can be added, this ensures it's initialized
2944 // before existing one. For now this can happen with expression trees
2945 // in base ctor initializer only
2946 //
2952 }
2953 }
2956 {
2958 }
2961 {
2963 }
2966 {
2968 }
2971 {
2984 }
2985 }
2990 }
2993 {
2999 }
3000 }
3003 {
3010 //
3011 // Compiler generated scope statements
3012 //
3014 for (resolving_init_idx = 0; resolving_init_idx < scope_initializers.Count; ++resolving_init_idx) {
3016 }
3019 }
3030 }
3031 }
3037 }
3040 {
3043 }
3044 }
3047 {
3052 }
3055 {
3058 }
3061 {
3065 }
3068 }
3071 {
3081 }
3083 //
3084 // Statement end reachability is needed mostly due to goto support. Consider
3085 //
3086 // if (cond) {
3087 // goto X;
3088 // } else {
3089 // goto Y;
3090 // }
3091 // X:
3092 //
3093 // X label is reachable only via goto not as another statement after if. We need
3094 // this for flow-analysis only to carry variable info correctly.
3095 //
3101 //
3102 // Special case for try-finally with unreachable code after
3103 // finally block. Try block has to include leave opcode but there is
3104 // no label to leave to after unreachable finally block closing
3105 // brace. This sentinel ensures there is always IL instruction to
3106 // leave to even if we know it'll never be reached.
3107 //
3117 }
3122 }
3123 }
3124 }
3126 //
3127 // Idea is to stop after goto case because goto case will always have at least same
3128 // variable assigned as switch case label. This saves a lot for complex goto case tests
3129 //
3134 }
3139 }
3141 //
3142 // The condition should be true unless there is forward jumping goto
3143 //
3144 // if (this is ExplicitBlock && end_unreachable != Explicit.HasReachableClosingBrace)
3145 // Debug.Fail ();
3148 }
3151 {
3152 // LAMESPEC: It's not clear whether declararion statement should be part of reachability
3153 // analysis. Even csc report unreachable warning for it but it's actually used hence
3154 // we try to emulate this behaviour
3155 //
3156 // Consider:
3157 // goto L;
3158 // int v;
3159 // L:
3160 // v = 1;
3166 }
3169 {
3174 }
3182 }
3185 }
3188 {
3193 }
3196 }
3198 #if DEBUG
3200 {
3201 return String.Format ("{0}: ID={1} Clone={2} Location={3}", GetType (), ID, clone_id != 0, StartLocation);
3202 }
3203 #endif
3206 {
3208 #if DEBUG
3210 #endif
3216 target.ParametersBlock = (ParametersBlock) (ParametersBlock == this ? target : clonectx.RemapBlockCopy (ParametersBlock));
3217 target.Explicit = (ExplicitBlock) (Explicit == this ? target : clonectx.LookupBlock (Explicit));
3225 }
3228 {
3230 }
3231 }
3234 {
3240 {
3241 }
3245 {
3247 }
3249 #region Properties
3254 }
3255 }
3260 }
3261 }
3266 }
3269 }
3270 }
3272 //
3273 // Used to indicate that the block has reference to parent
3274 // block and cannot be made static when defining anonymous method
3275 //
3279 }
3282 }
3283 }
3288 }
3291 }
3292 }
3297 }
3298 }
3300 #endregion
3302 //
3303 // Creates anonymous method storey in current block
3304 //
3306 {
3307 //
3308 // Return same story for iterator and async blocks unless we are
3309 // in nested anonymous method
3310 //
3311 if (ec.CurrentAnonymousMethod is StateMachineInitializer && ParametersBlock.Original == ec.CurrentAnonymousMethod.Block.Original)
3317 //
3318 // Creates anonymous method storey for this block
3319 //
3320 am_storey = new AnonymousMethodStorey (this, ec.CurrentMemberDefinition.Parent.PartialContainer, mc, ec.CurrentTypeParameters, "AnonStorey", MemberKind.Class);
3321 }
3324 }
3327 {
3334 }
3340 }
3343 {
3344 // TODO: It's needed only when scope has variable (normal or lifted)
3348 }
3354 }
3364 }
3365 }
3368 {
3372 }
3374 //
3375 // Creates anonymous method storey
3376 //
3381 if (Original.Explicit.HasCapturedThis && Original.ParametersBlock.TopBlock.ThisReferencesFromChildrenBlock != null) {
3383 //
3384 // Only first storey in path will hold this reference. All children blocks will
3385 // reference it indirectly using $ref field
3386 //
3393 }
3394 }
3396 if (b.Explicit == b.Explicit.ParametersBlock && b.Explicit.ParametersBlock.StateMachine != null) {
3402 }
3403 }
3405 //
3406 // We are the first storey on path and 'this' has to be hoisted
3407 //
3409 foreach (ExplicitBlock ref_block in Original.ParametersBlock.TopBlock.ThisReferencesFromChildrenBlock) {
3410 //
3411 // ThisReferencesFromChildrenBlock holds all reference even if they
3412 // are not on this path. It saves some memory otherwise it'd have to
3413 // be in every explicit block. We run this check to see if the reference
3414 // is valid for this storey
3415 //
3417 for (; block_on_path != null && block_on_path != Original; block_on_path = block_on_path.Parent);
3424 }
3427 ParametersBlock pb;
3431 //
3432 // Don't add storey cross reference for `this' when the storey ends up not
3433 // beeing attached to any parent
3434 //
3437 for (Block ab = b.AnonymousMethodStorey.OriginalSourceBlock.Parent; ab != null; ab = ab.Parent) {
3441 }
3443 // Needs to be in sync with AnonymousMethodBody::DoCreateMethodHost
3448 }
3450 }
3452 //
3453 // Stop propagation inside same top block
3454 //
3457 // b_storey.HoistedThis = storey.HoistedThis;
3459 }
3464 }
3470 //
3471 // If we are state machine with no parent. We can hook into parent without additional
3472 // reference and capture this directly
3473 //
3479 }
3480 }
3486 }
3489 }
3494 if (parent_this_block.StateMachine != null && parent_this_block.StateMachine.HoistedThis != null) {
3496 }
3497 }
3499 //
3500 // Add reference to closest storey which holds captured this
3501 //
3503 }
3505 //
3506 // Add parent storey reference only when this is not captured directly
3507 //
3511 }
3512 }
3513 }
3514 }
3515 }
3524 //
3525 // Stop propagation inside same top block
3526 //
3531 }
3539 }
3542 }
3543 }
3544 }
3549 }
3552 {
3554 }
3557 {
3562 }
3565 {
3574 }
3575 }
3578 {
3589 }
3590 }
3593 {
3595 }
3598 {
3600 }
3603 {
3607 }
3608 }
3610 //
3611 // ParametersBlock was introduced to support anonymous methods
3612 // and lambda expressions
3613 //
3615 {
3617 {
3624 {
3627 }
3629 #region Properties
3634 }
3635 }
3640 }
3641 }
3646 }
3647 }
3652 }
3653 }
3658 }
3661 }
3662 }
3667 }
3668 }
3673 }
3674 }
3679 }
3680 }
3682 #endregion
3685 {
3687 }
3688 }
3690 //
3691 // Block is converted into an expression
3692 //
3694 {
3695 Expression child;
3699 {
3702 }
3705 {
3707 }
3710 {
3712 }
3715 {
3726 }
3729 {
3732 }
3733 }
3742 public ParametersBlock (Block parent, ParametersCompiled parameters, Location start, Flags flags = 0)
3744 {
3755 }
3759 {
3765 }
3767 //
3768 // It's supposed to be used by method body implementation of anonymous methods
3769 //
3772 {
3785 //
3786 // Overwrite original for comparison purposes when linking cross references
3787 // between anonymous methods
3788 //
3790 }
3792 #region Properties
3797 }
3799 flags = value ? flags | Flags.HasReferenceToStoreyForInstanceLambdas : flags & ~Flags.HasReferenceToStoreyForInstanceLambdas;
3800 }
3801 }
3806 }
3809 }
3810 }
3812 //
3813 // Block has been converted to expression tree
3814 //
3818 }
3819 }
3821 //
3822 // The parameters for the block.
3823 //
3827 }
3828 }
3833 }
3834 }
3839 }
3842 }
3843 }
3848 }
3849 }
3851 public int TemporaryLocalsCount { get; set; }
3853 #endregion
3855 //
3856 // Checks whether all `out' parameters have been assigned.
3857 //
3859 {
3861 }
3864 {
3878 }
3879 }
3882 {
3887 //
3888 // Clone label statements as well as they contain block reference
3889 //
3902 }
3907 target.labels.Add (entry.Key, RemapLabeledStatement (labeled, clonectx.RemapBlockCopy (labeled.Block)));
3908 }
3909 }
3912 }
3918 }
3919 }
3922 {
3929 }
3932 }
3935 {
3939 }
3942 }
3945 {
3949 }
3952 }
3955 {
3962 }
3965 {
3967 }
3970 {
3971 //
3972 // Cloned parameters blocks can have their own cloned version of top-level labels
3973 //
3979 }
3984 }
3998 }
3999 }
4002 }
4005 {
4013 }
4016 {
4020 }
4023 }
4026 {
4028 }
4031 {
4036 }
4039 {
4049 // TODO: Should use Parameter only and more block there
4053 }
4054 }
4057 {
4060 //
4061 // Cannot remap label block if the label was not yet cloned which
4062 // can happen in case of anonymous method inside anoynymous method
4063 // with a label. But in this case we don't care because goto cannot
4064 // jump of out anonymous method
4065 //
4073 }
4076 }
4079 {
4080 // TODO: if ((flags & Flags.Resolved) != 0)
4097 if (e is CompletionResult || bc.Report.IsDisabled || e is FatalException || bc.Report.Printer is NullReportPrinter || bc.Module.Compiler.Settings.BreakOnInternalError)
4101 bc.Report.Error (584, bc.CurrentBlock.StartLocation, "Internal compiler error: {0}", e.Message);
4104 }
4105 }
4107 //
4108 // If an asynchronous body of F is either an expression classified as nothing, or a
4109 // statement block where no return statements have expressions, the inferred return type is Task
4110 //
4117 }
4118 }
4121 }
4124 {
4132 }
4133 }
4135 public ToplevelBlock ConvertToIterator (IMethodData method, TypeDefinition host, TypeSpec iterator_type, bool is_enumerable)
4136 {
4143 var tlb = new ToplevelBlock (host.Compiler, Parameters, Location.Null, Flags.CompilerGenerated);
4148 }
4150 public ParametersBlock ConvertToAsyncTask (IMemberContext context, TypeDefinition host, ParametersCompiled parameters, TypeSpec returnType, TypeSpec delegateType, Location loc)
4151 {
4159 }
4165 }
4171 }
4172 }
4177 }
4199 }
4200 }
4202 //
4203 //
4204 //
4206 {
4207 LocalVariable this_variable;
4208 CompilerContext compiler;
4215 {
4216 }
4218 public ToplevelBlock (CompilerContext ctx, ParametersCompiled parameters, Location start, Flags flags = 0)
4220 {
4226 }
4228 //
4229 // Recreates a top level block from parameters block. Used for
4230 // compiler generated methods where the original block comes from
4231 // explicit child block. This works for already resolved blocks
4232 // only to ensure we resolve them in the correct flow order
4233 //
4236 {
4239 }
4244 }
4247 }
4248 }
4253 }
4254 }
4256 //
4257 // Used by anonymous blocks to track references of `this' variable
4258 //
4262 }
4263 }
4265 //
4266 // Returns the "this" instance variable of this block.
4267 // See AddThisVariable() for more information.
4268 //
4272 }
4273 }
4275 public override void AddLocalName (string name, INamedBlockVariable li, bool ignoreChildrenBlocks)
4276 {
4284 }
4294 }
4296 //
4297 // A collision checking between local names
4298 //
4304 // Collision at same level
4308 }
4310 // Collision with parent
4317 }
4318 }
4321 // Collision with children
4327 }
4328 }
4329 }
4330 }
4333 }
4336 {
4344 }
4354 }
4356 //
4357 // A collision checking between labels
4358 //
4363 // Collision at same level
4368 }
4370 // Collision with parent
4378 }
4379 }
4381 // Collision with with children
4389 }
4390 }
4391 }
4394 }
4397 {
4403 }
4406 {
4408 }
4410 //
4411 // Creates an arguments set from all parameters, useful for method proxy calls
4412 //
4414 {
4432 }
4435 }
4438 }
4440 //
4441 // Lookup inside a block, the returned value can represent 3 states
4442 //
4443 // true+variable: A local name was found and it's valid
4444 // false+variable: A local name was found in a child block only
4445 // false+null: No local name was found
4446 //
4448 {
4493 }
4494 }
4498 }
4501 {
4509 }
4514 }
4515 }
4516 }
4518 // <summary>
4519 // This is used by non-static `struct' constructors which do not have an
4520 // initializer - in this case, the constructor must initialize all of the
4521 // struct's fields. To do this, we add a "this" variable and use the flow
4522 // analysis code to ensure that it's been fully initialized before control
4523 // leaves the constructor.
4524 // </summary>
4526 {
4530 this_variable = new LocalVariable (this, "this", LocalVariable.Flags.IsThis | LocalVariable.Flags.Used, StartLocation);
4533 }
4536 {
4537 //
4538 // If we're a non-static struct constructor which doesn't have an
4539 // initializer, then we must initialize all of the struct's fields.
4540 //
4545 }
4548 {
4563 }
4564 }
4570 }
4571 }
4574 }
4577 {
4580 }
4583 {
4594 }
4595 }
4600 }
4601 }
4602 }
4605 {
4613 }
4616 }
4618 //
4619 // If `HasReturnLabel' is set, then we already emitted a
4620 // jump to the end of the method, so we must emit a `ret'
4621 // there.
4622 //
4623 // Unfortunately, System.Reflection.Emit automatically emits
4624 // a leave to the end of a finally block. This is a problem
4625 // if no code is following the try/finally block since we may
4626 // jump to a point after the end of the method.
4627 // As a workaround, we're always creating a return label in
4628 // this case.
4629 //
4641 }
4645 }
4646 }
4649 {
4663 // TODO: var md = bc.CurrentMemberDefinition;
4664 bc.Report.Error (161, md.Location, "`{0}': not all code paths return a value", md.GetSignatureForError ());
4665 }
4675 }
4678 }
4679 }
4682 {
4683 Constant converted;
4684 Expression label;
4688 //
4689 // if expr == null, then it is the default case.
4690 //
4692 {
4695 }
4700 }
4701 }
4706 }
4707 }
4712 }
4713 }
4718 }
4721 }
4722 }
4724 public bool PatternMatching { get; set; }
4726 public bool SectionStart { get; set; }
4729 {
4732 }
4735 }
4738 {
4740 }
4743 {
4749 }
4752 {
4757 }
4759 //
4760 // Resolves the expression, reduces it to a literal if possible
4761 // and then converts it to the requested type.
4762 //
4764 {
4773 }
4782 }
4787 }
4791 }
4794 {
4796 ec.Report.Error (152, loc, "The label `{0}' already occurs in this switch statement", GetSignatureForError ());
4797 }
4800 {
4804 }
4807 {
4809 }
4812 {
4816 else
4820 }
4821 }
4824 {
4825 // structure used to hold blocks of keys while calculating table switch
4827 {
4833 {
4837 }
4840 {
4844 }
4849 }
4850 }
4853 {
4855 // Ensure the range has > 50% occupancy
4862 }
4865 {
4872 }
4873 }
4876 {
4880 {
4882 }
4885 {
4887 }
4890 {
4892 }
4895 {
4897 }
4898 }
4901 {
4905 {
4908 }
4910 public bool FallOut { get; set; }
4913 {
4914 }
4917 {
4918 }
4921 {
4923 fc.Report.Error (8070, loc, "Control cannot fall out of switch statement through final case label `{0}'",
4928 }
4930 }
4931 }
4935 //
4936 // Mapping of all labels to their SwitchLabels
4937 //
4945 /// <summary>
4946 /// The governing switch type
4947 /// </summary>
4950 Expression new_expr;
4952 SwitchLabel case_null;
4953 SwitchLabel case_default;
4957 ExpressionStatement string_dictionary;
4958 FieldExpr switch_cache_field;
4959 ExplicitBlock block;
4962 //
4963 // Nullable Types support
4964 //
4969 {
4973 }
4975 public SwitchLabel ActiveLabel { get; set; }
4980 }
4981 }
4986 }
4987 }
4992 }
4993 }
4998 }
4999 }
5004 }
5005 }
5010 }
5011 }
5013 //
5014 // Determines the governing type for a switch. The returned
5015 // expression might be the expression from the switch, or an
5016 // expression that includes any potential conversions to
5017 //
5019 {
5033 }
5038 //
5039 // Try to find a *user* defined implicit conversion.
5040 //
5041 // If there is no implicit conversion, or if there are multiple
5042 // conversions, we have to report an error
5043 //
5060 //
5061 // Ignore over-worked ImplicitUserConversions that do
5062 // an implicit conversion in addition to the user conversion.
5063 //
5069 // rc.Report.ExtraInformation (loc, "(Ambiguous implicit user defined conversion in previous ");
5071 }
5074 }
5076 }
5079 {
5082 // LAMESPEC: For some reason it does not contain bool which looks like csc bug
5093 types.String
5094 };
5102 }
5103 }
5106 }
5109 {
5117 }
5120 }
5130 else
5137 }
5138 }
5142 else
5144 }
5145 }
5147 //
5148 // This method emits code for a lookup-based switch statement (non-string)
5149 // Basically it groups the cases into blocks that are at least half full,
5150 // and then spits out individual lookup opcodes for each block.
5151 // It emits the longest blocks first, and short blocks are just
5152 // handled with direct compares.
5153 //
5155 {
5159 // We have done all hard work for string already
5160 // setup single range only
5168 //
5169 // Build possible ranges of switch labes to reduce number
5170 // of comparisons
5171 //
5182 }
5184 // sort the blocks so we can tackle the largest ones first
5186 }
5189 TypeSpec compare_type = SwitchType.IsEnum ? EnumSpec.GetUnderlyingType (SwitchType) : SwitchType;
5195 // Optimize small ranges using simple equality check
5208 }
5209 }
5211 // TODO: if all the keys in the block are the same and there are
5212 // no gaps/defaults then just use a range-check.
5213 if (compare_type.BuiltinType == BuiltinTypeSpec.Type.Long || compare_type.BuiltinType == BuiltinTypeSpec.Type.ULong) {
5214 // TODO: optimize constant/I4 cases
5216 // check block range (could be > 2^31)
5225 // normalize range
5230 }
5234 // normalize range
5243 }
5244 }
5246 // first, build the list of labels for the switch
5254 iKey++;
5257 }
5258 }
5260 // emit the switch opcode
5262 }
5264 // mark the default for this block
5267 }
5269 // the last default just goes to the end
5272 }
5273 }
5276 {
5288 }
5294 }
5295 }
5300 //
5301 // Always return section start, it simplifies handling of switch labels
5302 //
5307 }
5308 }
5311 {
5326 }
5331 }
5334 {
5339 //
5340 // LAMESPEC: User conversion from non-nullable governing type has a priority
5341 //
5350 //
5351 // Unwrap + user conversion using non-nullable type is not allowed but user operator
5352 // involving nullable Expr and nullable governing type is
5353 //
5355 }
5356 }
5358 Expression switch_expr;
5363 "A switch expression of type `{0}' cannot be converted to an integral type, bool, char, string, enum or nullable type",
5365 }
5368 }
5378 }
5380 if (SwitchType.BuiltinType == BuiltinTypeSpec.Type.Bool && ec.Module.Compiler.Settings.Version == LanguageVersion.ISO_1) {
5381 ec.Report.FeatureIsNotAvailable (ec.Module.Compiler, loc, "switch expression of boolean type");
5383 }
5392 }
5393 }
5397 //
5398 // Don't need extra variable for constant switch or switch with
5399 // only default case
5400 //
5402 //
5403 // Store switch expression for comparison purposes
5404 //
5409 // Create temporary variable inside switch scope
5413 }
5414 }
5428 //
5429 // Check if all goto cases are valid. Needs to be done after switch
5430 // is resolved because goto can jump forward in the scope.
5431 //
5437 }
5440 }
5447 }
5448 }
5449 }
5454 if (constant == null && SwitchType.BuiltinType == BuiltinTypeSpec.Type.String && string_labels.Count > 6) {
5456 }
5458 //
5459 // Anonymous storey initialization has to happen before
5460 // any generated switch dispatch
5461 //
5465 }
5468 {
5476 }
5479 }
5482 {
5501 }
5502 }
5512 //
5513 // Section is marked already via goto case
5514 //
5518 }
5521 //
5522 // Common case. Previous label section end is unreachable as
5523 // it ends with break, return, etc. For next section revert
5524 // to reachable again unless we have constant switch block
5525 //
5530 //
5531 // Error case as control cannot fall through from one case label
5532 //
5539 //
5540 // Special case for the first unreachable label in constant
5541 // switch block
5542 //
5544 }
5547 }
5550 }
5556 };
5560 }
5562 //
5563 // Reachability can affect parent only when all possible paths are handled but
5564 // we still need to run reachability check on switch body to check for fall-through
5565 //
5569 //
5570 // We have at least one local exit from the switch
5571 //
5576 }
5579 {
5584 }
5586 //
5587 // Converts string switch into string hashtable
5588 //
5590 {
5591 FullNamedExpression string_dictionary_type;
5596 loc);
5598 string_dictionary_type = new TypeExpression (ec.Module.PredefinedTypes.Hashtable.TypeSpec, loc);
5602 }
5607 new MemberName (CompilerGeneratedContainer.MakeName (null, "f", "switch$map", ec.Module.CounterSwitchTypes++), loc), null);
5633 }
5642 }
5645 {
5648 //
5649 // Skip initialization when value is null
5650 //
5653 //
5654 // Check if string dictionary is initialized and initialize
5655 //
5659 }
5670 Expression get_item = new Invocation (new MemberAccess (switch_cache_field, "TryGetValue", loc), get_value_args).Resolve (rc);
5674 //
5675 // A value was not found, go to default case
5676 //
5682 Expression get_item = new ElementAccess (switch_cache_field, get_value_args, loc).Resolve (rc);
5690 ExpressionStatement get_item_int = (ExpressionStatement) new SimpleAssign (string_switch_variable,
5695 }
5699 }
5701 //
5702 // Emits switch using simple if/else comparison for small label count (4 + optional default)
5703 //
5705 {
5709 }
5713 }
5725 }
5735 }
5737 if (constant.IsZeroInteger && constant.Type.BuiltinType != BuiltinTypeSpec.Type.Long && constant.Type.BuiltinType != BuiltinTypeSpec.Type.ULong) {
5740 }
5745 }
5748 }
5751 {
5755 }
5758 //
5759 // Constant switch, we've already done the work if there is only 1 label
5760 // referenced
5761 //
5773 }
5774 }
5777 }
5785 }
5786 }
5789 {
5790 //
5791 // Setup the codegen context
5792 //
5812 }
5815 //
5816 // Next statement is compiler generated we don't need extra
5817 // nop when we can use the statement for sequence point
5818 //
5823 }
5827 // Restore context state.
5830 //
5831 // Restore the previous context
5832 //
5835 }
5838 {
5843 }
5846 {
5848 }
5851 {
5859 }
5862 {
5864 }
5865 }
5867 // A place where execution can restart in a state machine
5869 {
5874 {
5878 }
5880 }
5883 {
5885 }
5887 public virtual void EmitForDispose (EmitContext ec, LocalBuilder pc, Label end, bool have_dispatcher)
5888 {
5889 }
5890 }
5893 {
5895 Label dispose_try_block;
5897 Method finally_host;
5901 {
5903 }
5905 #region Properties
5910 }
5911 }
5913 #endregion
5919 {
5923 }
5925 }
5928 {
5941 }
5950 // Now it's safe to add, to close it properly and emit sequence points
5958 }
5962 }
5964 public override void EmitForDispose (EmitContext ec, LocalBuilder pc, Label end, bool have_dispatcher)
5965 {
5973 // Ensure that the only way we can get into this code is through a dispatcher
5991 }
5993 }
6007 }
6011 }
6023 }
6026 }
6029 {
6033 }
6036 {
6039 }
6042 {
6045 }
6048 {
6059 }
6060 }
6064 //
6065 // Finally block inside iterator is called from MoveNext and
6066 // Dispose methods that means we need to lift the block into
6067 // newly created host method to emit the body only once. The
6068 // original block then simply calls the newly generated method.
6069 //
6074 }
6075 }
6078 }
6079 }
6081 //
6082 // Base class for blocks using exception handling
6083 //
6085 {
6092 {
6094 }
6097 {
6104 }
6106 //
6107 // The resume points in catch section when this is try-catch-finally
6108 //
6116 // For normal control flow, we want to fall-through the Switch
6117 // So, we use CurrentPC rather than the $PC field, and initialize it to an outside value above
6126 }
6127 }
6131 //
6132 // The resume points for try section
6133 //
6138 // For normal control flow, we want to fall-through the Switch
6139 // So, we use CurrentPC rather than the $PC field, and initialize it to an outside value above
6144 var labels = new Label [first_catch_resume_pc > 0 ? first_catch_resume_pc : resume_points.Count];
6148 }
6149 }
6152 {
6162 }
6164 public int AddResumePoint (ResumableStatement stmt, int pc, StateMachineInitializer stateMachine, TryCatch catchBlock)
6165 {
6170 }
6175 }
6183 }
6187 }
6188 }
6191 {
6192 Expression expr;
6193 TemporaryVariableReference expr_copy;
6194 TemporaryVariableReference lock_taken;
6198 {
6200 }
6205 }
6206 }
6209 {
6212 }
6215 {
6224 }
6227 expr = Convert.ImplicitTypeParameterConversion (expr, (TypeParameterSpec)expr.Type, ec.BuiltinTypes.Object);
6228 }
6238 }
6240 //
6241 // Have to keep original lock value around to unlock same location
6242 // in the case of original value has changed or is null
6243 //
6247 //
6248 // Ensure Monitor methods are available
6249 //
6253 }
6257 }
6261 }
6264 }
6267 {
6271 //
6272 // Initialize ref variable
6273 //
6276 //
6277 // Monitor.Enter (expr_copy)
6278 //
6281 }
6284 }
6287 {
6288 //
6289 // Monitor.Enter (expr_copy, ref lock_taken)
6290 //
6296 }
6299 }
6302 {
6303 //
6304 // if (lock_taken) Monitor.Exit (expr_copy)
6305 //
6311 }
6319 }
6322 {
6323 // Try 4.0 Monitor.Enter (object, ref bool) overload first
6334 }
6337 {
6342 }
6345 {
6347 }
6349 }
6355 {
6359 }
6362 {
6365 }
6368 {
6371 }
6374 {
6376 }
6379 {
6382 }
6385 {
6389 }
6392 {
6394 }
6395 }
6401 {
6405 }
6408 {
6411 }
6414 {
6417 }
6420 {
6422 }
6425 {
6428 }
6431 {
6435 }
6438 {
6440 }
6441 }
6447 {
6451 }
6454 {
6460 }
6463 {
6465 }
6468 {
6470 }
6473 {
6476 }
6479 {
6483 }
6486 {
6488 }
6489 }
6491 //
6492 // Fixed statement
6493 //
6495 {
6497 {
6502 {
6504 }
6509 {
6511 }
6512 }
6517 {
6518 }
6521 {
6523 }
6526 //
6527 // Store pointer in pinned location
6528 //
6531 }
6534 {
6538 }
6539 }
6542 {
6543 LocalVariable pinned_string;
6547 {
6548 }
6551 {
6553 LocalVariable.Flags.FixedVariable | LocalVariable.Flags.CompilerGenerated | LocalVariable.Flags.Used,
6561 }
6564 {
6570 // TODO: Should use Binary::Add
6585 //pe.InstanceExpression = pinned_string;
6592 }
6595 {
6598 }
6599 }
6602 {
6605 {
6606 }
6608 protected override Expression ResolveInitializer (BlockContext bc, LocalVariable li, Expression initializer)
6609 {
6614 }
6620 //
6621 // Case 1: Array
6622 //
6627 //
6628 // Provided that array_type is unmanaged,
6629 //
6633 Expression res_init;
6640 }
6642 //
6643 // and T* is implicitly convertible to the
6644 // pointer type given in the fixed statement.
6645 //
6648 Expression converted = Convert.ImplicitConversionRequired (bc, array_ptr.Resolve (bc), li.Type, loc);
6652 //
6653 // fixed (T* e_ptr = (e == null || e.Length == 0) ? null : converted [0])
6654 //
6657 new Binary (Binary.Operator.Equality, new MemberAccess (res, "Length"), new IntConstant (bc.BuiltinTypes, 0, loc)))),
6664 }
6666 //
6667 // Case 2: string
6668 //
6671 }
6673 // Case 3: fixed buffer
6676 }
6678 //
6679 // Case 4: & object.
6680 //
6689 }
6690 }
6693 bc.Report.Error (213, loc, "You cannot use the fixed statement to take the address of an already fixed expression");
6695 }
6699 }
6702 bc.Report.Error (254, initializer.Location, "The right hand side of a fixed statement assignment may not be a cast expression");
6704 }
6706 //
6707 // Case 5: by-ref GetPinnableReference method on the rhs expression
6708 //
6711 bc.Report.Error (8385, initializer.Location, "The given expression cannot be used in a fixed statement");
6713 }
6717 bc.Report.FeatureIsNotAvailable (compiler, initializer.Location, "extensible fixed statement");
6718 }
6728 // CSC: Should be better error code
6731 }
6735 }
6738 {
6752 // TODO: handle extension methods
6756 if (mg == null || mg.BestCandidate.IsStatic || !mg.BestCandidate.IsPublic || mg.BestCandidateReturnType.Kind != MemberKind.ByRef || !mg.BestCandidate.Parameters.IsEmpty) {
6758 bc.Report.Warning (280, 2, expr.Location, "`{0}' has the wrong signature to be used in extensible fixed statement", mg.GetSignatureForError ());
6759 }
6762 }
6765 }
6766 }
6769 VariableDeclaration decl;
6770 Statement statement;
6774 {
6778 }
6780 #region Properties
6785 }
6786 }
6791 }
6792 }
6794 #endregion
6797 {
6801 }
6804 }
6807 {
6810 }
6813 {
6820 }
6821 }
6828 //
6829 // Clear the pinned variable
6830 //
6835 }
6836 }
6837 }
6840 {
6847 // TODO: What if there is local exit?
6850 }
6853 {
6858 }
6861 {
6863 }
6864 }
6867 {
6869 {
6873 {
6875 }
6878 {
6879 }
6882 {
6883 // Emits catch variable debug information inside correct block
6885 }
6888 {
6890 }
6891 }
6894 {
6898 {
6900 }
6903 {
6904 }
6907 {
6911 else
6916 }
6932 }
6935 {
6938 }
6941 {
6946 bc.Report.Error (7094, ctch.Filter.Location, "The `await' operator cannot be used in the filter expression of a catch clause");
6947 }
6951 bc.Report.Warning (7095, 1, ctch.Filter.Location, "Exception filter expression is a constant");
6952 }
6953 }
6956 }
6957 }
6959 ExplicitBlock block;
6960 LocalVariable li;
6961 FullNamedExpression type_expr;
6962 CompilerAssign assign;
6963 TypeSpec type;
6964 LocalTemporary hoisted_temp;
6967 {
6970 }
6972 #region Properties
6977 }
6978 }
6983 }
6984 }
6988 }
6993 }
6994 }
6999 }
7002 }
7003 }
7008 }
7011 }
7012 }
7014 #endregion
7017 {
7026 }
7029 }
7033 else
7044 }
7045 }
7048 {
7051 //
7052 // For hoisted catch variable we have to use a temporary local variable
7053 // for captured variable initialization during storey setup because variable
7054 // needs to be on the stack after storey instance for stfld operation
7055 //
7060 // switch to assignment from temporary variable and not from top of the stack
7062 }
7063 }
7066 {
7074 assign = new CompilerAssign (new LocalVariableReference (li, Location.Null), source, Location.Null);
7076 }
7085 if (type.BuiltinType != BuiltinTypeSpec.Type.Exception && !TypeSpec.IsBaseClass (type, bc.BuiltinTypes.Exception, false)) {
7091 // source variable is at the top of the stack
7099 //
7100 // Uses Location.Null to hide from symbol file
7101 //
7102 assign = new CompilerAssign (new LocalVariableReference (li, Location.Null), source, Location.Null);
7104 }
7105 }
7109 }
7113 }
7114 }
7117 {
7121 // TODO: Scan the block for rethrow expression
7122 //if (!Block.HasRethrow)
7123 // return;
7127 }
7130 {
7133 }
7136 }
7139 {
7147 }
7150 {
7160 }
7161 }
7164 {
7165 ExplicitBlock fini;
7172 {
7174 }
7179 }
7180 }
7183 {
7188 }
7191 {
7197 }
7200 }
7203 {
7220 }
7223 }
7226 {
7231 }
7234 {
7238 }
7240 //
7241 // Emits catch block like
7242 //
7243 // catch (object temp) {
7244 // this.exception_field = temp;
7245 // }
7246 //
7265 //
7266 // Emits exception rethrow
7267 //
7268 // if (this.exception_field != null)
7269 // throw this.exception_field;
7270 //
7281 }
7284 {
7288 }
7291 }
7293 public static Label EmitRedirectedJump (EmitContext ec, AsyncInitializer initializer, Label label, Block labelBlock, bool unwindProtect)
7294 {
7301 }
7304 }
7318 }
7321 }
7324 }
7326 public static Label EmitRedirectedReturn (EmitContext ec, AsyncInitializer initializer, bool unwindProtect)
7327 {
7329 }
7331 void EmitRedirectedExit (EmitContext ec, Label label, AsyncInitializer initializer, bool setReturnState, bool unwindProtect)
7332 {
7336 // Add fallthrough label
7340 initializer.HoistedReturnState = ec.GetTemporaryField (ec.Module.Compiler.BuiltinTypes.Int, true);
7341 }
7347 }
7349 //
7350 // Indicates we have captured exit jump
7351 //
7355 }
7356 }
7358 //
7359 // Emits state table of jumps outside of try block and reload of return
7360 // value when try block returns value
7361 //
7363 {
7383 }
7384 }
7392 }
7393 }
7395 // Mark fallthrough label
7397 }
7400 {
7416 //
7417 // try block has global exit but we need to run definite assignment check
7418 // for parameter block out parameter after finally block because it's always
7419 // executed before exit
7420 //
7425 }
7429 }
7432 {
7433 //
7434 // Mark finally block first for any exit statement in try block
7435 // to know whether the code which follows finally is reachable
7436 //
7438 }
7441 {
7447 }
7450 {
7452 }
7453 }
7456 {
7464 {
7468 }
7473 }
7474 }
7479 }
7480 }
7485 }
7486 }
7489 {
7503 }
7504 }
7505 }
7520 }
7547 "A previous catch clause already catches all exceptions. All non-exceptions thrown will be wrapped in a `System.Runtime.CompilerServices.RuntimeWrappedException'");
7550 }
7564 }
7565 }
7566 }
7571 }
7574 {
7586 //
7587 // Cannot reuse temp variable because non-catch path assumes the value is 0
7588 // which may not be true for reused local variable
7589 //
7591 }
7599 }
7600 }
7613 }
7618 // 0 value is default label
7636 }
7640 }
7641 }
7644 {
7655 else
7659 }
7660 }
7665 }
7668 {
7680 }
7683 {
7691 }
7692 }
7695 {
7697 }
7698 }
7701 {
7703 {
7704 Statement dispose_call;
7708 {
7709 }
7713 {
7716 }
7720 {
7723 }
7725 #region Properties
7727 public bool IsNested { get; private set; }
7729 #endregion
7732 {
7734 }
7737 {
7742 }
7745 {
7753 }
7755 protected override Expression ResolveInitializer (BlockContext bc, LocalVariable li, Expression initializer)
7756 {
7762 // Once there is dynamic used defer conversion to runtime even if we know it will never succeed
7765 initializer = new DynamicConversion (bc.BuiltinTypes.IDisposable, 0, args, initializer.Location).Resolve (bc);
7773 return base.ResolveInitializer (bc, li, new SimpleAssign (var.CreateReferenceExpression (bc, loc), initializer, loc));
7774 }
7780 }
7783 }
7785 protected virtual void CheckIDiposableConversion (BlockContext bc, LocalVariable li, Expression initializer)
7786 {
7789 if (type.BuiltinType != BuiltinTypeSpec.Type.IDisposable && !CanConvertToIDisposable (bc, type)) {
7791 // it's handled in CreateDisposeCall
7793 }
7798 bc.Report.Error (1674, loc, "`{0}': type used in a using statement must be implicitly convertible to `System.IDisposable'",
7800 }
7803 }
7804 }
7807 {
7814 }
7817 {
7828 lvr;
7830 //
7831 // Hide it from symbol file via null location
7832 //
7833 Statement dispose = new StatementExpression (new Invocation (dispose_mg, null), Location.Null);
7835 // Add conditional call when disposing possible null variable
7837 dispose = new If (new Binary (Binary.Operator.Inequality, lvr, new NullLiteral (loc)), dispose, dispose.loc);
7840 }
7843 {
7845 }
7848 {
7858 }
7862 }
7865 {
7867 }
7868 }
7870 VariableDeclaration decl;
7874 {
7876 }
7880 {
7882 }
7884 #region Properties
7889 }
7890 }
7895 }
7896 }
7898 #endregion
7901 {
7902 //
7903 // Don't emit sequence point it will be set on variable declaration
7904 //
7906 }
7909 {
7912 }
7915 {
7917 }
7920 {
7922 }
7925 {
7928 }
7931 {
7934 }
7937 {
7938 VariableReference vr;
7947 }
7957 }
7958 }
7961 }
7962 }
7970 }
7973 {
7978 }
7981 {
7983 }
7984 }
7986 /// <summary>
7987 /// Implementation of the foreach C# statement
7988 /// </summary>
7990 {
7992 {
7996 {
7999 }
8002 {
8004 }
8007 {
8010 }
8013 }
8016 {
8018 }
8019 }
8022 {
8028 TemporaryVariableReference copy;
8032 {
8037 //
8038 // Only use temporary length variables when dealing with
8039 // multi-dimensional arrays
8040 //
8043 }
8046 {
8056 counter[i] = new StatementExpression (new UnaryMutator (UnaryMutator.Mode.PostIncrement, v, Location.Null));
8068 }
8071 }
8077 TypeSpec var_type;
8079 // Infer implicitly typed local variable from foreach array type
8090 }
8102 for_each.body.AddScopeStatement (new StatementExpression (new CompilerAssign (variable_ref, access, Location.Null), for_each.type.Location));
8105 }
8108 {
8121 }
8129 }
8144 else
8148 }
8151 }
8152 }
8155 {
8157 {
8160 {
8162 }
8164 protected override void CheckIDiposableConversion (BlockContext bc, LocalVariable li, Expression initializer)
8165 {
8166 // Defered to runtime check
8167 }
8170 {
8173 //
8174 // Fabricates code like
8175 //
8176 // if ((temp = vr as IDisposable) != null) temp.Dispose ();
8177 //
8183 new As (lv.CreateReferenceExpression (bc, loc), new TypeExpression (dispose_variable.Type, loc), loc),
8193 }
8194 }
8196 LocalVariable variable;
8197 Expression expr;
8198 Statement statement;
8199 ExpressionStatement init;
8200 TemporaryVariableReference enumerator_variable;
8205 {
8208 }
8211 {
8214 "foreach statement requires that the return type `{0}' of `{1}' must have a suitable public MoveNext method and public Current property",
8216 }
8219 {
8220 //
8221 // Option 1: Try to match by name GetEnumerator first
8222 //
8224 "GetEnumerator", 0, Expression.MemberLookupRestrictions.ExactArity, loc); // TODO: What if CS0229 ?
8230 mg = mg.OverloadResolve (rc, ref args, this, OverloadResolver.Restrictions.ProbingOnly | OverloadResolver.Restrictions.GetEnumeratorLookup);
8232 // For ambiguous GetEnumerator name warning CS0278 was reported, but Option 2 could still apply
8238 }
8239 }
8241 //
8242 // Option 2: Try to match using IEnumerable interfaces with preference of generic version
8243 //
8254 if (gen_ienumerable != null && iface.MemberDefinition == gen_ienumerable.TypeSpec.MemberDefinition) {
8255 if (iface_candidate != null && iface_candidate != rc.Module.PredefinedMembers.IEnumerableGetEnumerator) {
8258 "foreach statement cannot operate on variables of type `{0}' because it contains multiple implementation of `{1}'. Try casting to a specific implementation",
8262 }
8264 // TODO: Cache this somehow
8269 }
8273 }
8274 }
8275 }
8282 "foreach statement cannot operate on variables of type `{0}' because it does not contain a definition for `{1}' or is inaccessible",
8284 }
8287 }
8296 }
8299 {
8301 MemberFilter.Method ("MoveNext", 0, ParametersCompiled.EmptyReadOnlyParameters, rc.BuiltinTypes.Bool),
8307 }
8310 }
8313 {
8321 }
8324 }
8327 {
8334 }
8339 }
8342 enumerator_variable = TemporaryVariableReference.Create (get_enumerator.ReturnType, variable.Block, loc);
8345 // Prepare bool MoveNext ()
8349 }
8353 // Prepare ~T~ Current { get; }
8357 }
8359 var current_pe = new PropertyExpr (current_prop, loc) { InstanceExpression = enumerator_variable }.Resolve (ec);
8367 // Source type is dynamic, set element type to dynamic too
8370 // Infer implicitly typed local variable from foreach enumerable type
8372 }
8375 // Explicit cast of dynamic collection elements has to be done at runtime
8377 }
8387 }
8396 for_each.body.AddScopeStatement (new StatementExpression (new CompilerAssign (variable_ref, current_pe, Location.Null), for_each.type.Location));
8405 //
8406 // Add Dispose method call when enumerator can be IDisposable
8407 //
8410 //
8411 // Runtime Dispose check
8412 //
8417 //
8418 // No Dispose call needed
8419 //
8422 }
8424 //
8425 // Static Dispose check
8426 //
8430 }
8433 }
8436 {
8443 }
8445 #region IErrorHandler Members
8447 bool OverloadResolver.IErrorHandler.AmbiguousCandidates (ResolveContext ec, MemberSpec best, MemberSpec ambiguous)
8448 {
8451 "`{0}' contains ambiguous implementation of `{1}' pattern. Method `{2}' is ambiguous with method `{3}'",
8457 }
8459 bool OverloadResolver.IErrorHandler.ArgumentMismatch (ResolveContext rc, MemberSpec best, Argument arg, int index)
8460 {
8462 }
8465 {
8467 }
8470 {
8472 }
8474 #endregion
8475 }
8477 Expression type;
8478 LocalVariable variable;
8479 Expression expr;
8480 Block body;
8482 public Foreach (Expression type, LocalVariable var, Expression expr, Statement stmt, Block body, Location l)
8484 {
8490 }
8493 get { return expr; }
8494 }
8497 get { return type; }
8498 }
8501 get { return variable; }
8502 }
8505 {
8511 }
8514 {
8522 }
8535 }
8538 }
8541 }
8544 {
8560 }
8563 {
8570 }
8573 {
8580 }
8583 {
8585 }
8586 }
8589 {
8591 {
8592 }
8595 {
8599 }
8602 {
8604 }
8605 }
8606 }