//
// Copyright 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
// Copyright 2004-2008 Novell, Inc
+// Copyright 2011 Xamarin Inc
//
using System;
public Expression Initializer { get; private set; }
#endregion
+
+ public virtual FullNamedExpression GetFieldTypeExpression (FieldBase field)
+ {
+ return new TypeExpression (field.MemberType, Name.Location);
+ }
}
//
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");
}
}
+ public List<FieldDeclarator> Declarators {
+ get {
+ return this.declarators;
+ }
+ }
+
public Expression Initializer {
get {
return initializer;
}
}
+ public string Name {
+ get {
+ return MemberName.Name;
+ }
+ }
+
public FieldSpec Spec {
get {
return spec;
declarators.Add (declarator);
- // TODO: This will probably break
- Parent.AddMember (this, declarator.Name.Value);
+ Parent.AddNameToContainer (this, declarator.Name.Value);
}
public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
return false;
MemberSpec candidate;
- var conflict_symbol = MemberCache.FindBaseMember (this, out candidate);
+ bool overrides = false;
+ var conflict_symbol = MemberCache.FindBaseMember (this, out candidate, ref overrides);
if (conflict_symbol == null)
conflict_symbol = candidate;
{
if (member_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
Module.PredefinedAttributes.Dynamic.EmitAttribute (FieldBuilder);
- } else if (!(Parent is CompilerGeneratedClass) && member_type.HasDynamicElement) {
+ } else if (!Parent.IsCompilerGenerated && member_type.HasDynamicElement) {
Module.PredefinedAttributes.Dynamic.EmitAttribute (FieldBuilder, member_type, Location);
}
if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated)
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 ();
}
return fs;
}
- public override List<TypeSpec> ResolveMissingDependencies ()
+ public override List<MissingTypeSpecReference> ResolveMissingDependencies (MemberSpec caller)
{
- return memberType.ResolveMissingDependencies ();
+ return memberType.ResolveMissingDependencies (this);
}
}
Modifiers.PRIVATE |
Modifiers.UNSAFE;
- public FixedField (DeclSpace parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs)
+ public FixedField (TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs)
: base (parent, type, mod, AllowedModifiers, name, attrs)
{
}
"`{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);
- int index = Parent.PartialContainer.Fields.IndexOf (this);
foreach (var d in declarators) {
- var f = new FixedField (Parent, t, ModFlags, new MemberName (d.Name.Value, d.Name.Location), OptAttributes);
+ var f = new FixedField (Parent, d.GetFieldTypeExpression (this), ModFlags, new MemberName (d.Name.Value, d.Name.Location), OptAttributes);
f.initializer = d.Initializer;
((ConstInitializer) f.initializer).Name = d.Name.Value;
- Parent.PartialContainer.Fields.Insert (++index, f);
+ f.Define ();
+ Parent.PartialContainer.Members.Add (f);
}
}
FieldBuilder = Parent.TypeBuilder.DefineField (Name, fixed_buffer_type, ModifiersExtensions.FieldAttr (ModFlags));
var element_spec = new FieldSpec (null, this, MemberType, ffield, ModFlags);
- spec = new FixedFieldSpec (Parent.Definition, this, FieldBuilder, element_spec, ModFlags);
+ spec = new FixedFieldSpec (Module, Parent.Definition, this, FieldBuilder, element_spec, ModFlags);
Parent.MemberCache.AddMember (spec);
return true;
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",
- GetSignatureForError (), buffer_size.ToString (), TypeManager.CSharpName (MemberType));
+ GetSignatureForError (), buffer_size.ToString (), MemberType.GetSignatureForError ());
return;
}
{
readonly FieldSpec element;
- public FixedFieldSpec (TypeSpec declaringType, IMemberDefinition definition, FieldInfo info, FieldSpec element, Modifiers modifiers)
- : base (declaringType, definition, element.MemberType, info, modifiers)
+ public FixedFieldSpec (ModuleContainer module, TypeSpec declaringType, IMemberDefinition definition, FieldInfo info, FieldSpec element, Modifiers modifiers)
+ : base (declaringType, definition, PointerContainer.MakeType (module, element.MemberType), info, modifiers)
{
this.element = element;
return element;
}
}
-
+
public TypeSpec ElementType {
get {
- return MemberType;
+ return element.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))
- return true;
-
switch (MemberType.BuiltinType) {
case BuiltinTypeSpec.Type.Bool:
case BuiltinTypeSpec.Type.Char:
return true;
}
+ if (TypeSpec.IsReferenceType (MemberType))
+ return true;
+
if (MemberType.IsEnum)
return true;
return false;
}
+ public override void Accept (StructuralVisitor visitor)
+ {
+ visitor.Visit (this);
+ }
+
public override bool Define ()
{
if (!base.Define ())
MetaType[] required_modifier = null;
if ((ModFlags & Modifiers.VOLATILE) != 0) {
- var mod = Module.PredefinedTypes.IsVolatile.Resolve (Location);
+ var mod = Module.PredefinedTypes.IsVolatile.Resolve ();
if (mod != null)
required_modifier = new MetaType[] { mod.GetMetaInfo () };
}
spec = new FieldSpec (Parent.Definition, this, MemberType, FieldBuilder, ModFlags);
- // Don't cache inaccessible fields
- if ((ModFlags & Modifiers.BACKING_FIELD) == 0) {
+ //
+ // 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 (spec, initializer, this));
+ Parent.RegisterFieldForInitialization (this, new FieldInitializer (this, initializer, TypeExpression.Location));
}
if (declarators != null) {
- var t = new TypeExpression (MemberType, TypeExpression.Location);
- int index = Parent.PartialContainer.Fields.IndexOf (this);
foreach (var d in declarators) {
- var f = new Field (Parent, t, ModFlags, new MemberName (d.Name.Value, d.Name.Location), OptAttributes);
+ 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;
- Parent.PartialContainer.Fields.Insert (++index, f);
+ f.Define ();
+ Parent.PartialContainer.Members.Add (f);
}
}
-/*
- if ((ModFlags & (Modifiers.STATIC | Modifiers.READONLY | Modifiers.COMPILER_GENERATED)) == Modifiers.STATIC)
- Console.WriteLine ("{0}: {1}", Location.ToString (), GetSignatureForError ());
-*/
return true;
}
if ((ModFlags & Modifiers.VOLATILE) != 0) {
if (!CanBeVolatile ()) {
Report.Error (677, Location, "`{0}': A volatile field cannot be of the type `{1}'",
- GetSignatureForError (), TypeManager.CSharpName (MemberType));
+ GetSignatureForError (), MemberType.GetSignatureForError ());
}
if ((ModFlags & Modifiers.READONLY) != 0) {
projects / mono.git / blobdiff