// decl.cs: Declaration base class for structs, classes, enums and interfaces.
//
// Author: Miguel de Icaza (miguel@gnu.org)
+// Marek Safar (marek.safar@seznam.cz)
//
// Licensed under the terms of the GNU GPL
//
using System;
using System.Text;
using System.Collections;
+using System.Globalization;
using System.Reflection.Emit;
using System.Reflection;
namespace Mono.CSharp {
- public class MemberName {
+ public class TypeName {
public readonly string Name;
public readonly TypeArguments TypeArguments;
- public readonly MemberName Left;
+ public readonly TypeName Left;
- public static readonly MemberName Null = new MemberName ("");
+ public static readonly TypeName Null = new TypeName ("");
- public MemberName (string name)
+ public TypeName (string name)
{
this.Name = name;
}
- public MemberName (string name, TypeArguments args)
+ public TypeName (string name, TypeArguments args)
: this (name)
{
this.TypeArguments = args;
}
- public MemberName (MemberName left, string name, TypeArguments args)
+ public TypeName (TypeName left, string name, TypeArguments args)
: this (name, args)
{
this.Left = left;
return Name;
}
+ public int CountTypeArguments {
+ get {
+ if (TypeArguments == null)
+ return 0;
+ else
+ return TypeArguments.Count;
+ }
+ }
+
public string GetFullName ()
{
string full_name;
return full_name;
}
- public string GetMemberName ()
+ public string GetTypeName (bool full)
{
- string full_name;
+ string suffix = "";
+ if (full && (TypeArguments != null))
+ suffix = "!" + TypeArguments.Count;
if (Left != null)
- return Left.GetFullName () + "." + Name;
+ return Left.GetTypeName (full) + "." + Name + suffix;
else
- return Name;
+ return Name + suffix;
}
public Expression GetTypeExpression (Location loc)
if (Left != null) {
Expression lexpr = Left.GetTypeExpression (loc);
- if (TypeArguments != null)
- return new GenericMemberAccess (lexpr, Name, TypeArguments, loc);
- else
- return new MemberAccess (lexpr, Name, loc);
+ return new MemberAccess (lexpr, Name, TypeArguments, loc);
} else {
if (TypeArguments != null)
return new ConstructedType (Name, TypeArguments, loc);
}
}
+ public MemberName GetMemberName ()
+ {
+ if (TypeArguments != null) {
+ string[] type_params = TypeArguments.GetDeclarations ();
+ return new MemberName (Left, Name, type_params);
+ } else
+ return new MemberName (Left, Name);
+ }
+
public override string ToString ()
{
string full_name;
}
}
+ public class MemberName {
+ public readonly TypeName TypeName;
+ public readonly string Name;
+ public readonly string[] TypeParameters;
+
+ public MemberName (string name)
+ {
+ this.Name = name;
+ }
+
+ public MemberName (TypeName type, string name)
+ {
+ this.TypeName = type;
+ this.Name = name;
+ }
+
+ public MemberName (TypeName type, MemberName name)
+ {
+ this.TypeName = type;
+ this.Name = name.Name;
+ this.TypeParameters = name.TypeParameters;
+ }
+
+ public MemberName (TypeName type, string name, ArrayList type_params)
+ : this (type, name)
+ {
+ if (type_params != null) {
+ TypeParameters = new string [type_params.Count];
+ type_params.CopyTo (TypeParameters, 0);
+ }
+ }
+
+ public MemberName (TypeName type, string name, string[] type_params)
+ : this (type, name)
+ {
+ this.TypeParameters = type_params;
+ }
+
+ public TypeName MakeTypeName (Location loc)
+ {
+ if (TypeParameters != null) {
+ TypeArguments args = new TypeArguments (loc);
+ foreach (string param in TypeParameters)
+ args.Add (new SimpleName (param, loc));
+ return new TypeName (TypeName, Name, args);
+ }
+
+ return new TypeName (TypeName, Name, null);
+ }
+
+ public static readonly MemberName Null = new MemberName ("");
+
+ public string Basename {
+ get {
+ if (TypeParameters != null)
+ return Name + "!" + TypeParameters.Length;
+ else
+ return Name;
+ }
+ }
+
+ public string GetName (bool is_generic)
+ {
+ string name = is_generic ? Basename : Name;
+ if (TypeName != null)
+ return TypeName.GetTypeName (is_generic) + "." + name;
+ else
+ return name;
+ }
+
+ public int CountTypeParameters {
+ get {
+ if (TypeParameters != null)
+ return 0;
+ else
+ return TypeParameters.Length;
+ }
+ }
+
+ protected string PrintTypeParams ()
+ {
+ if (TypeParameters != null) {
+ StringBuilder sb = new StringBuilder ();
+ sb.Append ("<");
+ for (int i = 0; i < TypeParameters.Length; i++) {
+ if (i > 0)
+ sb.Append (",");
+ sb.Append (TypeParameters [i]);
+ }
+ sb.Append (">");
+ return sb.ToString ();
+ }
+
+ return "";
+ }
+
+ public string FullName {
+ get {
+ string full_name = Name + PrintTypeParams ();
+
+ if (TypeName != null)
+ return TypeName + "." + full_name;
+ else
+ return full_name;
+ }
+ }
+
+ public override string ToString ()
+ {
+ return String.Format ("MemberName [{0}:{1}:{2}]",
+ TypeName, Name, PrintTypeParams ());
+ }
+ }
+
/// <summary>
- /// Base representation for members. This is only used to keep track
- /// of Name, Location and Modifier flags.
+ /// Base representation for members. This is used to keep track
+ /// of Name, Location and Modifier flags, and handling Attributes.
/// </summary>
- public abstract class MemberCore {
+ public abstract class MemberCore : Attributable {
/// <summary>
/// Public name
/// </summary>
public string Name;
+ public readonly MemberName MemberName;
+
/// <summary>
/// Modifier flags that the user specified in the source code
/// </summary>
/// </summary>
public readonly Location Location;
+ [Flags]
+ public enum Flags {
+ Obsolete_Undetected = 1, // Obsolete attribute has not been detected yet
+ Obsolete = 1 << 1, // Type has obsolete attribute
+ ClsCompliance_Undetected = 1 << 2, // CLS Compliance has not been detected yet
+ ClsCompliant = 1 << 3, // Type is CLS Compliant
+ CloseTypeCreated = 1 << 4, // Tracks whether we have Closed the type
+ HasCompliantAttribute_Undetected = 1 << 5, // Presence of CLSCompliantAttribute has not been detected
+ HasClsCompliantAttribute = 1 << 6, // Type has CLSCompliantAttribute
+ ClsCompliantAttributeTrue = 1 << 7, // Type has CLSCompliant (true)
+ Excluded_Undetected = 1 << 8, // Conditional attribute has not been detected yet
+ Excluded = 1 << 9 // Method is conditional
+
+ }
+
/// <summary>
- /// Attributes for this type
- /// </summary>
- Attributes attributes;
+ /// MemberCore flags at first detected then cached
+ /// </summary>
+ protected Flags caching_flags;
- public MemberCore (string name, Attributes attrs, Location loc)
+ public MemberCore (MemberName name, Attributes attrs, Location loc)
+ : base (attrs)
{
- Name = name;
+ Name = name.GetName (!(this is GenericMethod) && !(this is Method));
+ MemberName = name;
Location = loc;
- attributes = attrs;
+ caching_flags = Flags.Obsolete_Undetected | Flags.ClsCompliance_Undetected | Flags.HasCompliantAttribute_Undetected | Flags.Excluded_Undetected;
+ }
+
+ /// <summary>
+ /// Tests presence of ObsoleteAttribute and report proper error
+ /// </summary>
+ protected void CheckUsageOfObsoleteAttribute (Type type)
+ {
+ if (type == null)
+ return;
+
+ ObsoleteAttribute obsolete_attr = AttributeTester.GetObsoleteAttribute (type);
+ if (obsolete_attr == null)
+ return;
+
+ AttributeTester.Report_ObsoleteMessage (obsolete_attr, type.FullName, Location);
}
public abstract bool Define (TypeContainer parent);
//
// Returns full member name for error message
//
- public virtual string GetSignatureForError () {
+ public virtual string GetSignatureForError ()
+ {
return Name;
}
- public Attributes OptAttributes
+ /// <summary>
+ /// Base Emit method. This is also entry point for CLS-Compliant verification.
+ /// </summary>
+ public virtual void Emit (TypeContainer container)
{
- get {
- return attributes;
- }
- set {
- attributes = value;
- }
+ VerifyObsoleteAttribute ();
+
+ if (!RootContext.VerifyClsCompliance)
+ return;
+
+ VerifyClsCompliance (container);
}
//
Expression.UnsafeError (Location);
return false;
}
+
+ /// <summary>
+ /// Returns instance of ObsoleteAttribute for this MemberCore
+ /// </summary>
+ public ObsoleteAttribute GetObsoleteAttribute (DeclSpace ds)
+ {
+ // ((flags & (Flags.Obsolete_Undetected | Flags.Obsolete)) == 0) is slower, but why ?
+ if ((caching_flags & Flags.Obsolete_Undetected) == 0 && (caching_flags & Flags.Obsolete) == 0) {
+ return null;
+ }
+
+ caching_flags &= ~Flags.Obsolete_Undetected;
+
+ if (OptAttributes == null)
+ return null;
+
+ // TODO: remove this allocation
+ EmitContext ec = new EmitContext (ds.Parent, ds, ds.Location,
+ null, null, ds.ModFlags, false);
+
+ Attribute obsolete_attr = OptAttributes.Search (TypeManager.obsolete_attribute_type, ec);
+ if (obsolete_attr == null)
+ return null;
+
+ ObsoleteAttribute obsolete = obsolete_attr.GetObsoleteAttribute (ds);
+ if (obsolete == null)
+ return null;
+
+ caching_flags |= Flags.Obsolete;
+ return obsolete;
+ }
+
+ /// <summary>
+ /// Analyze whether CLS-Compliant verification must be execute for this MemberCore.
+ /// </summary>
+ public override bool IsClsCompliaceRequired (DeclSpace container)
+ {
+ if ((caching_flags & Flags.ClsCompliance_Undetected) == 0)
+ return (caching_flags & Flags.ClsCompliant) != 0;
+
+ if (GetClsCompliantAttributeValue (container) && IsExposedFromAssembly (container)) {
+ caching_flags &= ~Flags.ClsCompliance_Undetected;
+ caching_flags |= Flags.ClsCompliant;
+ return true;
+ }
+
+ caching_flags &= ~Flags.ClsCompliance_Undetected;
+ return false;
+ }
+
+ /// <summary>
+ /// Returns true when MemberCore is exposed from assembly.
+ /// </summary>
+ protected bool IsExposedFromAssembly (DeclSpace ds)
+ {
+ if ((ModFlags & (Modifiers.PUBLIC | Modifiers.PROTECTED)) == 0)
+ return false;
+
+ DeclSpace parentContainer = ds;
+ while (parentContainer != null && parentContainer.ModFlags != 0) {
+ if ((parentContainer.ModFlags & (Modifiers.PUBLIC | Modifiers.PROTECTED)) == 0)
+ return false;
+ parentContainer = parentContainer.Parent;
+ }
+ return true;
+ }
+
+ /// <summary>
+ /// Resolve CLSCompliantAttribute value or gets cached value.
+ /// </summary>
+ bool GetClsCompliantAttributeValue (DeclSpace ds)
+ {
+ if (OptAttributes != null) {
+ EmitContext ec = new EmitContext (ds.Parent, ds, ds.Location,
+ null, null, ds.ModFlags, false);
+ Attribute cls_attribute = OptAttributes.GetClsCompliantAttribute (ec);
+ if (cls_attribute != null) {
+ caching_flags |= Flags.HasClsCompliantAttribute;
+ return cls_attribute.GetClsCompliantAttributeValue (ds);
+ }
+ }
+ return ds.GetClsCompliantAttributeValue ();
+ }
+
+ /// <summary>
+ /// Returns true if MemberCore is explicitly marked with CLSCompliantAttribute
+ /// </summary>
+ protected bool HasClsCompliantAttribute {
+ get {
+ return (caching_flags & Flags.HasClsCompliantAttribute) != 0;
+ }
+ }
+
+ /// <summary>
+ /// This method is used to testing error 3005 (Method or parameter name collision).
+ /// </summary>
+ protected abstract bool IsIdentifierClsCompliant (DeclSpace ds);
+
+ /// <summary>
+ /// Common helper method for identifier and parameters CLS-Compliant testing.
+ /// When return false error 3005 is reported. True means no violation.
+ /// And error 3006 tests are peformed here because of speed.
+ /// </summary>
+ protected bool IsIdentifierAndParamClsCompliant (DeclSpace ds, string name, MemberInfo methodBuilder, Type[] paramTypes)
+ {
+ MemberList ml = ds.FindMembers (MemberTypes.Event | MemberTypes.Field | MemberTypes.Method | MemberTypes.Property,
+ BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance, System.Type.FilterNameIgnoreCase, name);
+
+ if (ml.Count < 2)
+ return true;
+
+ bool error3006 = false;
+ for (int i = 0; i < ml.Count; ++i) {
+ MemberInfo mi = ml [i];
+ if (name == mi.Name) {
+ MethodBase method = mi as MethodBase;
+ if (method == null || method == methodBuilder || paramTypes == null || paramTypes.Length == 0)
+ continue;
+
+ if (AttributeTester.AreOverloadedMethodParamsClsCompliant (paramTypes, TypeManager.GetArgumentTypes (method))) {
+ error3006 = false;
+ continue;
+ }
+
+ error3006 = true;
+ }
+
+ // We need to test if member is not marked as CLSCompliant (false) and if type is not only internal
+ // because BindingFlags.Public returns internal types too
+ DeclSpace temp_ds = TypeManager.LookupDeclSpace (mi.DeclaringType);
+
+ // Type is external, we can get attribute directly
+ if (temp_ds == null) {
+ object[] cls_attribute = mi.GetCustomAttributes (TypeManager.cls_compliant_attribute_type, false);
+ if (cls_attribute.Length == 1 && (!((CLSCompliantAttribute)cls_attribute[0]).IsCompliant))
+ continue;
+ } else {
+ string tmp_name = String.Concat (temp_ds.Name, '.', mi.Name);
+
+ MemberCore mc = temp_ds.GetDefinition (tmp_name) as MemberCore;
+ if (!mc.IsClsCompliaceRequired (ds))
+ continue;
+ }
+
+ for (int ii = 0; ii < ml.Count; ++ii) {
+ mi = ml [ii];
+ if (name == mi.Name)
+ continue;
+ Report.SymbolRelatedToPreviousError (mi);
+ }
+
+ if (error3006)
+ Report.Error_T (3006, Location, GetSignatureForError ());
+
+ return error3006;
+
+ }
+ return true;
+ }
+
+ /// <summary>
+ /// The main virtual method for CLS-Compliant verifications.
+ /// The method returns true if member is CLS-Compliant and false if member is not
+ /// CLS-Compliant which means that CLS-Compliant tests are not necessary. A descendants override it
+ /// and add their extra verifications.
+ /// </summary>
+ protected virtual bool VerifyClsCompliance (DeclSpace ds)
+ {
+ if (!IsClsCompliaceRequired (ds)) {
+ if (HasClsCompliantAttribute && !IsExposedFromAssembly (ds)) {
+ Report.Warning_T (3019, Location, GetSignatureForError ());
+ }
+ return false;
+ }
+
+ if (!CodeGen.Assembly.IsClsCompliant) {
+ if (HasClsCompliantAttribute) {
+ Report.Error_T (3014, Location, GetSignatureForError ());
+ }
+ }
+
+ int index = Name.LastIndexOf ('.');
+ if (Name [index > 0 ? index + 1 : 0] == '_') {
+ Report.Error_T (3008, Location, GetSignatureForError () );
+ }
+
+ if (!IsIdentifierClsCompliant (ds)) {
+ Report.Error_T (3005, Location, GetSignatureForError ());
+ }
+
+ return true;
+ }
+
+ protected abstract void VerifyObsoleteAttribute ();
+
}
/// <summary>
/// provides the common foundation for managing those name
/// spaces.
/// </remarks>
- public abstract class DeclSpace : MemberCore {
+ public abstract class DeclSpace : MemberCore, IAlias {
/// <summary>
/// This points to the actual definition that is being
/// created with System.Reflection.Emit
/// </summary>
public TypeExpr CurrentType;
- /// <summary>
- /// This variable tracks whether we have Closed the type
- /// </summary>
- public bool Created = false;
-
//
// This is the namespace in which this typecontainer
// was declared. We use this to resolve names.
/// </summary>
protected Hashtable defined_names;
- bool is_generic;
+ readonly bool is_generic;
+ readonly int count_type_params;
//
// Whether we are Generic
TypeContainer parent;
- public DeclSpace (NamespaceEntry ns, TypeContainer parent, string name, Attributes attrs, Location l)
+ static string[] attribute_targets = new string [] { "type" };
+
+ public DeclSpace (NamespaceEntry ns, TypeContainer parent, MemberName name,
+ Attributes attrs, Location l)
: base (name, attrs, l)
{
NamespaceEntry = ns;
- Basename = name.Substring (1 + name.LastIndexOf ('.'));
+ Basename = name.Name;
defined_names = new Hashtable ();
+ if (name.TypeParameters != null) {
+ is_generic = true;
+ count_type_params = name.TypeParameters.Length;
+ }
+ if (parent != null)
+ count_type_params += parent.count_type_params;
this.parent = parent;
}
public void RecordDecl ()
{
if ((NamespaceEntry != null) && (parent == RootContext.Tree.Types))
- NamespaceEntry.DefineName (Basename, this);
+ NamespaceEntry.DefineName (MemberName.Basename, this);
}
/// <summary>
/// <summary>
/// Looks up the alias for the name
/// </summary>
- public string LookupAlias (string name)
+ public IAlias LookupAlias (string name)
{
if (NamespaceEntry != null)
return NamespaceEntry.LookupAlias (name);
public virtual void CloseType ()
{
- if (!Created){
+ if ((caching_flags & Flags.CloseTypeCreated) == 0){
try {
TypeBuilder.CreateType ();
} catch {
// Note that this still creates the type and
// it is possible to save it
}
- Created = true;
+ caching_flags |= Flags.CloseTypeCreated;
}
}
if (d == null)
return null;
+ return ResolveType (d, loc);
+ }
+
+ public Type ResolveType (TypeExpr d, Location loc)
+ {
if (!d.CheckAccessLevel (this)) {
- Report. Error (122, loc, "`" + d.Name + "' " +
- "is inaccessible because of its protection level");
+ Report.Error_T (122, loc, d.Name);
return null;
}
TypeContainer tc = TypeManager.LookupTypeContainer (t);
if ((tc != null) && tc.IsGeneric) {
+ if (!IsGeneric) {
+ int tnum = TypeManager.GetNumberOfTypeArguments (t);
+ Report.Error (305, loc,
+ "Using the generic type `{0}' " +
+ "requires {1} type arguments",
+ TypeManager.GetFullName (t), tnum);
+ return null;
+ }
+
ConstructedType ctype = new ConstructedType (
t, TypeParameters, loc);
return null;
if (e is SimpleName){
- SimpleName s = new SimpleName (((SimpleName) e).Name, -1, loc);
+ SimpleName s = new SimpleName (((SimpleName) e).Name, loc);
d = s.ResolveAsTypeTerminal (type_resolve_ec);
if ((d == null) || (d.Type == null)) {
return true;
case TypeAttributes.NotPublic:
- //
- // This test should probably use the declaringtype.
- //
- if (check_type.Assembly == tb.Assembly){
- return true;
- }
- return false;
-
+
+ // In same cases is null.
+ if (TypeBuilder == null)
+ return true;
+
+ //
+ // This test should probably use the declaringtype.
+ //
+ return check_type.Assembly == TypeBuilder.Assembly;
+
case TypeAttributes.NestedPublic:
return true;
return t;
}
- public static void Error_AmbiguousTypeReference (Location loc, string name, Type t1, Type t2)
+ public static void Error_AmbiguousTypeReference (Location loc, string name, string t1, string t2)
{
Report.Error (104, loc,
- String.Format ("`{0}' is an ambiguous reference ({1} or {2}) ", name,
- t1.FullName, t2.FullName));
+ "`{0}' is an ambiguous reference ({1} or {2})",
+ name, t1, t2);
}
public Type FindNestedType (Location loc, string name,
/// during the tree resolution process and potentially define
/// recursively the type
/// </remarks>
- public Type FindType (Location loc, string name, int num_type_args)
+ public Type FindType (Location loc, string name)
{
Type t;
bool error;
if (error)
return null;
- if ((t != null) &&
- containing_ds.CheckAccessLevel (t) &&
- TypeManager.CheckGeneric (t, num_type_args))
+ if ((t != null) && containing_ds.CheckAccessLevel (t))
return t;
current_type = current_type.BaseType;
if (error)
return null;
- if ((t != null) && TypeManager.CheckGeneric (t, num_type_args))
+ if (t != null)
return t;
}
if (error)
return null;
- if ((t != null) && TypeManager.CheckGeneric (t, num_type_args))
+ if (t != null)
return t;
//
if (error)
return null;
- if ((t != null) && TypeManager.CheckGeneric (t, num_type_args))
+ if (t != null)
return t;
+ if (name.IndexOf ('.') > 0)
+ continue;
+
+ IAlias alias_value = ns.LookupAlias (name);
+ if (alias_value != null) {
+ t = LookupInterfaceOrClass ("", alias_value.Name, out error);
+ if (error)
+ return null;
+
+ if (t != null)
+ return t;
+ }
+
//
// Now check the using clause list
//
if (error)
return null;
- if (match != null){
+ if (match != null) {
if (t != null){
if (CheckAccessLevel (match)) {
- Error_AmbiguousTypeReference (loc, name, t, match);
+ Error_AmbiguousTypeReference (loc, name, t.FullName, match.FullName);
return null;
}
continue;
t = match;
}
}
- if ((t != null) && TypeManager.CheckGeneric (t, num_type_args))
+ if (t != null)
return t;
}
get;
}
+ public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+ {
+ try {
+ TypeBuilder.SetCustomAttribute (cb);
+ } catch (System.ArgumentException e) {
+ Report.Warning (-21, a.Location,
+ "The CharSet named property on StructLayout\n"+
+ "\tdoes not work correctly on Microsoft.NET\n"+
+ "\tYou might want to remove the CharSet declaration\n"+
+ "\tor compile using the Mono runtime instead of the\n"+
+ "\tMicrosoft .NET runtime\n"+
+ "\tThe runtime gave the error: " + e);
+ }
+ }
+
+ /// <summary>
+ /// Goes through class hierarchy and get value of first CLSCompliantAttribute that found.
+ /// If no is attribute exists then return assembly CLSCompliantAttribute.
+ /// </summary>
+ public bool GetClsCompliantAttributeValue ()
+ {
+ if ((caching_flags & Flags.HasCompliantAttribute_Undetected) == 0)
+ return (caching_flags & Flags.ClsCompliantAttributeTrue) != 0;
+
+ caching_flags &= ~Flags.HasCompliantAttribute_Undetected;
+
+ if (OptAttributes != null) {
+ EmitContext ec = new EmitContext (parent, this, Location,
+ null, null, ModFlags, false);
+ Attribute cls_attribute = OptAttributes.GetClsCompliantAttribute (ec);
+ if (cls_attribute != null) {
+ caching_flags |= Flags.HasClsCompliantAttribute;
+ if (cls_attribute.GetClsCompliantAttributeValue (this)) {
+ caching_flags |= Flags.ClsCompliantAttributeTrue;
+ return true;
+ }
+ return false;
+ }
+ }
+
+ if (parent == null) {
+ if (CodeGen.Assembly.IsClsCompliant) {
+ caching_flags |= Flags.ClsCompliantAttributeTrue;
+ return true;
+ }
+ return false;
+ }
+
+ if (parent.GetClsCompliantAttributeValue ()) {
+ caching_flags |= Flags.ClsCompliantAttributeTrue;
+ return true;
+ }
+ return false;
+ }
+
+
+ // Tests container name for CLS-Compliant name (differing only in case)
+ // Possible optimalization: search in same namespace only
+ protected override bool IsIdentifierClsCompliant (DeclSpace ds)
+ {
+ int l = Name.Length;
+
+ if (Namespace.LookupNamespace (NamespaceEntry.FullName, false) != null) {
+ // Seek through all imported types
+ foreach (string type_name in TypeManager.all_imported_types.Keys)
+ {
+ if (l != type_name.Length)
+ continue;
+
+ if (String.Compare (Name, type_name, true, CultureInfo.InvariantCulture) == 0 &&
+ AttributeTester.IsClsCompliant (TypeManager.all_imported_types [type_name] as Type)) {
+ Report.SymbolRelatedToPreviousError ((Type)TypeManager.all_imported_types [type_name]);
+ return false;
+ }
+ }
+ }
+
+ // Seek through generated types
+ foreach (string name in RootContext.Tree.Decls.Keys) {
+ if (l != name.Length)
+ continue;
+
+ if (String.Compare (Name, name, true, CultureInfo.InvariantCulture) == 0) {
+
+ if (Name == name)
+ continue;
+
+ DeclSpace found_ds = RootContext.Tree.Decls[name] as DeclSpace;
+ if (found_ds.IsClsCompliaceRequired (found_ds.Parent)) {
+ Report.SymbolRelatedToPreviousError (found_ds.Location, found_ds.GetSignatureForError ());
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
//
// Extensions for generics
//
DeclSpace the_parent = parent;
if (this is GenericMethod)
- the_parent = the_parent.Parent;
+ the_parent = null;
int start = 0;
TypeParameter[] parent_params = null;
return type_param_list;
}
- ///
- /// Called by the parser to configure the type_parameter_list for this
- /// declaration space
- ///
- public AdditionResult SetParameterInfo (TypeArguments args,
- ArrayList constraints_list)
+ public AdditionResult SetParameterInfo (ArrayList constraints_list)
{
- string[] type_parameter_list = args.GetDeclarations ();
- if (type_parameter_list == null)
- return AdditionResult.Error;
-
- return SetParameterInfo (type_parameter_list, constraints_list);
- }
+ if (!is_generic) {
+ if (constraints_list != null) {
+ Report.Error (
+ 80, Location, "Contraints are not allowed " +
+ "on non-generic declarations");
+ return AdditionResult.Error;
+ }
- public AdditionResult SetParameterInfo (IList type_parameter_list,
- ArrayList constraints_list)
- {
- type_params = new TypeParameter [type_parameter_list.Count];
+ return AdditionResult.Success;
+ }
- //
- // Mark this type as Generic
- //
- is_generic = true;
+ type_params = new TypeParameter [MemberName.TypeParameters.Length];
//
// Register all the names
//
- for (int i = 0; i < type_parameter_list.Count; i++) {
- string name = (string) type_parameter_list [i];
+ for (int i = 0; i < MemberName.TypeParameters.Length; i++) {
+ string name = MemberName.TypeParameters [i];
AdditionResult res = IsValid (name, name);
public int CountTypeParameters {
get {
- if (!IsGeneric)
- return 0;
- if (type_param_list == null)
- initialize_type_params ();
-
- return type_param_list.Length;
+ return count_type_params;
}
}
return null;
}
+
+ bool IAlias.IsType {
+ get { return true; }
+ }
+
+ string IAlias.Name {
+ get { return Name; }
+ }
+
+ TypeExpr IAlias.Type
+ {
+ get {
+ if (TypeBuilder == null)
+ throw new InvalidOperationException ();
+
+ if (CurrentType != null)
+ return CurrentType;
+
+ return new TypeExpression (TypeBuilder, Location);
+ }
+ }
+
+ protected override string[] ValidAttributeTargets {
+ get {
+ return attribute_targets;
+ }
+ }
}
/// <summary>
protected Hashtable member_hash;
protected Hashtable method_hash;
- Hashtable interface_hash;
-
/// <summary>
/// Create a new MemberCache for the given IMemberContainer `container'.
/// </summary>
// TypeManager.object_type), we deep-copy its MemberCache here.
if (Container.IsInterface) {
MemberCache parent;
- interface_hash = new Hashtable ();
if (Container.Parent != null)
parent = Container.Parent.MemberCache;
// If this is neither a dynamic type nor an interface, create a special
// method cache with all declared and inherited methods.
Type type = container.Type;
- if (!(type is TypeBuilder) && !type.IsInterface) {
+ if (!(type is TypeBuilder) && !type.IsInterface && !type.IsGenericParameter) {
method_hash = new Hashtable ();
AddMethods (type);
}
/// <summary>
/// Add the contents of `new_hash' to `hash'.
/// </summary>
- void AddHashtable (Hashtable hash, Hashtable new_hash)
+ void AddHashtable (Hashtable hash, MemberCache cache)
{
+ Hashtable new_hash = cache.member_hash;
IDictionaryEnumerator it = new_hash.GetEnumerator ();
while (it.MoveNext ()) {
ArrayList list = (ArrayList) hash [it.Key];
- if (list != null)
- list.AddRange ((ArrayList) it.Value);
- else
- hash [it.Key] = ((ArrayList) it.Value).Clone ();
+ if (list == null)
+ hash [it.Key] = list = new ArrayList ();
+
+ foreach (CacheEntry entry in (ArrayList) it.Value) {
+ if (entry.Container != cache.Container)
+ break;
+ list.Add (entry);
+ }
}
}
foreach (TypeExpr iface in ifaces) {
Type itype = iface.Type;
- if (interface_hash.Contains (itype))
- continue;
-
- interface_hash [itype] = null;
-
IMemberContainer iface_container =
TypeManager.LookupMemberContainer (itype);
MemberCache iface_cache = iface_container.MemberCache;
- AddHashtable (hash, iface_cache.member_hash);
-
- if (iface_cache.interface_hash == null)
- continue;
-
- foreach (Type parent_contains in iface_cache.interface_hash.Keys)
- interface_hash [parent_contains] = null;
+ AddHashtable (hash, iface_cache);
}
return hash;
ArrayList global = new ArrayList ();
bool using_global = false;
- public MemberList FindMembers (MemberTypes mt, BindingFlags bf, string name,
+ static MemberInfo [] emptyMemberInfo = new MemberInfo [0];
+
+ public MemberInfo [] FindMembers (MemberTypes mt, BindingFlags bf, string name,
MemberFilter filter, object criteria)
{
if (using_global)
applicable = (ArrayList) method_hash [name];
else
applicable = (ArrayList) member_hash [name];
-
+
if (applicable == null)
- return MemberList.Empty;
+ return emptyMemberInfo;
//
// 32 slots gives 53 rss/54 size
IMemberContainer current = Container;
+
// `applicable' is a list of all members with the given member name `name'
// in the current class and all its parent classes. The list is sorted in
// reverse order due to the way how the cache is initialy created (to speed
using_global = false;
MemberInfo [] copy = new MemberInfo [global.Count];
global.CopyTo (copy);
- return new MemberList (copy);
+ return copy;
}
//
for (int i = applicable.Count - 1; i >= 0; i--) {
CacheEntry entry = (CacheEntry) applicable [i];
- if ((entry.EntryType & (is_property ? EntryType.Property : EntryType.Method)) == 0)
+ if ((entry.EntryType & (is_property ? (EntryType.Property | EntryType.Field) : EntryType.Method)) == 0)
continue;
PropertyInfo pi = null;
MethodInfo mi = null;
- Type [] cmpAttrs;
+ FieldInfo fi = null;
+ Type [] cmpAttrs = null;
if (is_property) {
- pi = (PropertyInfo) entry.Member;
- cmpAttrs = TypeManager.GetArgumentTypes (pi);
+ if ((entry.EntryType & EntryType.Field) != 0) {
+ fi = (FieldInfo)entry.Member;
+
+ // TODO: For this case we ignore member type
+ //fb = TypeManager.GetField (fi);
+ //cmpAttrs = new Type[] { fb.MemberType };
+ } else {
+ pi = (PropertyInfo) entry.Member;
+ cmpAttrs = TypeManager.GetArgumentTypes (pi);
+ }
} else {
mi = (MethodInfo) entry.Member;
cmpAttrs = TypeManager.GetArgumentTypes (mi);
}
-
+
+ if (fi != null) {
+ // TODO: Almost duplicate !
+ // Check visibility
+ switch (fi.Attributes & FieldAttributes.FieldAccessMask) {
+ case FieldAttributes.Private:
+ //
+ // A private method is Ok if we are a nested subtype.
+ // The spec actually is not very clear about this, see bug 52458.
+ //
+ if (invocationType != entry.Container.Type &
+ TypeManager.IsNestedChildOf (invocationType, entry.Container.Type))
+ continue;
+
+ break;
+ case FieldAttributes.FamANDAssem:
+ case FieldAttributes.Assembly:
+ //
+ // Check for assembly methods
+ //
+ if (mi.DeclaringType.Assembly != CodeGen.Assembly.Builder)
+ continue;
+ break;
+ }
+ return entry.Member;
+ }
+
//
// Check the arguments
//
if (cmpAttrs.Length != paramTypes.Length)
continue;
-
- for (int j = cmpAttrs.Length - 1; j >= 0; j --)
- if (paramTypes [j] != cmpAttrs [j])
+
+ for (int j = cmpAttrs.Length - 1; j >= 0; j --) {
+ if (!paramTypes [j].Equals (cmpAttrs [j]))
goto next;
+ }
//
// get one of the methods because this has the visibility info.
projects / mono.git / blobdiff