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                         if (!IsCompilerGenerated)
 227                                 CheckBase ();
 228
 229                         IsTypePermitted ();
 230                 }
 231
 232                 //
 233                 //   Represents header string for documentation comment.
 234                 //
 235                 public override string DocCommentHeader {
 236                         get { return "F:"; }
 237                 }
 238
 239                 public override void Emit ()
 240                 {
 241                         if (member_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
 242                                 Module.PredefinedAttributes.Dynamic.EmitAttribute (FieldBuilder);
 243                         } else if (!Parent.IsCompilerGenerated && member_type.HasDynamicElement) {
 244                                 Module.PredefinedAttributes.Dynamic.EmitAttribute (FieldBuilder, member_type, Location);
 245                         }
 246
 247                         if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated)
 248                                 Module.PredefinedAttributes.CompilerGenerated.EmitAttribute (FieldBuilder);
 249                         if ((ModFlags & Modifiers.DEBUGGER_HIDDEN) != 0)
 250                                 Module.PredefinedAttributes.DebuggerBrowsable.EmitAttribute (FieldBuilder, System.Diagnostics.DebuggerBrowsableState.Never);
 251
 252                         if (OptAttributes != null) {
 253                                 OptAttributes.Emit ();
 254                         }
 255
 256                         if (((status & Status.HAS_OFFSET) == 0) && (ModFlags & (Modifiers.STATIC | Modifiers.BACKING_FIELD)) == 0 && Parent.PartialContainer.HasExplicitLayout) {
 257                                 Report.Error (625, Location, "`{0}': Instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute", GetSignatureForError ());
 258                         }
 259
 260                         ConstraintChecker.Check (this, member_type, type_expr.Location);
 261
 262                         base.Emit ();
 263                 }
 264
 265                 public static void Error_VariableOfStaticClass (Location loc, string variable_name, TypeSpec static_class, Report Report)
 266                 {
 267                         Report.SymbolRelatedToPreviousError (static_class);
 268                         Report.Error (723, loc, "`{0}': cannot declare variables of static types",
 269                                 variable_name);
 270                 }
 271
 272                 protected override bool VerifyClsCompliance ()
 273                 {
 274                         if (!base.VerifyClsCompliance ())
 275                                 return false;
 276
 277                         if (!MemberType.IsCLSCompliant () || this is FixedField) {
 278                                 Report.Warning (3003, 1, Location, "Type of `{0}' is not CLS-compliant",
 279                                         GetSignatureForError ());
 280                         }
 281                         return true;
 282                 }
 283         }
 284
 285         //
 286         // Field specification
 287         //
 288         public class FieldSpec : MemberSpec, IInterfaceMemberSpec
 289         {
 290                 FieldInfo metaInfo;
 291                 TypeSpec memberType;
 292
 293                 public FieldSpec (TypeSpec declaringType, IMemberDefinition definition, TypeSpec memberType, FieldInfo info, Modifiers modifiers)
 294                         : base (MemberKind.Field, declaringType, definition, modifiers)
 295                 {
 296                         this.metaInfo = info;
 297                         this.memberType = memberType;
 298                 }
 299
 300                 #region Properties
 301
 302                 public bool IsReadOnly {
 303                         get {
 304                                 return (Modifiers & Modifiers.READONLY) != 0;
 305                         }
 306                 }
 307
 308                 public TypeSpec MemberType {
 309                         get {
 310                                 return memberType;
 311                         }
 312                 }
 313
 314 #endregion
 315
 316                 public FieldInfo GetMetaInfo ()
 317                 {
 318                         if ((state & StateFlags.PendingMetaInflate) != 0) {
 319                                 var decl_meta = DeclaringType.GetMetaInfo ();
 320                                 if (DeclaringType.IsTypeBuilder) {
 321                                         metaInfo = TypeBuilder.GetField (decl_meta, metaInfo);
 322                                 } else {
 323                                         var orig_token = metaInfo.MetadataToken;
 324                                         metaInfo = decl_meta.GetField (Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
 325                                         if (metaInfo.MetadataToken != orig_token)
 326                                                 throw new NotImplementedException ("Resolved to wrong meta token");
 327
 328                                         // What a stupid API, does not work because field handle is imported
 329                                         // metaInfo = FieldInfo.GetFieldFromHandle (metaInfo.FieldHandle, DeclaringType.MetaInfo.TypeHandle);
 330                                 }
 331
 332                                 state &= ~StateFlags.PendingMetaInflate;
 333                         }
 334
 335                         return metaInfo;
 336                 }
 337
 338                 public override MemberSpec InflateMember (TypeParameterInflator inflator)
 339                 {
 340                         var fs = (FieldSpec) base.InflateMember (inflator);
 341                         fs.memberType = inflator.Inflate (memberType);
 342                         return fs;
 343                 }
 344
 345                 public FieldSpec Mutate (TypeParameterMutator mutator)
 346                 {
 347                         var decl = DeclaringType;
 348                         if (DeclaringType.IsGenericOrParentIsGeneric)
 349                                 decl = mutator.Mutate (decl);
 350
 351                         if (decl == DeclaringType)
 352                                 return this;
 353
 354                         var fs = (FieldSpec) MemberwiseClone ();
 355                         fs.declaringType = decl;
 356                         fs.state |= StateFlags.PendingMetaInflate;
 357
 358                         // Gets back FieldInfo in case of metaInfo was inflated
 359                         fs.metaInfo = MemberCache.GetMember (TypeParameterMutator.GetMemberDeclaringType (DeclaringType), this).metaInfo;
 360                         return fs;
 361                 }
 362
 363                 public override List<MissingTypeSpecReference> ResolveMissingDependencies (MemberSpec caller)
 364                 {
 365                         return memberType.ResolveMissingDependencies (this);
 366                 }
 367         }
 368
 369         /// <summary>
 370         /// Fixed buffer implementation
 371         /// </summary>
 372         public class FixedField : FieldBase
 373         {
 374                 public const string FixedElementName = "FixedElementField";
 375                 static int GlobalCounter;
 376
 377                 TypeBuilder fixed_buffer_type;
 378
 379                 const Modifiers AllowedModifiers =
 380                         Modifiers.NEW |
 381                         Modifiers.PUBLIC |
 382                         Modifiers.PROTECTED |
 383                         Modifiers.INTERNAL |
 384                         Modifiers.PRIVATE |
 385                         Modifiers.UNSAFE;
 386
 387                 public FixedField (TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs)
 388                         : base (parent, type, mod, AllowedModifiers, name, attrs)
 389                 {
 390                 }
 391
 392                 #region Properties
 393
 394                 //
 395                 // Explicit struct layout set by parent
 396                 //
 397                 public CharSet? CharSet {
 398                         get; set;
 399                 }
 400
 401                 #endregion
 402
 403                 public override Constant ConvertInitializer (ResolveContext rc, Constant expr)
 404                 {
 405                         return expr.ImplicitConversionRequired (rc, rc.BuiltinTypes.Int);
 406                 }
 407
 408                 public override bool Define ()
 409                 {
 410                         if (!base.Define ())
 411                                 return false;
 412
 413                         if (!BuiltinTypeSpec.IsPrimitiveType (MemberType)) {
 414                                 Report.Error (1663, Location,
 415                                         "`{0}': Fixed size buffers type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double",
 416                                         GetSignatureForError ());
 417                         } else if (declarators != null) {
 418                                 foreach (var d in declarators) {
 419                                         var f = new FixedField (Parent, d.GetFieldTypeExpression (this), ModFlags, new MemberName (d.Name.Value, d.Name.Location), OptAttributes);
 420                                         f.initializer = d.Initializer;
 421                                         ((ConstInitializer) f.initializer).Name = d.Name.Value;
 422                                         f.Define ();
 423                                         Parent.PartialContainer.Members.Add (f);
 424                                 }
 425                         }
 426
 427                         // Create nested fixed buffer container
 428                         string name = String.Format ("<{0}>__FixedBuffer{1}", TypeDefinition.FilterNestedName (Name), GlobalCounter++);
 429                         fixed_buffer_type = Parent.TypeBuilder.DefineNestedType (name,
 430                                 TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit,
 431                                 Compiler.BuiltinTypes.ValueType.GetMetaInfo ());
 432
 433                         var ffield = fixed_buffer_type.DefineField (FixedElementName, MemberType.GetMetaInfo (), FieldAttributes.Public);
 434
 435                         FieldBuilder = Parent.TypeBuilder.DefineField (Name, fixed_buffer_type, ModifiersExtensions.FieldAttr (ModFlags));
 436
 437                         var element_spec = new FieldSpec (null, this, MemberType, ffield, ModFlags);
 438                         spec = new FixedFieldSpec (Module, Parent.Definition, this, FieldBuilder, element_spec, ModFlags);
 439
 440                         Parent.MemberCache.AddMember (spec);
 441                         return true;
 442                 }
 443
 444                 protected override void DoMemberTypeIndependentChecks ()
 445                 {
 446                         base.DoMemberTypeIndependentChecks ();
 447
 448                         if (!IsUnsafe)
 449                                 Expression.UnsafeError (Report, Location);
 450
 451                         if (Parent.PartialContainer.Kind != MemberKind.Struct) {
 452                                 Report.Error (1642, Location, "`{0}': Fixed size buffer fields may only be members of structs",
 453                                         GetSignatureForError ());
 454                         }
 455                 }
 456
 457                 public override void Emit()
 458                 {
 459                         ResolveContext rc = new ResolveContext (this);
 460                         IntConstant buffer_size_const = initializer.Resolve (rc) as IntConstant;
 461                         if (buffer_size_const == null)
 462                                 return;
 463
 464                         int buffer_size = buffer_size_const.Value;
 465
 466                         if (buffer_size <= 0) {
 467                                 Report.Error (1665, Location, "`{0}': Fixed size buffers must have a length greater than zero", GetSignatureForError ());
 468                                 return;
 469                         }
 470
 471                         EmitFieldSize (buffer_size);
 472
 473 #if STATIC
 474                         if (Module.HasDefaultCharSet)
 475                                 fixed_buffer_type.__SetAttributes (fixed_buffer_type.Attributes | Module.DefaultCharSetType);
 476 #endif
 477
 478                         Module.PredefinedAttributes.UnsafeValueType.EmitAttribute (fixed_buffer_type);
 479                         Module.PredefinedAttributes.CompilerGenerated.EmitAttribute (fixed_buffer_type);
 480                         fixed_buffer_type.CreateType ();
 481
 482                         base.Emit ();
 483                 }
 484
 485                 void EmitFieldSize (int buffer_size)
 486                 {
 487                         int type_size = BuiltinTypeSpec.GetSize (MemberType);
 488
 489                         if (buffer_size > int.MaxValue / type_size) {
 490                                 Report.Error (1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
 491                                         GetSignatureForError (), buffer_size.ToString (), MemberType.GetSignatureForError ());
 492                                 return;
 493                         }
 494
 495                         AttributeEncoder encoder;
 496
 497                         var ctor = Module.PredefinedMembers.StructLayoutAttributeCtor.Resolve (Location);
 498                         if (ctor == null)
 499                                 return;
 500
 501                         var field_size = Module.PredefinedMembers.StructLayoutSize.Resolve (Location);
 502                         var field_charset = Module.PredefinedMembers.StructLayoutCharSet.Resolve (Location);
 503                         if (field_size == null || field_charset == null)
 504                                 return;
 505
 506                         var char_set = CharSet ?? Module.DefaultCharSet ?? 0;
 507
 508                         encoder = new AttributeEncoder ();
 509                         encoder.Encode ((short)LayoutKind.Sequential);
 510                         encoder.EncodeNamedArguments (
 511                                 new [] { field_size, field_charset },
 512                                 new Constant [] {
 513                                         new IntConstant (Compiler.BuiltinTypes, buffer_size * type_size, Location),
 514                                         new IntConstant (Compiler.BuiltinTypes, (int) char_set, Location)
 515                                 }
 516                         );
 517
 518                         fixed_buffer_type.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
 519
 520                         //
 521                         // Don't emit FixedBufferAttribute attribute for private types
 522                         //
 523                         if ((ModFlags & Modifiers.PRIVATE) != 0)
 524                                 return;
 525
 526                         ctor = Module.PredefinedMembers.FixedBufferAttributeCtor.Resolve (Location);
 527                         if (ctor == null)
 528                                 return;
 529
 530                         encoder = new AttributeEncoder ();
 531                         encoder.EncodeTypeName (MemberType);
 532                         encoder.Encode (buffer_size);
 533                         encoder.EncodeEmptyNamedArguments ();
 534
 535                         FieldBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
 536                 }
 537         }
 538
 539         class FixedFieldSpec : FieldSpec
 540         {
 541                 readonly FieldSpec element;
 542
 543                 public FixedFieldSpec (ModuleContainer module, TypeSpec declaringType, IMemberDefinition definition, FieldInfo info, FieldSpec element, Modifiers modifiers)
 544                         : base (declaringType, definition, PointerContainer.MakeType (module, element.MemberType), info, modifiers)
 545                 {
 546                         this.element = element;
 547
 548                         // It's never CLS-Compliant
 549                         state &= ~StateFlags.CLSCompliant_Undetected;
 550                 }
 551
 552                 public FieldSpec Element {
 553                         get {
 554                                 return element;
 555                         }
 556                 }
 557
 558                 public TypeSpec ElementType {
 559                         get {
 560                                 return element.MemberType;
 561                         }
 562                 }
 563         }
 564
 565         //
 566         // The Field class is used to represents class/struct fields during parsing.
 567         //
 568         public class Field : FieldBase {
 569                 // <summary>
 570                 //   Modifiers allowed in a class declaration
 571                 // </summary>
 572                 const Modifiers AllowedModifiers =
 573                         Modifiers.NEW |
 574                         Modifiers.PUBLIC |
 575                         Modifiers.PROTECTED |
 576                         Modifiers.INTERNAL |
 577                         Modifiers.PRIVATE |
 578                         Modifiers.STATIC |
 579                         Modifiers.VOLATILE |
 580                         Modifiers.UNSAFE |
 581                         Modifiers.READONLY;
 582
 583                 public Field (TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs)
 584                         : base (parent, type, mod, AllowedModifiers, name, attrs)
 585                 {
 586                 }
 587
 588                 bool CanBeVolatile ()
 589                 {
 590                         switch (MemberType.BuiltinType) {
 591                         case BuiltinTypeSpec.Type.Bool:
 592                         case BuiltinTypeSpec.Type.Char:
 593                         case BuiltinTypeSpec.Type.SByte:
 594                         case BuiltinTypeSpec.Type.Byte:
 595                         case BuiltinTypeSpec.Type.Short:
 596                         case BuiltinTypeSpec.Type.UShort:
 597                         case BuiltinTypeSpec.Type.Int:
 598                         case BuiltinTypeSpec.Type.UInt:
 599                         case BuiltinTypeSpec.Type.Float:
 600                         case BuiltinTypeSpec.Type.UIntPtr:
 601                         case BuiltinTypeSpec.Type.IntPtr:
 602                                 return true;
 603                         }
 604
 605                         if (TypeSpec.IsReferenceType (MemberType))
 606                                 return true;
 607
 608                         if (MemberType.IsPointer)
 609                                 return true;
 610
 611                         if (MemberType.IsEnum) {
 612                                 switch (EnumSpec.GetUnderlyingType (MemberType).BuiltinType) {
 613                                 case BuiltinTypeSpec.Type.SByte:
 614                                 case BuiltinTypeSpec.Type.Byte:
 615                                 case BuiltinTypeSpec.Type.Short:
 616                                 case BuiltinTypeSpec.Type.UShort:
 617                                 case BuiltinTypeSpec.Type.Int:
 618                                 case BuiltinTypeSpec.Type.UInt:
 619                                         return true;
 620                                 default:
 621                                         return false;
 622                                 }
 623                         }
 624
 625                         return false;
 626                 }
 627
 628                 public override void Accept (StructuralVisitor visitor)
 629                 {
 630                         visitor.Visit (this);
 631                 }
 632
 633                 public override bool Define ()
 634                 {
 635                         if (!base.Define ())
 636                                 return false;
 637
 638                         MetaType[] required_modifier = null;
 639                         if ((ModFlags & Modifiers.VOLATILE) != 0) {
 640                                 var mod = Module.PredefinedTypes.IsVolatile.Resolve ();
 641                                 if (mod != null)
 642                                         required_modifier = new MetaType[] { mod.GetMetaInfo () };
 643                         }
 644
 645                         FieldBuilder = Parent.TypeBuilder.DefineField (
 646                                 Name, member_type.GetMetaInfo (), required_modifier, null, ModifiersExtensions.FieldAttr (ModFlags));
 647
 648                         spec = new FieldSpec (Parent.Definition, this, MemberType, FieldBuilder, ModFlags);
 649
 650                         //
 651                         // Don't cache inaccessible fields except for struct where we
 652                         // need them for definitive assignment checks
 653                         //
 654                         if ((ModFlags & Modifiers.BACKING_FIELD) == 0 || Parent.Kind == MemberKind.Struct) {
 655                                 Parent.MemberCache.AddMember (spec);
 656                         }
 657
 658                         if (initializer != null) {
 659                                 Parent.RegisterFieldForInitialization (this, new FieldInitializer (this, initializer, TypeExpression.Location));
 660                         }
 661
 662                         if (declarators != null) {
 663                                 foreach (var d in declarators) {
 664                                         var f = new Field (Parent, d.GetFieldTypeExpression (this), ModFlags, new MemberName (d.Name.Value, d.Name.Location), OptAttributes);
 665                                         if (d.Initializer != null)
 666                                                 f.initializer = d.Initializer;
 667
 668                                         f.Define ();
 669                                         Parent.PartialContainer.Members.Add (f);
 670                                 }
 671                         }
 672
 673                         return true;
 674                 }
 675
 676                 protected override void DoMemberTypeDependentChecks ()
 677                 {
 678                         if ((ModFlags & Modifiers.BACKING_FIELD) != 0)
 679                                 return;
 680
 681                         base.DoMemberTypeDependentChecks ();
 682
 683                         if ((ModFlags & Modifiers.VOLATILE) != 0) {
 684                                 if (!CanBeVolatile ()) {
 685                                         Report.Error (677, Location, "`{0}': A volatile field cannot be of the type `{1}'",
 686                                                 GetSignatureForError (), MemberType.GetSignatureForError ());
 687                                 }
 688
 689                                 if ((ModFlags & Modifiers.READONLY) != 0) {
 690                                         Report.Error (678, Location, "`{0}': A field cannot be both volatile and readonly",
 691                                                 GetSignatureForError ());
 692                                 }
 693                         }
 694                 }
 695
 696                 protected override bool VerifyClsCompliance ()
 697                 {
 698                         if (!base.VerifyClsCompliance ())
 699                                 return false;
 700
 701                         if ((ModFlags & Modifiers.VOLATILE) != 0) {
 702                                 Report.Warning (3026, 1, Location, "CLS-compliant field `{0}' cannot be volatile", GetSignatureForError ());
 703                         }
 704
 705                         return true;
 706                 }
 707         }
 708
 709         class PrimaryConstructorField : Field
 710         {
 711                 //
 712                 // Proxy resolved parameter type expression to avoid type double resolve
 713                 // and problems with correct resolve context on partial classes
 714                 //
 715                 sealed class TypeExpressionFromParameter : TypeExpr
 716                 {
 717                         Parameter parameter;
 718
 719                         public TypeExpressionFromParameter (Parameter parameter)
 720                         {
 721                                 this.parameter = parameter;
 722                                 eclass = ExprClass.Type;
 723                                 loc = parameter.Location;
 724                         }
 725
 726                         public override TypeSpec ResolveAsType (IMemberContext mc, bool allowUnboundTypeArguments)
 727                         {
 728                                 return parameter.Type;
 729                         }
 730                 }
 731
 732                 public PrimaryConstructorField (TypeDefinition parent, Parameter parameter)
 733                         : base (parent, new TypeExpressionFromParameter (parameter), Modifiers.PRIVATE, new MemberName (parameter.Name, parameter.Location), null)
 734                 {
 735                         caching_flags |= Flags.IsUsed | Flags.IsAssigned;
 736                 }
 737
 738                 public override string GetSignatureForError ()
 739                 {
 740                         return MemberName.Name;
 741                 }
 742         }
 743 }