internal FieldBuilder(TypeBuilder typeBuilder, String fieldName, Type type, FieldAttributes attributes)
        {
            if (fieldName==null)
                throw new ArgumentNullException("fieldName");
			if (fieldName.Length == 0)
				throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "fieldName");
            if (fieldName[0] == '\0')
                throw new ArgumentException(Environment.GetResourceString("Argument_IllegalName"), "fieldName");
            if (type==null)
                throw new ArgumentNullException("type");
            if (type == SystemVoid)
                throw new ArgumentException(Environment.GetResourceString("Argument_BadFieldType"));
    
            m_fieldName = fieldName;
            m_typeBuilder = typeBuilder;
            m_fieldType = type;
            m_Attributes = attributes;
            
            SignatureHelper sigHelp = SignatureHelper.GetFieldSigHelper(m_typeBuilder.Module);
            sigHelp.AddArgument(type);
    
            int sigLength;
            byte[] signature = sigHelp.InternalGetSignature(out sigLength);
            
            m_tkField = new FieldToken(TypeBuilder.InternalDefineField(
                typeBuilder.TypeToken.Token, 
                fieldName, 
                signature, 
                sigLength, 
                attributes, 
                m_typeBuilder.Module), type);
        }

 public FieldDefinition(string name, TypeReference fieldType,
     FieldAttributes attrs)
     : base(name, fieldType)
 {
     m_hasInfo = false;
     m_attributes = attrs;
 }

 public FieldWeaver(TypeBuilder typeBuilder, Type type, string fieldName = null, FieldAttributes? fieldAttributes = null)
 {
     FieldType = type;
     this.fieldName = fieldName;
     this.typeBuilder = typeBuilder;
     this.fieldAttributes = fieldAttributes ?? FieldAttributes.Private;
 }

 public FieldKey(TypeKey typeKey, string type, string name, FieldAttributes fieldAttributes)
 {
     this.typeKey = typeKey;
     this.type = type;
     this.name = name;
     this.fieldAttributes = fieldAttributes;
 }

		void RenderFieldAttributes (FieldAttributes source, FieldAttributes target, ApiChange change)
		{
			// the visibility values are the same for MethodAttributes and FieldAttributes, so just use the same method.
			RenderVisibility ((MethodAttributes) source, (MethodAttributes) target, change);
			// same for the static flag
			RenderStatic ((MethodAttributes) source, (MethodAttributes) target, change);

			var srcLiteral = (source & FieldAttributes.Literal) != 0;
			var tgtLiteral = (target & FieldAttributes.Literal) != 0;

			if (srcLiteral) {
				if (tgtLiteral) {
					change.Append ("const ");
				} else {
					change.AppendRemoved ("const", true).Append (" ");
				}
			} else if (tgtLiteral) {
				change.AppendAdded ("const", true).Append (" ");
			}

			var srcInitOnly = (source & FieldAttributes.InitOnly) != 0;
			var tgtInitOnly = (target & FieldAttributes.InitOnly) != 0;
			if (srcInitOnly) {
				if (tgtInitOnly) {
					change.Append ("readonly ");
				} else {
					change.AppendRemoved ("readonly", false).Append (" ");
				}
			} else if (tgtInitOnly) {
				change.AppendAdded ("readonly", true).Append (" ");
			}
		}

 internal FieldBuilder(TypeBuilder typeBuilder, string fieldName, Type type, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers, FieldAttributes attributes)
 {
     int num;
     if (fieldName == null)
     {
         throw new ArgumentNullException("fieldName");
     }
     if (fieldName.Length == 0)
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "fieldName");
     }
     if (fieldName[0] == '\0')
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_IllegalName"), "fieldName");
     }
     if (type == null)
     {
         throw new ArgumentNullException("type");
     }
     if (type == typeof(void))
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_BadFieldType"));
     }
     this.m_fieldName = fieldName;
     this.m_typeBuilder = typeBuilder;
     this.m_fieldType = type;
     this.m_Attributes = attributes & ~FieldAttributes.ReservedMask;
     SignatureHelper fieldSigHelper = SignatureHelper.GetFieldSigHelper(this.m_typeBuilder.Module);
     fieldSigHelper.AddArgument(type, requiredCustomModifiers, optionalCustomModifiers);
     byte[] signature = fieldSigHelper.InternalGetSignature(out num);
     this.m_fieldTok = TypeBuilder.DefineField(this.m_typeBuilder.GetModuleBuilder().GetNativeHandle(), typeBuilder.TypeToken.Token, fieldName, signature, num, this.m_Attributes);
     this.m_tkField = new FieldToken(this.m_fieldTok, type);
 }

 internal virtual JSVariableField AddNewField(string name, object value, FieldAttributes attributeFlags)
 {
     JSVariableField field = this.CreateField(name, attributeFlags, value);
     this.name_table[name] = field;
     this.field_table.Add(field);
     return field;
 }

 internal JSWithField(string name, FieldAttributes attributes)
     : base(name, null, attributes)
 {
     // with-fields cannot be crunced because they might
     // need to reference a property on the with object
     CanCrunch = false;
 }

        [System.Security.SecurityCritical]  // auto-generated
        internal FieldBuilder(TypeBuilder typeBuilder, String fieldName, Type type, 
            Type[] requiredCustomModifiers, Type[] optionalCustomModifiers, FieldAttributes attributes)
        {
            if (fieldName == null)
                throw new ArgumentNullException("fieldName");

            if (fieldName.Length == 0)
                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "fieldName");

            if (fieldName[0] == '\0')
                throw new ArgumentException(Environment.GetResourceString("Argument_IllegalName"), "fieldName");

            if (type == null)
                throw new ArgumentNullException("type");

            if (type == typeof(void))
                throw new ArgumentException(Environment.GetResourceString("Argument_BadFieldType"));
            Contract.EndContractBlock();

            m_fieldName = fieldName;
            m_typeBuilder = typeBuilder;
            m_fieldType = type;
            m_Attributes = attributes & ~FieldAttributes.ReservedMask;
            
            SignatureHelper sigHelp = SignatureHelper.GetFieldSigHelper(m_typeBuilder.Module);
            sigHelp.AddArgument(type, requiredCustomModifiers, optionalCustomModifiers);

            int sigLength;
            byte[] signature = sigHelp.InternalGetSignature(out sigLength);
            
            m_fieldTok = TypeBuilder.DefineField(m_typeBuilder.GetModuleBuilder().GetNativeHandle(),
                typeBuilder.TypeToken.Token, fieldName, signature, sigLength, m_Attributes);

            m_tkField = new FieldToken(m_fieldTok, type);
        }

 internal EnumDeclaration(Context context, IdentifierLiteral id, TypeExpression baseType, Block body, FieldAttributes attributes, CustomAttributeList customAttributes) : base(context, id, new TypeExpression(new ConstantWrapper(Typeob.Enum, null)), new TypeExpression[0], body, attributes, false, false, true, false, customAttributes)
 {
     this.baseType = (baseType != null) ? baseType : new TypeExpression(new ConstantWrapper(Typeob.Int32, null));
     base.needsEngine = false;
     base.attributes &= TypeAttributes.NestedFamORAssem;
     TypeExpression expression = new TypeExpression(new ConstantWrapper(base.classob, base.context));
     AST ast = new ConstantWrapper(-1, null);
     AST ast2 = new ConstantWrapper(1, null);
     JSMemberField[] fields = base.fields;
     for (int i = 0; i < fields.Length; i++)
     {
         FieldInfo info = fields[i];
         JSVariableField field = (JSVariableField) info;
         field.attributeFlags = FieldAttributes.Literal | FieldAttributes.Static | FieldAttributes.Public;
         field.type = expression;
         if (field.value == null)
         {
             field.value = ast = new Plus(ast.context, ast, ast2);
         }
         else
         {
             ast = (AST) field.value;
         }
         field.value = new DeclaredEnumValue(field.value, field.Name, base.classob);
     }
 }

 protected override JSVariableField CreateField(String name, FieldAttributes attributeFlags, Object value){
   if (!(this.parent is ActivationObject))
     return base.CreateField(name, attributeFlags, value);
   JSVariableField field = ((ActivationObject)this.parent).AddNewField(name+":"+this.scopeId, value, attributeFlags);
   field.debuggerName = name;
   return field;
 }

		public FieldInfoMirror (TypeMirror parent, long id, string name, TypeMirror type, FieldAttributes attrs) : base (parent.VirtualMachine, id) {
			this.parent = parent;
			this.name = name;
			this.type = type;
			this.attrs = attrs;
			inited = true;
		}

 internal JSMemberField AddOverload(FunctionObject func, FieldAttributes attributeFlags){
   JSMemberField last = this;
   while (last.nextOverload != null) last = last.nextOverload;
   JSMemberField f = last.nextOverload = new JSMemberField((ClassScope)this.obj, this.Name, func, attributeFlags);
   f.type = this.type;
   return f;
 }

        public void DefineUninitalizedData_CreateGlobalFunctionsAlreadyCalled_ThrowsInvalidOperationException(FieldAttributes attributes)
        {
            ModuleBuilder module = Helpers.DynamicModule();
            module.CreateGlobalFunctions();

            Assert.Throws<InvalidOperationException>(() => module.DefineUninitializedData("TestField", 1, attributes));
        }

	public virtual void DefineGlobalVariable
				(String name, FieldAttributes attributes, 
				 byte[] signature, SymAddressKind addrKind,
				 int addr1, int addr2, int addr3)
			{
				throw new NotSupportedException();
			}

 /// <summary>
 /// Initializes a new instance of the <see cref="CilRuntimeField"/> class.
 /// </summary>
 /// <param name="module">The module.</param>
 /// <param name="name">The name.</param>
 /// <param name="signature">The signature.</param>
 /// <param name="token">The token.</param>
 /// <param name="offset">The offset.</param>
 /// <param name="rva">The rva.</param>
 /// <param name="declaringType">Type of the declaring.</param>
 /// <param name="attributes">The attributes.</param>
 public CilRuntimeField(ITypeModule module, string name, FieldSignature signature, Token token, uint offset, uint rva, RuntimeType declaringType, FieldAttributes attributes)
     : base(module, token, declaringType)
 {
     this.Name = name;
     this.Signature = signature;
     base.Attributes = attributes;
     base.RVA = rva;
 }

 public void DefineUnitializedData_InvalidSize_ThrowsArgumentException(FieldAttributes attributes)
 {
     ModuleBuilder module = Helpers.DynamicModule();
     foreach (int size in new int[] { -1, 0, 0x003f0000, 0x003f0000 + 1 })
     {
         Assert.Throws<ArgumentException>(null, () => module.DefineUninitializedData("TestField", size, attributes));
     }
 }

	public virtual void DefineLocalVariable
				(String name, FieldAttributes attributes, 
				 byte[] signature, SymAddressKind addrKind, 
				 int addr1, int addr2, int addr3, 
				 int startOffset, int endOffset)
			{
				// Nothing to do here.
			}

 public void TestWithStaticAndPublic(FieldAttributes attributes)
 {
     ModuleBuilder module = Helpers.DynamicModule();
     FieldBuilder field = module.DefineInitializedData("MyField", new byte[] { 01, 00, 01 }, attributes);
     Assert.True(field.IsStatic);
     Assert.Equal((attributes & FieldAttributes.Public) != 0 , field.IsPublic);
     Assert.Equal((attributes & FieldAttributes.Private) != 0, field.IsPrivate);
     Assert.Equal(field.Name, "MyField");
 }

 public FieldMetadata(
     string name, 
     Type fieldType, 
     FieldAttributes fieldAttributes)
     : base(name)
 {
     _fieldType = fieldType;
     _fieldAttributes = fieldAttributes;
 }