| blob | 336bd0be58b5ac78caaaeb36840a2634eedac569 |
1 //
2 // ecore.cs: Core of the Expression representation for the intermediate tree.
3 //
4 // Author:
5 // Miguel de Icaza (miguel@ximian.com)
6 // Marek Safar (marek.safar@seznam.cz)
7 //
8 // Copyright 2001, 2002, 2003 Ximian, Inc.
9 // Copyright 2003-2008 Novell, Inc.
10 //
11 //
24 /// <remarks>
25 /// The ExprClass class contains the is used to pass the
26 /// classification of an expression (value, variable, namespace,
27 /// type, method group, property access, event access, indexer access,
28 /// nothing).
29 /// </remarks>
33 Value,
34 Variable,
35 Namespace,
36 Type,
37 TypeParameter,
38 MethodGroup,
39 PropertyAccess,
40 EventAccess,
41 IndexerAccess,
42 Nothing,
43 }
45 /// <remarks>
46 /// This is used to tell Resolve in which types of expressions we're
47 /// interested.
48 /// </remarks>
51 // Returns Value, Variable, PropertyAccess, EventAccess or IndexerAccess.
54 // Returns a type expression.
57 // Returns a method group.
62 // Mask of all the expression class flags.
65 // Set if this is resolving the first part of a MemberAccess.
67 }
69 //
70 // This is just as a hint to AddressOf of what will be done with the
71 // address.
77 };
79 /// <summary>
80 /// This interface is implemented by variables
81 /// </summary>
83 /// <summary>
84 /// The AddressOf method should generate code that loads
85 /// the address of the object and leaves it on the stack.
86 ///
87 /// The `mode' argument is used to notify the expression
88 /// of whether this will be used to read from the address or
89 /// write to the address.
90 ///
91 /// This is just a hint that can be used to provide good error
92 /// reporting, and should have no other side effects.
93 /// </summary>
95 }
97 //
98 // An expressions resolved as a direct variable reference
99 //
101 {
102 bool IsHoisted { get; }
103 string Name { get; }
104 VariableInfo VariableInfo { get; }
107 }
109 //
110 // Implemented by an expression which could be or is always
111 // fixed
112 //
113 public interface IFixedExpression
114 {
115 bool IsFixed { get; }
116 }
118 /// <remarks>
119 /// Base class for expressions
120 /// </remarks>
127 get { return type; }
128 set { type = value; }
129 }
132 get { return loc; }
133 }
135 // Not nice but we have broken hierarchy.
137 {
138 }
141 {
145 }
148 {
150 }
152 public static bool IsAccessorAccessible (Type invocation_type, MethodSpec mi, out bool must_do_cs1540_check)
153 {
161 //
162 // If only accessible to the current class or children
163 //
169 var b = TypeManager.IsThisOrFriendAssembly (invocation_type.Assembly, mi.DeclaringType.Assembly);
172 }
174 // Family and FamANDAssem require that we derive.
175 // FamORAssem requires that we derive if in different assemblies.
183 }
188 }
189 }
191 /// <summary>
192 /// Performs semantic analysis on the Expression
193 /// </summary>
194 ///
195 /// <remarks>
196 /// The Resolve method is invoked to perform the semantic analysis
197 /// on the node.
198 ///
199 /// The return value is an expression (it can be the
200 /// same expression in some cases) or a new
201 /// expression that better represents this node.
202 ///
203 /// For example, optimizations of Unary (LiteralInt)
204 /// would return a new LiteralInt with a negated
205 /// value.
206 ///
207 /// If there is an error during semantic analysis,
208 /// then an error should be reported (using Report)
209 /// and a null value should be returned.
210 ///
211 /// There are two side effects expected from calling
212 /// Resolve(): the the field variable "eclass" should
213 /// be set to any value of the enumeration
214 /// `ExprClass' and the type variable should be set
215 /// to a valid type (this is the type of the
216 /// expression).
217 /// </remarks>
221 {
223 }
225 //
226 // This is used if the expression should be resolved as a type or namespace name.
227 // the default implementation fails.
228 //
230 {
236 }
239 }
241 //
242 // C# 3.0 introduced contextual keywords (var) which behaves like a type if type with
243 // same name exists or as a keyword when no type was found
244 //
246 {
248 }
250 //
251 // This is used to resolve the expression as a type, a null
252 // value will be returned if the expression is not a type
253 // reference
254 //
256 {
264 AttributeTester.Report_ObsoleteMessage (obsolete_attr, te.GetSignatureForError (), Location, ec.Compiler.Report);
265 }
266 }
270 //
271 // TODO: Constrained type parameters check for parameters of generic method overrides is broken
272 // There are 2 solutions.
273 // 1, Skip this check completely when we are in override/explicit impl scope
274 // 2, Copy type parameters constraints from base implementation and pass (they have to be emitted anyway)
275 //
282 }
284 // TODO: silent flag is ignored
286 }
289 }
292 {
305 }
311 }
315 }
318 {
320 }
322 protected static void Error_CannotAccessProtected (ResolveContext ec, Location loc, MemberInfo m, Type qualifier, Type container)
323 {
324 ec.Report.Error (1540, loc, "Cannot access protected member `{0}' via a qualifier of type `{1}'."
330 }
333 {
335 }
337 public void Error_ConstantCanBeInitializedWithNullOnly (ResolveContext rc, Type type, Location loc, string name)
338 {
339 rc.Report.Error (134, loc, "A constant `{0}' of reference type `{1}' can only be initialized with null",
341 }
344 {
347 }
350 {
352 }
355 {
357 }
359 public virtual void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, Type target, bool expl)
360 {
362 }
364 protected void Error_ValueCannotBeConvertedCore (ResolveContext ec, Location loc, Type target, bool expl)
365 {
366 // The error was already reported as CS1660
370 if (TypeManager.IsGenericParameter (Type) && TypeManager.IsGenericParameter (target) && type.Name == target.Name) {
379 "The generic parameter `{0}' of `{1}' cannot be converted to the generic parameter `{0}' of `{2}' (in the previous ",
384 "The type `{0}' has two conflicting definitions, one comes from `{1}' and the other from `{2}' (in the previous ",
386 }
392 }
403 }
408 }
411 {
413 }
416 {
417 // Better message for possible generic expressions
428 }
429 }
431 protected virtual void Error_TypeDoesNotContainDefinition (ResolveContext ec, Type type, string name)
432 {
434 }
436 public static void Error_TypeDoesNotContainDefinition (ResolveContext ec, Location loc, Type type, string name)
437 {
441 }
444 {
445 ec.Report.Error (131, loc, "The left-hand side of an assignment must be a variable, a property or an indexer");
446 }
448 ResolveFlags ExprClassToResolveFlags {
469 throw new InternalErrorException (loc.ToString () + " " + GetType () + " ExprClass is Invalid after resolve");
470 }
471 }
472 }
474 /// <summary>
475 /// Resolves an expression and performs semantic analysis on it.
476 /// </summary>
477 ///
478 /// <remarks>
479 /// Currently Resolve wraps DoResolve to perform sanity
480 /// checking and assertion checking on what we expect from Resolve.
481 /// </remarks>
483 {
487 Expression e;
492 }
500 }
503 throw new InternalErrorException ("Expression `{0}' didn't set its type in DoResolve", e.GetType ());
506 }
508 /// <summary>
509 /// Resolves an expression and performs semantic analysis on it.
510 /// </summary>
512 {
514 }
516 /// <summary>
517 /// Resolves an expression for LValue assignment
518 /// </summary>
519 ///
520 /// <remarks>
521 /// Currently ResolveLValue wraps DoResolveLValue to perform sanity
522 /// checking and assertion checking on what we expect from Resolve
523 /// </remarks>
525 {
532 // FIXME: There's no problem with correctness, the 'Expr = null' handles that.
533 // Enabling this 'throw' will "only" result in deleting useless code elsewhere,
535 //throw new InternalErrorException ("ResolveLValue didn't return an IMemoryLocation: " +
536 // e.GetType () + " " + e.GetSignatureForError ());
538 }
544 else
546 }
548 }
557 }
559 /// <summary>
560 /// Emits the code for the expression
561 /// </summary>
562 ///
563 /// <remarks>
564 /// The Emit method is invoked to generate the code
565 /// for the expression.
566 /// </remarks>
569 // Emit code to branch to @target if this expression is equivalent to @on_true.
570 // The default implementation is to emit the value, and then emit a brtrue or brfalse.
571 // Subclasses can provide more efficient implementations, but those MUST be equivalent,
572 // including the use of conditional branches. Note also that a branch MUST be emitted
574 {
577 }
579 // Emit this expression for its side effects, not for its value.
580 // The default implementation is to emit the value, and then throw it away.
581 // Subclasses can provide more efficient implementations, but those MUST be equivalent
583 {
586 }
588 /// <summary>
589 /// Protected constructor. Only derivate types should
590 /// be able to be created
591 /// </summary>
594 {
595 }
597 /// <summary>
598 /// Returns a fully formed expression after a MemberLookup
599 /// </summary>
600 ///
601 public static Expression ExprClassFromMemberInfo (Type container_type, MemberInfo mi, Location loc)
602 {
615 }
618 }
620 // TODO: [Obsolete ("Can be removed")]
623 //
624 // FIXME: Probably implement a cache for (t,name,current_access_set)?
625 //
626 // This code could use some optimizations, but we need to do some
627 // measurements. For example, we could use a delegate to `flag' when
628 // something can not any longer be a method-group (because it is something
629 // else).
630 //
631 // Return values:
632 // If the return value is an Array, then it is an array of
633 // MethodBases
634 //
635 // If the return value is an MemberInfo, it is anything, but a Method
636 //
637 // null on error.
638 //
639 // FIXME: When calling MemberLookup inside an `Invocation', we should pass
640 // the arguments here and have MemberLookup return only the methods that
641 // match the argument count/type, unlike we are doing now (we delay this
642 // decision).
643 //
644 // This is so we can catch correctly attempts to invoke instance methods
645 // from a static body (scan for error 120 in ResolveSimpleName).
646 //
647 //
648 // FIXME: Potential optimization, have a static ArrayList
649 //
651 public static Expression MemberLookup (CompilerContext ctx, Type container_type, Type queried_type, string name,
653 {
655 }
657 //
658 // Lookup type `queried_type' for code in class `container_type' with a qualifier of
659 // `qualifier_type' or null to lookup members in the current class.
660 //
666 {
684 }
692 if (n_m.DeclaringType.IsInterface && TypeManager.ImplementsInterface (m.DeclaringType, n_m.DeclaringType)) {
695 } else if (m.DeclaringType.IsInterface && TypeManager.ImplementsInterface (n_m.DeclaringType, m.DeclaringType)) {
698 }
699 }
703 }
704 }
713 }
722 // Cannot happen with C# code, but is valid in IL
729 }
734 ctx.Report.Warning (467, 2, loc, "Ambiguity between method `{0}' and non-method `{1}'. Using method `{0}'",
736 }
737 }
740 }
743 return new MethodGroupExpr (mi.Select (l => Import.CreateMethod ((MethodBase) l)).ToArray (), queried_type, loc);
746 }
761 public static Expression MemberLookup (CompilerContext ctx, Type container_type, Type queried_type,
763 {
766 }
768 public static Expression MemberLookup (CompilerContext ctx, Type container_type, Type qualifier_type,
770 {
773 }
775 public static MethodGroupExpr MethodLookup (CompilerContext ctx, Type container_type, Type queried_type,
777 {
780 }
782 /// <summary>
783 /// This is a wrapper for MemberLookup that is not used to "probe", but
784 /// to find a final definition. If the final definition is not found, we
785 /// look for private members and display a useful debugging message if we
786 /// find it.
787 /// </summary>
791 Location loc)
792 {
793 Expression e;
796 e = MemberLookup (ec.Compiler, ec.CurrentType, qualifier_type, queried_type, name, mt, bf, loc);
801 // No errors were reported by MemberLookup, but there was an error.
804 }
806 protected virtual Expression Error_MemberLookupFailed (ResolveContext ec, Type container_type, Type qualifier_type,
809 {
821 //
822 // FIXME: This is still very wrong, it should be done inside
823 // OverloadResolve to do correct arguments matching.
824 // Requires MemberLookup accessiblity check removal
825 //
831 // Although a derived class can access protected members of
832 // its base class it cannot do so through an instance of the
833 // base class (CS1540). If the qualifier_type is a base of the
834 // ec.CurrentType and the lookup succeeds with the latter one,
835 // then we are in this situation.
839 }
840 }
843 }
848 }
853 name);
856 }
858 }
872 }
873 }
876 }
878 protected virtual Expression Error_MemberLookupFailed (ResolveContext ec, Type type, MemberInfo[] members)
879 {
886 }
888 // By default propagate the closest candidates upwards
890 }
893 {
895 }
898 {
900 }
902 /// <summary>
903 /// Returns an expression that can be used to invoke operator true
904 /// on the expression if it exists.
905 /// </summary>
907 {
909 }
911 /// <summary>
912 /// Returns an expression that can be used to invoke operator false
913 /// on the expression if it exists.
914 /// </summary>
916 {
918 }
920 static Expression GetOperatorTrueOrFalse (ResolveContext ec, Expression e, bool is_true, Location loc)
921 {
922 MethodGroupExpr operator_group;
923 string mname = Operator.GetMetadataName (is_true ? Operator.OpType.True : Operator.OpType.False);
924 operator_group = MethodLookup (ec.Compiler, ec.CurrentType, e.Type, mname, loc) as MethodGroupExpr;
937 }
939 public virtual string ExprClassName
940 {
965 }
967 }
968 }
970 /// <summary>
971 /// Reports that we were expecting `expr' to be of class `expected'
972 /// </summary>
974 {
976 }
978 public void Error_UnexpectedKind (Report r, MemberCore mc, string expected, string was, Location loc)
979 {
983 else
988 }
991 {
998 }
1013 }
1017 }
1021 }
1024 {
1026 }
1029 {
1030 Report.Error (214, loc, "Pointers and fixed size buffers may only be used in an unsafe context");
1031 }
1033 //
1034 // Load the object from the pointer.
1035 //
1037 {
1067 else
1073 else
1075 }
1077 //
1078 // The stack contains the pointer and the value of type `type'
1079 //
1081 {
1102 else
1104 }
1106 //
1107 // Returns the size of type `t' if known, otherwise, 0
1108 //
1110 {
1130 else
1132 }
1135 {
1137 }
1140 {
1143 ec.Report.Error (1918, loc, "Members of value type `{0}' cannot be assigned using a property `{1}' object initializer",
1146 ec.Report.Error (1612, loc, "Cannot modify a value type return value of `{0}'. Consider storing the value in a temporary variable",
1148 }
1149 }
1151 //
1152 // Converts `source' to an int, uint, long or ulong.
1153 //
1155 {
1159 return new DynamicConversion (TypeManager.int32_type, CSharpBinderFlags.ConvertArrayIndex, args, loc).Resolve (ec);
1160 }
1162 Expression converted;
1176 }
1177 }
1179 //
1180 // Only positive constants are allowed at compile time
1181 //
1186 // No conversion needed to array index
1191 }
1193 //
1194 // Derived classes implement this method by cloning the fields that
1195 // could become altered during the Resolve stage
1196 //
1197 // Only expressions that are created for the parser need to implement
1198 // this.
1199 //
1201 {
1205 }
1207 //
1208 // Clones an expression created by the parser.
1209 //
1210 // We only support expressions created by the parser so far, not
1211 // expressions that have been resolved (many more classes would need
1212 // to implement CloneTo).
1213 //
1214 // This infrastructure is here merely for Lambda expressions which
1215 // compile the same code using different type values for the same
1216 // arguments to find the correct overload
1217 //
1219 {
1224 }
1226 //
1227 // Implementation of expression to expression tree conversion
1228 //
1231 protected Expression CreateExpressionFactoryCall (ResolveContext ec, string name, Arguments args)
1232 {
1234 }
1236 protected Expression CreateExpressionFactoryCall (ResolveContext ec, string name, TypeArguments typeArguments, Arguments args)
1237 {
1239 }
1241 public static Expression CreateExpressionFactoryCall (ResolveContext ec, string name, TypeArguments typeArguments, Arguments args, Location loc)
1242 {
1243 return new Invocation (new MemberAccess (CreateExpressionTypeExpression (ec, loc), name, typeArguments, loc), args);
1244 }
1247 {
1250 Type t = TypeManager.CoreLookupType (ec.Compiler, "System.Linq.Expressions", "Expression", MemberKind.Class, true);
1255 }
1258 }
1260 //
1261 // Implemented by all expressions which support conversion from
1262 // compiler expression to invokable runtime expression. Used by
1263 // dynamic C# binder.
1264 //
1266 {
1268 }
1271 {
1272 // TODO: It should probably be type = storey.MutateType (type);
1273 }
1274 }
1276 /// <summary>
1277 /// This is just a base class for expressions that can
1278 /// appear on statements (invocations, object creation,
1279 /// assignments, post/pre increment and decrement). The idea
1280 /// being that they would support an extra Emition interface that
1281 /// does not leave a result on the stack.
1282 /// </summary>
1286 {
1296 }
1298 /// <summary>
1299 /// Requests the expression to be emitted in a `statement'
1300 /// context. This means that no new value is left on the
1301 /// stack after invoking this method (constrasted with
1302 /// Emit that will always leave a value on the stack).
1303 /// </summary>
1307 {
1309 }
1310 }
1312 /// <summary>
1313 /// This kind of cast is used to encapsulate the child
1314 /// whose type is child.Type into an expression that is
1315 /// reported to return "return_type". This is used to encapsulate
1316 /// expressions which have compatible types, but need to be dealt
1317 /// at higher levels with.
1318 ///
1319 /// For example, a "byte" expression could be encapsulated in one
1320 /// of these as an "unsigned int". The type for the expression
1321 /// would be "unsigned int".
1322 ///
1323 /// </summary>
1325 {
1329 {
1334 }
1337 {
1345 return CreateExpressionFactoryCall (ec, ec.HasSet (ResolveContext.Options.CheckedScope) ? "ConvertChecked" : "Convert", args);
1346 }
1349 {
1350 // This should never be invoked, we are born in fully
1351 // initialized state.
1354 }
1357 {
1359 }
1361 public override bool GetAttributableValue (ResolveContext ec, Type value_type, out object value)
1362 {
1364 }
1367 {
1371 }
1374 {
1377 }
1380 {
1381 // Nothing to clone
1382 }
1385 get { return child.IsNull; }
1386 }
1387 }
1392 {
1393 }
1396 {
1406 }
1409 {
1411 }
1414 {
1416 }
1417 }
1419 //
1420 // Used for predefined class library user casts (no obsolete check, etc.)
1421 //
1423 MethodInfo conversion_operator;
1427 {
1428 }
1432 {
1436 }
1438 // Returns the implicit operator that converts from
1439 // 'child.Type' to our target type (type)
1441 {
1452 }
1459 }
1462 }
1465 {
1468 }
1469 }
1471 /// <summary>
1472 /// This is a numeric cast to a Decimal
1473 /// </summary>
1477 {
1478 }
1482 {
1483 }
1484 }
1486 /// <summary>
1487 /// This is an explicit numeric cast from a Decimal
1488 /// </summary>
1490 {
1495 {
1499 }
1501 // Returns the explicit operator that converts from an
1502 // express of type System.Decimal to 'type'.
1504 {
1515 }
1516 }
1519 }
1522 {
1527 }
1528 }
1531 //
1532 // Constant specialization of EmptyCast.
1533 // We need to special case this since an empty cast of
1534 // a constant is still a constant.
1535 //
1537 {
1542 {
1549 }
1552 {
1554 }
1557 {
1559 }
1562 {
1566 // FIXME: check that 'type' can be converted to 'target_type' first
1568 }
1571 {
1580 }
1583 get { return child.IsDefaultValue; }
1584 }
1587 get { return child.IsNegative; }
1588 }
1591 get { return child.IsNull; }
1592 }
1595 get { return child.IsOneInteger; }
1596 }
1599 get { return child.IsZeroInteger; }
1600 }
1603 {
1605 }
1608 {
1610 }
1613 {
1616 // Only to make verifier happy
1619 }
1622 {
1624 }
1627 {
1628 // FIXME: Do we need to check user conversions?
1632 }
1635 {
1637 }
1638 }
1640 /// <summary>
1641 /// This class is used to wrap literals which belong inside Enums
1642 /// </summary>
1644 {
1649 {
1652 }
1656 {
1657 }
1660 {
1664 }
1667 {
1669 }
1672 {
1674 }
1677 {
1679 }
1681 public override bool GetAttributableValue (ResolveContext ec, Type value_type, out object value)
1682 {
1685 }
1688 {
1690 }
1693 {
1695 }
1698 {
1699 // FIXME: runtime is not ready to work with just emited enums
1702 }
1704 #if MS_COMPATIBLE
1705 // Small workaround for big problem
1706 // System.Enum.ToObject cannot be called on dynamic types
1707 // EnumBuilder has to be used, but we cannot use EnumBuilder
1708 // because it does not properly support generics
1709 //
1710 // This works only sometimes
1711 //
1714 #endif
1717 }
1720 {
1722 }
1725 {
1727 }
1732 }
1733 }
1736 get { return Child.IsZeroInteger; }
1737 }
1742 }
1743 }
1746 {
1751 }
1754 {
1759 // This is workaround of mono bug. It can be removed when the latest corlib spreads enough
1767 }
1771 }
1774 }
1775 }
1777 /// <summary>
1778 /// This kind of cast is used to encapsulate Value Types in objects.
1779 ///
1780 /// The effect of it is to box the value type emitted by the previous
1781 /// operation.
1782 /// </summary>
1787 {
1789 }
1792 {
1793 // This should never be invoked, we are born in fully
1794 // initialized state.
1797 }
1800 {
1804 }
1807 {
1808 // boxing is side-effectful, since it involves runtime checks, except when boxing to Object or ValueType
1809 // so, we need to emit the box+pop instructions in most cases
1813 else
1815 }
1816 }
1821 {
1822 }
1825 {
1826 // This should never be invoked, we are born in fully
1827 // initialized state.
1830 }
1833 {
1834 if (right_side == EmptyExpression.LValueMemberAccess || right_side == EmptyExpression.LValueMemberOutAccess)
1837 }
1840 {
1845 }
1848 {
1851 }
1852 }
1854 /// <summary>
1855 /// This is used to perform explicit numeric conversions.
1856 ///
1857 /// Explicit numeric conversions might trigger exceptions in a checked
1858 /// context, so they should generate the conv.ovf opcodes instead of
1859 /// conv opcodes.
1860 /// </summary>
1874 I_I8,
1875 }
1877 Mode mode;
1881 {
1883 }
1886 {
1887 // This should never be invoked, we are born in fully
1888 // initialized state.
1891 }
1894 {
1896 }
1899 {
1988 }
2073 }
2074 }
2075 }
2076 }
2083 {
2085 }
2088 {
2089 // This should never be invoked, we are born in fully
2090 // initialized state.
2093 }
2096 {
2099 }
2102 get { return child.Type; }
2103 }
2104 }
2106 /// <summary>
2107 /// This kind of cast is used to encapsulate a child and cast it
2108 /// to the class requested
2109 /// </summary>
2115 {
2116 }
2120 {
2122 }
2125 {
2135 }
2141 }
2142 }
2144 //
2145 // Created during resolving pahse when an expression is wrapped or constantified
2146 // and original expression can be used later (e.g. for expression trees)
2147 //
2149 {
2151 {
2156 {
2158 }
2161 {
2167 }
2170 {
2172 }
2174 public override bool GetAttributableValue (ResolveContext ec, Type value_type, out object value)
2175 {
2176 //
2177 // Even if resolved result is a constant original expression was not
2178 // and attribute accepts constants only
2179 //
2183 }
2186 {
2191 }
2192 }
2195 {
2200 {
2204 }
2207 {
2209 }
2212 {
2216 }
2219 {
2221 }
2224 {
2226 }
2229 {
2231 }
2232 }
2237 {
2243 }
2245 //
2246 // Creates fully resolved expression switcher
2247 //
2249 {
2254 }
2257 {
2259 }
2261 //
2262 // Creates unresolved reduce expression. The original expression has to be
2263 // already resolved
2264 //
2266 {
2279 }
2282 {
2284 }
2287 {
2289 }
2292 {
2294 }
2297 {
2299 }
2302 {
2304 }
2307 {
2309 }
2310 }
2312 //
2313 // Standard composite pattern
2314 //
2316 {
2317 Expression expr;
2320 {
2323 }
2326 {
2328 }
2331 get { return expr; }
2332 }
2335 {
2340 }
2343 }
2346 {
2348 }
2351 get { return expr.IsNull; }
2352 }
2353 }
2355 //
2356 // Base of expressions used only to narrow resolve flow
2357 //
2359 {
2363 {
2365 }
2368 {
2374 }
2377 {
2379 }
2382 {
2384 }
2387 get { return expr; }
2388 }
2391 {
2393 }
2394 }
2396 //
2397 // Unresolved type name expressions
2398 //
2400 {
2405 {
2408 }
2411 {
2415 }
2420 }
2421 }
2424 {
2428 }
2431 {
2433 }
2436 {
2440 }
2443 }
2448 }
2451 }
2452 }
2457 }
2458 }
2459 }
2461 /// <summary>
2462 /// SimpleName expressions are formed of a single word and only happen at the beginning
2463 /// of a dotted-name.
2464 /// </summary>
2466 {
2469 {
2470 }
2474 {
2475 }
2479 {
2483 }
2486 {
2497 }
2503 pos++;
2505 pos++;
2511 }
2514 {
2516 }
2519 {
2523 name);
2524 else
2527 name);
2528 }
2531 {
2535 }
2538 {
2540 }
2543 {
2545 }
2548 {
2550 }
2553 {
2559 }
2562 }
2565 {
2591 }
2592 }
2595 }
2598 {
2614 }
2617 }
2620 }
2628 "Dynamic keyword requires `{0}' to be defined. Are you missing System.Core.dll assembly reference?",
2630 }
2633 }
2640 }
2643 {
2650 }
2651 }
2661 }
2662 }
2669 }
2670 }
2671 }
2674 FullNamedExpression retval = ec.LookupNamespaceOrType (SimpleName.RemoveGenericArity (Name), loc, true);
2678 }
2679 }
2682 }
2684 // TODO: I am still not convinced about this. If someone else will need it
2685 // implement this as virtual property in MemberCore hierarchy
2687 {
2702 }
2705 {
2711 if (ec.CurrentBlock == null || ec.CurrentBlock.CheckInvariantMeaningInBlock (Name, e, Location))
2715 }
2717 /// <remarks>
2718 /// 7.5.2: Simple Names.
2719 ///
2720 /// Local Variables and Parameters are handled at
2721 /// parse time, so they never occur as SimpleNames.
2722 ///
2723 /// The `intermediate' flag is used by MemberAccess only
2724 /// and it is used to inform us that it is ok for us to
2725 /// avoid the static check, because MemberAccess might end
2726 /// up resolving the Name as a Type name and the access as
2727 /// a static type access.
2728 ///
2729 /// ie: Type Type; .... { Type.GetType (""); }
2730 ///
2731 /// Type is both an instance variable and a Type; Type.GetType
2732 /// is the static method not an instance method of type.
2733 /// </remarks>
2735 {
2738 //
2739 // Stage 1: Performed by the parser (binding to locals or parameters).
2740 //
2753 }
2756 }
2757 }
2763 }
2769 else
2776 }
2777 }
2779 //
2780 // Stage 2: Lookup members
2781 //
2785 for (Type lookup_ds = ec.CurrentType; lookup_ds != null; lookup_ds = lookup_ds.DeclaringType) {
2792 // since TypeManager.MemberLookup doesn't know if we're doing a lvalue access or not,
2793 // it doesn't know which accessor to check permissions against
2804 }
2806 }
2811 }
2812 }
2818 }
2820 }
2827 // Supress CS0219 warning
2833 }
2834 }
2840 }
2847 string type_name = ec.MemberContext.CurrentType == null ? null : ec.MemberContext.CurrentType.Name;
2850 }
2855 Expression left;
2857 if (ec.IsStatic || ec.HasAny (ResolveContext.Options.FieldInitializerScope | ResolveContext.Options.BaseInitializer | ResolveContext.Options.ConstantScope)) {
2858 //
2859 // Note that an MemberExpr can be both IsInstance and IsStatic.
2860 // An unresolved MethodGroupExpr can contain both kinds of methods
2861 // and each predicate is true if the MethodGroupExpr contains
2862 // at least one of that kind of method.
2863 //
2869 }
2871 //
2872 // Pass the buck to MemberAccess and Invocation.
2873 //
2877 }
2880 }
2891 }
2893 if (!me.IsStatic && (me.InstanceExpression != null && me.InstanceExpression != EmptyExpression.Null) &&
2898 ec.Report.Error (38, loc, "Cannot access a nonstatic member of outer type `{0}' via nested type `{1}'",
2899 TypeManager.CSharpName (me.DeclaringType), TypeManager.CSharpName (me.InstanceExpression.Type));
2901 }
2906 }
2909 }
2910 }
2912 /// <summary>
2913 /// Represents a namespace or a type. The name of the class was inspired by
2914 /// section 10.8.1 (Fully Qualified Names).
2915 /// </summary>
2917 {
2919 {
2920 // Do nothing, most unresolved type expressions cannot be
2921 // resolved to different type
2922 }
2925 {
2927 }
2930 {
2932 }
2935 {
2937 }
2940 {
2943 }
2944 }
2946 /// <summary>
2947 /// Expression that evaluates to a type
2948 /// </summary>
2951 {
2958 }
2961 {
2963 }
2966 {
2968 }
2971 get { return Type.IsClass; }
2972 }
2975 get { return TypeManager.IsStruct (Type); }
2976 }
2979 get { return Type.IsInterface; }
2980 }
2983 get { return Type.IsSealed; }
2984 }
2987 {
2996 }
3001 {
3007 }
3010 {
3012 }
3015 {
3017 }
3018 }
3020 /// <summary>
3021 /// Fully resolved Expression that already evaluated to a type
3022 /// </summary>
3025 {
3029 }
3032 {
3034 }
3037 {
3039 }
3040 }
3042 //
3043 // Used to create types from a fully qualified name. These are just used
3044 // by the parser to setup the core types.
3045 //
3051 {
3055 }
3058 {
3059 //
3060 // It's null only during mscorlib bootstrap when DefineType
3061 // nees to resolve base type of same type
3062 //
3063 // For instance struct Char : IComparable<char>
3064 //
3065 // TODO: it could be removed when Resolve starts to use
3066 // DeclSpace instead of Type
3067 //
3073 }
3076 }
3079 {
3081 }
3084 {
3089 }
3090 }
3092 /// <summary>
3093 /// This class denotes an expression which evaluates to a member
3094 /// of a struct or a class.
3095 /// </summary>
3097 {
3100 /// <summary>
3101 /// The name of this member.
3102 /// </summary>
3105 }
3107 //
3108 // When base.member is used
3109 //
3111 get { return is_base; }
3112 set { is_base = value; }
3113 }
3115 /// <summary>
3116 /// Whether this is an instance member.
3117 /// </summary>
3120 }
3122 /// <summary>
3123 /// Whether this is a static member.
3124 /// </summary>
3127 }
3129 /// <summary>
3130 /// The type which declares this member.
3131 /// </summary>
3134 }
3136 /// <summary>
3137 /// The instance expression associated with this member, if it's a
3138 /// non-static member.
3139 /// </summary>
3143 {
3146 }
3149 {
3151 }
3154 {
3157 }
3159 // TODO: possible optimalization
3160 // Cache resolved constant result in FieldBuilder <-> expression map
3161 public virtual MemberExpr ResolveMemberAccess (ResolveContext ec, Expression left, Location loc,
3162 SimpleName original)
3163 {
3164 //
3165 // Precondition:
3166 // original == null || original.Resolve (...) ==> left
3167 //
3174 // TODO: Same problem as in class.cs, TypeTerminal does not
3175 // always do all necessary checks
3179 }
3184 //
3189 }
3192 }
3199 }
3203 }
3206 {
3209 }
3212 {
3217 // FIXME: This should not be here at all
3218 SimpleName.Error_ObjectRefRequired (new ResolveContext (ec.MemberContext), loc, GetSignatureForError ());
3220 }
3230 }
3236 }
3239 {
3240 // TODO: need to get correct member type
3243 }
3244 }
3246 ///
3247 /// Represents group of extension methods
3248 ///
3250 {
3253 Argument extension_argument;
3255 public ExtensionMethodGroupExpr (List<MethodSpec> list, NamespaceEntry n, Type extensionType, Location l)
3257 {
3259 }
3262 get { return true; }
3263 }
3266 get { return namespace_entry == null; }
3267 }
3270 {
3273 }
3275 public override MethodGroupExpr OverloadResolve (ResolveContext ec, ref Arguments arguments, bool may_fail, Location loc)
3276 {
3283 // Store resolved argument and restore original arguments
3286 else
3290 }
3292 MethodGroupExpr ResolveOverloadExtensions (ResolveContext ec, ref Arguments arguments, NamespaceEntry ns, Location loc)
3293 {
3294 // Use normal resolve rules
3302 // Search continues
3310 }
3311 }
3313 /// <summary>
3314 /// MethodGroupExpr represents a group of method candidates which
3315 /// can be resolved to the best method overload
3316 /// </summary>
3318 {
3319 public interface IErrorHandler
3320 {
3323 }
3327 MethodSpec best_candidate;
3328 // TODO: make private
3332 Type delegate_type;
3333 Type queried_type;
3337 {
3340 }
3342 public MethodGroupExpr (MethodSpec[] mi, Type type, Location l, bool inacessibleCandidatesOnly)
3344 {
3346 }
3350 {
3354 //foreach (MemberInfo m in list){
3355 // if (!(m is MethodBase)){
3356 // Console.WriteLine ("Name " + m.Name);
3357 // Console.WriteLine ("Found a: " + m.GetType ().FullName);
3358 // }
3359 //}
3361 }
3364 }
3367 {
3372 }
3377 }
3378 }
3383 }
3384 }
3389 }
3390 }
3395 }
3396 }
3399 {
3404 }
3409 }
3410 }
3422 }
3423 }
3435 }
3436 }
3439 {
3441 }
3443 //
3444 // 7.4.3.3 Better conversion from expression
3445 // Returns : 1 if a->p is better,
3446 // 2 if a->q is better,
3447 // 0 if neither is better
3448 //
3450 {
3452 if (argument_type == InternalType.AnonymousMethod && RootContext.Version > LanguageVersion.ISO_2) {
3453 //
3454 // Uwrap delegate from Expression<T>
3455 //
3458 }
3461 }
3475 }
3478 }
3480 //
3481 // 7.4.3.4 Better conversion from type
3482 //
3484 {
3505 }
3524 }
3526 // TODO: this is expensive
3540 }
3542 /// <summary>
3543 /// Determines "Better function" between candidate
3544 /// and the current best match
3545 /// </summary>
3546 /// <remarks>
3547 /// Returns a boolean indicating :
3548 /// false if candidate ain't better
3549 /// true if candidate is better than the current best match
3550 /// </remarks>
3554 {
3561 {
3564 // Provided default argument value is never better
3571 if (candidate_params && candidate_pd.FixedParameters [c_idx].ModFlags == Parameter.Modifier.PARAMS)
3572 {
3575 }
3578 {
3581 }
3589 // for each argument, the conversion to 'ct' should be no worse than
3590 // the conversion to 'bt'.
3594 // for at least one argument, the conversion to 'ct' should be better than
3595 // the conversion to 'bt'.
3598 }
3603 //
3604 // This handles the case
3605 //
3606 // Add (float f1, float f2, float f3);
3607 // Add (params decimal [] foo);
3608 //
3609 // The call Add (3, 4, 5) should be ambiguous. Without this check, the
3610 // first candidate would've chosen as better.
3611 //
3615 //
3616 // The two methods have equal parameter types. Now apply tie-breaking rules
3617 //
3623 }
3625 //
3626 // This handles the following cases:
3627 //
3628 // Trim () is better than Trim (params char[] chars)
3629 // Concat (string s1, string s2, string s3) is better than
3630 // Concat (string s1, params string [] srest)
3631 // Foo (int, params int [] rest) is better than Foo (params int [] rest)
3632 //
3642 // can only happen if (candidate_params && best_params)
3645 //
3646 // now, both methods have the same number of parameters, and the parameters have the same types
3647 // Pick the "more specific" signature
3648 //
3658 {
3668 }
3673 // FIXME: handle lifted operators
3674 // ...
3677 }
3679 protected override MemberExpr ResolveExtensionMemberAccess (ResolveContext ec, Expression left)
3680 {
3684 //
3685 // When left side is an expression and at least one candidate method is
3686 // static, it can be extension method
3687 //
3690 }
3692 public override MemberExpr ResolveMemberAccess (ResolveContext ec, Expression left, Location loc,
3693 SimpleName original)
3694 {
3700 }
3703 {
3705 ec.Report.Error (1953, loc, "An expression tree cannot contain an expression with method group");
3707 }
3712 "Partial methods with only a defining declaration or removed conditional methods cannot be used in an expression tree");
3715 }
3718 {
3725 }
3728 }
3731 {
3734 }
3737 {
3739 // ReportUsageError ();
3740 }
3743 {
3745 }
3748 {
3753 ec.Report.Error (121, loc, "The call is ambiguous between the following methods or properties: `{0}' and `{1}'",
3754 TypeManager.CSharpSignature (ambiguous), TypeManager.CSharpSignature (best_candidate.MetaInfo));
3755 }
3757 protected virtual void Error_InvalidArguments (ResolveContext ec, Location loc, int idx, MethodSpec method,
3759 {
3765 ec.Report.Error (1954, loc, "The best overloaded collection initalizer method `{0}' cannot have 'ref', or `out' modifier",
3768 }
3769 ec.Report.Error (1950, loc, "The best overloaded collection initalizer method `{0}' has some invalid arguments",
3778 "Type `{0}' does not contain a member `{1}' and the best extension method overload `{2}' has some invalid arguments",
3782 ec.Report.Error (1502, loc, "The best overloaded method match for `{0}' has some invalid arguments",
3784 }
3785 }
3787 Parameter.Modifier mod = idx >= expected_par.Count ? 0 : expected_par.FixedParameters [idx].ModFlags;
3793 ec.Report.Error (1615, loc, "Argument `#{0}' does not require `{1}' modifier. Consider removing `{1}' modifier",
3795 else
3803 ec.Report.ExtraInformation (loc, "(equally named types possibly from different assemblies in previous ");
3806 }
3814 }
3815 }
3816 }
3818 public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, Type target, bool expl)
3819 {
3820 ec.Report.Error (428, loc, "Cannot convert method group `{0}' to non-delegate type `{1}'. Consider using parentheses to invoke the method",
3822 }
3825 {
3828 }
3830 protected virtual int GetApplicableParametersCount (MethodSpec method, AParametersCollection parameters)
3831 {
3833 }
3836 {
3840 }
3842 ///
3843 /// Determines if the candidate method is applicable (section 14.4.2.1)
3844 /// to the given set of arguments
3845 /// A return value rates candidate method compatibility,
3846 /// 0 = the best, int.MaxValue = the worst
3847 ///
3850 {
3862 }
3863 }
3870 // Readjust expected number when params used
3872 optional_count--;
3874 param_count--;
3877 }
3883 }
3885 // Initialize expanded form of a method with 1 params parameter
3888 // Resize to fit optional arguments
3890 Arguments resized;
3896 }
3901 }
3902 }
3905 //
3906 // Shuffle named arguments to the right positions if there are any
3907 //
3920 // Named parameter not found or already reordered
3924 // When using parameters which should not be available to the user
3931 }
3939 }
3940 }
3943 }
3946 }
3948 //
3949 // 1. Handle generic method using type arguments when specified or type inference
3950 //
3966 throw new InternalErrorException ("A generic method `{0}' definition took part in overload resolution",
3970 }
3974 }
3976 //
3977 // 2. Each argument has to be implicitly convertible to method parameter
3978 //
3994 }
3997 p_mod = pd.FixedParameters [i].ModFlags & ~(Parameter.Modifier.OUTMASK | Parameter.Modifier.REFMASK);
4001 }
4003 Parameter.Modifier a_mod = a.Modifier & ~(Parameter.Modifier.OUTMASK | Parameter.Modifier.REFMASK);
4009 // It can be applicable in expanded form
4013 }
4019 }
4020 }
4026 }
4028 int IsArgumentCompatible (ResolveContext ec, Parameter.Modifier arg_mod, Argument argument, Parameter.Modifier param_mod, Type parameter)
4029 {
4030 //
4031 // Types have to be identical when ref or out modifer is used
4032 //
4046 }
4053 }
4054 }
4060 }
4063 {
4074 {
4082 }
4085 }
4087 public static MethodGroupExpr MakeUnionSet (MethodGroupExpr mg1, MethodGroupExpr mg2, Location loc)
4088 {
4093 }
4100 if (!TypeManager.ArrayContainsMethod (mg1.Methods.Select (l => l.MetaInfo).ToArray (), m.MetaInfo, false))
4102 }
4105 }
4108 {
4115 {
4123 }
4125 {
4133 {
4134 Type specific = MoreSpecific (TypeManager.TypeToCoreType (pargs [i]), TypeManager.TypeToCoreType (qargs [i]));
4139 }
4145 }
4148 }
4151 {
4158 }
4159 }
4161 /// <summary>
4162 /// Find the Applicable Function Members (7.4.2.1)
4163 ///
4164 /// me: Method Group expression with the members to select.
4165 /// it might contain constructors or methods (or anything
4166 /// that maps to a method).
4167 ///
4168 /// Arguments: ArrayList containing resolved Argument objects.
4169 ///
4170 /// loc: The location if we want an error to be reported, or a Null
4171 /// location for "probing" purposes.
4172 ///
4173 /// Returns: The MethodBase (either a ConstructorInfo or a MethodInfo)
4174 /// that is the best match of me on Arguments.
4175 ///
4176 /// </summary>
4179 {
4185 //
4186 // Used to keep a map between the candidate
4187 // and whether it is being considered in its
4188 // normal or expanded form
4189 //
4190 // false is normal form, true is expanded form
4191 //
4198 if (RootContext.Version == LanguageVersion.ISO_1 && Name == "Invoke" && TypeManager.IsDelegateType (DeclaringType)) {
4202 }
4207 //
4208 // Methods marked 'override' don't take part in 'applicable_type'
4209 // computation, nor in the actual overload resolution.
4210 // However, they still need to be emitted instead of a base virtual method.
4211 // So, we salt them away into the 'candidate_overrides' array.
4212 //
4213 // In case of reflected methods, we replace each overriding method with
4214 // its corresponding base virtual method. This is to improve compatibility
4215 // with non-C# libraries which change the visibility of overrides (#75636)
4216 //
4229 }
4232 }
4234 }
4236 //
4237 // Enable message recording, it's used mainly by lambda expressions
4238 //
4242 //
4243 // First we construct the set of applicable methods
4244 //
4250 //
4251 // If we have already found an applicable method
4252 // we eliminate all base types (Section 14.5.5.1)
4253 //
4257 //
4258 // Check if candidate is applicable (section 14.4.2.1)
4259 //
4261 int candidate_rate = IsApplicable (ec, ref candidate_args, arg_count, ref Methods [i], ref params_expanded_form);
4266 }
4270 candidate_to_form = new Dictionary<MethodSpec, MethodSpec> (4, ReferenceEquality<MethodSpec>.Default);
4273 }
4277 candidates_expanded = new Dictionary<MethodSpec, Arguments> (4, ReferenceEquality<MethodSpec>.Default);
4281 }
4287 }
4298 }
4299 }
4307 }
4312 //
4313 // When we found a top level method which does not match and it's
4314 // not an extension method. We start extension methods lookup from here
4315 //
4322 }
4323 }
4328 //
4329 // Okay so we have failed to find exact match so we
4330 // return error info about the closest match
4331 //
4333 if (CustomErrorHandler != null && !has_inaccessible_candidates_only && CustomErrorHandler.NoExactMatch (ec, best_candidate))
4338 }
4340 //
4341 // We failed to find any method with correct argument count
4342 //
4350 }
4353 }
4358 }
4361 //
4362 // At this point, applicable_type is _one_ of the most derived types
4363 // in the set of types containing the methods in this MethodGroup.
4364 // Filter the candidates so that they only contain methods from the
4365 // most derived types.
4366 //
4371 // Invariant: applicable_type is a most derived type
4373 // We'll try to complete Section 14.5.5.1 for 'applicable_type' by
4374 // eliminating all it's base types. At the same time, we'll also move
4375 // every unrelated type to the end of the array, and pick the next
4376 // 'applicable_type'.
4389 }
4403 }
4409 }
4411 //
4412 // Now we actually find the best method
4413 //
4418 //
4419 // TODO: Broken inverse order of candidates logic does not work with optional
4420 // parameters used for method overrides and I am not going to fix it for SRE
4421 //
4425 }
4440 }
4441 }
4442 //
4443 // Now check that there are no ambiguities i.e the selected method
4444 // should be better than all the others
4445 //
4457 {
4461 }
4462 }
4467 }
4469 //
4470 // If the method is a virtual function, pick an override closer to the LHS type.
4471 //
4475 "Should not happen. An 'override' method took part in overload resolution: " + best_candidate);
4493 }
4498 }
4499 }
4503 }
4504 }
4505 }
4507 //
4508 // And now check if the arguments are all
4509 // compatible, perform conversions if
4510 // necessary etc. and return if everything is
4511 // all right
4512 //
4525 //
4526 // Check ObsoleteAttribute on the best method
4527 //
4538 }
4540 bool NoExactMatch (ResolveContext ec, ref Arguments Arguments, IDictionary<MethodSpec, MethodSpec> candidate_to_form)
4541 {
4553 }
4562 }
4567 }
4568 }
4571 if (InstanceExpression != null && type != ec.CurrentType && TypeManager.IsNestedFamilyAccessible (ec.CurrentType, best_candidate.DeclaringType)) {
4572 // Although a derived class can access protected members of
4573 // its base class it cannot do so through an instance of the
4574 // base class (CS1540). If the qualifier_type is a base of the
4575 // ec.CurrentType and the lookup succeeds with the latter one,
4576 // then we are in this situation.
4581 }
4582 }
4584 bool cand_params = candidate_to_form != null && candidate_to_form.ContainsKey (best_candidate);
4585 if (!VerifyArgumentsCompat (ec, ref Arguments, arg_count, best_candidate, cand_params, false, loc))
4590 }
4593 }
4596 {
4598 }
4604 {
4627 }
4628 }
4629 }
4631 //
4632 // Types have to be identical when ref or out modifer is used
4633 //
4657 }
4661 else
4667 }
4668 }
4669 }
4681 //
4682 // Convert params arguments to an array initializer
4683 //
4685 // we choose to use 'a.Expr' rather than 'conv' so that
4686 // we don't hide the kind of expression we have (esp. CompoundAssign.Helper)
4691 }
4693 // Update the argument with the implicit conversion
4695 }
4701 else
4703 }
4705 }
4707 //
4708 // Fill not provided arguments required by params modifier
4709 //
4718 }
4720 //
4721 // Append an array argument with all params arguments
4722 //
4725 new ArrayCreation (new TypeExpression (pt, loc), "[]", params_initializers, loc).Resolve (ec)));
4726 arg_count++;
4727 }
4733 }
4739 }
4742 }
4743 }
4746 {
4747 ConstSpec constant;
4750 {
4753 }
4756 get { throw new NotImplementedException (); }
4757 }
4760 get { return !IsStatic; }
4761 }
4764 get { return true; }
4765 }
4768 get { return constant.DeclaringType; }
4769 }
4772 {
4774 }
4777 {
4783 AttributeTester.Report_ObsoleteMessage (oa, TypeManager.GetFullNameSignature (constant.MetaInfo), loc, rc.Report);
4784 }
4786 // Constants are resolved on-demand
4789 // Creates reference expression to the constant value
4791 }
4794 {
4796 }
4799 {
4801 }
4802 }
4804 /// <summary>
4805 /// Fully resolved expression that evaluates to a Field
4806 /// </summary>
4810 VariableInfo variable_info;
4812 LocalTemporary temp;
4816 {
4818 }
4821 {
4826 }
4830 {
4832 }
4836 {
4840 }
4845 }
4846 }
4851 }
4852 }
4857 }
4858 }
4863 }
4864 }
4869 }
4870 }
4873 {
4875 }
4880 }
4881 }
4883 public override MemberExpr ResolveMemberAccess (ResolveContext ec, Expression left, Location loc,
4884 SimpleName original)
4885 {
4891 }
4894 }
4897 {
4901 }
4904 {
4905 Expression instance;
4910 }
4913 instance,
4917 }
4920 {
4922 }
4925 {
4927 }
4930 {
4933 //
4934 // This can happen when referencing an instance field using
4935 // a fully qualified type expression: TypeName.InstanceField = xxx
4936 //
4939 }
4941 // Resolve the field's instance expression while flow analysis is turned
4942 // off: when accessing a field "a.b", we must check whether the field
4943 // "a.b" is initialized, not whether the whole struct "a" is initialized.
4947 Expression right_side =
4952 }
4957 }
4958 }
4959 }
4966 }
4967 }
4976 AttributeTester.Report_ObsoleteMessage (oa, TypeManager.GetFullNameSignature (spec.MetaInfo), loc, ec.Report);
4977 }
4978 }
4985 if (!ec.HasSet (ResolveContext.Options.FixedInitializerScope) && (fe == null || !fe.IsFixed)) {
4986 ec.Report.Error (1666, loc, "You cannot use fixed size buffers contained in unfixed expressions. Try using the fixed statement");
4987 }
4991 ec.Report.Error (1708, loc, "`{0}': Fixed size buffers can only be accessed through locals or fields",
4995 }
4998 }
5002 // If the instance expression is a local variable or parameter.
5012 }
5023 };
5026 /*0191*/ "A readonly field `{0}' cannot be assigned to (except in a constructor or a variable initializer)",
5028 /*0198*/ "A static readonly field `{0}' cannot be assigned to (except in a static constructor or a variable initializer)",
5029 /*0199*/ "A static readonly field `{0}' cannot be passed ref or out (except in a static constructor)",
5030 /*1648*/ "Members of readonly field `{0}' cannot be modified (except in a constructor or a variable initializer)",
5031 /*1649*/ "Members of readonly field `{0}' cannot be passed ref or out (except in a constructor)",
5032 /*1650*/ "Fields of static readonly field `{0}' cannot be assigned to (except in a static constructor or a variable initializer)",
5033 /*1651*/ "Fields of static readonly field `{0}' cannot be passed ref or out (except in a static constructor)"
5034 };
5036 // The return value is always null. Returning a value simplifies calling code.
5038 {
5040 if (right_side == EmptyExpression.OutAccess.Instance || right_side == EmptyExpression.LValueMemberOutAccess)
5044 if (right_side == EmptyExpression.LValueMemberAccess || right_side == EmptyExpression.LValueMemberOutAccess)
5049 }
5052 {
5057 bool lvalue_instance = !spec.IsStatic && TypeManager.IsValueType (spec.MetaInfo.DeclaringType);
5058 bool out_access = right_side == EmptyExpression.OutAccess.Instance || right_side == EmptyExpression.LValueMemberOutAccess;
5069 if ((right_side == EmptyExpression.UnaryAddress || right_side == EmptyExpression.OutAccess.Instance) &&
5074 }
5075 }
5078 // InitOnly fields can only be assigned in constructors or initializers
5079 if (!ec.HasAny (ResolveContext.Options.FieldInitializerScope | ResolveContext.Options.ConstructorScope))
5085 // InitOnly fields cannot be assigned-to in a different constructor from their declaring type
5088 // static InitOnly fields cannot be assigned-to in an instance constructor
5091 // instance constructors can't modify InitOnly fields of other instances of the same type
5094 }
5095 }
5098 !IsStatic && !(InstanceExpression is This) && TypeManager.mbr_type != null && TypeManager.IsSubclassOf (DeclaringType, TypeManager.mbr_type)) {
5101 "Passing `{0}' as ref or out or taking its address may cause a runtime exception because it is a field of a marshal-by-reference class",
5103 }
5107 }
5110 {
5111 return !IsStatic && TypeManager.IsStruct (Type) && TypeManager.mbr_type != null && TypeManager.IsSubclassOf (DeclaringType, TypeManager.mbr_type);
5112 }
5115 {
5118 ec.Report.Warning (1690, 1, loc, "Cannot call methods, properties, or indexers on `{0}' because it is a value type member of a marshal-by-reference class",
5120 }
5121 }
5124 {
5126 }
5130 //
5131 // A variable of the form V.I is fixed when V is a fixed variable of a struct type
5132 //
5139 }
5140 }
5146 }
5147 }
5150 {
5162 }
5165 {
5175 }
5186 // Optimization for build-in types
5187 if (TypeManager.IsStruct (type) && TypeManager.IsEqual (type, ec.MemberContext.CurrentType) && TypeManager.IsEqual (InstanceExpression.Type, type)) {
5199 }
5200 }
5201 }
5208 }
5209 }
5210 }
5212 public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
5213 {
5214 //FieldAttributes fa = FieldInfo.Attributes;
5215 //bool is_static = (fa & FieldAttributes.Static) != 0;
5227 }
5228 }
5236 }
5240 else
5247 }
5248 }
5251 {
5253 }
5256 {
5262 }
5265 {
5267 "A local variable `{0}' cannot be used before it is declared. Consider renaming the local variable when it hides the field `{1}'",
5269 }
5272 {
5281 }
5283 //
5284 // Handle initonly fields specially: make a copy and then
5285 // get the address of the copy.
5286 //
5296 }
5301 LocalBuilder local;
5307 }
5316 }
5317 }
5320 {
5325 }
5328 {
5330 }
5333 {
5335 }
5338 {
5341 }
5342 }
5345 /// <summary>
5346 /// Expression that evaluates to a Property. The Assign class
5347 /// might set the `Value' expression if we are in an assignment.
5348 ///
5349 /// This is not an LValue because we need to re-write the expression, we
5350 /// can not take data from the stack and store it.
5351 /// </summary>
5353 {
5354 PropertySpec spec;
5358 TypeArguments targs;
5360 LocalTemporary temp;
5364 {
5371 }
5376 }
5377 }
5382 }
5383 }
5388 }
5389 }
5392 {
5393 Arguments args;
5398 }
5403 }
5408 else
5412 }
5415 {
5417 }
5422 }
5423 }
5426 {
5428 }
5431 {
5446 // Oooops, can this ever happen ?
5455 }
5461 }
5467 }
5468 }
5470 //
5471 // We also perform the permission checking here, as the PropertyInfo does not
5472 // hold the information for the accessibility of its setter/getter
5473 //
5474 // TODO: Refactor to use some kind of cache together with GetPropertyFromAccessor
5476 {
5486 }
5495 }
5496 }
5499 {
5500 return SLE.Expression.Property (InstanceExpression.MakeExpression (ctx), (MethodInfo) setter.MetaInfo);
5501 }
5504 {
5505 return SLE.Expression.Property (InstanceExpression.MakeExpression (ctx), (MethodInfo) getter.MetaInfo);
5506 }
5509 {
5518 }
5523 }
5524 }
5527 {
5531 }
5536 }
5540 InstanceExpression = InstanceExpression.ResolveLValue (ec, EmptyExpression.LValueMemberAccess);
5554 }
5557 }
5560 {
5561 // TODO: correctly we should compare arguments but it will lead to bigger changes
5565 }
5575 ec.Report.Error (1546, loc, "Property `{0}' is not supported by the C# language. Try to call the accessor method `{1}' directly",
5577 }
5580 {
5586 }
5589 {
5596 }
5599 {
5615 }
5616 }
5620 }
5625 //
5626 // Only base will allow this invocation to happen.
5627 //
5630 }
5634 }
5644 }
5645 }
5648 }
5651 {
5656 ec.Report.Error (1939, loc, "A range variable `{0}' may not be passes as `ref' or `out' parameter",
5660 }
5662 }
5664 if (right_side == EmptyExpression.LValueMemberAccess || right_side == EmptyExpression.LValueMemberOutAccess) {
5666 }
5669 //
5670 // The following condition happens if the PropertyExpr was
5671 // created, but is invalid (ie, the property is inaccessible),
5672 // and we did not want to embed the knowledge about this in
5673 // the caller routine. This only avoids double error reporting.
5674 //
5679 ec.Report.Error (1947, loc, "A range variable `{0}' cannot be assigned to. Consider using `let' clause to store the value",
5682 ec.Report.Error (200, loc, "Property or indexer `{0}' cannot be assigned to (it is read only)",
5684 }
5686 }
5691 }
5696 }
5700 PropertyBase.PropertyMethod pm = TypeManager.GetMethod (setter.MetaInfo) as PropertyBase.PropertyMethod;
5703 ec.Report.Error (272, loc, "The property or indexer `{0}' cannot be used in this context because the set accessor is inaccessible",
5705 }
5709 }
5711 }
5716 //
5717 // Only base will allow this invocation to happen.
5718 //
5721 }
5725 }
5735 }
5736 }
5739 }
5742 {
5744 }
5747 {
5748 //
5749 // Special case: length of single dimension array property is turned into ldlen
5750 //
5757 }
5766 }
5767 }
5768 }
5770 //
5771 // Implements the IAssignMethod interface for assignments
5772 //
5773 public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
5774 {
5786 }
5787 }
5793 }
5803 }
5804 }
5807 {
5811 }
5817 }
5818 }
5821 //
5822 // The following condition happens if the PropertyExpr was
5823 // created, but is invalid (ie, the property is inaccessible),
5824 // and we did not want to embed the knowledge about this in
5825 // the caller routine. This only avoids double error reporting.
5826 //
5831 ec.Report.Error (154, loc, "The property or indexer `{0}' cannot be used in this context because it lacks the `get' accessor",
5834 }
5835 }
5839 PropertyBase.PropertyMethod pm = TypeManager.GetMethod (getter.MetaInfo) as PropertyBase.PropertyMethod;
5842 ec.Report.Error (271, loc, "The property or indexer `{0}' cannot be used in this context because the get accessor is inaccessible",
5847 }
5850 }
5853 }
5856 {
5858 }
5859 }
5861 /// <summary>
5862 /// Fully resolved expression that evaluates to an Event
5863 /// </summary>
5865 {
5869 {
5872 }
5877 }
5878 }
5883 }
5884 }
5889 }
5890 }
5895 }
5896 }
5899 {
5900 ec.Report.Error (79, loc, "The event `{0}' can only appear on the left hand side of `+=' or `-=' operator",
5902 }
5904 public override MemberExpr ResolveMemberAccess (ResolveContext ec, Expression left, Location loc,
5905 SimpleName original)
5906 {
5907 //
5908 // If the event is local to this class, we transform ourselves into a FieldExpr
5909 //
5914 // TODO: Breaks dynamic binder as currect context fields are imported and not compiled
5922 if ((mi.ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) != 0 && !ec.HasSet (ResolveContext.Options.CompoundAssignmentScope))
5930 }
5931 }
5937 }
5940 {
5944 }
5949 }
5958 }
5960 //
5961 // This is using the same mechanism as the CS1540 check in PropertyExpr.
5962 // However, in the Event case, we reported a CS0122 instead.
5963 //
5964 // TODO: Exact copy from PropertyExpr
5965 //
5973 }
5976 }
5979 {
5983 }
5986 {
5988 }
5991 {
5992 // contexts where an LValue is valid have already devolved to FieldExprs
5995 }
5998 {
6007 }
6015 }
6021 }
6027 }
6030 {
6032 //Error_CannotAssign ();
6033 }
6036 {
6038 "The event `{0}' can only appear on the left hand side of += or -= when used outside of the type `{1}'",
6040 }
6043 {
6045 }
6048 {
6054 }
6055 }
6058 {
6059 LocalInfo li;
6062 {
6065 }
6068 {
6070 }
6073 {
6081 //
6082 // Don't capture temporary variables except when using
6083 // iterator redirection
6084 //
6085 if (ec.CurrentAnonymousMethod != null && ec.CurrentAnonymousMethod.IsIterator && ec.IsVariableCapturingRequired) {
6088 }
6091 }
6094 {
6096 }
6099 {
6101 }
6104 {
6106 }
6109 {
6111 }
6114 get { return true; }
6115 }
6118 get { return false; }
6119 }
6122 get { throw new NotImplementedException (); }
6123 }
6126 {
6128 }
6131 get { return li; }
6132 }
6135 get { throw new NotImplementedException (); }
6136 }
6137 }
6139 ///
6140 /// Handles `var' contextual keyword; var becomes a keyword only
6141 /// if no type called var exists in a variable scope
6142 ///
6144 {
6145 // Used for error reporting only
6150 {
6152 }
6157 }
6158 }
6161 {
6163 throw new InternalErrorException ("An implicitly typed local variable could not be redefined");
6166 if (type == TypeManager.null_type || type == TypeManager.void_type || type == InternalType.AnonymousMethod || type == InternalType.MethodGroup) {
6167 ec.Report.Error (815, loc, "An implicitly typed local variable declaration cannot be initialized with `{0}'",
6170 }
6174 }
6177 {
6180 else
6181 ec.Compiler.Report.Error (825, loc, "The contextual keyword `var' may only appear within a local variable declaration");
6182 }
6185 {
6197 rc.Compiler.Report.Error (819, loc, "An implicitly typed local variable declaration cannot include multiple declarators");
6200 }
6204 rc.Compiler.Report.Error (818, loc, "An implicitly typed local variable declarator must include an initializer");
6206 }
6209 }
6210 }
6211 }