mcs/mcs/field.cs

   1 //
   2 // field.cs: All field 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 // Dual licensed under the terms of the MIT X11 or GNU GPL
   9 //
  10 // Copyright 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
  11 // Copyright 2004-2008 Novell, Inc
  12 // Copyright 2011 Xamarin Inc
  13 //
  14
  15 using System;
  16 using System.Collections.Generic;
  17 using System.Runtime.InteropServices;
  18
  19 #if STATIC
  20 using MetaType = IKVM.Reflection.Type;
  21 using IKVM.Reflection;
  22 using IKVM.Reflection.Emit;
  23 #else
  24 using MetaType = System.Type;
  25 using System.Reflection;
  26 using System.Reflection.Emit;
  27 #endif
  28
  29 namespace Mono.CSharp
  30 {
  31         public class FieldDeclarator
  32         {
  33                 public FieldDeclarator (SimpleMemberName name, Expression initializer)
  34                 {
  35                         this.Name = name;
  36                         this.Initializer = initializer;
  37                 }
  38
  39                 #region Properties
  40
  41                 public SimpleMemberName Name { get; private set; }
  42                 public Expression Initializer { get; private set; }
  43
  44                 #endregion
  45
  46                 public virtual FullNamedExpression GetFieldTypeExpression (FieldBase field)
  47                 {
  48                         return new TypeExpression (field.MemberType, Name.Location);
  49                 }
  50         }
  51
  52         //
  53         // Abstract class for all fields
  54         //
  55         abstract public class FieldBase : MemberBase
  56         {
  57                 protected FieldBuilder FieldBuilder;
  58                 protected FieldSpec spec;
  59                 public Status status;
  60                 protected Expression initializer;
  61                 protected List<FieldDeclarator> declarators;
  62
  63                 [Flags]
  64                 public enum Status : byte {
  65                         HAS_OFFSET = 4          // Used by FieldMember.
  66                 }
  67
  68                 static readonly string[] attribute_targets = new string [] { "field" };
  69
  70                 protected FieldBase (TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs)
  71                         : base (parent, type, mod, allowed_mod | Modifiers.ABSTRACT, Modifiers.PRIVATE, name, attrs)
  72                 {
  73                         if ((mod & Modifiers.ABSTRACT) != 0)
  74                                 Report.Error (681, Location, "The modifier 'abstract' is not valid on fields. Try using a property instead");
  75                 }
  76
  77                 #region Properties
  78
  79                 public override AttributeTargets AttributeTargets {
  80                         get {
  81                                 return AttributeTargets.Field;
  82                         }
  83                 }
  84
  85                 public List<FieldDeclarator> Declarators {
  86                         get {
  87                                 return this.declarators;
  88                         }
  89                 }
  90
  91                 public Expression Initializer {
  92                         get {
  93                                 return initializer;
  94                         }
  95                         set {
  96                                 this.initializer = value;
  97                         }
  98                 }
  99
 100                 public string Name {
 101                         get {
 102                                 return MemberName.Name;
 103                         }
 104                 }
 105
 106                 public FieldSpec Spec {
 107                         get {
 108                                 return spec;
 109                         }
 110                 }
 111
 112                 public override string[] ValidAttributeTargets  {
 113                         get {
 114                                 return attribute_targets;
 115                         }
 116                 }
 117
 118                 #endregion
 119
 120                 public void AddDeclarator (FieldDeclarator declarator)
 121                 {
 122                         if (declarators == null)
 123                                 declarators = new List<FieldDeclarator> (2);
 124
 125                         declarators.Add (declarator);
 126
 127                         Parent.AddNameToContainer (this, declarator.Name.Value);
 128                 }
 129
 130                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
 131                 {
 132                         if (a.Type == pa.FieldOffset) {
 133                                 status |= Status.HAS_OFFSET;
 134
 135                                 if (!Parent.PartialContainer.HasExplicitLayout) {
 136                                         Report.Error (636, Location, "The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit)");
 137                                         return;
 138                                 }
 139
 140                                 if ((ModFlags & Modifiers.STATIC) != 0 || this is Const) {
 141                                         Report.Error (637, Location, "The FieldOffset attribute is not allowed on static or const fields");
 142                                         return;
 143                                 }
 144                         }
 145
 146                         if (a.Type == pa.FixedBuffer) {
 147                                 Report.Error (1716, Location, "Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead");
 148                                 return;
 149                         }
 150
 151 #if false
 152                         if (a.Type == pa.MarshalAs) {
 153                                 UnmanagedMarshal marshal = a.GetMarshal (this);
 154                                 if (marshal != null) {
 155                                         FieldBuilder.SetMarshal (marshal);
 156                                 }
 157                                 return;
 158                         }
 159 #endif
 160                         if ((a.HasSecurityAttribute)) {
 161                                 a.Error_InvalidSecurityParent ();
 162                                 return;
 163                         }
 164
 165                         if (a.Type == pa.Dynamic) {
 166                                 a.Error_MisusedDynamicAttribute ();
 167                                 return;
 168                         }
 169
 170                         FieldBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), cdata);
 171                 }
 172
 173                 public void SetCustomAttribute (MethodSpec ctor, byte[] data)
 174                 {
 175                         FieldBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), data);
 176                 }
 177
 178                 protected override bool CheckBase ()
 179                 {
 180                         if (!base.CheckBase ())
 181                                 return false;
 182
 183                         MemberSpec candidate;
 184                         bool overrides = false;
 185                         var conflict_symbol = MemberCache.FindBaseMember (this, out candidate, ref overrides);
 186                         if (conflict_symbol == null)
 187                                 conflict_symbol = candidate;
 188
 189                         if (conflict_symbol == null) {
 190                                 if ((ModFlags & Modifiers.NEW) != 0) {
 191                                         Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required",
 192                                                 GetSignatureForError ());
 193                                 }
 194                         } else {
 195                                 if ((ModFlags & (Modifiers.NEW | Modifiers.OVERRIDE | Modifiers.BACKING_FIELD)) == 0) {
 196                                         Report.SymbolRelatedToPreviousError (conflict_symbol);
 197                                         Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
 198                                                 GetSignatureForError (), conflict_symbol.GetSignatureForError ());
 199                                 }
 200
 201                                 if (conflict_symbol.IsAbstract) {
 202                                         Report.SymbolRelatedToPreviousError (conflict_symbol);
 203                                         Report.Error (533, Location, "`{0}' hides inherited abstract member `{1}'",
 204                                                 GetSignatureForError (), conflict_symbol.GetSignatureForError ());
 205                                 }
 206                         }
 207
 208                         return true;
 209                 }
 210
 211                 public virtual Constant ConvertInitializer (ResolveContext rc, Constant expr)
 212                 {
 213                         return expr.ConvertImplicitly (MemberType);
 214                 }
 215
 216                 protected override void DoMemberTypeDependentChecks ()
 217                 {
 218                         base.DoMemberTypeDependentChecks ();
 219
 220                         if (MemberType.IsGenericParameter)
 221                                 return;
 222
 223                         if (MemberType.IsStatic)
 224                                 Error_VariableOfStaticClass (Location, GetSignatureForError (), MemberType, Report);
 225
 226                         CheckBase ();
 227                         IsTypePermitted ();
 228                 }
 229
 230                 //
 231                 //   Represents header string for documentation comment.
 232                 //
 233                 public override string DocCommentHeader {
 234                         get { return "F:"; }
 235                 }
 236
 237                 public override void Emit ()
 238                 {
 239                         if (member_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
 240                                 Module.PredefinedAttributes.Dynamic.EmitAttribute (FieldBuilder);
 241                         } else if (!Parent.IsCompilerGenerated && member_type.HasDynamicElement) {
 242                                 Module.PredefinedAttributes.Dynamic.EmitAttribute (FieldBuilder, member_type, Location);
 243                         }
 244
 245                         if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated)
 246                                 Module.PredefinedAttributes.CompilerGenerated.EmitAttribute (FieldBuilder);
 247                         if ((ModFlags & Modifiers.DEBUGGER_HIDDEN) != 0)
 248                                 Module.PredefinedAttributes.DebuggerBrowsable.EmitAttribute (FieldBuilder, System.Diagnostics.DebuggerBrowsableState.Never);
 249
 250                         if (OptAttributes != null) {
 251                                 OptAttributes.Emit ();
 252                         }
 253
 254                         if (((status & Status.HAS_OFFSET) == 0) && (ModFlags & (Modifiers.STATIC | Modifiers.BACKING_FIELD)) == 0 && Parent.PartialContainer.HasExplicitLayout) {
 255                                 Report.Error (625, Location, "`{0}': Instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute", GetSignatureForError ());
 256                         }
 257
 258                         ConstraintChecker.Check (this, member_type, type_expr.Location);
 259
 260                         base.Emit ();
 261                 }
 262
 263                 public static void Error_VariableOfStaticClass (Location loc, string variable_name, TypeSpec static_class, Report Report)
 264                 {
 265                         Report.SymbolRelatedToPreviousError (static_class);
 266                         Report.Error (723, loc, "`{0}': cannot declare variables of static types",
 267                                 variable_name);
 268                 }
 269
 270                 protected override bool VerifyClsCompliance ()
 271                 {
 272                         if (!base.VerifyClsCompliance ())
 273                                 return false;
 274
 275                         if (!MemberType.IsCLSCompliant () || this is FixedField) {
 276                                 Report.Warning (3003, 1, Location, "Type of `{0}' is not CLS-compliant",
 277                                         GetSignatureForError ());
 278                         }
 279                         return true;
 280                 }
 281         }
 282
 283         //
 284         // Field specification
 285         //
 286         public class FieldSpec : MemberSpec, IInterfaceMemberSpec
 287         {
 288                 FieldInfo metaInfo;
 289                 TypeSpec memberType;
 290
 291                 public FieldSpec (TypeSpec declaringType, IMemberDefinition definition, TypeSpec memberType, FieldInfo info, Modifiers modifiers)
 292                         : base (MemberKind.Field, declaringType, definition, modifiers)
 293                 {
 294                         this.metaInfo = info;
 295                         this.memberType = memberType;
 296                 }
 297
 298                 #region Properties
 299
 300                 public bool IsReadOnly {
 301                         get {
 302                                 return (Modifiers & Modifiers.READONLY) != 0;
 303                         }
 304                 }
 305
 306                 public TypeSpec MemberType {
 307                         get {
 308                                 return memberType;
 309                         }
 310                 }
 311
 312 #endregion
 313
 314                 public FieldInfo GetMetaInfo ()
 315                 {
 316                         if ((state & StateFlags.PendingMetaInflate) != 0) {
 317                                 var decl_meta = DeclaringType.GetMetaInfo ();
 318                                 if (DeclaringType.IsTypeBuilder) {
 319                                         metaInfo = TypeBuilder.GetField (decl_meta, metaInfo);
 320                                 } else {
 321                                         var orig_token = metaInfo.MetadataToken;
 322                                         metaInfo = decl_meta.GetField (Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
 323                                         if (metaInfo.MetadataToken != orig_token)
 324                                                 throw new NotImplementedException ("Resolved to wrong meta token");
 325
 326                                         // What a stupid API, does not work because field handle is imported
 327                                         // metaInfo = FieldInfo.GetFieldFromHandle (metaInfo.FieldHandle, DeclaringType.MetaInfo.TypeHandle);
 328                                 }
 329
 330                                 state &= ~StateFlags.PendingMetaInflate;
 331                         }
 332
 333                         return metaInfo;
 334                 }
 335
 336                 public override MemberSpec InflateMember (TypeParameterInflator inflator)
 337                 {
 338                         var fs = (FieldSpec) base.InflateMember (inflator);
 339                         fs.memberType = inflator.Inflate (memberType);
 340                         return fs;
 341                 }
 342
 343                 public FieldSpec Mutate (TypeParameterMutator mutator)
 344                 {
 345                         var decl = DeclaringType;
 346                         if (DeclaringType.IsGenericOrParentIsGeneric)
 347                                 decl = mutator.Mutate (decl);
 348
 349                         if (decl == DeclaringType)
 350                                 return this;
 351
 352                         var fs = (FieldSpec) MemberwiseClone ();
 353                         fs.declaringType = decl;
 354                         fs.state |= StateFlags.PendingMetaInflate;
 355
 356                         // Gets back FieldInfo in case of metaInfo was inflated
 357                         fs.metaInfo = MemberCache.GetMember (TypeParameterMutator.GetMemberDeclaringType (DeclaringType), this).metaInfo;
 358                         return fs;
 359                 }
 360
 361                 public override List<MissingTypeSpecReference> ResolveMissingDependencies (MemberSpec caller)
 362                 {
 363                         return memberType.ResolveMissingDependencies (this);
 364                 }
 365         }
 366
 367         /// <summary>
 368         /// Fixed buffer implementation
 369         /// </summary>
 370         public class FixedField : FieldBase
 371         {
 372                 public const string FixedElementName = "FixedElementField";
 373                 static int GlobalCounter;
 374
 375                 TypeBuilder fixed_buffer_type;
 376
 377                 const Modifiers AllowedModifiers =
 378                         Modifiers.NEW |
 379                         Modifiers.PUBLIC |
 380                         Modifiers.PROTECTED |
 381                         Modifiers.INTERNAL |
 382                         Modifiers.PRIVATE |
 383                         Modifiers.UNSAFE;
 384
 385                 public FixedField (TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs)
 386                         : base (parent, type, mod, AllowedModifiers, name, attrs)
 387                 {
 388                 }
 389
 390                 #region Properties
 391
 392                 //
 393                 // Explicit struct layout set by parent
 394                 //
 395                 public CharSet? CharSet {
 396                         get; set;
 397                 }
 398
 399                 #endregion
 400
 401                 public override Constant ConvertInitializer (ResolveContext rc, Constant expr)
 402                 {
 403                         return expr.ImplicitConversionRequired (rc, rc.BuiltinTypes.Int);
 404                 }
 405
 406                 public override bool Define ()
 407                 {
 408                         if (!base.Define ())
 409                                 return false;
 410
 411                         if (!BuiltinTypeSpec.IsPrimitiveType (MemberType)) {
 412                                 Report.Error (1663, Location,
 413                                         "`{0}': Fixed size buffers type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double",
 414                                         GetSignatureForError ());
 415                         } else if (declarators != null) {
 416                                 foreach (var d in declarators) {
 417                                         var f = new FixedField (Parent, d.GetFieldTypeExpression (this), ModFlags, new MemberName (d.Name.Value, d.Name.Location), OptAttributes);
 418                                         f.initializer = d.Initializer;
 419                                         ((ConstInitializer) f.initializer).Name = d.Name.Value;
 420                                         f.Define ();
 421                                         Parent.PartialContainer.Members.Add (f);
 422                                 }
 423                         }
 424
 425                         // Create nested fixed buffer container
 426                         string name = String.Format ("<{0}>__FixedBuffer{1}", Name, GlobalCounter++);
 427                         fixed_buffer_type = Parent.TypeBuilder.DefineNestedType (name,
 428                                 TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit,
 429                                 Compiler.BuiltinTypes.ValueType.GetMetaInfo ());
 430
 431                         var ffield = fixed_buffer_type.DefineField (FixedElementName, MemberType.GetMetaInfo (), FieldAttributes.Public);
 432
 433                         FieldBuilder = Parent.TypeBuilder.DefineField (Name, fixed_buffer_type, ModifiersExtensions.FieldAttr (ModFlags));
 434
 435                         var element_spec = new FieldSpec (null, this, MemberType, ffield, ModFlags);
 436                         spec = new FixedFieldSpec (Module, Parent.Definition, this, FieldBuilder, element_spec, ModFlags);
 437
 438                         Parent.MemberCache.AddMember (spec);
 439                         return true;
 440                 }
 441
 442                 protected override void DoMemberTypeIndependentChecks ()
 443                 {
 444                         base.DoMemberTypeIndependentChecks ();
 445
 446                         if (!IsUnsafe)
 447                                 Expression.UnsafeError (Report, Location);
 448
 449                         if (Parent.PartialContainer.Kind != MemberKind.Struct) {
 450                                 Report.Error (1642, Location, "`{0}': Fixed size buffer fields may only be members of structs",
 451                                         GetSignatureForError ());
 452                         }
 453                 }
 454
 455                 public override void Emit()
 456                 {
 457                         ResolveContext rc = new ResolveContext (this);
 458                         IntConstant buffer_size_const = initializer.Resolve (rc) as IntConstant;
 459                         if (buffer_size_const == null)
 460                                 return;
 461
 462                         int buffer_size = buffer_size_const.Value;
 463
 464                         if (buffer_size <= 0) {
 465                                 Report.Error (1665, Location, "`{0}': Fixed size buffers must have a length greater than zero", GetSignatureForError ());
 466                                 return;
 467                         }
 468
 469                         EmitFieldSize (buffer_size);
 470
 471 #if STATIC
 472                         if (Module.HasDefaultCharSet)
 473                                 fixed_buffer_type.__SetAttributes (fixed_buffer_type.Attributes | Module.DefaultCharSetType);
 474 #endif
 475
 476                         Module.PredefinedAttributes.UnsafeValueType.EmitAttribute (fixed_buffer_type);
 477                         Module.PredefinedAttributes.CompilerGenerated.EmitAttribute (fixed_buffer_type);
 478                         fixed_buffer_type.CreateType ();
 479
 480                         base.Emit ();
 481                 }
 482
 483                 void EmitFieldSize (int buffer_size)
 484                 {
 485                         int type_size = BuiltinTypeSpec.GetSize (MemberType);
 486
 487                         if (buffer_size > int.MaxValue / type_size) {
 488                                 Report.Error (1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
 489                                         GetSignatureForError (), buffer_size.ToString (), MemberType.GetSignatureForError ());
 490                                 return;
 491                         }
 492
 493                         AttributeEncoder encoder;
 494
 495                         var ctor = Module.PredefinedMembers.StructLayoutAttributeCtor.Resolve (Location);
 496                         if (ctor == null)
 497                                 return;
 498
 499                         var field_size = Module.PredefinedMembers.StructLayoutSize.Resolve (Location);
 500                         var field_charset = Module.PredefinedMembers.StructLayoutCharSet.Resolve (Location);
 501                         if (field_size == null || field_charset == null)
 502                                 return;
 503
 504                         var char_set = CharSet ?? Module.DefaultCharSet ?? 0;
 505
 506                         encoder = new AttributeEncoder ();
 507                         encoder.Encode ((short)LayoutKind.Sequential);
 508                         encoder.EncodeNamedArguments (
 509                                 new [] { field_size, field_charset },
 510                                 new Constant [] {
 511                                         new IntConstant (Compiler.BuiltinTypes, buffer_size * type_size, Location),
 512                                         new IntConstant (Compiler.BuiltinTypes, (int) char_set, Location)
 513                                 }
 514                         );
 515
 516                         fixed_buffer_type.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
 517
 518                         //
 519                         // Don't emit FixedBufferAttribute attribute for private types
 520                         //
 521                         if ((ModFlags & Modifiers.PRIVATE) != 0)
 522                                 return;
 523
 524                         ctor = Module.PredefinedMembers.FixedBufferAttributeCtor.Resolve (Location);
 525                         if (ctor == null)
 526                                 return;
 527
 528                         encoder = new AttributeEncoder ();
 529                         encoder.EncodeTypeName (MemberType);
 530                         encoder.Encode (buffer_size);
 531                         encoder.EncodeEmptyNamedArguments ();
 532
 533                         FieldBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
 534                 }
 535         }
 536
 537         class FixedFieldSpec : FieldSpec
 538         {
 539                 readonly FieldSpec element;
 540
 541                 public FixedFieldSpec (ModuleContainer module, TypeSpec declaringType, IMemberDefinition definition, FieldInfo info, FieldSpec element, Modifiers modifiers)
 542                         : base (declaringType, definition, PointerContainer.MakeType (module, element.MemberType), info, modifiers)
 543                 {
 544                         this.element = element;
 545
 546                         // It's never CLS-Compliant
 547                         state &= ~StateFlags.CLSCompliant_Undetected;
 548                 }
 549
 550                 public FieldSpec Element {
 551                         get {
 552                                 return element;
 553                         }
 554                 }
 555
 556                 public TypeSpec ElementType {
 557                         get {
 558                                 return element.MemberType;
 559                         }
 560                 }
 561         }
 562
 563         //
 564         // The Field class is used to represents class/struct fields during parsing.
 565         //
 566         public class Field : FieldBase {
 567                 // <summary>
 568                 //   Modifiers allowed in a class declaration
 569                 // </summary>
 570                 const Modifiers AllowedModifiers =
 571                         Modifiers.NEW |
 572                         Modifiers.PUBLIC |
 573                         Modifiers.PROTECTED |
 574                         Modifiers.INTERNAL |
 575                         Modifiers.PRIVATE |
 576                         Modifiers.STATIC |
 577                         Modifiers.VOLATILE |
 578                         Modifiers.UNSAFE |
 579                         Modifiers.READONLY;
 580
 581                 public Field (TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs)
 582                         : base (parent, type, mod, AllowedModifiers, name, attrs)
 583                 {
 584                 }
 585
 586                 bool CanBeVolatile ()
 587                 {
 588                         switch (MemberType.BuiltinType) {
 589                         case BuiltinTypeSpec.Type.Bool:
 590                         case BuiltinTypeSpec.Type.Char:
 591                         case BuiltinTypeSpec.Type.SByte:
 592                         case BuiltinTypeSpec.Type.Byte:
 593                         case BuiltinTypeSpec.Type.Short:
 594                         case BuiltinTypeSpec.Type.UShort:
 595                         case BuiltinTypeSpec.Type.Int:
 596                         case BuiltinTypeSpec.Type.UInt:
 597                         case BuiltinTypeSpec.Type.Float:
 598                         case BuiltinTypeSpec.Type.UIntPtr:
 599                         case BuiltinTypeSpec.Type.IntPtr:
 600                                 return true;
 601                         }
 602
 603                         if (TypeSpec.IsReferenceType (MemberType))
 604                                 return true;
 605
 606                         if (MemberType.IsEnum)
 607                                 return true;
 608
 609                         return false;
 610                 }
 611
 612                 public override void Accept (StructuralVisitor visitor)
 613                 {
 614                         visitor.Visit (this);
 615                 }
 616
 617                 public override bool Define ()
 618                 {
 619                         if (!base.Define ())
 620                                 return false;
 621
 622                         MetaType[] required_modifier = null;
 623                         if ((ModFlags & Modifiers.VOLATILE) != 0) {
 624                                 var mod = Module.PredefinedTypes.IsVolatile.Resolve ();
 625                                 if (mod != null)
 626                                         required_modifier = new MetaType[] { mod.GetMetaInfo () };
 627                         }
 628
 629                         FieldBuilder = Parent.TypeBuilder.DefineField (
 630                                 Name, member_type.GetMetaInfo (), required_modifier, null, ModifiersExtensions.FieldAttr (ModFlags));
 631
 632                         spec = new FieldSpec (Parent.Definition, this, MemberType, FieldBuilder, ModFlags);
 633
 634                         //
 635                         // Don't cache inaccessible fields except for struct where we
 636                         // need them for definitive assignment checks
 637                         //
 638                         if ((ModFlags & Modifiers.BACKING_FIELD) == 0 || Parent.Kind == MemberKind.Struct) {
 639                                 Parent.MemberCache.AddMember (spec);
 640                         }
 641
 642                         if (initializer != null) {
 643                                 Parent.RegisterFieldForInitialization (this, new FieldInitializer (this, initializer, TypeExpression.Location));
 644                         }
 645
 646                         if (declarators != null) {
 647                                 foreach (var d in declarators) {
 648                                         var f = new Field (Parent, d.GetFieldTypeExpression (this), ModFlags, new MemberName (d.Name.Value, d.Name.Location), OptAttributes);
 649                                         if (d.Initializer != null)
 650                                                 f.initializer = d.Initializer;
 651
 652                                         f.Define ();
 653                                         Parent.PartialContainer.Members.Add (f);
 654                                 }
 655                         }
 656
 657                         return true;
 658                 }
 659
 660                 protected override void DoMemberTypeDependentChecks ()
 661                 {
 662                         if ((ModFlags & Modifiers.BACKING_FIELD) != 0)
 663                                 return;
 664
 665                         base.DoMemberTypeDependentChecks ();
 666
 667                         if ((ModFlags & Modifiers.VOLATILE) != 0) {
 668                                 if (!CanBeVolatile ()) {
 669                                         Report.Error (677, Location, "`{0}': A volatile field cannot be of the type `{1}'",
 670                                                 GetSignatureForError (), MemberType.GetSignatureForError ());
 671                                 }
 672
 673                                 if ((ModFlags & Modifiers.READONLY) != 0) {
 674                                         Report.Error (678, Location, "`{0}': A field cannot be both volatile and readonly",
 675                                                 GetSignatureForError ());
 676                                 }
 677                         }
 678                 }
 679
 680                 protected override bool VerifyClsCompliance ()
 681                 {
 682                         if (!base.VerifyClsCompliance ())
 683                                 return false;
 684
 685                         if ((ModFlags & Modifiers.VOLATILE) != 0) {
 686                                 Report.Warning (3026, 1, Location, "CLS-compliant field `{0}' cannot be volatile", GetSignatureForError ());
 687                         }
 688
 689                         return true;
 690                 }
 691         }
 692
 693         class PrimaryConstructorField : Field
 694         {
 695                 //
 696                 // Proxy resolved parameter type expression to avoid type double resolve
 697                 // and problems with correct resolve context on partial classes
 698                 //
 699                 sealed class TypeExpressionFromParameter : TypeExpr
 700                 {
 701                         Parameter parameter;
 702
 703                         public TypeExpressionFromParameter (Parameter parameter)
 704                         {
 705                                 this.parameter = parameter;
 706                                 eclass = ExprClass.Type;
 707                                 loc = parameter.Location;
 708                         }
 709
 710                         public override TypeSpec ResolveAsType (IMemberContext mc)
 711                         {
 712                                 return parameter.Type;
 713                         }
 714                 }
 715
 716                 public PrimaryConstructorField (TypeDefinition parent, Parameter parameter)
 717                         : base (parent, new TypeExpressionFromParameter (parameter), Modifiers.PRIVATE, new MemberName (parameter.Name, parameter.Location), null)
 718                 {
 719                         caching_flags |= Flags.IsUsed | Flags.IsAssigned;
 720                 }
 721
 722                 public override string GetSignatureForError ()
 723                 {
 724                         return MemberName.Name;
 725                 }
 726         }
 727 }