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;
}
}
- MethodGroupExpr mg = MemberLookupFinal (ec, ec.CurrentType,
- Type, ConstructorInfo.ConstructorName, 0, MemberKind.Constructor,
- BindingRestriction.AccessibleOnly | BindingRestriction.DeclaredOnly,
- Location) as MethodGroupExpr;
-
- if (mg == null)
- throw new NotImplementedException ();
-
- mg = mg.OverloadResolve (ec, ref PosArguments, false, Location);
- if (mg == null)
- return null;
-
- var constructor = (MethodSpec) mg;
- return constructor;
+ return ConstructorLookup (ec, Type, ref PosArguments, loc);
}
protected virtual bool ResolveNamedArguments (ResolveContext ec)
a.Resolve (ec);
- Expression member = Expression.MemberLookup (ec.Compiler,
- ec.CurrentType, Type, name, 0,
- MemberKind.All,
- BindingRestriction.AccessibleOnly,
- Location);
+ Expression member = Expression.MemberLookup (ec, ec.CurrentType, Type, name, 0, MemberLookupRestrictions.ExactArity, loc);
if (member == null) {
- member = Expression.MemberLookup (ec.Compiler, ec.CurrentType, Type, name, 0,
- MemberKind.All, BindingRestriction.None,
- Location);
+ member = Expression.MemberLookup (null, ec.CurrentType, Type, name, 0, MemberLookupRestrictions.ExactArity, loc);
if (member != null) {
- ec.Report.SymbolRelatedToPreviousError (member.Type);
- Expression.ErrorIsInaccesible (Location, member.GetSignatureForError (), ec.Report);
+ // TODO: ec.Report.SymbolRelatedToPreviousError (member);
+ Expression.ErrorIsInaccesible (ec, member.GetSignatureForError (), loc);
return false;
}
}
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, ");
/// </summary>
public ObsoleteAttribute GetObsoleteAttribute ()
{
- if (!arg_resolved)
+ if (!arg_resolved) {
+ // corlib only case when obsolete is used before is resolved
+ var c = type.MemberDefinition as Class;
+ if (c != null && !c.HasMembersDefined)
+ c.Define ();
+
// TODO: It is not neccessary to call whole Resolve (ApplyAttribute does it now) we need only ctor args.
// But because a lot of attribute class code must be rewritten will be better to wait...
Resolve ();
+ }
if (resolve_error)
return null;
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) {
foreach (Attributable target in targets)
target.ApplyAttributeBuilder (this, ctor, cdata, predefined);
} catch (Exception e) {
- var w = e;
Error_AttributeEmitError (e.Message);
return;
}
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 bool EncodeTypeName (TypeSpec type)
+ public void EncodeTypeName (TypeSpec type)
{
-// if (TypeManager.ContainsGenericParameters (type) && !TypeManager.IsGenericTypeDefinition (type))
-// return false;
-
var old_type = type.GetMetaInfo ();
Encode (type.MemberDefinition.IsImported ? old_type.AssemblyQualifiedName : old_type.FullName);
- return true;
}
void WriteCompressedValue (int value)
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
projects / mono.git / blobdiff