//
// Copyright 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
// Copyright 2004-2008 Novell, Inc
+// Copyright 2011 Xamarin Inc
//
using System;
using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+#if STATIC
+using MetaType = IKVM.Reflection.Type;
+using IKVM.Reflection;
+using IKVM.Reflection.Emit;
+#else
+using MetaType = System.Type;
using System.Reflection;
using System.Reflection.Emit;
-using System.Runtime.InteropServices;
+#endif
namespace Mono.CSharp
{
+ public class FieldDeclarator
+ {
+ public FieldDeclarator (SimpleMemberName name, Expression initializer)
+ {
+ this.Name = name;
+ this.Initializer = initializer;
+ }
+
+ #region Properties
+
+ public SimpleMemberName Name { get; private set; }
+ public Expression Initializer { get; private set; }
+
+ #endregion
+ }
+
//
// Abstract class for all fields
//
abstract public class FieldBase : MemberBase
{
- public FieldBuilder FieldBuilder;
+ protected FieldBuilder FieldBuilder;
protected FieldSpec spec;
public Status status;
protected Expression initializer;
+ protected List<FieldDeclarator> declarators;
[Flags]
public enum Status : byte {
static readonly string[] attribute_targets = new string [] { "field" };
- protected FieldBase (DeclSpace parent, FullNamedExpression type, Modifiers mod,
- Modifiers allowed_mod, MemberName name, Attributes attrs)
- : base (parent, null, type, mod, allowed_mod | Modifiers.ABSTRACT, Modifiers.PRIVATE,
- name, attrs)
+ protected FieldBase (TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs)
+ : base (parent, type, mod, allowed_mod | Modifiers.ABSTRACT, Modifiers.PRIVATE, name, attrs)
{
if ((mod & Modifiers.ABSTRACT) != 0)
Report.Error (681, Location, "The modifier 'abstract' is not valid on fields. Try using a property instead");
}
+ #region Properties
+
public override AttributeTargets AttributeTargets {
get {
return AttributeTargets.Field;
}
}
- public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa)
+ public List<FieldDeclarator> Declarators {
+ get {
+ return this.declarators;
+ }
+ }
+
+ public Expression Initializer {
+ get {
+ return initializer;
+ }
+ set {
+ this.initializer = value;
+ }
+ }
+
+ public string Name {
+ get {
+ return MemberName.Name;
+ }
+ }
+
+ public FieldSpec Spec {
+ get {
+ return spec;
+ }
+ }
+
+ public override string[] ValidAttributeTargets {
+ get {
+ return attribute_targets;
+ }
+ }
+
+ #endregion
+
+ public void AddDeclarator (FieldDeclarator declarator)
+ {
+ if (declarators == null)
+ declarators = new List<FieldDeclarator> (2);
+
+ declarators.Add (declarator);
+
+ Parent.AddNameToContainer (this, declarator.Name.Value);
+ }
+
+ public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
{
if (a.Type == pa.FieldOffset) {
status |= Status.HAS_OFFSET;
return;
}
- FieldBuilder.SetCustomAttribute (cb);
+ FieldBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), cdata);
+ }
+
+ public void SetCustomAttribute (MethodSpec ctor, byte[] data)
+ {
+ FieldBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), data);
}
protected override bool CheckBase ()
{
if (!base.CheckBase ())
return false;
-
- MemberInfo conflict_symbol = Parent.PartialContainer.FindBaseMemberWithSameName (Name, false);
+
+ MemberSpec candidate;
+ bool overrides = false;
+ var conflict_symbol = MemberCache.FindBaseMember (this, out candidate, ref overrides);
+ if (conflict_symbol == null)
+ conflict_symbol = candidate;
+
if (conflict_symbol == null) {
if ((ModFlags & Modifiers.NEW) != 0) {
- Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
+ Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required",
+ GetSignatureForError ());
}
- return true;
- }
-
- if ((ModFlags & (Modifiers.NEW | Modifiers.OVERRIDE | Modifiers.BACKING_FIELD)) == 0) {
- Report.SymbolRelatedToPreviousError (conflict_symbol);
- Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
- GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
+ } else {
+ if ((ModFlags & (Modifiers.NEW | Modifiers.OVERRIDE | Modifiers.BACKING_FIELD)) == 0) {
+ Report.SymbolRelatedToPreviousError (conflict_symbol);
+ Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
+ GetSignatureForError (), conflict_symbol.GetSignatureForError ());
+ }
+
+ if (conflict_symbol.IsAbstract) {
+ Report.SymbolRelatedToPreviousError (conflict_symbol);
+ Report.Error (533, Location, "`{0}' hides inherited abstract member `{1}'",
+ GetSignatureForError (), conflict_symbol.GetSignatureForError ());
+ }
}
return true;
public virtual Constant ConvertInitializer (ResolveContext rc, Constant expr)
{
- return expr.ConvertImplicitly (rc, MemberType);
+ return expr.ConvertImplicitly (MemberType);
}
protected override void DoMemberTypeDependentChecks ()
{
base.DoMemberTypeDependentChecks ();
- if (TypeManager.IsGenericParameter (MemberType))
+ if (MemberType.IsGenericParameter)
return;
- if (MemberType.IsSealed && MemberType.IsAbstract) {
+ if (MemberType.IsStatic)
Error_VariableOfStaticClass (Location, GetSignatureForError (), MemberType, Report);
- }
CheckBase ();
IsTypePermitted ();
public override void Emit ()
{
- if (TypeManager.IsDynamicType (member_type)) {
- PredefinedAttributes.Get.Dynamic.EmitAttribute (FieldBuilder);
- } else {
- var trans_flags = TypeManager.HasDynamicTypeUsed (member_type);
- if (trans_flags != null) {
- var pa = PredefinedAttributes.Get.DynamicTransform;
- if (pa.Constructor != null || pa.ResolveConstructor (Location, TypeManager.bool_type.MakeArrayType ())) {
- FieldBuilder.SetCustomAttribute (new CustomAttributeBuilder (pa.Constructor, new object[] { trans_flags }));
- }
- }
+ if (member_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
+ Module.PredefinedAttributes.Dynamic.EmitAttribute (FieldBuilder);
+ } else if (!Parent.IsCompilerGenerated && member_type.HasDynamicElement) {
+ Module.PredefinedAttributes.Dynamic.EmitAttribute (FieldBuilder, member_type, Location);
}
if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated)
- PredefinedAttributes.Get.CompilerGenerated.EmitAttribute (FieldBuilder);
+ Module.PredefinedAttributes.CompilerGenerated.EmitAttribute (FieldBuilder);
+ if ((ModFlags & Modifiers.DEBUGGER_HIDDEN) != 0)
+ Module.PredefinedAttributes.DebuggerBrowsable.EmitAttribute (FieldBuilder, System.Diagnostics.DebuggerBrowsableState.Never);
if (OptAttributes != null) {
OptAttributes.Emit ();
Report.Error (625, Location, "`{0}': Instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute", GetSignatureForError ());
}
+ ConstraintChecker.Check (this, member_type, type_expr.Location);
+
base.Emit ();
}
- public static void Error_VariableOfStaticClass (Location loc, string variable_name, Type static_class, Report Report)
+ public static void Error_VariableOfStaticClass (Location loc, string variable_name, TypeSpec static_class, Report Report)
{
Report.SymbolRelatedToPreviousError (static_class);
Report.Error (723, loc, "`{0}': cannot declare variables of static types",
variable_name);
}
- public Expression Initializer {
- get {
- return initializer;
- }
- set {
- if (value != null) {
- this.initializer = value;
- }
- }
- }
-
- protected virtual bool IsFieldClsCompliant {
- get {
- if (FieldBuilder == null)
- return true;
-
- return AttributeTester.IsClsCompliant (FieldBuilder.FieldType);
- }
- }
-
- public FieldSpec Spec {
- get { return spec; }
- }
-
- public override string[] ValidAttributeTargets
- {
- get {
- return attribute_targets;
- }
- }
-
protected override bool VerifyClsCompliance ()
{
if (!base.VerifyClsCompliance ())
return false;
- if (!IsFieldClsCompliant) {
+ if (!MemberType.IsCLSCompliant () || this is FixedField) {
Report.Warning (3003, 1, Location, "Type of `{0}' is not CLS-compliant",
GetSignatureForError ());
}
return true;
}
-
- public void SetAssigned ()
- {
- caching_flags |= Flags.IsAssigned;
- }
}
//
// Field specification
//
- public class FieldSpec : MemberSpec
+ public class FieldSpec : MemberSpec, IInterfaceMemberSpec
{
- FieldInfo info;
+ FieldInfo metaInfo;
+ TypeSpec memberType;
- public FieldSpec (IMemberDefinition definition, FieldInfo info, Modifiers modifiers)
- : base (MemberKind.Field, definition, info.Name, modifiers)
+ public FieldSpec (TypeSpec declaringType, IMemberDefinition definition, TypeSpec memberType, FieldInfo info, Modifiers modifiers)
+ : base (MemberKind.Field, declaringType, definition, modifiers)
{
- this.info = info;
+ this.metaInfo = info;
+ this.memberType = memberType;
}
- public bool IsReadOnly {
- get { return (Modifiers & Modifiers.READONLY) != 0; }
- }
+ #region Properties
- public FieldInfo MetaInfo {
+ public bool IsReadOnly {
get {
- return info;
- }
- set {
- info = value;
+ return (Modifiers & Modifiers.READONLY) != 0;
}
}
- public override Type DeclaringType {
+ public TypeSpec MemberType {
get {
- return MetaInfo.DeclaringType;
+ return memberType;
}
}
- // Obsolete
- public Type FieldType {
- get {
- return MetaInfo.FieldType;
+#endregion
+
+ public FieldInfo GetMetaInfo ()
+ {
+ if ((state & StateFlags.PendingMetaInflate) != 0) {
+ var decl_meta = DeclaringType.GetMetaInfo ();
+ if (DeclaringType.IsTypeBuilder) {
+ metaInfo = TypeBuilder.GetField (decl_meta, metaInfo);
+ } else {
+ var orig_token = metaInfo.MetadataToken;
+ metaInfo = decl_meta.GetField (Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
+ if (metaInfo.MetadataToken != orig_token)
+ throw new NotImplementedException ("Resolved to wrong meta token");
+
+ // What a stupid API, does not work because field handle is imported
+ // metaInfo = FieldInfo.GetFieldFromHandle (metaInfo.FieldHandle, DeclaringType.MetaInfo.TypeHandle);
+ }
+
+ state &= ~StateFlags.PendingMetaInflate;
}
+
+ return metaInfo;
+ }
+
+ public override MemberSpec InflateMember (TypeParameterInflator inflator)
+ {
+ var fs = (FieldSpec) base.InflateMember (inflator);
+ fs.memberType = inflator.Inflate (memberType);
+ return fs;
+ }
+
+ public FieldSpec Mutate (TypeParameterMutator mutator)
+ {
+ var decl = DeclaringType;
+ if (DeclaringType.IsGenericOrParentIsGeneric)
+ decl = mutator.Mutate (decl);
+
+ if (decl == DeclaringType)
+ return this;
+
+ var fs = (FieldSpec) MemberwiseClone ();
+ fs.declaringType = decl;
+ fs.state |= StateFlags.PendingMetaInflate;
+
+ // Gets back FieldInfo in case of metaInfo was inflated
+ fs.metaInfo = MemberCache.GetMember (TypeParameterMutator.GetMemberDeclaringType (DeclaringType), this).metaInfo;
+ return fs;
+ }
+
+ public override List<TypeSpec> ResolveMissingDependencies ()
+ {
+ return memberType.ResolveMissingDependencies ();
}
}
{
public const string FixedElementName = "FixedElementField";
static int GlobalCounter = 0;
- static object[] ctor_args = new object[] { (short)LayoutKind.Sequential };
- static FieldInfo[] fi;
TypeBuilder fixed_buffer_type;
Modifiers.PRIVATE |
Modifiers.UNSAFE;
- public FixedField (DeclSpace parent, FullNamedExpression type, Modifiers mod, string name,
- Expression size_expr, Attributes attrs, Location loc):
- base (parent, type, mod, AllowedModifiers, new MemberName (name, loc), attrs)
+ public FixedField (TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs)
+ : base (parent, type, mod, AllowedModifiers, name, attrs)
{
- if (RootContext.Version < LanguageVersion.ISO_2)
- Report.FeatureIsNotAvailable (loc, "fixed size buffers");
-
- initializer = new ConstInitializer (this, size_expr);
}
+ #region Properties
+
+ //
+ // Explicit struct layout set by parent
+ //
+ public CharSet? CharSet {
+ get; set;
+ }
+
+ #endregion
+
public override Constant ConvertInitializer (ResolveContext rc, Constant expr)
{
- return expr.ImplicitConversionRequired (rc, TypeManager.int32_type, Location);
+ return expr.ImplicitConversionRequired (rc, rc.BuiltinTypes.Int, Location);
}
public override bool Define ()
if (!base.Define ())
return false;
- if (!TypeManager.IsPrimitiveType (MemberType)) {
+ if (!BuiltinTypeSpec.IsPrimitiveType (MemberType)) {
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",
GetSignatureForError ());
- }
+ } else if (declarators != null) {
+ var t = new TypeExpression (MemberType, TypeExpression.Location);
+ foreach (var d in declarators) {
+ var f = new FixedField (Parent, t, ModFlags, new MemberName (d.Name.Value, d.Name.Location), OptAttributes);
+ f.initializer = d.Initializer;
+ ((ConstInitializer) f.initializer).Name = d.Name.Value;
+ f.Define ();
+ Parent.PartialContainer.Members.Add (f);
+ }
+ }
// Create nested fixed buffer container
string name = String.Format ("<{0}>__FixedBuffer{1}", Name, GlobalCounter++);
- fixed_buffer_type = Parent.TypeBuilder.DefineNestedType (name, Parent.Module.DefaultCharSetType |
- TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit, TypeManager.value_type);
-
- var element = fixed_buffer_type.DefineField (FixedElementName, MemberType, FieldAttributes.Public);
- RootContext.RegisterCompilerGeneratedType (fixed_buffer_type);
+ fixed_buffer_type = Parent.TypeBuilder.DefineNestedType (name,
+ TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit,
+ Compiler.BuiltinTypes.ValueType.GetMetaInfo ());
+
+ var ffield = fixed_buffer_type.DefineField (FixedElementName, MemberType.GetMetaInfo (), FieldAttributes.Public);
FieldBuilder = Parent.TypeBuilder.DefineField (Name, fixed_buffer_type, ModifiersExtensions.FieldAttr (ModFlags));
- spec = new FixedFieldSpec (this, FieldBuilder, element, ModFlags);
- Parent.MemberCache.AddMember (FieldBuilder, spec);
- TypeManager.RegisterFieldBase (FieldBuilder, this);
+ var element_spec = new FieldSpec (null, this, MemberType, ffield, ModFlags);
+ spec = new FixedFieldSpec (Parent.Definition, this, FieldBuilder, element_spec, ModFlags);
+ Parent.MemberCache.AddMember (spec);
return true;
}
return;
}
- int type_size = Expression.GetTypeSize (MemberType);
+ EmitFieldSize (buffer_size);
+
+#if STATIC
+ if (Module.HasDefaultCharSet)
+ fixed_buffer_type.__SetAttributes (fixed_buffer_type.Attributes | Module.DefaultCharSetType);
+#endif
+
+ Module.PredefinedAttributes.UnsafeValueType.EmitAttribute (fixed_buffer_type);
+ Module.PredefinedAttributes.CompilerGenerated.EmitAttribute (fixed_buffer_type);
+ fixed_buffer_type.CreateType ();
+
+ base.Emit ();
+ }
+
+ void EmitFieldSize (int buffer_size)
+ {
+ int type_size = BuiltinTypeSpec.GetSize (MemberType);
if (buffer_size > int.MaxValue / type_size) {
Report.Error (1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
return;
}
- buffer_size *= type_size;
- EmitFieldSize (buffer_size);
+ AttributeEncoder encoder;
- PredefinedAttributes.Get.UnsafeValueType.EmitAttribute (fixed_buffer_type);
+ var ctor = Module.PredefinedMembers.StructLayoutAttributeCtor.Resolve (Location);
+ if (ctor == null)
+ return;
- base.Emit ();
- }
+ var field_size = Module.PredefinedMembers.StructLayoutSize.Resolve (Location);
+ var field_charset = Module.PredefinedMembers.StructLayoutCharSet.Resolve (Location);
+ if (field_size == null || field_charset == null)
+ return;
- void EmitFieldSize (int buffer_size)
- {
- CustomAttributeBuilder cab;
- PredefinedAttribute pa;
+ var char_set = CharSet ?? Module.DefaultCharSet ?? 0;
- pa = PredefinedAttributes.Get.StructLayout;
- if (pa.Constructor == null &&
- !pa.ResolveConstructor (Location, TypeManager.short_type))
- return;
+ encoder = new AttributeEncoder ();
+ encoder.Encode ((short)LayoutKind.Sequential);
+ encoder.EncodeNamedArguments (
+ new [] { field_size, field_charset },
+ new Constant [] {
+ new IntConstant (Compiler.BuiltinTypes, buffer_size * type_size, Location),
+ new IntConstant (Compiler.BuiltinTypes, (int) char_set, Location)
+ }
+ );
- // TODO: It's not cleared
- if (fi == null)
- fi = new FieldInfo[] { pa.Type.GetField ("Size") };
+ fixed_buffer_type.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
- object[] fi_val = new object[] { buffer_size };
- cab = new CustomAttributeBuilder (pa.Constructor,
- ctor_args, fi, fi_val);
- fixed_buffer_type.SetCustomAttribute (cab);
-
//
// Don't emit FixedBufferAttribute attribute for private types
//
if ((ModFlags & Modifiers.PRIVATE) != 0)
return;
- pa = PredefinedAttributes.Get.FixedBuffer;
- if (pa.Constructor == null &&
- !pa.ResolveConstructor (Location, TypeManager.type_type, TypeManager.int32_type))
+ ctor = Module.PredefinedMembers.FixedBufferAttributeCtor.Resolve (Location);
+ if (ctor == null)
return;
- cab = new CustomAttributeBuilder (pa.Constructor, new object[] { MemberType, buffer_size });
- FieldBuilder.SetCustomAttribute (cab);
- }
-
- protected override bool IsFieldClsCompliant {
- get {
- return false;
- }
- }
-
- public void SetCharSet (TypeAttributes ta)
- {
- TypeAttributes cta = fixed_buffer_type.Attributes;
- if ((cta & TypeAttributes.UnicodeClass) != (ta & TypeAttributes.UnicodeClass))
- SetTypeBuilderCharSet ((cta & ~TypeAttributes.AutoClass) | TypeAttributes.UnicodeClass);
- else if ((cta & TypeAttributes.AutoClass) != (ta & TypeAttributes.AutoClass))
- SetTypeBuilderCharSet ((cta & ~TypeAttributes.UnicodeClass) | TypeAttributes.AutoClass);
- else if (cta == 0 && ta != 0)
- SetTypeBuilderCharSet (cta & ~(TypeAttributes.UnicodeClass | TypeAttributes.AutoClass));
- }
+ encoder = new AttributeEncoder ();
+ encoder.EncodeTypeName (MemberType);
+ encoder.Encode (buffer_size);
+ encoder.EncodeEmptyNamedArguments ();
- void SetTypeBuilderCharSet (TypeAttributes ta)
- {
- MethodInfo mi = typeof (TypeBuilder).GetMethod ("SetCharSet", BindingFlags.Instance | BindingFlags.NonPublic);
- if (mi == null) {
- Report.RuntimeMissingSupport (Location, "TypeBuilder::SetCharSet");
- } else {
- mi.Invoke (fixed_buffer_type, new object [] { ta });
- }
+ FieldBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
}
}
class FixedFieldSpec : FieldSpec
{
- readonly FieldInfo element;
+ readonly FieldSpec element;
- public FixedFieldSpec (IMemberDefinition definition, FieldInfo info, FieldInfo element, Modifiers modifiers)
- : base (definition, info, modifiers)
+ public FixedFieldSpec (TypeSpec declaringType, IMemberDefinition definition, FieldInfo info, FieldSpec element, Modifiers modifiers)
+ : base (declaringType, definition, element.MemberType, info, modifiers)
{
this.element = element;
+
+ // It's never CLS-Compliant
+ state &= ~StateFlags.CLSCompliant_Undetected;
}
- public FieldInfo Element {
+ public FieldSpec Element {
get {
return element;
}
}
- public Type ElementType {
+ public TypeSpec ElementType {
get {
- return element.FieldType;
+ return MemberType;
}
}
}
Modifiers.UNSAFE |
Modifiers.READONLY;
- public Field (DeclSpace parent, FullNamedExpression type, Modifiers mod, MemberName name,
- Attributes attrs)
+ public Field (TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs)
: base (parent, type, mod, AllowedModifiers, name, attrs)
{
}
bool CanBeVolatile ()
{
- if (TypeManager.IsReferenceType (MemberType))
+ switch (MemberType.BuiltinType) {
+ case BuiltinTypeSpec.Type.Bool:
+ case BuiltinTypeSpec.Type.Char:
+ case BuiltinTypeSpec.Type.SByte:
+ case BuiltinTypeSpec.Type.Byte:
+ case BuiltinTypeSpec.Type.Short:
+ case BuiltinTypeSpec.Type.UShort:
+ case BuiltinTypeSpec.Type.Int:
+ case BuiltinTypeSpec.Type.UInt:
+ case BuiltinTypeSpec.Type.Float:
+ case BuiltinTypeSpec.Type.UIntPtr:
+ case BuiltinTypeSpec.Type.IntPtr:
return true;
+ }
- if (MemberType == TypeManager.bool_type || MemberType == TypeManager.char_type ||
- MemberType == TypeManager.sbyte_type || MemberType == TypeManager.byte_type ||
- MemberType == TypeManager.short_type || MemberType == TypeManager.ushort_type ||
- MemberType == TypeManager.int32_type || MemberType == TypeManager.uint32_type ||
- MemberType == TypeManager.float_type ||
- MemberType == TypeManager.intptr_type || MemberType == TypeManager.uintptr_type)
+ if (TypeSpec.IsReferenceType (MemberType))
return true;
- if (TypeManager.IsEnumType (MemberType))
+ if (MemberType.IsEnum)
return true;
return false;
}
- bool CheckStructLayout (Type type, bool isStatic)
+ public override void Accept (StructuralVisitor visitor)
{
- if (TypeManager.IsBuiltinType (type))
- return true;
-
- if (isStatic) {
- if (!TypeManager.IsValueType (type) || TypeManager.IsEqual (type, Parent.TypeBuilder))
- return true;
- }
-
- if (!TypeManager.IsEqual (TypeManager.DropGenericTypeArguments (type), Parent.TypeBuilder)) {
- if (!TypeManager.IsGenericType (type))
- return true;
-
- foreach (Type t in TypeManager.GetTypeArguments (type)) {
- if (!CheckStructLayout (t, false))
- return false;
- }
- return true;
- }
-
- Report.Error (523, Location,
- "Struct member `{0}' of type `{1}' causes a cycle in the struct layout",
- GetSignatureForError (), TypeManager.CSharpName (MemberType));
- return false;
+ visitor.Visit (this);
}
-
+
public override bool Define ()
{
if (!base.Define ())
return false;
- try {
- Type[] required_modifier = null;
- if ((ModFlags & Modifiers.VOLATILE) != 0) {
- if (TypeManager.isvolatile_type == null)
- TypeManager.isvolatile_type = TypeManager.CoreLookupType (Compiler,
- "System.Runtime.CompilerServices", "IsVolatile", MemberKind.Class, true);
-
- if (TypeManager.isvolatile_type != null)
- required_modifier = new Type [] { TypeManager.isvolatile_type };
- }
-
- FieldBuilder = Parent.TypeBuilder.DefineField (
- Name, MemberType, required_modifier, null, ModifiersExtensions.FieldAttr (ModFlags));
+ MetaType[] required_modifier = null;
+ if ((ModFlags & Modifiers.VOLATILE) != 0) {
+ var mod = Module.PredefinedTypes.IsVolatile.Resolve ();
+ if (mod != null)
+ required_modifier = new MetaType[] { mod.GetMetaInfo () };
+ }
- spec = new FieldSpec (this, FieldBuilder, ModFlags);
+ FieldBuilder = Parent.TypeBuilder.DefineField (
+ Name, member_type.GetMetaInfo (), required_modifier, null, ModifiersExtensions.FieldAttr (ModFlags));
- // Don't cache inaccessible fields
- if ((ModFlags & Modifiers.BACKING_FIELD) == 0) {
- Parent.MemberCache.AddMember (FieldBuilder, spec);
- }
+ spec = new FieldSpec (Parent.Definition, this, MemberType, FieldBuilder, ModFlags);
- TypeManager.RegisterFieldBase (FieldBuilder, this);
- }
- catch (ArgumentException) {
- Report.RuntimeMissingSupport (Location, "`void' or `void*' field type");
- return false;
+ //
+ // 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) {
- ((TypeContainer) Parent).RegisterFieldForInitialization (this,
- new FieldInitializer (this, initializer, this));
- } else {
- if (Parent.PartialContainer.Kind == MemberKind.Struct)
- CheckStructLayout (member_type, (ModFlags & Modifiers.STATIC) != 0);
+ Parent.RegisterFieldForInitialization (this, new FieldInitializer (this, initializer, TypeExpression.Location));
+ }
+
+ if (declarators != null) {
+ foreach (var d in declarators) {
+ var t = new TypeExpression (MemberType, d.Name.Location);
+ var f = new Field (Parent, t, 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;
protected override void DoMemberTypeDependentChecks ()
{
+ if ((ModFlags & Modifiers.BACKING_FIELD) != 0)
+ return;
+
base.DoMemberTypeDependentChecks ();
if ((ModFlags & Modifiers.VOLATILE) != 0) {