| blob | 8f3425cde6451837180a2156b53a1cadab2ac2a1 |
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
45 #if BOOTSTRAP_WITH_OLDLIB
47 #else
49 #endif
56 Root,
57 Struct,
58 Class,
59 Interface,
60 Enum
61 }
63 /// <summary>
64 /// This is the base class for structs and classes.
65 /// </summary>
69 {
70 /// <summary>
71 /// Defines the MemberCore objects that are in this array
72 /// </summary>
74 {
80 }
81 }
82 }
85 {
88 }
89 }
92 {
97 }
99 CachedMethods cached_method;
100 TypeContainer container;
103 {
105 }
107 /// <summary>
108 /// Method container contains Equals method
109 /// </summary>
113 }
117 }
118 }
120 /// <summary>
121 /// Method container contains GetHashCode method
122 /// </summary>
126 }
130 }
131 }
134 {
138 Report.Warning (659, 3, container.Location, "`{0}' overrides Object.Equals(object) but does not override Object.GetHashCode()", container.GetSignatureForError ());
139 }
140 }
141 }
144 {
145 /// <summary>
146 /// The indexer name for this container
147 /// </summary>
152 TypeContainer container;
155 {
157 }
159 /// <summary>
160 /// Defines the indexers, and also verifies that the IndexerNameAttribute in the
161 /// class is consistent. Either it is `Item' or it is the name defined by all the
162 /// indexers with the `IndexerName' attribute.
163 ///
164 /// Turns out that the IndexerNameAttribute is applied to each indexer,
165 /// but it is never emitted, instead a DefaultMember attribute is attached
166 /// to the class.
167 /// </summary>
169 {
174 //
175 // If there's both an explicit and an implicit interface implementation, the
176 // explicit one actually implements the interface while the other one is just
177 // a normal indexer. See bug #37714.
178 //
180 // Invariant maintained by AddIndexer(): All explicit interface indexers precede normal indexers
186 }
193 }
196 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");
197 }
201 }
204 {
210 CustomAttributeBuilder cb = new CustomAttributeBuilder (TypeManager.default_member_ctor, new string [] { IndexerName });
212 }
213 }
216 {
217 TypeContainer container;
220 {
222 }
224 //
225 // Operator pair checking
226 //
227 class OperatorEntry
228 {
236 {
245 }
248 {
250 }
253 {
263 }
264 }
266 //
267 // Checks that some operators come in pairs:
268 // == and !=
269 // > and <
270 // >= and <=
271 // true and false
272 //
273 // They are matched based on the return type and the argument types
274 //
276 {
282 // Register all the operators we care about.
286 // Skip erroneous code.
316 }
328 }
329 }
333 Report.Error (216, true_op.Location, "The operator `{0}' requires a matching operator `false' to also be defined",
336 Report.Error (216, false_op.Location, "The operator `{0}' requires a matching operator `true' to also be defined",
339 //
340 // Look for the mistakes.
341 //
368 }
372 }
376 Report.Warning (660, 2, container.Location, "`{0}' defines operator == or operator != but does not override Object.Equals(object o)", container.GetSignatureForError ());
379 Report.Warning (661, 2, container.Location, "`{0}' defines operator == or operator != but does not override Object.GetHashCode()", container.GetSignatureForError ());
380 }
381 }
384 {
387 }
388 }
391 // Whether this is a struct, class or interface
394 // Holds a list of classes and structures
397 // Holds the list of properties
398 MemberCoreArrayList properties;
400 // Holds the list of enumerations
401 MemberCoreArrayList enums;
403 // Holds the list of delegates
404 MemberCoreArrayList delegates;
406 // Holds the list of constructors
409 // Holds the list of fields
410 MemberCoreArrayList fields;
412 // Holds a list of fields that have initializers
415 // Holds a list of static fields that have initializers
418 // Holds the list of constants
419 MemberCoreArrayList constants;
421 // Holds the list of
422 MemberCoreArrayList interfaces;
424 // Holds the methods.
425 MethodArrayList methods;
427 // Holds the events
430 // Holds the indexers
431 IndexerArrayList indexers;
433 // Holds the operators
434 MemberCoreArrayList operators;
436 // Holds the compiler generated classes
437 ArrayList compiler_generated;
439 //
440 // Pointers to the default constructor and the default static constructor
441 //
445 //
446 // Points to the first non-static field added to the container.
447 //
448 // This is an arbitrary choice. We are interested in looking at _some_ non-static field,
449 // and the first one's as good as any.
450 //
453 //
454 // This one is computed after we can distinguish interfaces
455 // from classes from the arraylist `type_bases'
456 //
457 TypeExpr base_type;
459 Type GenericType;
461 ArrayList type_bases;
468 // The interfaces we implement.
471 // The base member cache and our member cache
472 MemberCache base_cache;
473 MemberCache member_cache;
477 #if GMCS_SOURCE
479 #endif
481 ArrayList partial_parts;
483 /// <remarks>
484 /// The pending methods that need to be implemented
485 // (interfaces or abstract methods)
486 /// </remarks>
487 PendingImplementation pending;
492 {
494 throw new InternalErrorException ("A nested type should be in the same NamespaceEntry as its enclosing class");
498 }
501 {
503 }
506 {
508 }
511 {
519 }
522 {
530 }
533 {
545 }
547 }
550 {
552 }
555 {
566 }
574 }
584 }
595 Report.Error (264, tc.Location, "Partial declarations of `{0}' must have the same type parameter names in the same order",
598 }
599 }
608 else
610 }
615 }
618 {
626 }
629 {
638 else
640 }
642 //
643 // Do not use this method: use AddMethod.
644 //
645 // This is only used by iterators.
646 //
648 {
656 }
659 {
662 }
671 }
680 }
682 }
688 }
689 }
694 }
695 }
698 {
713 }
722 }
723 }
726 {
736 else
738 }
741 {
751 }
757 }
759 /// <summary>
760 /// Indexer has special handling in constrast to other AddXXX because the name can be driven by IndexerNameAttribute
761 /// </summary>
763 {
769 else
771 }
774 {
782 }
785 {
792 }
795 {
798 Report.Error (646, a.Location, "Cannot specify the `DefaultMember' attribute on type containing an indexer");
800 }
801 }
804 }
809 }
810 }
815 }
816 }
821 }
822 }
827 }
828 }
833 }
834 }
839 }
840 }
845 }
846 }
851 }
855 }
856 }
861 }
862 }
867 }
868 }
873 }
874 }
879 }
880 }
885 }
886 }
891 }
892 }
897 }
898 }
903 }
904 }
909 }
910 }
915 }
916 }
924 }
925 }
927 public virtual void RegisterFieldForInitialization (MemberCore field, FieldInitializer expression)
928 {
939 }
940 }
942 //
943 // Emits the instance field initializers
944 //
946 {
947 ArrayList fields;
953 }
960 }
962 }
967 }
973 }
974 }
977 get { return pending; }
978 }
981 {
986 }
989 {
990 // FIXME: get rid of partial_parts and store lists of bases of each part here
991 // assumed, not verified: 'part' is in 'partial_parts'
993 }
996 {
1009 }
1012 // base_class could be a class, struct, enum, delegate.
1013 // This is validated in GetClassBases.
1016 }
1017 }
1025 }
1028 }
1031 }
1035 {
1041 TypeExpr new_base_class;
1054 }
1055 }
1056 }
1066 }
1067 }
1073 }
1075 /// <summary>
1076 /// This function computes the Base class and also the
1077 /// list of interfaces that the class or struct @c implements.
1078 ///
1079 /// The return value is an array (might be null) of
1080 /// interfaces implemented (as Types).
1081 ///
1082 /// The @base_class argument is set to the base object or null
1083 /// if this is `System.Object'.
1084 /// </summary>
1086 {
1099 // TODO: location of symbol related ....
1101 }
1103 Report.Error (1721, Location, "`{0}': Classes cannot have multiple base classes (`{1}' and `{2}')",
1108 }
1110 }
1118 }
1119 }
1127 Name);
1129 }
1130 }
1132 }
1135 {
1136 #if GMCS_SOURCE
1155 }
1158 }
1159 #endif
1162 }
1167 {
1169 }
1172 {
1183 }
1193 }
1197 }
1201 #if GMCS_SOURCE
1212 }
1213 #endif
1218 }
1220 //
1221 // GetClassBases calls ResolveBaseTypeExpr() on the various type expressions involved,
1222 // which in turn should have called DefineType()s on base types if necessary.
1223 //
1224 // None of the code below should trigger DefineType()s on classes that we depend on.
1225 // Thus, we are eligible to be on the topological sort `type_container_resolve_order'.
1226 //
1227 // Let's do it as soon as possible, since code below can call DefineType() on classes
1228 // that depend on us to be populated before they are.
1229 //
1238 }
1248 AttributeTester.Report_ObsoleteMessage (obsolete_attr, base_type.GetSignatureForError (), Location);
1249 }
1251 // add interfaces that were not added at type creation
1265 }
1271 }
1274 }
1276 //
1277 // Defines the type in the appropriate ModuleBuilder or TypeBuilder.
1278 //
1280 {
1290 }
1295 }
1301 }
1302 }
1307 }
1310 }
1313 {
1321 }
1324 {
1329 }
1330 }
1336 }
1337 }
1342 }
1348 }
1349 }
1357 }
1358 }
1366 }
1367 }
1375 }
1376 }
1379 }
1383 {
1387 }
1400 }
1401 }
1402 }
1403 }
1406 {
1418 }
1419 }
1422 }
1425 {
1433 }
1436 }
1439 {
1444 }
1458 }
1459 }
1466 }
1467 }
1468 }
1474 }
1475 }
1483 }
1490 }
1493 }
1496 }
1499 {
1504 }
1510 }
1516 }
1522 }
1528 }
1529 }
1532 }
1534 TypeContainer InTransit;
1537 {
1545 else
1551 }
1560 }
1568 }
1569 }
1576 }
1579 {
1581 }
1583 /// <summary>
1584 /// Populates our TypeBuilder with fields and methods
1585 /// </summary>
1587 {
1598 }
1601 {
1607 }
1608 }
1614 }
1617 MemberInfo conflict_symbol = Parent.PartialContainer.FindBaseMemberWithSameName (Basename, false);
1620 Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
1624 Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
1626 }
1627 }
1628 }
1635 }
1637 //
1638 // Constructors are not in the defined_names array
1639 //
1652 }
1655 #if CACHE
1660 }
1661 #endif
1664 }
1667 {
1670 }
1673 {
1678 }
1679 }
1682 }
1685 {
1686 return BaseCache == null ? null : BaseCache.FindMemberWithSameName (name, ignore_methods, null);
1687 }
1689 /// <summary>
1690 /// This function is based by a delegate to the FindMembers routine
1691 /// </summary>
1693 {
1695 }
1697 /// <summary>
1698 /// This filter is used by FindMembers, and we just keep
1699 /// a global for the filter to `AlwaysAccept'
1700 /// </summary>
1705 {
1707 }
1710 {
1721 }
1722 }
1730 }
1731 }
1742 }
1743 }
1754 }
1755 }
1766 }
1767 }
1772 }
1774 // Indicated whether container has StructLayout attribute set Explicit
1776 get { return (caching_flags & Flags.HasExplicitLayout) != 0; }
1777 set { caching_flags |= Flags.HasExplicitLayout; }
1778 }
1780 //
1781 // Return the nested type with name @name. Ensures that the nested type
1782 // is defined if necessary. Do _not_ use this when you have a MemberCache handy.
1783 //
1785 {
1801 }
1802 }
1803 }
1806 }
1811 {
1830 }
1837 }
1838 }
1839 }
1840 }
1842 /// <summary>
1843 /// This method returns the members of this type just like Type.FindMembers would
1844 /// Only, we need to use this for types which are _being_ defined because MS'
1845 /// implementation can't take care of that.
1846 /// </summary>
1847 //
1848 // FIXME: return an empty static array instead of null, that cleans up
1849 // some code and is consistent with some coding conventions I just found
1850 // out existed ;-)
1851 //
1852 //
1853 // Notice that in various cases we check if our field is non-null,
1854 // something that would normally mean that there was a bug elsewhere.
1855 //
1856 // The problem happens while we are defining p-invoke methods, as those
1857 // will trigger a FindMembers, but this happens before things are defined
1858 //
1859 // Since the whole process is a no-op, it is fine to check for null here.
1860 //
1863 {
1887 }
1911 }
1912 }
1913 }
1929 }
1935 }
1936 }
1937 }
1938 }
1958 }
1959 }
1960 }
1978 }
1979 }
1980 }
1995 }
2003 }
2004 }
2005 }
2017 MethodBuilder b;
2025 }
2033 }
2034 }
2035 }
2047 MethodBuilder b;
2055 }
2063 }
2064 }
2065 }
2066 }
2085 }
2086 }
2087 }
2088 }
2107 }
2108 }
2109 }
2127 }
2128 }
2129 }
2130 }
2147 }
2148 }
2149 }
2152 ConstructorBuilder cb =
2160 }
2161 }
2162 }
2164 //
2165 // Lookup members in base if requested.
2166 //
2175 }
2176 }
2177 }
2183 else
2185 }
2190 }
2191 }
2195 {
2200 else
2202 }
2204 /// <summary>
2205 /// Emits the values for the constants
2206 /// </summary>
2208 {
2213 }
2216 {
2225 Report.Warning (169, 3, mc.Location, "The private {0} `{1}' is never used", member_type, mc.GetSignatureForError ());
2226 }
2227 }
2228 }
2231 {
2232 //
2233 // Check for internal or private fields that were never assigned
2234 //
2247 Report.Warning (169, 3, f.Location, "The private field `{0}' is never used", f.GetSignatureForError ());
2249 #if NET_2_0
2251 #else
2253 #endif
2254 Report.Warning (error_code, 3, f.Location, "The private field `{0}' is assigned but its value is never used",
2256 }
2258 }
2260 //
2261 // Only report 649 on level 4
2262 //
2270 Report.Warning (649, 4, f.Location, "Field `{0}' is never assigned to, and will always have its default value `{1}'",
2272 }
2273 }
2274 }
2275 }
2277 // TODO: move to ClassOrStruct
2279 {
2283 if (TypeBuilder.IsSubclassOf (TypeManager.attribute_type) && RootContext.VerifyClsCompliance && IsClsComplianceRequired ()) {
2289 }
2292 }
2298 }
2300 Report.Error (3015, Location, "`{0}' has no accessible constructors which use only CLS-compliant types", GetSignatureForError ());
2305 }
2308 }
2309 }
2310 }
2311 }
2313 /// <summary>
2314 /// Emits the code, this step is performed after all
2315 /// the types, enumerations, constructors
2316 /// </summary>
2318 {
2322 #if GMCS_SOURCE
2327 }
2328 #endif
2330 //
2331 // Structs with no fields need to have at least one byte.
2332 // The right thing would be to set the PackingSize in a DefineType
2333 // but there are no functions that allow interfaces *and* the size to
2334 // be specified.
2335 //
2348 }
2349 }
2355 // Can not continue if constants are broken
2366 }
2378 }
2387 }
2392 }
2393 }
2406 }
2409 }
2410 }
2413 {
2421 //
2422 // This is fine, the code still created the type
2423 //
2424 // Report.Warning (-20, "Exception while creating class: " + TypeBuilder.Name);
2425 // Console.WriteLine (e.Message);
2428 }
2442 }
2473 }
2475 //
2476 // Performs the validation on a Method's modifiers (properties have
2477 // the same properties).
2478 //
2480 {
2487 //
2488 // At most one of static, virtual or override
2489 //
2492 Report.Error (112, mc.Location, "A static member `{0}' cannot be marked as override, virtual or abstract",
2495 }
2496 }
2502 }
2503 }
2506 Report.Error (113, mc.Location, "A member `{0}' marked as override cannot be marked as new or virtual",
2509 }
2511 //
2512 // If the declaration includes the abstract modifier, then the
2513 // declaration does not include static, virtual or extern
2514 //
2520 }
2523 Report.Error (502, mc.Location, "`{0}' cannot be both abstract and sealed", mc.GetSignatureForError ());
2525 }
2528 Report.Error (503, mc.Location, "The abstract method `{0}' cannot be marked virtual", mc.GetSignatureForError ());
2530 }
2534 Report.Error (513, mc.Location, "`{0}' is abstract but it is declared in the non-abstract class `{1}'",
2537 }
2538 }
2542 Report.Error (621, mc.Location, "`{0}': virtual or abstract members cannot be private", mc.GetSignatureForError ());
2544 }
2545 }
2549 Report.Error (238, mc.Location, "`{0}' cannot be sealed because it is not an override", mc.GetSignatureForError ());
2551 }
2552 }
2555 }
2558 get { return default_static_constructor; }
2559 }
2562 {
2570 Report.Error (3009, Location, "`{0}': base type `{1}' is not CLS-compliant", GetSignatureForError (), TypeManager.CSharpName (base_type));
2571 }
2573 }
2576 /// <summary>
2577 /// Checks whether container name is CLS Compliant
2578 /// </summary>
2580 {
2601 }
2602 }
2613 }
2614 #if GMCS_SOURCE
2615 Report.Warning (3005, 1, mc.Location, "Identifier `{0}' differing only in case is not CLS-compliant", mc.GetSignatureForError ());
2616 #else
2617 Report.Error (3005, mc.Location, "Identifier `{0}' differing only in case is not CLS-compliant", mc.GetSignatureForError ());
2618 #endif
2619 }
2620 }
2623 /// <summary>
2624 /// Performs checks for an explicit interface implementation. First it
2625 /// checks whether the `interface_type' is a base inteface implementation.
2626 /// Then it checks whether `name' exists in the interface type.
2627 /// </summary>
2629 {
2634 }
2635 }
2641 }
2644 {
2653 }
2654 }
2657 }
2660 {
2662 }
2665 {
2667 }
2669 //
2670 // IMemberContainer
2671 //
2676 }
2677 }
2682 }
2683 }
2688 }
2689 }
2694 }
2695 }
2698 {
2704 else
2706 }
2708 //
2709 // Generates xml doc comments (if any), and if required,
2710 // handle warning report.
2711 //
2713 {
2715 }
2718 get { return "T:"; }
2719 }
2730 }
2731 }
2732 }
2735 ListDictionary declarative_security;
2740 {
2741 }
2744 {
2751 }
2754 Report.Error (542, symbol.Location, "`{0}': member names cannot be the same as their enclosing type",
2757 }
2760 }
2763 {
2772 Report.Warning (67, 3, e.Location, "The event `{0}' is never used", e.GetSignatureForError ());
2773 }
2774 }
2775 }
2778 {
2779 if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
2785 }
2787 if (a.Type == TypeManager.struct_layout_attribute_type && a.GetLayoutKindValue () == LayoutKind.Explicit) {
2789 }
2792 }
2794 /// <summary>
2795 /// Defines the default constructors
2796 /// </summary>
2798 {
2799 // The default instance constructor is public
2800 // If the class is abstract, the default constructor is protected
2801 // The default static constructor is private
2808 }
2813 Location);
2817 }
2820 {
2831 // Field is re-initialized to its default value => removed
2834 }
2835 }
2836 }
2852 }
2854 // Need special check to not optimize code like this
2855 // static int a = b = 5;
2856 // static int b = 0;
2863 }
2864 }
2865 }
2869 }
2870 }
2872 }
2875 {
2882 }
2885 {
2891 }
2892 }
2893 }
2895 public override ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name)
2896 {
2898 }
2906 }
2907 }
2908 }
2911 // TODO: should be sealed
2924 public const TypeAttributes StaticClassAttribute = TypeAttributes.Abstract | TypeAttributes.Sealed;
2927 Attributes attrs)
2929 {
2935 }
2936 }
2939 {
2941 if (BaseType != TypeManager.attribute_type && !BaseType.IsSubclassOf (TypeManager.attribute_type) &&
2943 Report.Error (641, a.Location, "Attribute `{0}' is only valid on classes derived from System.Attribute", a.GetSignatureForError ());
2944 }
2945 }
2948 !(BaseType == TypeManager.attribute_type || BaseType.IsSubclassOf (TypeManager.attribute_type))) {
2949 Report.Error (1689, a.Location, "Attribute `System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes");
2951 }
2957 }
2962 }
2968 }
2973 }
2974 }
2977 {
2984 }
2988 Report.Error (715, m.Location, "`{0}': Static classes cannot contain user-defined operators", m.GetSignatureForError ());
2990 }
2993 Report.Error (711, m.Location, "`{0}': Static classes cannot contain destructor", GetSignatureForError ());
2995 }
2998 Report.Error (1057, m.Location, "`{0}': Static classes cannot contain protected members", m.GetSignatureForError ());
3000 }
3003 Report.Error (720, m.Location, "`{0}': cannot declare indexers in a static class", m.GetSignatureForError ());
3005 }
3011 Report.Error (710, m.Location, "`{0}': Static classes cannot have instance constructors", GetSignatureForError ());
3013 }
3017 Report.Error (1105, m.Location, "`{0}': Extension methods must be declared static", m.GetSignatureForError ());
3019 }
3021 Report.Error (708, m.Location, "`{0}': cannot declare instance members in a static class", m.GetSignatureForError ());
3022 }
3025 }
3028 {
3029 if ((ModFlags & Modifiers.ABSTRACT) == Modifiers.ABSTRACT && (ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) != 0) {
3030 Report.Error (418, Location, "`{0}': an abstract class cannot be sealed or static", GetSignatureForError ());
3032 }
3034 if ((ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) == (Modifiers.SEALED | Modifiers.STATIC)) {
3035 Report.Error (441, Location, "`{0}': a class cannot be both static and sealed", GetSignatureForError ());
3037 }
3040 }
3043 {
3048 }
3051 {
3056 }
3059 {
3074 }
3079 }
3089 }
3091 }
3097 }
3101 Report.Error (60, Location, "Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'",
3103 }
3104 }
3108 Report.Error (713, Location, "Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object",
3111 }
3116 Report.Error (714, Location, "`{0}': static classes cannot implement interfaces", GetSignatureForError ());
3117 }
3118 }
3121 }
3123 /// Search for at least one defined condition in ConditionalAttribute of attribute class
3124 /// Valid only for attribute classes.
3126 {
3144 }
3148 }
3153 }
3154 }
3156 //
3157 // FIXME: How do we deal with the user specifying a different
3158 // layout?
3159 //
3166 }
3167 }
3168 }
3171 // <summary>
3172 // Modifiers allowed in a struct declaration
3173 // </summary>
3185 {
3190 else
3196 }
3201 }
3202 }
3211 {
3213 //
3214 // If we are compiling our runtime,
3215 // and we are defining ValueType, then our
3216 // base is `System.Object'.
3217 //
3221 else
3223 }
3226 }
3228 //
3229 // FIXME: Allow the user to specify a different set of attributes
3230 // in some cases (Sealed for example is mandatory for a class,
3231 // but what SequentialLayout can be changed
3232 //
3236 }
3237 }
3239 public override void RegisterFieldForInitialization (MemberCore field, FieldInitializer expression)
3240 {
3245 }
3247 }
3249 }
3251 /// <summary>
3252 /// Interfaces
3253 /// </summary>
3256 /// <summary>
3257 /// Modifiers allowed in a class declaration
3258 /// </summary>
3268 Attributes attrs)
3270 {
3275 else
3279 }
3282 {
3287 }
3289 }
3295 }
3296 }
3306 }
3307 }
3310 {
3320 Report.Warning (3027, 1, Location, "`{0}' is not CLS-compliant because base interface `{1}' is not CLS-compliant",
3322 }
3323 }
3326 }
3327 }
3329 // It is used as a base class for all property based members
3330 // This includes properties, indexers, and events
3332 {
3337 {
3338 }
3341 {
3343 }
3346 {
3353 }
3355 }
3357 }
3361 {
3369 {
3371 }
3373 //
3374 // Returns the System.Type array for the parameters of this method
3375 //
3379 }
3380 }
3382 public Parameters ParameterInfo
3383 {
3386 }
3387 }
3392 }
3396 }
3397 }
3400 {
3401 // Check whether arguments were correct.
3409 }
3411 // TODO: create a special method for operators only to make code better
3413 {
3421 {
3423 if (op1 == null || !(op1.OperatorType == Operator.OpType.Explicit || op1.OperatorType == Operator.OpType.Implicit))
3427 if (op2 == null || !(op2.OperatorType == Operator.OpType.Explicit || op2.OperatorType == Operator.OpType.Implicit))
3432 }
3435 // This never happen. Rewrite this as Equal
3452 }
3457 // TODO: make operator compatible with MethodCore to avoid this
3461 }
3464 //
3465 // Try to report 663: method only differs on out/ref
3466 //
3472 Report.Error (663, Location, "`{0}': Methods cannot differ only on their use of ref and out on a parameters",
3475 }
3476 }
3481 else
3485 }
3488 }
3490 //
3491 // Returns a string that represents the signature for this
3492 // member which should be used in XML documentation.
3493 //
3495 {
3497 }
3499 //
3500 // Raised (and passed an XmlElement that contains the comment)
3501 // when GenerateDocComment is writing documentation expectedly.
3502 //
3503 // FIXME: with a few effort, it could be done with XmlReader,
3504 // that means removal of DOM use.
3505 //
3507 {
3509 }
3511 //
3512 // Represents header string for documentation comment.
3513 //
3514 public override string DocCommentHeader
3515 {
3516 get { return "M:"; }
3517 }
3520 {
3522 }
3525 {
3531 }
3536 }
3540 }
3542 }
3545 //
3546 // Whether this is an interface member.
3547 //
3550 //
3551 // If true, this is an explicit interface implementation
3552 //
3557 //
3558 // The interface type we are explicitly implementing
3559 //
3562 //
3563 // The method we're overriding if this is an override method.
3564 //
3575 {
3579 }
3582 {
3592 // Is null for System.Object while compiling corlib and base interfaces
3595 Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
3596 }
3598 }
3603 // method is override
3613 Report.Warning (672, 1, Location, "Member `{0}' overrides obsolete member `{1}'. Add the Obsolete attribute to `{0}'",
3615 }
3620 }
3621 }
3622 }
3624 }
3626 MemberInfo conflict_symbol = Parent.PartialContainer.FindBaseMemberWithSameName (Name, !((this is Event) || (this is Property)));
3631 Report.Error (72, Location, "`{0}': cannot override because `{1}' is not an event", GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
3633 Report.Error (544, Location, "`{0}': cannot override because `{1}' is not a property", GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
3634 else
3635 Report.Error (505, Location, "`{0}': cannot override because `{1}' is not a method", GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
3637 Report.Error (115, Location, "`{0}' is marked as an override but no suitable {1} found to override",
3639 }
3641 }
3645 Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
3646 }
3648 }
3655 Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
3657 }
3660 }
3662 //
3663 // Performs various checks on the MethodInfo `mb' regarding the modifier flags
3664 // that have been defined.
3665 //
3666 // `name' is the user visible name for reporting errors (this is used to
3667 // provide the right name regarding method names and properties)
3668 //
3670 {
3676 "`{0}': cannot override inherited member `{1}' because it is not marked virtual, abstract or override",
3679 }
3681 // Now we check that the overriden method is not final
3685 Report.Error (239, Location, "`{0}': cannot override inherited member `{1}' because it is sealed",
3688 }
3689 //
3690 // Check that the permissions are not being changed
3691 //
3698 }
3704 GetSignatureForError (), TypeManager.CSharpName (baseMethodType), TypeManager.CSharpSignature (base_method));
3705 }
3707 Report.Error (508, Location, "`{0}': return type must be `{1}' to match overridden member `{2}'",
3708 GetSignatureForError (), TypeManager.CSharpName (baseMethodType), TypeManager.CSharpSignature (base_method));
3709 }
3711 }
3712 }
3719 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",
3722 Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
3724 }
3725 }
3732 }
3733 }
3736 }
3738 protected bool CheckAccessModifiers (MethodAttributes thisp, MethodAttributes base_classp, MethodInfo base_method)
3739 {
3741 //
3742 // when overriding protected internal, the method can be declared
3743 // protected internal only within the same assembly
3744 //
3748 //
3749 // assemblies differ - report an error
3750 //
3754 //
3755 // same assembly, but other attributes differ - report an error
3756 //
3759 };
3761 //
3762 // if it's not "protected internal", it must be "protected"
3763 //
3767 //
3768 // protected within the same assembly - an error
3769 //
3773 //
3774 // protected ok, but other attributes differ - report an error
3775 //
3777 }
3781 }
3782 }
3785 {
3794 }
3800 }
3803 Report.Error (501, Location, "`{0}' must declare a body because it is not marked abstract or extern",
3806 }
3807 }
3810 }
3813 {
3835 else
3840 }
3842 }
3845 {
3858 Report.Error (538, Location, "`{0}' in explicit interface declaration is not an interface", TypeManager.CSharpName (InterfaceType));
3860 }
3865 }
3867 }
3870 {
3889 }
3900 Report.Error (538, Location, "'{0}' in explicit interface declaration is not an interface", TypeManager.CSharpName (InterfaceType));
3902 }
3908 }
3911 }
3914 {
3915 // for extern static method must be specified either DllImport attribute or MethodImplAttribute.
3916 // We are more strict than Microsoft and report CS0626 as error
3919 "`{0}' is marked as an external but has no DllImport attribute. Consider adding a DllImport attribute to specify the external implementation",
3921 }
3924 }
3926 protected void Error_CannotChangeAccessModifiers (MemberInfo base_method, MethodAttributes ma, string suffix)
3927 {
3934 }
3936 Report.Error (507, Location, "`{0}': cannot change access modifiers when overriding `{1}' inherited member `{2}'",
3938 }
3943 }
3944 }
3946 /// <summary>
3947 /// For custom member duplication search in a container
3948 /// </summary>
3951 /// <summary>
3952 /// Gets base method and its return type
3953 /// </summary>
3956 //
3957 // The "short" name of this property / indexer / event. This is the
3958 // name without the explicit interface.
3959 //
3960 public string ShortName
3961 {
3962 get { return MemberName.Name; }
3963 set { SetMemberName (new MemberName (MemberName.Left, value, Location)); }
3964 }
3967 {
3970 Report.Error (3010, Location, "`{0}': CLS-compliant interfaces must have only CLS-compliant members", GetSignatureForError ());
3971 }
3973 if ((ModFlags & Modifiers.ABSTRACT) != 0 && Parent.TypeBuilder.IsClass && IsExposedFromAssembly () && Parent.IsClsComplianceRequired ()) {
3974 Report.Error (3011, Location, "`{0}': only CLS-compliant members can be abstract", GetSignatureForError ());
3975 }
3977 }
3983 }
3985 public override bool IsUsed
3986 {
3987 get { return IsExplicitImpl || base.IsUsed; }
3988 }
3990 }
3993 {
3995 ReturnParameter return_attributes;
3996 ListDictionary declarative_security;
3999 Iterator iterator;
4000 ArrayList anonymous_methods;
4009 {
4010 }
4013 {
4020 }
4023 MethodBuilder.SetImplementationFlags (MethodImplAttributes.InternalCall | MethodImplAttributes.Runtime);
4025 }
4030 Report.Error (601, a.Location, "The DllImport attribute must be specified on a method marked `static' and `extern'");
4031 }
4033 }
4035 if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
4040 }
4043 }
4048 }
4049 }
4052 {
4055 }
4058 {
4062 }
4065 {
4069 #if GMCS_SOURCE
4076 }
4078 #if MS_COMPATIBLE
4080 #else
4082 #endif
4086 }
4087 #endif
4090 }
4093 {
4101 }
4107 }
4108 }
4111 }
4114 {
4136 }
4137 }
4140 }
4143 {
4150 }
4151 }
4154 }
4157 {
4159 "Conditional not valid on `{0}' because it is a constructor, destructor, operator or explicit interface implementation",
4161 }
4164 {
4167 }
4172 }
4173 }
4175 #region IMethodData Members
4187 // FIXME: How is `ExplicitThis' used in C#?
4190 }
4191 }
4196 }
4197 }
4202 }
4203 }
4206 get { return iterator; }
4207 }
4212 }
4213 }
4216 {
4220 // TODO: Destructor should derive from MethodCore
4223 Report.Error (249, Location, "Do not override object.Finalize. Instead, provide a destructor");
4225 }
4228 }
4230 /// <summary>
4231 /// Returns true if method has conditional attribute and the conditions is not defined (method is excluded).
4232 /// </summary>
4255 }
4259 }
4266 }
4268 }
4273 }
4275 }
4280 }
4281 }
4283 #endregion
4285 }
4288 {
4289 DeclSpace parent;
4290 MethodBase builder;
4294 {
4299 }
4302 get { return builder.Name; }
4303 }
4306 get { return parent.NamespaceEntry.SymbolFileID; }
4307 }
4315 else
4317 }
4318 }
4321 {
4324 }
4327 {
4347 }
4348 }
4352 /// <summary>
4353 /// Modifiers allowed in a class declaration
4354 /// </summary>
4373 //
4374 // return_type can be "null" for VOID values.
4375 //
4382 {
4383 }
4386 {
4388 }
4391 {
4395 }
4398 {
4413 }
4416 {
4421 }
4424 Report.Error (578, Location, "Conditional not valid on `{0}' because its return type is not void", GetSignatureForError ());
4426 }
4429 Report.Error (243, Location, "Conditional not valid on `{0}' because it is an override method", GetSignatureForError ());
4431 }
4436 }
4439 Report.Error (629, Location, "Conditional member `{0}' cannot implement interface member `{1}'",
4442 }
4446 Report.Error (685, Location, "Conditional method `{0}' cannot have an out parameter", GetSignatureForError ());
4448 }
4449 }
4450 }
4455 }
4458 }
4461 {
4470 }
4471 }
4479 }
4480 }
4488 }
4489 }
4497 }
4498 }
4501 }
4503 //
4504 // Creates the type
4505 //
4507 {
4511 if (RootContext.StdLib && (ReturnType == TypeManager.arg_iterator_type || ReturnType == TypeManager.typed_reference_type)) {
4514 }
4518 Report.Warning (465, 1, Location, "Introducing a 'Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor?");
4519 }
4522 if (Parameters.Count == 1 && ParameterTypes [0] == TypeManager.object_type && Name == "Equals")
4526 }
4539 "`{0}': Extension methods cannot be declared without a reference to System.Core.dll assembly. Add the assembly reference or remove `this' modifer from the first parameter",
4546 Report.Error (1106, Location, "`{0}': Extension methods must be defined in a non-generic static class",
4548 }
4549 }
4551 //
4552 // This is used to track the Entry Point,
4553 //
4562 Report.Warning (402, 4, Location, "`{0}': an entry point cannot be generic or in a generic type",
4570 }
4574 }
4578 }
4579 }
4582 }
4584 //
4585 // Emits the code
4586 //
4588 {
4598 }
4601 {
4602 Report.Error (1599, loc, "Method or delegate cannot return type `{0}'", TypeManager.CSharpName (t));
4603 }
4606 {
4618 }
4621 {
4629 }
4632 }
4633 }
4636 ArrayList argument_list;
4638 Location loc;
4641 {
4644 }
4649 }
4650 }
4653 {
4654 Expression base_constructor_group;
4655 Type t;
4664 }
4665 }
4675 "`{0}': Struct constructors cannot call base constructors", TypeManager.CSharpSignature (caller_builder));
4677 }
4679 //
4680 // It is legal to have "this" initializers that take no arguments
4681 // in structs, they are just no-ops.
4682 //
4683 // struct D { public D (int a) : this () {}
4684 //
4689 }
4694 loc);
4701 loc);
4702 }
4716 }
4723 }
4726 Report.Error (516, loc, "Constructor `{0}' cannot call itself", TypeManager.CSharpSignature (caller_builder));
4728 }
4731 }
4734 {
4739 else
4741 }
4742 }
4743 }
4748 {
4749 }
4750 }
4755 {
4756 }
4757 }
4762 {
4763 }
4764 }
4769 ListDictionary declarative_security;
4770 ArrayList anonymous_methods;
4772 // <summary>
4773 // Modifiers allowed for a constructor.
4774 // </summary>
4787 get { return null; }
4788 }
4791 //
4792 // The spec claims that static is not permitted, but
4793 // my very own code has static constructors.
4794 //
4799 {
4801 }
4804 get { return has_compliant_args; }
4805 }
4808 get { return AttributeTargets.Constructor; }
4809 }
4812 //
4813 // Returns true if this is a default constructor
4814 //
4816 {
4823 }
4826 {
4827 if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
4830 }
4833 }
4836 ConstructorBuilder.SetImplementationFlags (MethodImplAttributes.InternalCall | MethodImplAttributes.Runtime);
4838 }
4841 }
4844 {
4848 }
4851 {
4856 }
4857 }
4860 }
4863 {
4872 }
4873 }
4875 }
4878 {
4884 }
4886 // the rest can be ignored
4888 }
4890 // Check whether arguments were correct.
4902 }
4905 Report.Error (666, Location, "`{0}': new protected member declared in struct", GetSignatureForError ());
4907 }
4908 }
4910 if ((RootContext.WarningLevel >= 4) && ((Parent.ModFlags & Modifiers.SEALED) != 0 && (ModFlags & Modifiers.PROTECTED) != 0)) {
4911 Report.Warning (628, 4, Location, "`{0}': new protected member declared in sealed class", GetSignatureForError ());
4912 }
4915 }
4917 //
4918 // Creates the ConstructorBuilder
4919 //
4921 {
4938 else
4942 else
4944 }
4949 // Check if arguments were correct.
4955 ParameterTypes);
4962 Report.Error (669, Location, "`{0}': A class with the ComImport attribute cannot have a user-defined constructor",
4965 }
4967 }
4972 }
4974 //
4975 // Emits the code
4976 //
4978 {
4985 // If this is a non-static `struct' constructor and doesn't have any
4986 // initializer, it must initialize all of the struct's fields.
4993 }
5000 //
5001 // Spec mandates that Initializers will not have
5002 // `this' access
5003 //
5009 }
5016 //
5017 // Classes can have base initializers and instance field initializers.
5018 //
5022 //
5023 // If we use a "this (...)" constructor initializer, then
5024 // do not emit field initializers, they are initialized in the other constructor
5025 //
5028 }
5029 }
5040 }
5041 }
5045 }
5061 }
5062 }
5065 }
5067 // Is never override
5069 {
5071 }
5074 {
5076 }
5081 }
5082 }
5085 {
5088 }
5099 }
5100 }
5101 }
5102 }
5105 }
5107 #region IMethodData Members
5117 // FIXME: How is `ExplicitThis' used in C#?
5120 }
5121 }
5126 }
5127 }
5132 }
5133 }
5138 }
5139 }
5142 {
5145 }
5148 {
5150 }
5155 }
5156 }
5158 #endregion
5159 }
5161 /// <summary>
5162 /// Interface for MethodData class. Holds links to parent members to avoid member duplication.
5163 /// </summary>
5164 public interface IMethodData
5165 {
5166 CallingConventions CallingConventions { get; }
5167 Location Location { get; }
5168 MemberName MethodName { get; }
5169 Type ReturnType { get; }
5170 GenericMethod GenericMethod { get; }
5171 Parameters ParameterInfo { get; }
5173 Iterator Iterator { get; }
5175 Attributes OptAttributes { get; }
5176 ToplevelBlock Block { get; set; }
5184 }
5186 //
5187 // Encapsulates most of the Method's state
5188 //
5195 //
5196 // Are we implementing an interface ?
5197 //
5200 //
5201 // Protected data.
5202 //
5213 }
5214 }
5219 }
5220 }
5224 {
5230 }
5237 {
5241 }
5244 {
5255 else
5262 Report.Error (550, method.Location, "`{0}' is an accessor not found in interface member `{1}{2}'",
5270 }
5272 }
5275 Report.Error (683, method.Location, "`{0}' explicit method implementation cannot implement `{1}' because it is an accessor",
5278 }
5288 Report.Error (470, method.Location, "Method `{0}' cannot implement interface accessor `{1}.{2}'",
5292 }
5296 Report.Error (686, method.Location, "Accessor `{0}' cannot implement interface member `{1}' for type `{2}'. Use an explicit interface implementation",
5297 method.GetSignatureForError (), TypeManager.CSharpSignature (implementing), container.GetSignatureForError ());
5299 }
5303 Report.Error (277, method.Location, "Accessor `{0}' must be declared public to implement interface member `{1}'",
5306 }
5307 }
5308 }
5309 }
5310 }
5312 //
5313 // For implicit implementations, make sure we are public, for
5314 // explicit implementations, make sure we are private.
5315 //
5317 //
5318 // Setting null inside this block will trigger a more
5319 // verbose error reporting for missing interface implementations
5320 //
5321 // The "candidate" function has been flagged already
5322 // but it wont get cleared
5323 //
5325 if (method.ParameterInfo.HasParams && !TypeManager.GetParameterData (implementing).HasParams) {
5327 Report.Error (466, method.Location, "`{0}': the explicit interface implementation cannot introduce the params modifier",
5330 }
5333 //
5334 // If this is an interface method implementation,
5335 // check for public accessibility
5336 //
5338 {
5340 }
5342 // We may never be private.
5346 //
5347 // We may be protected if we're overriding something.
5348 //
5350 }
5351 }
5353 //
5354 // Static is not allowed
5355 //
5358 }
5359 }
5361 //
5362 // If implementing is still valid, set flags
5363 //
5365 //
5366 // When implementing interface methods, set NewSlot
5367 // unless, we are overwriting a method.
5368 //
5372 }
5373 flags |=
5377 // Set Final unless we're virtual, abstract or already overriding a method.
5380 }
5391 else
5399 //
5400 // clear the pending implemntation flag
5401 //
5414 }
5427 }
5430 }
5433 /// <summary>
5434 /// Create the MethodBuilder for the method
5435 /// </summary>
5437 {
5443 }
5445 #if GMCS_SOURCE && !MS_COMPATIBLE
5449 #endif
5450 }
5452 //
5453 // Emits the code
5454 //
5456 {
5459 EmitContext ec;
5462 else
5472 //
5473 // Handle destructors specially
5474 //
5475 // FIXME: This code generates buggy code
5476 //
5479 else
5484 }
5487 {
5499 // ig.MarkLabel (finish);
5512 }
5513 }
5516 //ig.MarkLabel (ec.ReturnLabel);
5518 }
5519 }
5521 // TODO: Should derive from MethodCore
5528 Location l)
5531 { }
5534 {
5538 }
5541 }
5544 {
5546 }
5551 }
5552 }
5553 }
5560 //
5561 // The type of this property / indexer / event
5562 //
5571 }
5572 }
5574 }
5575 }
5577 //
5578 // The constructor is only exposed to our children
5579 //
5584 {
5591 }
5594 {
5596 Report.Error (666, Location, "`{0}': new protected member declared in struct", GetSignatureForError ());
5598 }
5604 Report.Warning (628, 4, Location, "`{0}': new protected member declared in sealed class", GetSignatureForError ());
5605 }
5607 }
5610 {
5619 }
5621 // verify accessibility
5640 else
5650 }
5652 }
5655 }
5658 {
5659 if (MemberType == TypeManager.arg_iterator_type || MemberType == TypeManager.typed_reference_type) {
5660 Report.Error (610, Location, "Field or property cannot be of type `{0}'", TypeManager.CSharpName (MemberType));
5662 }
5664 }
5665 }
5667 //
5668 // Abstract class for all fields
5669 //
5678 }
5686 {
5688 Report.Error (681, Location, "The modifier 'abstract' is not valid on fields. Try using a property instead");
5689 }
5694 }
5695 }
5698 {
5703 Report.Error (636, Location, "The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit)");
5705 }
5708 Report.Error (637, Location, "The FieldOffset attribute is not allowed on static or const fields");
5710 }
5711 }
5713 #if NET_2_0
5715 Report.Error (1716, Location, "Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead");
5717 }
5718 #endif
5724 }
5726 }
5731 }
5734 }
5737 {
5744 Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
5745 }
5747 }
5751 Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
5753 }
5756 }
5759 {
5767 // TODO: wrong location
5770 }
5775 }
5786 }
5792 }
5794 //
5795 // Represents header string for documentation comment.
5796 //
5798 get { return "F:"; }
5799 }
5802 {
5805 }
5807 if (((status & Status.HAS_OFFSET) == 0) && (ModFlags & Modifiers.STATIC) == 0 && Parent.PartialContainer.HasExplicitLayout) {
5808 Report.Error (625, Location, "`{0}': Instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute.", GetSignatureForError ());
5809 }
5812 }
5814 public static void Error_VariableOfStaticClass (Location loc, string variableName, Type staticClass)
5815 {
5818 variableName);
5819 }
5825 }
5826 }
5827 }
5835 }
5836 }
5839 {
5842 }
5843 }
5846 {
5852 }
5854 }
5857 {
5859 }
5860 }
5862 interface IFixedBuffer
5863 {
5864 FieldInfo Element { get; }
5865 Type ElementType { get; }
5866 }
5869 {
5870 FieldInfo element_field;
5873 {
5875 }
5877 #region IFixedField Members
5882 }
5883 }
5888 }
5889 }
5891 #endregion
5892 }
5894 /// <summary>
5895 /// Fixed buffer implementation
5896 /// </summary>
5898 {
5904 TypeBuilder fixed_buffer_type;
5905 FieldBuilder element;
5906 Expression size_expr;
5919 {
5924 }
5927 {
5928 #if !NET_2_0
5930 Report.Warning (-23, 1, Location, "Only private or internal fixed sized buffers are supported by .NET 1.x");
5931 #endif
5934 Report.Error (1642, Location, "`{0}': Fixed size buffer fields may only be members of structs",
5937 }
5943 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",
5946 }
5953 IntConstant buffer_size_const = c.ImplicitConversionRequired (TypeManager.int32_type, Location) as IntConstant;
5960 Report.Error (1665, Location, "`{0}': Fixed size buffers must have a length greater than zero", GetSignatureForError ());
5962 }
5967 Report.Error (1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
5970 }
5974 // Define nested
5978 TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit, TypeManager.value_type);
5979 element = fixed_buffer_type.DefineField (FixedElementName, MemberType, FieldAttributes.Public);
5982 FieldBuilder = Parent.TypeBuilder.DefineField (Name, fixed_buffer_type, Modifiers.FieldAttr (ModFlags));
5986 }
5989 {
5996 CustomAttributeBuilder cab = new CustomAttributeBuilder (TypeManager.struct_layout_attribute_ctor,
6000 #if NET_2_0
6001 cab = new CustomAttributeBuilder (TypeManager.fixed_buffer_attr_ctor, new object[] { MemberType, buffer_size } );
6003 #endif
6005 }
6010 }
6011 }
6013 #region IFixedField Members
6018 }
6019 }
6024 }
6025 }
6027 #endregion
6028 }
6030 //
6031 // The Field class is used to represents class/struct fields during parsing.
6032 //
6034 // <summary>
6035 // Modifiers allowed in a class declaration
6036 // </summary>
6051 attrs)
6052 {
6053 }
6056 {
6063 // ptype is only null for System.Object while compiling corlib.
6070 }
6071 }
6093 }
6094 }
6100 }
6101 }
6112 }
6119 }
6121 Report.Warning (-24, 1, Location, "The Microsoft runtime is unable to use [void|void*] as a field type, try using the Mono runtime.");
6123 }
6130 }
6133 {
6138 Report.Warning (3026, 1, Location, "CLS-compliant field `{0}' cannot be volatile", GetSignatureForError ());
6139 }
6142 }
6143 }
6145 //
6146 // `set' and `get' accessors are represented with an Accessor.
6147 //
6149 //
6150 // Null if the accessor is empty, or a Block if not
6151 //
6166 {
6171 }
6174 {
6176 }
6179 {
6183 }
6184 }
6186 // Ooouh Martin, templates are missing here.
6187 // When it will be possible move here a lot of child code and template method type.
6193 // The accessor are created event if they are not wanted.
6194 // But we need them because their names are reserved.
6195 // Field says whether accessor will be emited or not
6200 ReturnParameter return_attributes;
6204 {
6207 }
6213 {
6216 }
6219 {
6221 }
6224 {
6226 }
6228 #region IMethodData Members
6232 }
6237 }
6241 }
6242 }
6247 }
6248 }
6251 {
6253 }
6258 }
6259 }
6264 }
6265 }
6270 }
6271 }
6273 public abstract Parameters ParameterInfo { get ; }
6274 public abstract Type ReturnType { get; }
6277 #endregion
6280 {
6281 if (a.Type == TypeManager.cls_compliant_attribute_type || a.Type == TypeManager.obsolete_attribute_type ||
6284 "Attribute `{0}' is not valid on property or event accessors. It is valid on `{1}' declarations only",
6287 }
6289 if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
6294 }
6299 }
6307 }
6310 }
6313 {
6315 }
6317 // It is not supported for the accessors
6319 {
6321 }
6324 {
6332 method_data.MethodBuilder.AddDeclarativeSecurity ((SecurityAction)de.Key, (PermissionSet)de.Value);
6333 }
6334 }
6337 }
6340 {
6342 }
6345 {
6347 }
6350 {
6366 }
6368 public override bool IsUsed
6369 {
6375 }
6376 }
6381 }
6382 }
6385 {
6387 }
6389 //
6390 // Represents header string for documentation comment.
6391 //
6393 get { throw new InvalidOperationException ("Unexpected attempt to get doc comment from " + this.GetType () + "."); }
6394 }
6396 }
6398 //
6399 // Properties and Indexers both generate PropertyBuilders, we use this to share
6400 // their common bits.
6401 //
6405 {
6410 {
6411 }
6415 {
6416 }
6419 {
6428 }
6433 }
6434 }
6439 }
6440 }
6445 }
6446 }
6447 }
6452 ImplicitParameter param_attr;
6457 {
6458 }
6462 {
6463 }
6466 {
6473 }
6476 }
6483 }
6484 }
6487 {
6489 new Parameter[] { new Parameter (method.MemberType, "value", Parameter.Modifier.NONE, null, Location) },
6491 }
6494 {
6506 }
6511 }
6512 }
6517 }
6518 }
6519 }
6524 {
6527 Iterator iterator;
6528 ArrayList anonymous_methods;
6533 {
6535 }
6540 {
6548 }
6549 }
6552 get { return iterator; }
6553 }
6556 {
6558 method_data.MethodBuilder.SetImplementationFlags (MethodImplAttributes.InternalCall | MethodImplAttributes.Runtime);
6560 }
6563 }
6568 }
6569 }
6572 {
6574 }
6577 {
6582 }
6588 }
6589 }
6592 }
6595 {
6601 //
6602 // Check for custom access modifier
6603 //
6609 Report.Error (275, Location, "`{0}': accessibility modifiers may not be used on accessors in an interface",
6613 Report.Error (442, Location, "`{0}': abstract properties cannot have private accessors", GetSignatureForError ());
6614 }
6621 }
6624 }
6626 public bool HasCustomAccessModifier
6627 {
6630 }
6631 }
6634 {
6638 }
6641 {
6643 }
6646 {
6648 }
6651 {
6657 }
6663 }
6669 "The accessibility modifier of the `{0}' accessor must be more restrictive than the modifier of the property or indexer `{1}'",
6671 }
6672 }
6675 {
6678 }
6679 }
6691 {
6693 }
6696 {
6700 }
6703 }
6708 }
6709 }
6712 {
6720 }
6723 {
6727 //
6728 // Accessors modifiers check
6729 //
6731 Report.Error (274, Location, "`{0}': Cannot specify accessibility modifiers for both accessors of the property or indexer",
6734 }
6739 "`{0}': accessibility modifiers on accessors may only be used if the property or indexer has both a get and a set accessor",
6742 }
6747 }
6750 }
6753 {
6759 }
6762 {
6768 }
6771 {
6775 }
6779 // TODO: rename to Resolve......
6781 {
6794 Report.Error (545, Location, "`{0}.get': cannot override because `{1}' does not have an overridable get accessor", GetSignatureForError (), TypeManager.GetFullNameSignature (base_property));
6795 }
6799 Report.Error (546, Location, "`{0}.set': cannot override because `{1}' does not have an overridable set accessor", GetSignatureForError (), TypeManager.GetFullNameSignature (base_property));
6800 }
6801 }
6803 //
6804 // Check base class accessors access
6805 //
6807 // TODO: rewrite to reuse Get|Set.CheckAccessModifiers and share code there
6811 MethodAttributes get_flags = Modifiers.MethodAttr (Get.ModFlags != 0 ? Get.ModFlags : ModFlags);
6814 if (!Get.IsDummy && !CheckAccessModifiers (get_flags & MethodAttributes.MemberAccessMask, get_accessor_access, get_accessor))
6816 }
6819 MethodAttributes set_flags = Modifiers.MethodAttr (Set.ModFlags != 0 ? Set.ModFlags : ModFlags);
6822 if (!Set.IsDummy && !CheckAccessModifiers (set_flags & MethodAttributes.MemberAccessMask, set_accessor_access, set_accessor))
6824 }
6825 }
6827 // When one accessor does not exist and property hides base one
6828 // we need to propagate this upwards
6832 //
6833 // Get the less restrictive access
6834 //
6836 }
6839 {
6840 //
6841 // The PropertyBuilder can be null for explicit implementations, in that
6842 // case, we do not actually emit the ".property", so there is nowhere to
6843 // put the attribute
6844 //
6855 }
6857 /// <summary>
6858 /// Tests whether accessors are not in collision with some method (CS0111)
6859 /// </summary>
6861 {
6863 }
6865 public override bool IsUsed
6866 {
6872 }
6873 }
6876 {
6881 }
6886 }
6887 }
6889 //
6890 // Represents header string for documentation comment.
6891 //
6893 get { return "P:"; }
6894 }
6895 }
6922 {
6925 else
6930 else
6932 }
6935 {
6950 // FIXME - PropertyAttributes.HasDefault ?
6963 }
6966 {
6968 Parent.TypeBuilder, Name, Parameters.EmptyReadOnlyParameters.Types, null, true) as PropertyInfo;
6969 }
6970 }
6972 /// </summary>
6973 /// Gigantic workaround for lameness in SRE follows :
6974 /// This class derives from EventInfo and attempts to basically
6975 /// wrap around the EventBuilder so that FindMembers can quickly
6976 /// return this in it search for members
6977 /// </summary>
6980 //
6981 // We use this to "point" to our Builder which is
6982 // not really a MemberInfo
6983 //
6984 EventBuilder MyBuilder;
6986 //
6987 // We "catch" and wrap these methods
6988 //
6991 EventAttributes attributes;
6995 Event my_event;
6997 public MyEventBuilder (Event ev, TypeBuilder type_builder, string name, EventAttributes event_attr, Type event_type)
6998 {
7001 // And now store the values in our own fields.
7011 }
7013 //
7014 // Methods that you have to override. Note that you only need
7015 // to "implement" the variants that take the argument (those are
7016 // the "abstract" methods, the others (GetAddMethod()) are
7017 // regular.
7018 //
7020 {
7022 }
7025 {
7027 }
7030 {
7032 }
7034 //
7035 // These methods make "MyEventInfo" look like a Builder
7036 //
7038 {
7041 }
7044 {
7047 }
7050 {
7053 }
7056 {
7058 }
7061 {
7062 // FIXME : There's nothing which can be seemingly done here because
7063 // we have no way of getting at the custom attribute objects of the
7064 // EventBuilder !
7066 }
7069 {
7070 // FIXME : Same here !
7072 }
7075 {
7077 }
7082 }
7083 }
7088 }
7089 }
7094 }
7095 }
7100 }
7101 }
7106 }
7107 }
7110 {
7112 // my_event.SetAssigned ();
7114 }
7115 }
7116 }
7118 /// <summary>
7119 /// For case when event is declared like property (with add and remove accessors).
7120 /// </summary>
7123 {
7128 {
7130 }
7133 {
7136 }
7139 {
7146 }
7149 }
7151 }
7154 {
7157 {
7158 }
7163 }
7164 }
7165 }
7168 {
7171 {
7172 }
7177 }
7178 }
7179 }
7182 static readonly string[] attribute_targets = new string [] { "event" }; // "property" target was disabled for 2.0 version
7188 {
7191 }
7194 {
7202 }
7207 }
7208 }
7209 }
7211 /// <summary>
7212 /// Event is declared like field.
7213 /// </summary>
7216 {
7219 {
7220 }
7223 {
7230 // TODO: because we cannot use generics yet
7233 mb.SetImplementationFlags (mb.GetMethodImplementationFlags () | MethodImplAttributes.Synchronized);
7248 }
7250 }
7251 }
7254 {
7257 {
7258 }
7263 }
7264 }
7265 }
7268 {
7271 {
7272 }
7277 }
7278 }
7279 }
7290 Attributes attrs)
7292 {
7295 }
7298 {
7302 }
7310 }
7313 }
7316 {
7323 // FIXME: We are unable to detect whether generic event is used because
7324 // we are using FieldExpr instead of EventExpr for event access in that
7325 // case. When this issue will be fixed this hack can be removed.
7339 }
7343 }
7346 }
7349 {
7352 }
7353 }
7354 }
7358 {
7360 ImplicitParameter param_attr;
7366 {
7368 }
7372 {
7374 }
7377 get { return null; }
7378 }
7381 {
7383 method_data.MethodBuilder.SetImplementationFlags (MethodImplAttributes.InternalCall | MethodImplAttributes.Runtime);
7385 }
7388 }
7391 {
7398 }
7401 }
7406 }
7407 }
7410 {
7412 }
7415 {
7425 }
7427 protected abstract MethodInfo DelegateMethodInfo { get; }
7432 }
7433 }
7436 {
7440 }
7443 {
7445 }
7450 }
7451 }
7456 }
7457 }
7458 }
7482 Parameters parameters;
7489 {
7490 }
7493 {
7497 }
7500 }
7503 {
7505 }
7510 }
7511 }
7514 {
7522 Report.Error (66, Location, "`{0}': event must be of a delegate type", GetSignatureForError ());
7524 }
7527 new Parameter[] { new Parameter (MemberType, "value", Parameter.Modifier.NONE, null, Location) },
7533 //
7534 // Now define the accessors
7535 //
7545 EventBuilder = new MyEventBuilder (this, Parent.TypeBuilder, Name, EventAttributes.None, MemberType);
7549 }
7552 {
7555 }
7561 }
7564 {
7574 }
7576 //
7577 // Represents header string for documentation comment.
7578 //
7580 get { return "E:"; }
7581 }
7582 }
7588 {
7591 {
7592 }
7596 {
7597 }
7602 }
7603 }
7604 }
7607 {
7610 {
7611 }
7615 {
7616 }
7619 {
7622 }
7623 }
7649 {
7654 else
7659 else
7661 }
7664 {
7673 }
7674 }
7677 }
7680 {
7689 // When it is not yet defined
7703 }
7707 {
7720 }
7725 // Remove the attribute from the list because it is not emitted
7739 }
7745 }
7746 }
7747 }
7753 }
7768 // Setup iterator if we are one
7773 }
7774 }
7776 //
7777 // Now name the parameters
7778 //
7781 // TODO: should be done in parser and it needs to do cycle
7785 }
7786 }
7800 }
7803 {
7805 }
7808 {
7813 }
7818 }
7821 {
7824 }
7827 {
7830 }
7833 {
7839 }
7840 }
7852 // Unary operators
7853 LogicalNot,
7854 OnesComplement,
7855 Increment,
7856 Decrement,
7857 True,
7858 False,
7860 // Unary and Binary operators
7861 Addition,
7862 Subtraction,
7864 UnaryPlus,
7865 UnaryNegation,
7867 // Binary operators
7868 Multiply,
7869 Division,
7870 Modulus,
7871 BitwiseAnd,
7872 BitwiseOr,
7873 ExclusiveOr,
7874 LeftShift,
7875 RightShift,
7876 Equality,
7877 Inequality,
7878 GreaterThan,
7879 LessThan,
7880 GreaterThanOrEqual,
7881 LessThanOrEqual,
7883 // Implicit and Explicit
7884 Implicit,
7885 Explicit,
7887 // Just because of enum
7888 TOP
7889 };
7898 {
7901 }
7904 {
7908 }
7911 }
7914 {
7923 }
7924 }
7934 }
7935 }
7938 }
7941 {
7944 Report.Error (558, Location, "User-defined operator `{0}' must be declared static and public", GetSignatureForError ());
7946 }
7948 // imlicit and explicit operator of same types are not allowed
7958 }
7964 // Rules for conversion operators
7969 "User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type");
7971 }
7981 }
7984 Report.Error (552, Location, "User-defined conversion `{0}' cannot convert to or from an interface type",
7987 }
7990 if (declaring_type.IsSubclassOf (return_type) || declaring_type.IsSubclassOf (first_arg_type)) {
7991 Report.Error (553, Location, "User-defined conversion `{0}' cannot convert to or from base class",
7994 }
7995 Report.Error (554, Location, "User-defined conversion `{0}' cannot convert to or from derived class",
7998 }
8001 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");
8003 }
8005 // Checks for Unary operators
8008 if (return_type != declaring_type && !TypeManager.IsSubclassOf (return_type, declaring_type)) {
8010 "The return type for ++ or -- operator must be the containing type or derived from the containing type");
8012 }
8017 }
8018 }
8026 }
8035 }
8036 }
8039 // Checks for Binary operators
8048 }
8049 }
8052 }
8055 {
8061 }
8064 {
8069 //
8070 // abstract or extern methods have no bodies
8071 //
8075 EmitContext ec;
8078 else
8088 }
8090 // Operator cannot be override
8092 {
8094 }
8097 {
8152 }
8153 }
8156 {
8161 }
8166 }
8167 }
8169 }
8172 {
8175 sb.AppendFormat ("{0}.{1} operator {2}", Parent.GetSignatureForError (), GetName (OperatorType), Type.Type == null ? Type.ToString () : TypeManager.CSharpName (Type.Type));
8176 }
8179 }
8183 }
8184 }
8186 //
8187 // This is used to compare method signatures
8188 //
8194 /// <summary>
8195 /// This delegate is used to extract methods which have the
8196 /// same signature as the argument
8197 /// </summary>
8198 public static MemberFilter method_signature_filter = new MemberFilter (MemberSignatureCompare);
8201 {
8207 else
8209 }
8212 {
8220 }
8222 }
8225 }
8228 {
8230 }
8233 {
8246 }
8260 }
8263 {
8269 Type ReturnType;
8277 else
8280 //
8281 // we use sig.RetType == null to mean `do not check the
8282 // method return value.
8283 //
8291 else
8299 i--;
8302 }
8304 }
8305 }
8306 }