name.Name);
}
- public static void Error_AttributeArgumentNotValid (IMemberContext rc, Location loc)
+ public static void Error_AttributeArgumentIsDynamic (IMemberContext context, Location loc)
{
- rc.Compiler.Report.Error (182, loc,
- "An attribute argument must be a constant expression, typeof " +
- "expression or array creation expression");
+ context.Compiler.Report.Error (1982, loc, "An attribute argument cannot be dynamic expression");
}
public void Error_MissingGuidAttribute ()
public bool HasSecurityAttribute {
get {
- PredefinedAttribute pa = PredefinedAttributes.Get.Security;
- return pa.IsDefined && TypeManager.IsSubclassOf (type, pa.Type);
+ PredefinedAttribute pa = context.Compiler.PredefinedAttributes.Security;
+ return pa.IsDefined && TypeSpec.IsBaseClass (type, pa.Type, false);
}
}
void ApplyModuleCharSet (ResolveContext rc)
{
- if (Type != PredefinedAttributes.Get.DllImport)
+ if (Type != context.Compiler.PredefinedAttributes.DllImport)
return;
if (!RootContext.ToplevelTypes.HasDefaultCharSet)
}
}
- var char_set = Import.ImportType (typeof (CharSet));
+ var char_set = rc.Compiler.MetaImporter.ImportType (typeof (CharSet)); // TODO: typeof
NamedArguments.Add (new NamedArgument (CharSetEnumMember, loc,
Constant.CreateConstant (rc, char_set, RootContext.ToplevelTypes.DefaultCharSet, Location)));
}
bool dynamic;
PosArguments.Resolve (ec, out dynamic);
if (dynamic) {
- Error_AttributeArgumentNotValid (ec, loc);
+ Error_AttributeArgumentIsDynamic (ec.MemberContext, loc);
return null;
}
}
a.Resolve (ec);
- Expression member = Expression.MemberLookup (ec, ec.CurrentType, Type, name, 0, false, loc);
+ Expression member = Expression.MemberLookup (ec, ec.CurrentType, Type, name, 0, MemberLookupRestrictions.ExactArity, loc);
if (member == null) {
- member = Expression.MemberLookup (null, ec.CurrentType, Type, name, 0, false, loc);
+ member = Expression.MemberLookup (null, ec.CurrentType, Type, name, 0, MemberLookupRestrictions.ExactArity, loc);
if (member != null) {
// TODO: ec.Report.SymbolRelatedToPreviousError (member);
if (member is PropertyExpr) {
var pi = ((PropertyExpr) member).PropertyInfo;
- if (!pi.HasSet || !pi.HasGet || pi.IsStatic) {
+ if (!pi.HasSet || !pi.HasGet || pi.IsStatic || !pi.Get.IsPublic || !pi.Set.IsPublic) {
ec.Report.SymbolRelatedToPreviousError (pi);
Error_InvalidNamedArgument (ec, a);
return false;
}
obsolete_attr = pi.GetAttributeObsolete ();
+ pi.MemberDefinition.SetIsAssigned ();
} else {
var fi = ((FieldExpr) member).Spec;
- if (fi.IsReadOnly || fi.IsStatic) {
+ if (fi.IsReadOnly || fi.IsStatic || !fi.IsPublic) {
Error_InvalidNamedArgument (ec, a);
return false;
}
}
obsolete_attr = fi.GetAttributeObsolete ();
+ fi.MemberDefinition.SetIsAssigned ();
}
if (obsolete_attr != null && !context.IsObsolete)
public string GetValidTargets ()
{
StringBuilder sb = new StringBuilder ();
- AttributeTargets targets = Type.GetAttributeUsage (PredefinedAttributes.Get.AttributeUsage).ValidOn;
+ AttributeTargets targets = Type.GetAttributeUsage (context.Compiler.PredefinedAttributes.AttributeUsage).ValidOn;
if ((targets & AttributeTargets.Assembly) != 0)
sb.Append ("assembly, ");
public bool IsInternalMethodImplAttribute {
get {
- if (Type != PredefinedAttributes.Get.MethodImpl)
+ if (Type != context.Compiler.PredefinedAttributes.MethodImpl)
return false;
MethodImplOptions options;
if (ctor == null)
return;
- AttributeUsageAttribute usage_attr = Type.GetAttributeUsage (PredefinedAttributes.Get.AttributeUsage);
+ var predefined = context.Compiler.PredefinedAttributes;
+
+ AttributeUsageAttribute usage_attr = Type.GetAttributeUsage (predefined.AttributeUsage);
if ((usage_attr.ValidOn & Target) == 0) {
Report.Error (592, Location, "The attribute `{0}' is not valid on this declaration type. " +
"It is valid on `{1}' declarations only",
return;
}
- var predefined = PredefinedAttributes.Get;
-
AttributeEncoder encoder = new AttributeEncoder (false);
if (PosArguments != null) {
var param_types = ctor.Parameters.Types;
for (int j = 0; j < PosArguments.Count; ++j) {
var pt = param_types[j];
- if (!IsValidArgumentType (pt)) {
- Error_AttributeArgumentNotValid (context, loc);
- return;
- }
-
var arg_expr = PosArguments[j].Expr;
if (j == 0) {
if (Type == predefined.IndexerName || Type == predefined.Conditional) {
public struct AttributeEncoder
{
+ [Flags]
+ public enum EncodedTypeProperties
+ {
+ None = 0,
+ DynamicType = 1,
+ TypeParameter = 1 << 1
+ }
+
public readonly BinaryWriter Stream;
public AttributeEncoder (bool empty)
Stream.Write (buf);
}
- public void Encode (TypeSpec type)
+ public EncodedTypeProperties Encode (TypeSpec type)
{
if (type == TypeManager.bool_type) {
Stream.Write ((byte) 0x02);
EncodeTypeName (type);
} else if (type.IsArray) {
Stream.Write ((byte) 0x1D);
- Encode (TypeManager.GetElementType (type));
- } else {
- throw new NotImplementedException (type.ToString ());
+ return Encode (TypeManager.GetElementType (type));
+ } else if (type == InternalType.Dynamic) {
+ Stream.Write ((byte) 0x51);
+ return EncodedTypeProperties.DynamicType;
}
+
+ return EncodedTypeProperties.None;
}
public void EncodeTypeName (TypeSpec type)
public static void VerifyModulesClsCompliance (CompilerContext ctx)
{
- Module[] modules = GlobalRootNamespace.Instance.Modules;
+ Module[] modules = ctx.GlobalRootNamespace.Modules;
if (modules == null)
return;
public readonly PredefinedAttribute StructLayout;
public readonly PredefinedAttribute FieldOffset;
- public static PredefinedAttributes Get = new PredefinedAttributes ();
-
- private PredefinedAttributes ()
+ public PredefinedAttributes ()
{
ParamArray = new PredefinedAttribute ("System", "ParamArrayAttribute");
Out = new PredefinedAttribute ("System.Runtime.InteropServices", "OutAttribute");
((PredefinedAttribute) fi.GetValue (this)).Initialize (ctx, true);
}
}
-
- public static void Reset ()
- {
- Get = new PredefinedAttributes ();
- }
}
public class PredefinedAttribute