Mono.CSharp.Field.Define C# (CSharp) Method

		public override bool Define ()
		{
			if (!base.Define ())
				return false;

			MetaType[] required_modifier = null;
			if ((ModFlags & Modifiers.VOLATILE) != 0) {
				var mod = Module.PredefinedTypes.IsVolatile.Resolve ();
				if (mod != null)
					required_modifier = new MetaType[] { mod.GetMetaInfo () };
			}

			FieldBuilder = Parent.TypeBuilder.DefineField (
				Name, member_type.GetMetaInfo (), required_modifier, null, ModifiersExtensions.FieldAttr (ModFlags));

			spec = new FieldSpec (Parent.Definition, this, MemberType, FieldBuilder, ModFlags);

			//
			// Don't cache inaccessible fields except for struct where we
			// need them for definitive assignment checks
			//
			if ((ModFlags & Modifiers.BACKING_FIELD) == 0 || Parent.Kind == MemberKind.Struct) {
				Parent.MemberCache.AddMember (spec);
			}

			if (initializer != null) {
				Parent.RegisterFieldForInitialization (this, new FieldInitializer (this, initializer, TypeExpression.Location));
			}

			if (declarators != null) {
				foreach (var d in declarators) {
					var f = new Field (Parent, d.GetFieldTypeExpression (this), ModFlags, new MemberName (d.Name.Value, d.Name.Location), OptAttributes);
					if (d.Initializer != null)
						f.initializer = d.Initializer;

					f.Define ();
					Parent.PartialContainer.Members.Add (f);
				}
			}

			return true;
		}

        public override bool Define()
        {
            if (!base.Define())
            {
                return(false);
            }
            // SYNC_MOD_CTRL
            if ((ModFlags & Modifiers.SYNC) == Modifiers.SYNC)
            {
                Report.Error(3661, Location, "A sync modifier cannot be used in field declaration. ");
            }

            MetaType[] required_modifier = null;
            if ((ModFlags & Modifiers.VOLATILE) != 0)
            {
                var mod = Module.PredefinedTypes.IsVolatile.Resolve();
                if (mod != null)
                {
                    required_modifier = new MetaType[] { mod.GetMetaInfo() }
                }
                ;
            }

            FieldBuilder = Parent.TypeBuilder.DefineField(
                Name, member_type.GetMetaInfo(), required_modifier, null, ModifiersExtensions.FieldAttr(ModFlags));

            spec = new FieldSpec(Parent.Definition, this, MemberType, FieldBuilder, ModFlags);

            //
            // Don't cache inaccessible fields except for struct where we
            // need them for definitive assignment checks
            //
            if ((ModFlags & Modifiers.BACKING_FIELD) == 0 || Parent.Kind == MemberKind.Struct)
            {
                Parent.MemberCache.AddMember(spec);
            }

            if (initializer != null)
            {
                Parent.RegisterFieldForInitialization(this, new FieldInitializer(this, initializer, TypeExpression.Location));
            }

            if (declarators != null)
            {
                foreach (var d in declarators)
                {
                    var f = new Field(Parent, d.GetFieldTypeExpression(this), ModFlags, new MemberName(d.Name.Value, d.Name.Location), OptAttributes);
                    if (d.Initializer != null)
                    {
                        f.initializer = d.Initializer;
                    }

                    f.Define();
                    Parent.PartialContainer.Members.Add(f);
                }
            }

            return(true);
        }