| blob | 24645f5ef8da0993824e553e6566cbfd143d50cf |
1 //
2 // class.cs: Class and Struct handlers
3 //
4 // Authors: Miguel de Icaza (miguel@gnu.org)
5 // Martin Baulig (martin@ximian.com)
6 // Marek Safar (marek.safar@seznam.cz)
7 //
8 // Licensed under the terms of the GNU GPL
9 //
10 // (C) 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
11 // (C) 2004 Novell, Inc
12 //
13 //
14 // 2002-10-11 Miguel de Icaza <miguel@ximian.com>
15 //
16 // * class.cs: Following the comment from 2002-09-26 to AddMethod, I
17 // have fixed a remaining problem: not every AddXXXX was adding a
18 // fully qualified name.
19 //
20 // Now everyone registers a fully qualified name in the DeclSpace as
21 // being defined instead of the partial name.
22 //
23 // Downsides: we are slower than we need to be due to the excess
24 // copies and the names being registered this way.
25 //
26 // The reason for this is that we currently depend (on the corlib
27 // bootstrap for instance) that types are fully qualified, because
28 // we dump all the types in the namespace, and we should really have
29 // types inserted into the proper namespace, so we can only store the
30 // basenames in the defined_names array.
31 //
32 //
33 #define CACHE
51 Root,
52 Struct,
53 Class,
54 Interface
55 }
57 /// <summary>
58 /// This is the base class for structs and classes.
59 /// </summary>
63 {
64 /// <summary>
65 /// Defines the MemberCore objects that are in this array
66 /// </summary>
68 {
72 }
75 }
76 }
77 }
80 {
83 }
84 }
87 {
92 }
94 CachedMethods cached_method;
95 TypeContainer container;
98 {
100 }
102 /// <summary>
103 /// Method container contains Equals method
104 /// </summary>
108 }
112 }
113 }
115 /// <summary>
116 /// Method container contains GetHashCode method
117 /// </summary>
121 }
125 }
126 }
129 {
133 Report.Warning (659, 3, container.Location, "`{0}' overrides Object.Equals(object) but does not override Object.GetHashCode()", container.GetSignatureForError ());
134 }
135 }
137 }
140 {
141 /// <summary>
142 /// The indexer name for this container
143 /// </summary>
148 TypeContainer container;
151 {
153 }
155 /// <summary>
156 /// Defines the indexers, and also verifies that the IndexerNameAttribute in the
157 /// class is consistent. Either it is `Item' or it is the name defined by all the
158 /// indexers with the `IndexerName' attribute.
159 ///
160 /// Turns out that the IndexerNameAttribute is applied to each indexer,
161 /// but it is never emitted, instead a DefaultMember attribute is attached
162 /// to the class.
163 /// </summary>
165 {
170 //
171 // If there's both an explicit and an implicit interface implementation, the
172 // explicit one actually implements the interface while the other one is just
173 // a normal indexer. See bug #37714.
174 //
176 // Invariant maintained by AddIndexer(): All explicit interface indexers precede normal indexers
182 }
189 }
192 Report.Error (668, i.Location, "Two indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type");
193 }
197 }
200 {
206 CustomAttributeBuilder cb = new CustomAttributeBuilder (TypeManager.default_member_ctor, new string [] { IndexerName });
208 }
209 }
212 {
213 TypeContainer container;
216 {
218 }
220 //
221 // Operator pair checking
222 //
223 class OperatorEntry
224 {
232 {
241 }
244 {
246 }
249 {
259 }
260 }
262 //
263 // Checks that some operators come in pairs:
264 // == and !=
265 // > and <
266 // >= and <=
267 // true and false
268 //
269 // They are matched based on the return type and the argument types
270 //
272 {
278 // Register all the operators we care about.
282 // Skip erroneous code.
312 }
324 }
325 }
329 Report.Error (216, true_op.Location, "The operator `{0}' requires a matching operator `false' to also be defined",
332 Report.Error (216, false_op.Location, "The operator `{0}' requires a matching operator `true' to also be defined",
335 //
336 // Look for the mistakes.
337 //
364 }
368 }
372 Report.Warning (660, 2, container.Location, "`{0}' defines operator == or operator != but does not override Object.Equals(object o)", container.GetSignatureForError ());
375 Report.Warning (661, 2, container.Location, "`{0}' defines operator == or operator != but does not override Object.GetHashCode()", container.GetSignatureForError ());
376 }
377 }
380 {
383 }
384 }
387 // Whether this is a struct, class or interface
390 // Holds a list of classes and structures
393 // Holds the list of properties
394 MemberCoreArrayList properties;
396 // Holds the list of enumerations
397 MemberCoreArrayList enums;
399 // Holds the list of delegates
400 MemberCoreArrayList delegates;
402 // Holds the list of constructors
405 // Holds the list of fields
406 MemberCoreArrayList fields;
408 // Holds a list of fields that have initializers
411 // Holds a list of static fields that have initializers
414 // Holds the list of constants
415 MemberCoreArrayList constants;
417 // Holds the list of
418 MemberCoreArrayList interfaces;
420 // Holds the methods.
421 MethodArrayList methods;
423 // Holds the events
426 // Holds the indexers
427 IndexerArrayList indexers;
429 // Holds the operators
430 MemberCoreArrayList operators;
432 // Holds the iterators
433 ArrayList iterators;
435 //
436 // Pointers to the default constructor and the default static constructor
437 //
441 //
442 // Points to the first non-static field added to the container.
443 //
444 // This is an arbitrary choice. We are interested in looking at _some_ non-static field,
445 // and the first one's as good as any.
446 //
449 //
450 // This one is computed after we can distinguish interfaces
451 // from classes from the arraylist `type_bases'
452 //
453 TypeExpr base_type;
456 ArrayList type_bases;
461 // The interfaces we implement.
464 // The base member cache and our member cache
465 MemberCache base_cache;
466 MemberCache member_cache;
470 Type GenericType;
474 ArrayList partial_parts;
476 /// <remarks>
477 /// The pending methods that need to be implemented
478 // (interfaces or abstract methods)
479 /// </remarks>
480 PendingImplementation pending;
485 {
487 throw new InternalErrorException ("A nested type should be in the same NamespaceEntry as its enclosing class");
491 }
494 {
496 }
499 {
501 }
504 {
512 }
515 {
523 }
526 {
536 }
539 {
541 }
544 {
551 else
554 }
560 }
568 }
578 }
587 else
589 }
594 }
597 {
605 }
608 {
617 else
619 }
621 //
622 // Do not use this method: use AddMethod.
623 //
624 // This is only used by iterators.
625 //
627 {
635 }
638 {
641 }
650 }
659 }
661 }
667 }
668 }
673 }
674 }
677 {
683 }
688 }
691 {
706 }
715 }
716 }
719 {
729 else
731 }
734 {
744 }
750 }
752 /// <summary>
753 /// Indexer has special handling in constrast to other AddXXX because the name can be driven by IndexerNameAttribute
754 /// </summary>
756 {
762 else
764 }
767 {
775 }
778 {
783 }
786 {
789 Report.Error (646, a.Location, "Cannot specify the `DefaultMember' attribute on type containing an indexer");
791 }
792 }
795 }
800 }
801 }
806 }
807 }
812 }
813 }
818 }
819 }
824 }
825 }
830 }
831 }
836 }
837 }
842 }
846 }
847 }
852 }
853 }
858 }
859 }
864 }
865 }
870 }
871 }
876 }
877 }
882 }
883 }
888 }
889 }
894 }
895 }
900 }
901 }
906 }
907 }
915 }
916 }
919 {
930 }
931 }
933 //
934 // Emits the instance field initializers
935 //
937 {
938 ArrayList fields;
944 }
951 }
953 }
958 }
964 }
965 }
968 get { return pending; }
969 }
972 {
977 }
980 {
993 }
996 // base_class could be a class, struct, enum, delegate.
997 // This is validated in GetClassBases.
1000 }
1001 }
1009 }
1012 }
1015 }
1019 {
1025 TypeExpr new_base_class;
1038 }
1039 }
1040 }
1050 }
1051 }
1057 }
1059 /// <summary>
1060 /// This function computes the Base class and also the
1061 /// list of interfaces that the class or struct @c implements.
1062 ///
1063 /// The return value is an array (might be null) of
1064 /// interfaces implemented (as Types).
1065 ///
1066 /// The @base_class argument is set to the base object or null
1067 /// if this is `System.Object'.
1068 /// </summary>
1070 {
1083 // TODO: location of symbol related ....
1085 }
1087 Report.Error (1721, Location, "`{0}': Classes cannot have multiple base classes (`{1}' and `{2}')",
1092 }
1094 }
1102 }
1103 }
1111 Name);
1113 }
1114 }
1116 }
1119 {
1138 }
1141 }
1144 }
1149 {
1151 }
1154 {
1159 }
1172 }
1176 }
1190 }
1195 }
1197 //
1198 // GetClassBases calls ResolveBaseTypeExpr() on the various type expressions involved,
1199 // which in turn should have called DefineType()s on base types if necessary.
1200 //
1201 // None of the code below should trigger DefineType()s on classes that we depend on.
1202 // Thus, we are eligible to be on the topological sort `type_container_resolve_order'.
1203 //
1204 // Let's do it as soon as possible, since code below can call DefineType() on classes
1205 // that depend on us to be populated before they are.
1206 //
1217 }
1223 AttributeTester.Report_ObsoleteMessage (obsolete_attr, base_type.GetSignatureForError (), Location);
1224 }
1225 }
1229 }
1231 // add interfaces that were not added at type creation
1236 }
1243 }
1246 }
1250 }
1253 }
1255 //
1256 // Defines the type in the appropriate ModuleBuilder or TypeBuilder.
1257 //
1259 {
1269 }
1274 }
1279 }
1283 {
1287 }
1300 }
1301 }
1302 }
1303 }
1306 {
1319 }
1320 }
1323 }
1326 {
1331 }
1345 }
1346 }
1353 }
1354 }
1355 }
1361 }
1362 }
1370 }
1377 }
1380 }
1383 }
1386 {
1391 }
1397 }
1403 }
1409 }
1412 }
1414 TypeContainer InTransit;
1417 {
1425 else
1431 }
1440 }
1448 }
1449 }
1453 }
1456 {
1458 }
1460 /// <summary>
1461 /// Populates our TypeBuilder with fields and methods
1462 /// </summary>
1464 {
1475 }
1478 {
1484 }
1485 }
1491 }
1494 MemberInfo conflict_symbol = Parent.MemberCache.FindMemberWithSameName (Basename, false, TypeBuilder);
1497 Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
1501 Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
1503 }
1504 }
1505 }
1512 }
1514 //
1515 // Constructors are not in the defined_names array
1516 //
1529 }
1532 #if CACHE
1537 }
1538 #endif
1543 }
1548 }
1549 }
1552 }
1555 {
1558 }
1561 {
1566 }
1567 }
1570 }
1573 {
1575 }
1577 /// <summary>
1578 /// This function is based by a delegate to the FindMembers routine
1579 /// </summary>
1581 {
1583 }
1585 /// <summary>
1586 /// This filter is used by FindMembers, and we just keep
1587 /// a global for the filter to `AlwaysAccept'
1588 /// </summary>
1593 {
1595 }
1598 {
1609 }
1610 }
1618 }
1619 }
1630 }
1631 }
1642 }
1643 }
1654 }
1655 }
1660 }
1662 // Indicated whether container has StructLayout attribute set Explicit
1666 }
1669 }
1670 }
1673 {
1689 }
1690 }
1691 }
1694 }
1699 {
1718 }
1725 }
1726 }
1727 }
1728 }
1730 /// <summary>
1731 /// This method returns the members of this type just like Type.FindMembers would
1732 /// Only, we need to use this for types which are _being_ defined because MS'
1733 /// implementation can't take care of that.
1734 /// </summary>
1735 //
1736 // FIXME: return an empty static array instead of null, that cleans up
1737 // some code and is consistent with some coding conventions I just found
1738 // out existed ;-)
1739 //
1740 //
1741 // Notice that in various cases we check if our field is non-null,
1742 // something that would normally mean that there was a bug elsewhere.
1743 //
1744 // The problem happens while we are defining p-invoke methods, as those
1745 // will trigger a FindMembers, but this happens before things are defined
1746 //
1747 // Since the whole process is a no-op, it is fine to check for null here.
1748 //
1751 {
1775 }
1799 }
1800 }
1801 }
1817 }
1823 }
1824 }
1825 }
1826 }
1846 }
1847 }
1848 }
1866 }
1867 }
1868 }
1880 MethodBuilder b;
1888 }
1896 }
1897 }
1898 }
1910 MethodBuilder b;
1918 }
1926 }
1927 }
1928 }
1929 }
1948 }
1949 }
1950 }
1951 }
1970 }
1971 }
1972 }
1990 }
1991 }
1992 }
1993 }
2010 }
2011 }
2012 }
2015 ConstructorBuilder cb =
2023 }
2024 }
2025 }
2027 //
2028 // Lookup members in base if requested.
2029 //
2038 }
2039 }
2041 }
2047 else
2049 }
2054 }
2055 }
2059 {
2064 else
2066 }
2068 /// <summary>
2069 /// Emits the values for the constants
2070 /// </summary>
2072 {
2077 }
2080 {
2089 Report.Warning (169, 3, mc.Location, "The private {0} `{1}' is never used", member_type, mc.GetSignatureForError ());
2090 }
2091 }
2092 }
2095 {
2096 //
2097 // Check for internal or private fields that were never assigned
2098 //
2111 Report.Warning (169, 3, f.Location, "The private field `{0}' is never used", f.GetSignatureForError ());
2113 #if NET_2_0
2115 #else
2117 #endif
2118 Report.Warning (error_code, 3, f.Location, "The private field `{0}' is assigned but its value is never used",
2120 }
2122 }
2124 //
2125 // Only report 649 on level 4
2126 //
2133 Report.Warning (649, 4, f.Location, "Field `{0}' is never assigned to, and will always have its default value `{1}'",
2134 f.GetSignatureForError (), f.Type.Type.IsValueType ? Activator.CreateInstance (f.Type.Type).ToString() : "null");
2135 }
2136 }
2137 }
2138 }
2140 // TODO: move to ClassOrStruct
2142 {
2146 if (TypeBuilder.IsSubclassOf (TypeManager.attribute_type) && RootContext.VerifyClsCompliance && IsClsComplianceRequired ()) {
2156 }
2158 Report.Error (3015, Location, "`{0}' has no accessible constructors which use only CLS-compliant types", GetSignatureForError ());
2162 }
2163 }
2165 /// <summary>
2166 /// Emits the code, this step is performed after all
2167 /// the types, enumerations, constructors
2168 /// </summary>
2170 {
2178 }
2180 //
2181 // Structs with no fields need to have at least one byte.
2182 // The right thing would be to set the PackingSize in a DefineType
2183 // but there are no functions that allow interfaces *and* the size to
2184 // be specified.
2185 //
2198 }
2199 }
2205 // Can not continue if constants are broken
2216 }
2228 }
2237 }
2242 }
2243 }
2248 }
2249 }
2258 }
2261 {
2269 //
2270 // This is fine, the code still created the type
2271 //
2272 // Report.Warning (-20, "Exception while creating class: " + TypeBuilder.Name);
2273 // Console.WriteLine (e.Message);
2277 }
2291 }
2322 }
2324 //
2325 // Performs the validation on a Method's modifiers (properties have
2326 // the same properties).
2327 //
2329 {
2336 //
2337 // At most one of static, virtual or override
2338 //
2341 Report.Error (112, mc.Location, "A static member `{0}' cannot be marked as override, virtual or abstract",
2344 }
2345 }
2351 }
2352 }
2355 Report.Error (113, mc.Location, "A member `{0}' marked as override cannot be marked as new or virtual",
2358 }
2360 //
2361 // If the declaration includes the abstract modifier, then the
2362 // declaration does not include static, virtual or extern
2363 //
2369 }
2372 Report.Error (502, mc.Location, "`{0}' cannot be both abstract and sealed", mc.GetSignatureForError ());
2374 }
2377 Report.Error (503, mc.Location, "The abstract method `{0}' cannot be marked virtual", mc.GetSignatureForError ());
2379 }
2382 Report.Error (513, mc.Location, "`{0}' is abstract but it is contained in nonabstract class", mc.GetSignatureForError ());
2384 }
2385 }
2389 Report.Error (621, mc.Location, "`{0}': virtual or abstract members cannot be private", mc.GetSignatureForError ());
2391 }
2392 }
2396 Report.Error (238, mc.Location, "`{0}' cannot be sealed because it is not an override", mc.GetSignatureForError ());
2398 }
2399 }
2402 }
2405 get { return default_static_constructor; }
2406 }
2409 {
2417 Report.Error (3009, Location, "`{0}': base type `{1}' is not CLS-compliant", GetSignatureForError (), TypeManager.CSharpName (base_type));
2418 }
2421 Report.Error (3018, Location, "`{0}' cannot be marked as CLS-compliant because it is a member of non CLS-compliant type `{1}'",
2423 }
2425 }
2428 /// <summary>
2429 /// Checks whether container name is CLS Compliant
2430 /// </summary>
2432 {
2453 }
2454 }
2465 }
2466 Report.Warning (3005, 1, mc.Location, "Identifier `{0}' differing only in case is not CLS-compliant", mc.GetSignatureForError ());
2467 }
2468 }
2471 /// <summary>
2472 /// Performs checks for an explicit interface implementation. First it
2473 /// checks whether the `interface_type' is a base inteface implementation.
2474 /// Then it checks whether `name' exists in the interface type.
2475 /// </summary>
2477 {
2482 }
2483 }
2489 }
2492 {
2494 }
2497 {
2499 }
2501 //
2502 // IMemberContainer
2503 //
2508 }
2509 }
2514 }
2515 }
2520 }
2521 }
2526 }
2527 }
2530 {
2536 else
2538 }
2540 //
2541 // Generates xml doc comments (if any), and if required,
2542 // handle warning report.
2543 //
2545 {
2547 }
2550 get { return "T:"; }
2551 }
2562 }
2563 }
2565 }
2568 ListDictionary declarative_security;
2573 {
2574 }
2577 {
2584 }
2587 Report.Error (542, symbol.Location, "`{0}': member names cannot be the same as their enclosing type",
2590 }
2593 }
2596 {
2602 Report.Warning (67, 3, e.Location, "The event `{0}' is never used", e.GetSignatureForError ());
2603 }
2604 }
2605 }
2608 {
2609 if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
2615 }
2617 if (a.Type == TypeManager.struct_layout_attribute_type && a.GetLayoutKindValue () == LayoutKind.Explicit) {
2619 }
2622 }
2624 /// <summary>
2625 /// Defines the default constructors
2626 /// </summary>
2628 {
2629 // The default instance constructor is public
2630 // If the class is abstract, the default constructor is protected
2631 // The default static constructor is private
2638 }
2643 Location);
2647 }
2650 {
2656 // Field is re-initialized to its default value => removed
2659 }
2660 }
2661 }
2671 }
2673 // Need special check to not optimize code like this
2674 // static int a = b = 5;
2675 // static int b = 0;
2682 }
2683 }
2684 }
2688 }
2689 }
2691 }
2694 {
2701 }
2704 {
2710 }
2711 }
2712 }
2720 }
2721 }
2722 }
2725 // TODO: should be sealed
2739 Attributes attrs)
2741 {
2747 }
2748 }
2751 {
2753 if (BaseType != TypeManager.attribute_type && !BaseType.IsSubclassOf (TypeManager.attribute_type) &&
2755 Report.Error (641, a.Location, "Attribute `{0}' is only valid on classes derived from System.Attribute", a.GetSignatureForError ());
2756 }
2757 }
2760 !(BaseType == TypeManager.attribute_type || BaseType.IsSubclassOf (TypeManager.attribute_type))) {
2761 Report.Error (1689, a.Location, "Attribute `System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes");
2763 }
2769 }
2775 }
2780 }
2781 }
2784 {
2791 }
2795 Report.Error (715, m.Location, "`{0}': Static classes cannot contain user-defined operators", m.GetSignatureForError ());
2797 }
2800 Report.Error (711, m.Location, "`{0}': Static classes cannot contain destructor", GetSignatureForError ());
2802 }
2805 Report.Error (1057, m.Location, "`{0}': Static classes cannot contain protected members", m.GetSignatureForError ());
2807 }
2810 Report.Error (720, m.Location, "`{0}': cannot declare indexers in a static class", m.GetSignatureForError ());
2812 }
2818 Report.Error (710, m.Location, "`{0}': Static classes cannot have instance constructors", GetSignatureForError ());
2820 }
2822 Report.Error (708, m.Location, "`{0}': cannot declare instance members in a static class", m.GetSignatureForError ());
2823 }
2826 }
2829 {
2830 if ((ModFlags & Modifiers.ABSTRACT) == Modifiers.ABSTRACT && (ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) != 0) {
2831 Report.Error (418, Location, "`{0}': an abstract class cannot be sealed or static", GetSignatureForError ());
2833 }
2835 if ((ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) == (Modifiers.SEALED | Modifiers.STATIC)) {
2836 Report.Error (441, Location, "`{0}': a class cannot be both static and sealed", GetSignatureForError ());
2838 }
2841 }
2844 {
2849 }
2852 {
2867 }
2872 }
2882 }
2884 }
2890 }
2894 Report.Error (60, Location, "Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'",
2896 }
2897 }
2901 Report.Error (713, Location, "Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object",
2904 }
2909 Report.Error (714, Location, "`{0}': static classes cannot implement interfaces", GetSignatureForError ());
2910 }
2911 }
2914 }
2916 /// Search for at least one defined condition in ConditionalAttribute of attribute class
2917 /// Valid only for attribute classes.
2919 {
2937 }
2941 }
2946 }
2947 }
2949 //
2950 // FIXME: How do we deal with the user specifying a different
2951 // layout?
2952 //
2959 }
2960 }
2961 }
2964 // <summary>
2965 // Modifiers allowed in a struct declaration
2966 // </summary>
2978 {
2983 else
2989 }
2994 }
2995 }
3004 {
3006 //
3007 // If we are compiling our runtime,
3008 // and we are defining ValueType, then our
3009 // base is `System.Object'.
3010 //
3014 else
3016 }
3019 }
3021 //
3022 // FIXME: Allow the user to specify a different set of attributes
3023 // in some cases (Sealed for example is mandatory for a class,
3024 // but what SequentialLayout can be changed
3025 //
3029 }
3030 }
3033 {
3038 }
3040 }
3042 }
3044 /// <summary>
3045 /// Interfaces
3046 /// </summary>
3049 /// <summary>
3050 /// Modifiers allowed in a class declaration
3051 /// </summary>
3061 Attributes attrs)
3063 {
3068 else
3072 }
3075 {
3080 }
3082 }
3088 }
3089 }
3099 }
3100 }
3103 {
3113 Report.Warning (3027, 1, Location, "`{0}' is not CLS-compliant because base interface `{1}' is not CLS-compliant",
3115 }
3116 }
3119 }
3120 }
3126 //
3127 // The method we're overriding if this is an override method.
3128 //
3136 {
3139 }
3141 //
3142 // Returns the System.Type array for the parameters of this method
3143 //
3147 }
3148 }
3150 public Parameters ParameterInfo
3151 {
3154 }
3155 }
3160 }
3164 }
3165 }
3168 {
3170 }
3173 {
3177 // Check whether arguments were correct.
3187 // Is null for System.Object while compiling corlib and base interfaces
3190 Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
3191 }
3193 }
3198 // method is override
3209 GetSignatureForError (), TypeManager.CSharpName (base_ret_type), TypeManager.CSharpSignature (base_method));
3210 }
3212 Report.Error (508, Location, "`{0}': return type must be `{1}' to match overridden member `{2}'",
3213 GetSignatureForError (), TypeManager.CSharpName (base_ret_type), TypeManager.CSharpSignature (base_method));
3214 }
3216 }
3223 }
3224 }
3227 Report.Error (115, Location, "`{0}': no suitable method found to override", GetSignatureForError ());
3229 }
3231 if (Name == "Equals" && Parameters.Count == 1 && ParameterTypes [0] == TypeManager.object_type)
3241 Report.Warning (672, 1, Location, "Member `{0}' overrides obsolete member `{1}'. Add the Obsolete attribute to `{0}'",
3243 }
3244 }
3245 }
3247 }
3249 MemberInfo conflict_symbol = ParentContainer.FindBaseMemberWithSameName (Name, !(this is Property));
3254 Report.Error (544, Location, "`{0}': cannot override because `{1}' is not a property", GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
3255 else
3256 Report.Error (505, Location, "`{0}': cannot override because `{1}' is not a method", GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
3258 Report.Error (115, Location, "`{0}': no suitable method found to override", GetSignatureForError ());
3260 }
3264 Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
3265 }
3267 }
3274 Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
3276 }
3279 }
3281 //
3282 // Performs various checks on the MethodInfo `mb' regarding the modifier flags
3283 // that have been defined.
3284 //
3285 // `name' is the user visible name for reporting errors (this is used to
3286 // provide the right name regarding method names and properties)
3287 //
3289 {
3295 "`{0}': cannot override inherited member `{1}' because it is not marked virtual, abstract or override",
3298 }
3300 // Now we check that the overriden method is not final
3304 Report.Error (239, Location, "`{0}': cannot override inherited member `{1}' because it is sealed",
3307 }
3308 //
3309 // Check that the permissions are not being changed
3310 //
3317 }
3318 }
3324 Report.Warning (114, 2, Location, "`{0}' hides inherited member `{1}'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword",
3327 Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
3329 }
3330 }
3333 }
3335 protected bool CheckAccessModifiers (MethodAttributes thisp, MethodAttributes base_classp, MethodInfo base_method)
3336 {
3338 //
3339 // when overriding protected internal, the method can be declared
3340 // protected internal only within the same assembly
3341 //
3345 //
3346 // assemblies differ - report an error
3347 //
3351 //
3352 // same assembly, but other attributes differ - report an error
3353 //
3356 };
3358 //
3359 // if it's not "protected internal", it must be "protected"
3360 //
3364 //
3365 // protected within the same assembly - an error
3366 //
3370 //
3371 // protected ok, but other attributes differ - report an error
3372 //
3374 }
3378 }
3379 }
3382 {
3391 }
3397 }
3400 Report.Error (501, Location, "`{0}' must declare a body because it is not marked abstract or extern",
3403 }
3404 }
3407 }
3409 protected void Error_CannotChangeAccessModifiers (MemberInfo base_method, MethodAttributes ma, string suffix)
3410 {
3417 }
3419 Report.Error (507, Location, "`{0}': cannot change access modifiers when overriding `{1}' inherited member `{2}'",
3421 }
3426 }
3427 }
3429 /// <summary>
3430 /// For custom member duplication search in a container
3431 /// </summary>
3434 /// <summary>
3435 /// Gets base method and its return type
3436 /// </summary>
3440 {
3443 // Check if arguments were correct
3448 }
3451 {
3460 }
3465 }
3481 else
3487 }
3490 }
3493 {
3495 if ((ModFlags & Modifiers.ABSTRACT) != 0 && IsExposedFromAssembly () && Parent.IsClsComplianceRequired ()) {
3496 Report.Error (3011, Location, "`{0}': only CLS-compliant members can be abstract", GetSignatureForError ());
3497 }
3499 }
3503 }
3509 else
3512 }
3517 }
3520 {
3525 // This never happen. Rewrite this as Equal
3542 }
3547 // TODO: make operator compatible with MethodCore to avoid this
3551 }
3554 //
3555 // Try to report 663: method only differs on out/ref
3556 //
3563 Report.Error (663, Location, "`{0}': Methods cannot differ only on their use of ref and out on a parameters",
3569 }
3570 }
3575 else
3579 }
3582 }
3585 get { return IsExplicitImpl || base.IsUsed; }
3586 }
3588 //
3589 // Returns a string that represents the signature for this
3590 // member which should be used in XML documentation.
3591 //
3593 {
3595 }
3597 //
3598 // Raised (and passed an XmlElement that contains the comment)
3599 // when GenerateDocComment is writing documentation expectedly.
3600 //
3601 // FIXME: with a few effort, it could be done with XmlReader,
3602 // that means removal of DOM use.
3603 //
3605 {
3607 }
3609 //
3610 // Represents header string for documentation comment.
3611 //
3613 get { return "M:"; }
3614 }
3616 }
3619 {
3621 ReturnParameter return_attributes;
3622 ListDictionary declarative_security;
3632 {
3633 }
3636 {
3643 }
3647 MethodBuilder.SetImplementationFlags (MethodImplAttributes.InternalCall | MethodImplAttributes.Runtime);
3648 }
3653 Report.Error (601, a.Location, "The DllImport attribute must be specified on a method marked `static' and `extern'");
3654 }
3657 }
3659 if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
3664 }
3667 }
3672 }
3673 }
3676 {
3685 }
3688 {
3699 }
3705 }
3726 }
3729 }
3732 {
3739 }
3740 }
3743 }
3746 {
3748 "Conditional not valid on `{0}' because it is a constructor, destructor, operator or explicit interface implementation",
3750 }
3753 {
3756 }
3761 }
3762 }
3764 #region IMethodData Members
3776 // FIXME: How is `ExplicitThis' used in C#?
3779 }
3780 }
3785 }
3786 }
3791 }
3792 }
3797 }
3798 }
3804 // TODO: Destructor should derive from MethodCore
3807 Report.Error (249, Location, "Do not override object.Finalize. Instead, provide a destructor");
3809 }
3812 }
3814 /// <summary>
3815 /// Returns true if method has conditional attribute and the conditions is not defined (method is excluded).
3816 /// </summary>
3839 }
3843 }
3850 }
3852 }
3857 }
3859 }
3864 }
3865 }
3867 #endregion
3869 }
3872 {
3873 DeclSpace parent;
3874 MethodBase builder;
3878 {
3883 }
3886 get { return builder.Name; }
3887 }
3890 get { return parent.NamespaceEntry.SymbolFileID; }
3891 }
3899 else
3901 }
3902 }
3905 {
3908 }
3911 {
3931 }
3932 }
3936 /// <summary>
3937 /// Modifiers allowed in a class declaration
3938 /// </summary>
3957 //
3958 // return_type can be "null" for VOID values.
3959 //
3966 {
3967 }
3970 {
3972 }
3975 {
3979 }
3982 {
3999 else
4001 }
4004 {
4009 }
4012 Report.Error (578, Location, "Conditional not valid on `{0}' because its return type is not void", GetSignatureForError ());
4014 }
4017 Report.Error (243, Location, "Conditional not valid on `{0}' because it is an override method", GetSignatureForError ());
4019 }
4024 }
4027 Report.Error (629, Location, "Conditional member `{0}' cannot implement interface member `{1}'",
4030 }
4034 Report.Error (685, Location, "Conditional method `{0}' cannot have an out parameter", GetSignatureForError ());
4036 }
4037 }
4038 }
4041 }
4044 {
4053 }
4054 }
4062 }
4063 }
4071 }
4072 }
4080 }
4081 }
4084 }
4086 //
4087 // Creates the type
4088 //
4090 {
4094 if (RootContext.StdLib && (ReturnType == TypeManager.arg_iterator_type || ReturnType == TypeManager.typed_reference_type)) {
4097 }
4101 Report.Warning (465, 1, Location, "Introducing a 'Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor?");
4102 }
4104 //
4105 // Setup iterator if we are one
4106 //
4113 }
4115 //
4116 // This is used to track the Entry Point,
4117 //
4130 }
4137 }
4140 Report.Warning (28, 4, Location, "`{0}' has the wrong signature to be an entry point", TypeManager.CSharpSignature(MethodBuilder));
4141 }
4142 }
4145 }
4147 //
4148 // Emits the code
4149 //
4151 {
4157 }
4160 {
4161 Report.Error (1599, loc, "Method or delegate cannot return type `{0}'", TypeManager.CSharpName (t));
4162 }
4165 {
4174 }
4177 {
4185 }
4188 }
4189 }
4192 ArrayList argument_list;
4194 Location loc;
4197 {
4200 }
4205 }
4206 }
4209 {
4210 Expression base_constructor_group;
4211 Type t;
4220 }
4221 }
4231 "`{0}': Struct constructors cannot call base constructors", TypeManager.CSharpSignature (caller_builder));
4233 }
4240 loc);
4247 loc);
4248 }
4261 }
4267 }
4270 Report.Error (516, loc, "Constructor `{0}' cannot call itself", TypeManager.CSharpSignature (caller_builder));
4272 }
4275 }
4278 {
4283 else
4285 }
4286 }
4287 }
4292 {
4293 }
4294 }
4299 {
4300 }
4301 }
4306 {
4307 }
4308 }
4313 ListDictionary declarative_security;
4315 // <summary>
4316 // Modifiers allowed for a constructor.
4317 // </summary>
4330 //
4331 // The spec claims that static is not permitted, but
4332 // my very own code has static constructors.
4333 //
4338 {
4340 }
4343 get { return has_compliant_args; }
4344 }
4347 get { return AttributeTargets.Constructor; }
4348 }
4351 //
4352 // Returns true if this is a default constructor
4353 //
4355 {
4362 }
4365 {
4366 if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
4369 }
4372 }
4376 ConstructorBuilder.SetImplementationFlags (MethodImplAttributes.InternalCall | MethodImplAttributes.Runtime);
4377 }
4380 }
4383 {
4392 }
4393 }
4395 }
4398 {
4404 }
4406 // the rest can be ignored
4408 }
4410 // Check whether arguments were correct.
4422 }
4425 Report.Error (666, Location, "`{0}': new protected member declared in struct", GetSignatureForError ());
4427 }
4428 }
4430 if ((RootContext.WarningLevel >= 4) && ((Parent.ModFlags & Modifiers.SEALED) != 0 && (ModFlags & Modifiers.PROTECTED) != 0)) {
4431 Report.Warning (628, 4, Location, "`{0}': new protected member declared in sealed class", GetSignatureForError ());
4432 }
4435 }
4437 //
4438 // Creates the ConstructorBuilder
4439 //
4441 {
4458 else
4462 else
4464 }
4469 // Check if arguments were correct.
4475 ParameterTypes);
4482 Report.Error (669, Location, "`{0}': A class with the ComImport attribute cannot have a user-defined constructor",
4485 }
4487 }
4492 }
4494 //
4495 // Emits the code
4496 //
4498 {
4505 // If this is a non-static `struct' constructor and doesn't have any
4506 // initializer, it must initialize all of the struct's fields.
4513 }
4520 //
4521 // Spec mandates that Initializers will not have
4522 // `this' access
4523 //
4529 }
4536 //
4537 // Classes can have base initializers and instance field initializers.
4538 //
4542 //
4543 // If we use a "this (...)" constructor initializer, then
4544 // do not emit field initializers, they are initialized in the other constructor
4545 //
4548 }
4549 }
4552 }
4567 }
4568 }
4571 }
4573 // Is never override
4575 {
4577 }
4580 {
4582 }
4587 }
4588 }
4591 {
4594 }
4605 }
4606 }
4607 }
4608 }
4611 }
4613 #region IMethodData Members
4623 // FIXME: How is `ExplicitThis' used in C#?
4626 }
4627 }
4632 }
4633 }
4638 }
4639 }
4644 }
4645 }
4648 {
4651 }
4654 {
4656 }
4661 }
4662 }
4664 #endregion
4665 }
4667 /// <summary>
4668 /// Interface for MethodData class. Holds links to parent members to avoid member duplication.
4669 /// </summary>
4670 public interface IMethodData
4671 {
4672 CallingConventions CallingConventions { get; }
4673 Location Location { get; }
4674 MemberName MethodName { get; }
4675 Type ReturnType { get; }
4676 GenericMethod GenericMethod { get; }
4677 Parameters ParameterInfo { get; }
4679 Attributes OptAttributes { get; }
4680 ToplevelBlock Block { get; set; }
4688 }
4690 //
4691 // Encapsulates most of the Method's state
4692 //
4699 //
4700 // Are we implementing an interface ?
4701 //
4704 //
4705 // Protected data.
4706 //
4717 }
4718 }
4723 }
4724 }
4728 {
4734 }
4741 {
4745 }
4748 {
4759 else
4766 Report.Error (550, method.Location, "`{0}' is an accessor not found in interface member `{1}{2}'",
4774 }
4776 }
4779 Report.Error (683, method.Location, "`{0}' explicit method implementation cannot implement `{1}' because it is an accessor",
4782 }
4792 Report.Error (686, method.Location, "Accessor `{0}' cannot implement interface member `{1}' for type `{2}'. Use an explicit interface implementation",
4793 method.GetSignatureForError (), TypeManager.CSharpSignature (implementing), container.GetSignatureForError ());
4795 }
4799 Report.Error (277, method.Location, "Accessor `{0}' must be declared public to implement interface member `{1}'",
4802 }
4803 }
4804 }
4805 }
4806 }
4808 //
4809 // For implicit implementations, make sure we are public, for
4810 // explicit implementations, make sure we are private.
4811 //
4813 //
4814 // Setting null inside this block will trigger a more
4815 // verbose error reporting for missing interface implementations
4816 //
4817 // The "candidate" function has been flagged already
4818 // but it wont get cleared
4819 //
4824 }
4827 //
4828 // If this is an interface method implementation,
4829 // check for public accessibility
4830 //
4833 // We may never be private.
4836 //
4837 // We may be protected if we're overriding something.
4838 //
4840 }
4841 }
4843 //
4844 // Static is not allowed
4845 //
4848 }
4849 }
4851 //
4852 // If implementing is still valid, set flags
4853 //
4855 //
4856 // When implementing interface methods, set NewSlot
4857 // unless, we are overwriting a method.
4858 //
4862 }
4863 flags |=
4867 // Set Final unless we're virtual, abstract or already overriding a method.
4870 }
4881 else
4888 //
4889 // clear the pending implemntation flag
4890 //
4904 }
4917 }
4920 }
4923 /// <summary>
4924 /// Create the MethodBuilder for the method
4925 /// </summary>
4927 {
4941 }
4942 }
4944 // for extern static method must be specified either DllImport attribute or MethodImplAttribute.
4945 // We are more strict than Microsoft and report CS0626 like error
4948 Report.Error (626, method.Location, "Method, operator, or accessor `{0}' is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation",
4951 }
4952 }
4959 }
4960 #if !MS_COMPATIBLE
4964 #endif
4965 }
4967 //
4968 // Emits the code
4969 //
4971 {
4972 EmitContext ec;
4975 else
4987 //
4988 // Handle destructors specially
4989 //
4990 // FIXME: This code generates buggy code
4991 //
4994 else
4999 }
5002 {
5014 // ig.MarkLabel (finish);
5027 }
5028 }
5031 //ig.MarkLabel (ec.ReturnLabel);
5033 }
5034 }
5036 // TODO: Should derive from MethodCore
5043 Location l)
5046 { }
5049 {
5053 }
5056 }
5059 {
5061 }
5066 }
5067 }
5068 }
5079 //
5080 // The "short" name of this property / indexer / event. This is the
5081 // name without the explicit interface.
5082 //
5084 get { return MemberName.Name; }
5085 set { SetMemberName (new MemberName (MemberName.Left, value, Location)); }
5086 }
5089 get { return ((TypeContainer) Parent).PartialContainer; }
5090 }
5092 //
5093 // The type of this property / indexer / event
5094 //
5103 }
5104 }
5106 }
5107 }
5109 //
5110 // Whether this is an interface member.
5111 //
5114 //
5115 // If true, this is an explicit interface implementation
5116 //
5119 //
5120 // The interface type we are explicitly implementing
5121 //
5124 //
5125 // The constructor is only exposed to our children
5126 //
5131 {
5140 }
5143 {
5145 Report.Error (666, Location, "`{0}': new protected member declared in struct", GetSignatureForError ());
5147 }
5153 Report.Warning (628, 4, Location, "`{0}': new protected member declared in sealed class", GetSignatureForError ());
5154 }
5156 }
5159 {
5178 }
5189 Report.Error (538, Location, "'{0}' in explicit interface declaration is not an interface", TypeManager.CSharpName (InterfaceType));
5191 }
5197 }
5200 }
5203 {
5212 }
5214 // verify accessibility
5233 else
5243 }
5245 }
5256 Report.Error (538, Location, "`{0}' in explicit interface declaration is not an interface", TypeManager.CSharpName (InterfaceType));
5258 }
5265 }
5267 }
5270 {
5271 if (MemberType == TypeManager.arg_iterator_type || MemberType == TypeManager.typed_reference_type) {
5272 Report.Error (610, Location, "Field or property cannot be of type `{0}'", TypeManager.CSharpName (MemberType));
5274 }
5276 }
5279 {
5282 }
5285 Report.Error (3010, Location, "`{0}': CLS-compliant interfaces must have only CLS-compliant members", GetSignatureForError ());
5286 }
5288 }
5290 }
5292 //
5293 // Fields and Events both generate FieldBuilders, we use this to share
5294 // their common bits. This is also used to flag usage of the field
5295 //
5300 ExpressionStatement initializerStatement;
5305 }
5309 /// <summary>
5310 /// Symbol with same name in base class/struct
5311 /// </summary>
5318 {
5319 }
5324 }
5325 }
5328 {
5333 }
5335 }
5340 }
5343 }
5346 {
5348 }
5351 {
5355 // TODO: Implement
5362 Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
5363 }
5365 }
5369 Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
5371 }
5374 }
5381 }
5382 }
5383 }
5391 }
5392 }
5395 {
5396 // TODO: again it's too heavy-weight
5405 {
5407 }
5411 }
5413 public bool HasDefaultInitializer
5414 {
5415 get
5416 {
5422 }
5423 }
5426 {
5429 }
5430 }
5433 {
5439 }
5441 }
5445 {
5447 }
5448 }
5451 {
5455 {
5457 Report.Error (681, Location, "The modifier 'abstract' is not valid on fields. Try using a property instead");
5458 }
5461 {
5463 {
5467 Report.Error (636, Location, "The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit)");
5469 }
5472 Report.Error (637, Location, "The FieldOffset attribute is not allowed on static or const fields");
5474 }
5475 }
5478 Report.Error (1716, Location, "Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead");
5480 }
5483 }
5486 {
5493 }
5504 }
5510 }
5513 {
5516 }
5518 if (((status & Status.HAS_OFFSET) == 0) && (ModFlags & Modifiers.STATIC) == 0 && ParentContainer.HasExplicitLayout) {
5519 Report.Error (625, Location, "`{0}': Instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute.", GetSignatureForError ());
5520 }
5523 }
5525 //
5526 // Represents header string for documentation comment.
5527 //
5529 get { return "F:"; }
5530 }
5531 }
5533 interface IFixedBuffer
5534 {
5535 FieldInfo Element { get; }
5536 Type ElementType { get; }
5537 }
5540 {
5541 FieldInfo element_field;
5544 {
5546 }
5548 #region IFixedField Members
5553 }
5554 }
5559 }
5560 }
5562 #endregion
5563 }
5565 /// <summary>
5566 /// Fixed buffer implementation
5567 /// </summary>
5569 {
5575 TypeBuilder fixed_buffer_type;
5576 FieldBuilder element;
5577 Expression size_expr;
5590 {
5595 }
5598 {
5599 #if !NET_2_0
5601 Report.Warning (-23, 1, Location, "Only private or internal fixed sized buffers are supported by .NET 1.x");
5602 #endif
5605 Report.Error (1642, Location, "`{0}': Fixed size buffer fields may only be members of structs",
5608 }
5614 Report.Error (1663, Location, "`{0}': Fixed size buffers type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double",
5617 }
5631 Report.Error (1665, Location, "`{0}': Fixed size buffers must have a length greater than zero", GetSignatureForError ());
5633 }
5638 Report.Error (1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
5641 }
5645 // Define nested
5649 TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit, TypeManager.value_type);
5650 element = fixed_buffer_type.DefineField (FixedElementName, MemberType, FieldAttributes.Public);
5653 FieldBuilder = Parent.TypeBuilder.DefineField (Name, fixed_buffer_type, Modifiers.FieldAttr (ModFlags));
5657 }
5660 {
5667 CustomAttributeBuilder cab = new CustomAttributeBuilder (TypeManager.struct_layout_attribute_ctor,
5671 cab = new CustomAttributeBuilder (TypeManager.fixed_buffer_attr_ctor, new object[] { MemberType, buffer_size } );
5674 }
5679 }
5680 }
5682 #region IFixedField Members
5687 }
5688 }
5693 }
5694 }
5696 #endregion
5697 }
5699 //
5700 // The Field class is used to represents class/struct fields during parsing.
5701 //
5703 // <summary>
5704 // Modifiers allowed in a class declaration
5705 // </summary>
5720 attrs)
5721 {
5722 }
5725 {
5732 // ptype is only null for System.Object while compiling corlib.
5739 }
5740 }
5762 }
5763 }
5769 }
5770 }
5781 }
5788 }
5790 Report.Warning (-24, 1, Location, "The Microsoft runtime is unable to use [void|void*] as a field type, try using the Mono runtime.");
5792 }
5795 }
5798 {
5803 Report.Warning (3026, 1, Location, "CLS-compliant field `{0}' cannot be volatile", GetSignatureForError ());
5804 }
5807 }
5808 }
5810 //
5811 // `set' and `get' accessors are represented with an Accessor.
5812 //
5814 //
5815 // Null if the accessor is empty, or a Block if not
5816 //
5830 {
5835 }
5838 {
5840 }
5841 }
5843 // Ooouh Martin, templates are missing here.
5844 // When it will be possible move here a lot of child code and template method type.
5850 // The accessor are created event if they are not wanted.
5851 // But we need them because their names are reserved.
5852 // Field says whether accessor will be emited or not
5857 ReturnParameter return_attributes;
5861 {
5864 }
5870 {
5873 }
5876 {
5878 }
5881 {
5883 }
5885 #region IMethodData Members
5890 }
5894 }
5895 }
5900 }
5901 }
5904 {
5906 }
5911 }
5912 }
5917 }
5918 }
5923 }
5924 }
5926 public abstract Parameters ParameterInfo { get ; }
5927 public abstract Type ReturnType { get; }
5930 #endregion
5933 {
5934 if (a.Type == TypeManager.cls_compliant_attribute_type || a.Type == TypeManager.obsolete_attribute_type ||
5937 "Attribute `{0}' is not valid on property or event accessors. It is valid on `{1}' declarations only",
5940 }
5942 if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
5947 }
5952 }
5960 }
5963 }
5966 {
5968 }
5971 {
5973 }
5976 {
5984 method_data.MethodBuilder.AddDeclarativeSecurity ((SecurityAction)de.Key, (PermissionSet)de.Value);
5985 }
5986 }
5989 }
5992 {
5994 }
5997 {
5999 }
6002 {
6018 }
6020 public override bool IsUsed
6021 {
6027 }
6028 }
6033 }
6034 }
6036 //
6037 // Represents header string for documentation comment.
6038 //
6040 get { throw new InvalidOperationException ("Unexpected attempt to get doc comment from " + this.GetType () + "."); }
6041 }
6043 }
6045 //
6046 // Properties and Indexers both generate PropertyBuilders, we use this to share
6047 // their common bits.
6048 //
6052 {
6057 {
6058 }
6062 {
6063 }
6066 {
6075 }
6080 }
6081 }
6086 }
6087 }
6092 }
6093 }
6094 }
6099 ImplicitParameter param_attr;
6104 {
6105 }
6109 {
6110 }
6113 {
6120 }
6123 }
6128 }
6129 }
6132 {
6134 new Parameter[] { new Parameter (method.MemberType, "value", Parameter.Modifier.NONE, null, Location) },
6136 }
6139 {
6152 }
6157 }
6158 }
6163 }
6164 }
6165 }
6170 {
6177 {
6179 }
6184 {
6191 }
6192 }
6197 }
6198 }
6201 {
6203 }
6206 {
6212 //
6213 // Check for custom access modifier
6214 //
6220 Report.Error (275, Location, "`{0}': accessibility modifiers may not be used on accessors in an interface",
6224 Report.Error (442, Location, "`{0}': abstract properties cannot have private accessors", GetSignatureForError ());
6225 }
6232 }
6234 //
6235 // Setup iterator if we are one
6236 //
6242 }
6245 }
6247 public bool HasCustomAccessModifier
6248 {
6251 }
6252 }
6255 {
6259 }
6262 {
6264 }
6267 {
6269 }
6272 {
6278 }
6284 }
6290 "The accessibility modifier of the `{0}' accessor must be more restrictive than the modifier of the property or indexer `{1}'",
6292 }
6293 }
6296 {
6299 }
6300 }
6313 {
6314 }
6317 {
6321 }
6324 }
6329 }
6330 }
6333 {
6341 }
6344 {
6348 //
6349 // Accessors modifiers check
6350 //
6352 Report.Error (274, Location, "`{0}': Cannot specify accessibility modifiers for both accessors of the property or indexer",
6355 }
6360 "`{0}': accessibility modifiers on accessors may only be used if the property or indexer has both a get and a set accessor",
6363 }
6368 }
6372 }
6375 {
6384 }
6385 }
6395 }
6396 }
6399 }
6401 // TODO: rename to Resolve......
6403 {
6418 Report.Error (545, Location, "`{0}.get': cannot override because `{1}' does not have an overridable get accessor", GetSignatureForError (), TypeManager.GetFullNameSignature (base_property));
6419 }
6423 Report.Error (546, Location, "`{0}.set': cannot override because `{1}' does not have an overridable set accessor", GetSignatureForError (), TypeManager.GetFullNameSignature (base_property));
6424 }
6425 }
6427 //
6428 // Check base class accessors access
6429 //
6431 // TODO: rewrite to reuse Get|Set.CheckAccessModifiers and share code there
6435 MethodAttributes get_flags = Modifiers.MethodAttr (Get.ModFlags != 0 ? Get.ModFlags : ModFlags);
6438 if (!Get.IsDummy && !CheckAccessModifiers (get_flags & MethodAttributes.MemberAccessMask, get_accessor_access, get_accessor))
6440 }
6443 MethodAttributes set_flags = Modifiers.MethodAttr (Set.ModFlags != 0 ? Set.ModFlags : ModFlags);
6446 if (!Set.IsDummy && !CheckAccessModifiers (set_flags & MethodAttributes.MemberAccessMask, set_accessor_access, set_accessor))
6448 }
6449 }
6451 //
6452 // Get the less restrictive access
6453 //
6455 }
6458 {
6459 //
6460 // The PropertyBuilder can be null for explicit implementations, in that
6461 // case, we do not actually emit the ".property", so there is nowhere to
6462 // put the attribute
6463 //
6474 }
6476 /// <summary>
6477 /// Tests whether accessors are not in collision with some method (CS0111)
6478 /// </summary>
6480 {
6482 }
6484 public override bool IsUsed
6485 {
6491 }
6492 }
6495 {
6500 }
6505 }
6506 }
6508 //
6509 // Represents header string for documentation comment.
6510 //
6512 get { return "P:"; }
6513 }
6514 }
6537 Accessor set_block)
6541 {
6544 else
6549 else
6551 }
6554 {
6570 }
6576 }
6578 // FIXME - PropertyAttributes.HasDefault ?
6591 }
6592 }
6594 /// </summary>
6595 /// Gigantic workaround for lameness in SRE follows :
6596 /// This class derives from EventInfo and attempts to basically
6597 /// wrap around the EventBuilder so that FindMembers can quickly
6598 /// return this in it search for members
6599 /// </summary>
6602 //
6603 // We use this to "point" to our Builder which is
6604 // not really a MemberInfo
6605 //
6606 EventBuilder MyBuilder;
6608 //
6609 // We "catch" and wrap these methods
6610 //
6613 EventAttributes attributes;
6617 Event my_event;
6619 public MyEventBuilder (Event ev, TypeBuilder type_builder, string name, EventAttributes event_attr, Type event_type)
6620 {
6623 // And now store the values in our own fields.
6633 }
6635 //
6636 // Methods that you have to override. Note that you only need
6637 // to "implement" the variants that take the argument (those are
6638 // the "abstract" methods, the others (GetAddMethod()) are
6639 // regular.
6640 //
6642 {
6644 }
6647 {
6649 }
6652 {
6654 }
6656 //
6657 // These methods make "MyEventInfo" look like a Builder
6658 //
6660 {
6663 }
6666 {
6669 }
6672 {
6675 }
6678 {
6680 }
6683 {
6684 // FIXME : There's nothing which can be seemingly done here because
6685 // we have no way of getting at the custom attribute objects of the
6686 // EventBuilder !
6688 }
6691 {
6692 // FIXME : Same here !
6694 }
6697 {
6699 }
6704 }
6705 }
6710 }
6711 }
6716 }
6717 }
6722 }
6723 }
6728 }
6729 }
6732 {
6736 }
6737 }
6738 }
6740 /// <summary>
6741 /// For case when event is declared like property (with add and remove accessors).
6742 /// </summary>
6745 static string[] attribute_targets = new string [] { "event" }; // "property" target was disabled for 2.0 version
6751 {
6755 // For this event syntax we don't report error CS0067
6756 // because it is hard to do it.
6758 }
6763 }
6764 }
6765 }
6767 /// <summary>
6768 /// Event is declared like field.
6769 /// </summary>
6777 Attributes attrs)
6779 {
6782 }
6785 {
6789 }
6795 }
6798 }
6801 {
6810 }
6811 }
6814 }
6819 }
6820 }
6821 }
6826 {
6830 {
6831 }
6835 {
6836 }
6841 }
6842 }
6844 }
6847 {
6850 {
6851 }
6855 {
6856 }
6861 }
6862 }
6864 }
6867 {
6869 ImplicitParameter param_attr;
6875 {
6877 }
6881 {
6883 }
6886 {
6893 }
6896 }
6901 }
6902 }
6905 {
6907 }
6910 {
6920 }
6924 {
6928 }
6951 }
6953 }
6955 protected abstract MethodInfo DelegateMethodInfo { get; }
6960 }
6961 }
6964 {
6968 }
6971 {
6973 }
6978 }
6979 }
6984 }
6985 }
6987 }
7009 Parameters parameters;
7016 {
7018 }
7021 {
7025 }
7028 }
7031 {
7033 }
7038 }
7039 }
7042 {
7043 EventAttributes e_attr;
7053 Report.Error (66, Location, "`{0}': event must be of a delegate type", GetSignatureForError ());
7055 }
7058 new Parameter[] { new Parameter (MemberType, "value", Parameter.Modifier.NONE, null, Location) },
7064 //
7065 // Now define the accessors
7066 //
7085 }
7092 }
7095 {
7104 }
7105 }
7108 }
7111 {
7114 }
7120 }
7123 {
7125 }
7127 //
7128 // Represents header string for documentation comment.
7129 //
7131 get { return "E:"; }
7132 }
7133 }
7139 {
7142 {
7143 }
7147 {
7148 }
7153 }
7154 }
7155 }
7158 {
7161 {
7162 }
7166 {
7167 }
7170 {
7173 }
7174 }
7192 //
7193 // Are we implementing an interface ?
7194 //
7201 {
7204 else
7209 else
7211 }
7214 {
7224 }
7229 // Remove the attribute from the list because it is not emitted
7243 }
7249 }
7250 }
7251 }
7257 }
7272 //
7273 // Setup iterator if we are one
7274 //
7281 }
7282 }
7288 }
7290 //
7291 // Now name the parameters
7292 //
7295 // TODO: should be done in parser and it needs to do cycle
7299 }
7300 }
7314 }
7317 {
7322 }
7327 }
7330 {
7333 }
7334 }
7346 // Unary operators
7347 LogicalNot,
7348 OnesComplement,
7349 Increment,
7350 Decrement,
7351 True,
7352 False,
7354 // Unary and Binary operators
7355 Addition,
7356 Subtraction,
7358 UnaryPlus,
7359 UnaryNegation,
7361 // Binary operators
7362 Multiply,
7363 Division,
7364 Modulus,
7365 BitwiseAnd,
7366 BitwiseOr,
7367 ExclusiveOr,
7368 LeftShift,
7369 RightShift,
7370 Equality,
7371 Inequality,
7372 GreaterThan,
7373 LessThan,
7374 GreaterThanOrEqual,
7375 LessThanOrEqual,
7377 // Implicit and Explicit
7378 Implicit,
7379 Explicit,
7381 // Just because of enum
7382 TOP
7383 };
7392 {
7395 }
7398 {
7402 }
7405 }
7408 {
7417 }
7418 }
7428 }
7429 }
7432 }
7435 {
7438 Report.Error (558, Location, "User-defined operator `{0}' must be declared static and public", GetSignatureForError ());
7440 }
7448 }
7454 // Rules for conversion operators
7459 "User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type");
7461 }
7469 }
7472 Report.Error (552, Location, "User-defined conversion `{0}' cannot convert to or from an interface type",
7475 }
7478 if (declaring_type.IsSubclassOf (return_type) || declaring_type.IsSubclassOf (first_arg_type)) {
7479 Report.Error (553, Location, "User-defined conversion `{0}' cannot convert to or from base class",
7482 }
7483 Report.Error (554, Location, "User-defined conversion `{0}' cannot convert to or from derived class",
7486 }
7489 Report.Error (564, Location, "Overloaded shift operator must have the type of the first operand be the containing type, and the type of the second operand must be int");
7491 }
7493 // Checks for Unary operators
7496 if (return_type != declaring_type && !TypeManager.IsSubclassOf (return_type, declaring_type)) {
7498 "The return type for ++ or -- operator must be the containing type or derived from the containing type");
7500 }
7505 }
7506 }
7514 }
7523 }
7524 }
7527 // Checks for Binary operators
7536 }
7537 }
7540 }
7543 {
7549 }
7552 {
7557 //
7558 // abstract or extern methods have no bodies
7559 //
7563 EmitContext ec;
7566 else
7576 }
7578 // Operator cannot be override
7580 {
7582 }
7585 {
7640 }
7641 }
7644 {
7649 }
7654 }
7655 }
7657 }
7660 {
7663 sb.AppendFormat ("{0}.{1} operator {2}", Parent.GetSignatureForError (), GetName (OperatorType), Type.Type == null ? Type.ToString () : TypeManager.CSharpName (Type.Type));
7664 }
7667 }
7671 }
7672 }
7674 //
7675 // This is used to compare method signatures
7676 //
7682 /// <summary>
7683 /// This delegate is used to extract methods which have the
7684 /// same signature as the argument
7685 /// </summary>
7686 public static MemberFilter method_signature_filter = new MemberFilter (MemberSignatureCompare);
7689 {
7695 else
7697 }
7700 {
7708 }
7710 }
7713 }
7716 {
7718 }
7721 {
7734 }
7748 }
7751 {
7757 Type ReturnType;
7765 else
7768 //
7769 // we use sig.RetType == null to mean `do not check the
7770 // method return value.
7771 //
7779 else
7787 i--;
7790 }
7792 }
7793 }
7794 }