}
}
+ public void SetOwner (Attributable owner)
+ {
+ targets [0] = owner;
+ }
+
/// <summary>
/// Tries to resolve the type of the attribute. Flags an error if it can't, and complain is true.
/// </summary>
return ((MethodImplOptions) value | all) == all;
}
- static bool IsValidArgumentType (TypeSpec t)
+ public static bool IsValidArgumentType (TypeSpec t)
{
if (t.IsArray) {
var ac = (ArrayContainer) t;
return null;
}
- ObsoleteAttribute obsolete_attr = Type.GetAttributeObsolete ();
- if (obsolete_attr != null) {
- AttributeTester.Report_ObsoleteMessage (obsolete_attr, Type.GetSignatureForError (), Location, Report);
- }
+ Type.CheckObsoleteness (context, expression.StartLocation);
ResolveContext rc = null;
return false;
}
- ObsoleteAttribute obsolete_attr;
-
if (member is PropertyExpr) {
var pi = ((PropertyExpr) member).PropertyInfo;
return false;
}
- obsolete_attr = pi.GetAttributeObsolete ();
+// if (!context.IsObsolete)
+ pi.CheckObsoleteness (ec, member.StartLocation);
+
pi.MemberDefinition.SetIsAssigned ();
} else {
var fi = ((FieldExpr) member).Spec;
return false;
}
- obsolete_attr = fi.GetAttributeObsolete ();
+// if (!context.IsObsolete)
+ fi.CheckObsoleteness (ec, member.StartLocation);
+
fi.MemberDefinition.SetIsAssigned ();
}
- if (obsolete_attr != null && !context.IsObsolete)
- AttributeTester.Report_ObsoleteMessage (obsolete_attr, member.GetSignatureForError (), member.Location, Report);
-
if (a.Type != member.Type) {
a.Expr = Convert.ImplicitConversionRequired (ec, a.Expr, member.Type, a.Expr.Location);
}
/// </summary>
bool IsSecurityActionValid ()
{
- SecurityAction action = GetSecurityActionValue ();
+ Constant c = null;
+ var action = GetSecurityActionValue (ref c);
bool for_assembly = Target == AttributeTargets.Assembly || Target == AttributeTargets.Module;
- var c = (Constant)pos_args [0].Expr;
switch (action) {
#pragma warning disable 618
return true;
break;
#pragma warning restore 618
+ case null:
+ Report.Error (7048, loc, "First argument of a security attribute `{0}' must be a valid SecurityAction",
+ Type.GetSignatureForError ());
+ return false;
default:
Report.Error (7049, c.Location, "Security attribute `{0}' has an invalid SecurityAction value `{1}'",
return false;
}
- System.Security.Permissions.SecurityAction GetSecurityActionValue ()
+ SecurityAction? GetSecurityActionValue (ref Constant value)
{
- return (SecurityAction) ((Constant) pos_args[0].Expr).GetValue ();
+ if (pos_args == null) {
+ var predefined = context.Module.PredefinedAttributes;
+
+ //
+ // BCL defines System.Security.Permissions.HostProtectionAttribute with parameterless
+ // contructor which should not be valid but it's already part of the framework
+ //
+ if (Type == predefined.HostProtection.TypeSpec) {
+ value = new IntConstant (context.Module.Compiler.BuiltinTypes, (int)SecurityAction.LinkDemand, loc);
+ return SecurityAction.LinkDemand;
+ }
+
+ return null;
+ }
+
+ value = (Constant) pos_args [0].Expr;
+ return (SecurityAction) value.GetValue ();
}
/// <summary>
public void ExtractSecurityPermissionSet (MethodSpec ctor, ref SecurityType permissions)
{
#if STATIC
- object[] values = new object[pos_args.Count];
- for (int i = 0; i < values.Length; ++i)
- values[i] = ((Constant) pos_args[i].Expr).GetValue ();
+ object[] values;
+ if (pos_args != null) {
+ values = new object[pos_args.Count];
+ for (int i = 0; i < values.Length; ++i)
+ values[i] = ((Constant) pos_args[i].Expr).GetValue ();
+ } else {
+ values = null;
+ }
PropertyInfo[] prop;
object[] prop_values;
}
}
- arg_expr.EncodeAttributeValue (context, encoder, pt);
+ arg_expr.EncodeAttributeValue (context, encoder, pt, pt);
}
}
encoder.Encode (na.Key.Type);
encoder.Encode (na.Value.Name);
- na.Value.Expr.EncodeAttributeValue (context, encoder, na.Key.Type);
+ na.Value.Expr.EncodeAttributeValue (context, encoder, na.Key.Type, na.Key.Type);
}
} else {
encoder.EncodeEmptyNamedArguments ();
Attrs.AddRange (attrs);
}
+ public static void AttachFromPartial (Attributable target, Attributable partialSrc)
+ {
+ if (target.OptAttributes == null) {
+ target.OptAttributes = partialSrc.OptAttributes;
+ } else {
+ target.OptAttributes.Attrs.AddRange (partialSrc.OptAttributes.Attrs);
+ }
+
+ foreach (var attr in partialSrc.OptAttributes.Attrs) {
+ attr.SetOwner (target);
+ }
+ }
+
public void AttachTo (Attributable attributable, IMemberContext context)
{
foreach (Attribute a in Attrs)
Encode ((byte) 0x54); // property
Encode (property.MemberType);
Encode (property.Name);
- value.EncodeAttributeValue (null, this, property.MemberType);
+ value.EncodeAttributeValue (null, this, property.MemberType, property.MemberType);
}
//
Encode ((byte) 0x53); // field
Encode (field.MemberType);
Encode (field.Name);
- value.EncodeAttributeValue (null, this, field.MemberType);
+ value.EncodeAttributeValue (null, this, field.MemberType, field.MemberType);
}
public void EncodeNamedArguments<T> (T[] members, Constant[] values) where T : MemberSpec, IInterfaceMemberSpec
Encode (member.MemberType);
Encode (member.Name);
- values [i].EncodeAttributeValue (null, this, member.MemberType);
+ values [i].EncodeAttributeValue (null, this, member.MemberType, member.MemberType);
}
}
public readonly PredefinedAttribute AssemblyAlgorithmId;
public readonly PredefinedAttribute AssemblyFlags;
public readonly PredefinedAttribute AssemblyFileVersion;
+ public readonly PredefinedAttribute AssemblyInformationalVersion;
public readonly PredefinedAttribute ComImport;
public readonly PredefinedAttribute CoClass;
public readonly PredefinedAttribute AttributeUsage;
public readonly PredefinedDebuggerBrowsableAttribute DebuggerBrowsable;
public readonly PredefinedAttribute DebuggerStepThrough;
public readonly PredefinedDebuggableAttribute Debuggable;
+ public readonly PredefinedAttribute HostProtection;
// New in .NET 3.5
public readonly PredefinedAttribute Extension;
public readonly PredefinedAttribute FieldOffset;
public readonly PredefinedAttribute AssemblyProduct;
public readonly PredefinedAttribute AssemblyCompany;
- public readonly PredefinedAttribute AssemblyDescription;
public readonly PredefinedAttribute AssemblyCopyright;
public readonly PredefinedAttribute AssemblyTrademark;
public readonly PredefinedAttribute CallerMemberNameAttribute;
DefaultParameterValue = new PredefinedAttribute (module, "System.Runtime.InteropServices", "DefaultParameterValueAttribute");
OptionalParameter = new PredefinedAttribute (module, "System.Runtime.InteropServices", "OptionalAttribute");
UnverifiableCode = new PredefinedAttribute (module, "System.Security", "UnverifiableCodeAttribute");
+ HostProtection = new PredefinedAttribute (module, "System.Security.Permissions", "HostProtectionAttribute");
DefaultCharset = new PredefinedAttribute (module, "System.Runtime.InteropServices", "DefaultCharSetAttribute");
TypeForwarder = new PredefinedAttribute (module, "System.Runtime.CompilerServices", "TypeForwardedToAttribute");
FieldOffset = new PredefinedAttribute (module, "System.Runtime.InteropServices", "FieldOffsetAttribute");
AssemblyProduct = new PredefinedAttribute (module, "System.Reflection", "AssemblyProductAttribute");
AssemblyCompany = new PredefinedAttribute (module, "System.Reflection", "AssemblyCompanyAttribute");
- AssemblyDescription = new PredefinedAttribute (module, "System.Reflection", "AssemblyDescriptionAttribute");
AssemblyCopyright = new PredefinedAttribute (module, "System.Reflection", "AssemblyCopyrightAttribute");
AssemblyTrademark = new PredefinedAttribute (module, "System.Reflection", "AssemblyTrademarkAttribute");
+ AssemblyInformationalVersion = new PredefinedAttribute (module, "System.Reflection", "AssemblyInformationalVersionAttribute");
AsyncStateMachine = new PredefinedStateMachineAttribute (module, "System.Runtime.CompilerServices", "AsyncStateMachineAttribute");
int[] bits = decimal.GetBits (value);
AttributeEncoder encoder = new AttributeEncoder ();
- encoder.Encode ((byte) (bits[3] >> 16));
- encoder.Encode ((byte) (bits[3] >> 31));
+ encoder.Encode ((byte) ((bits[3] & 0xFF0000) >> 16)); // Scale
+ encoder.Encode ((byte) ((bits[3] >> 31) << 7)); // Sign encoded as 0x80 for negative, 0x0 for possitive
encoder.Encode ((uint) bits[2]);
encoder.Encode ((uint) bits[1]);
encoder.Encode ((uint) bits[0]);