X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fgmcs%2Fdecl.cs;h=dcd451b96f94b5aaef3ca8b55d97bafd624e29c4;hb=6c5378726ecdf63f9c3f7788f9fba69538af37ed;hp=51cc74a2c864f845ec795c4d9ef979a92b1894a6;hpb=d3ffb47006e3d3619a08c78dcac103e7847ba63c;p=mono.git

diff --git a/mcs/gmcs/decl.cs b/mcs/gmcs/decl.cs
index 51cc74a2c86..dcd451b96f9 100644
--- a/mcs/gmcs/decl.cs
+++ b/mcs/gmcs/decl.cs
@@ -23,39 +23,86 @@ using System.Xml;
 namespace Mono.CSharp {
 
 	public class MemberName {
-		public string Name;
+		public readonly string Name;
 		public readonly TypeArguments TypeArguments;
 
 		public readonly MemberName Left;
+		public readonly Location Location;
+
+		public static readonly MemberName Null = new MemberName ("", Location.Null);
 
-		public static readonly MemberName Null = new MemberName ("");
+		bool is_double_colon;
 
-		public MemberName (string name)
+		private MemberName (MemberName left, string name, bool is_double_colon,
+				    TypeArguments args, Location loc)
 		{
 			this.Name = name;
+			this.Location = loc;
+			this.is_double_colon = is_double_colon;
+			this.TypeArguments = args;
+			this.Left = left;
 		}
 
-		public MemberName (string name, TypeArguments args)
-			: this (name)
+		public MemberName (string name, TypeArguments args, Location loc)
+			: this (name, loc)
 		{
 			this.TypeArguments = args;
 		}
 
-		public MemberName (MemberName left, string name, TypeArguments args)
-			: this (name, args)
+		public MemberName (string name, Location loc)
+		{
+			this.Name = name;
+			this.Location = loc;
+		}
+
+		public MemberName (MemberName left, string name, Location loc)
+			: this (name, loc)
+		{
+			this.Left = left;
+		}
+
+		public MemberName (MemberName left, string name, TypeArguments args, Location loc)
+			: this (name, args, loc)
 		{
 			this.Left = left;
 		}
 
+		public MemberName (string alias, string name, Location loc)
+			: this (new MemberName (alias, loc), name, true, null, loc)
+		{
+		}
+
 		public MemberName (MemberName left, MemberName right)
-			: this (left, right.Name, right.TypeArguments)
+			: this (left, right, right.Location)
+		{
+		}
+
+		public MemberName (MemberName left, MemberName right, Location loc)
+			: this (null, right.Name, false, right.TypeArguments, loc)
 		{
+			if (right.is_double_colon)
+				throw new InternalErrorException ("Cannot append double_colon member name");
+			this.Left = (right.Left == null) ? left : new MemberName (left, right.Left);
+		}
+
+		static readonly char [] dot_array = { '.' };
+
+		public static MemberName FromDotted (string name, Location loc)
+		{
+			string [] elements = name.Split (dot_array);
+			int count = elements.Length;
+			int i = 0;
+			MemberName n = new MemberName (elements [i++], loc);
+			while (i < count)
+				n = new MemberName (n, elements [i++], loc);
+			return n;
 		}
 
 		public string GetName ()
 		{
+			string connect = is_double_colon ? "::" : ".";
 			if (Left != null)
-				return Left.GetName () + "." + Name;
+				return Left.GetName () + connect + Name;
 			else
 				return Name;
 		}
@@ -74,8 +121,9 @@ namespace Mono.CSharp {
 		public string GetName (bool is_generic)
 		{
 			string name = is_generic ? Basename : Name;
+			string connect = is_double_colon ? "::" : ".";
 			if (Left != null)
-				return Left.GetName (is_generic) + "." + name;
+				return Left.GetName (is_generic) + connect + name;
 			else
 				return name;
 		}
@@ -89,12 +137,14 @@ namespace Mono.CSharp {
 			}
 		}
 
-		public string GetMethodName ()
-		{
-			if (Left != null)
-				return Left.GetTypeName () + "." + Name;
-			else
-				return Name;
+		public string MethodName {
+			get {
+				string connect = is_double_colon ? "::" : ".";
+				if (Left != null)
+					return Left.FullName + connect + Name;
+				else
+					return Name;
+			}
 		}
 
 		public static string MakeName (string name, TypeArguments args)
@@ -112,9 +162,9 @@ namespace Mono.CSharp {
 
 		public string GetTypeName ()
 		{
-			string suffix = "";
+			string connect = is_double_colon ? "::" : ".";
 			if (Left != null)
-				return Left.GetTypeName () + "." +
+				return Left.GetTypeName () + connect +
 					MakeName (Name, TypeArguments);
 			else
 				return MakeName (Name, TypeArguments);
@@ -143,33 +193,36 @@ namespace Mono.CSharp {
 			return true;
 		}
 
-		public Expression GetTypeExpression (Location loc)
+		public Expression GetTypeExpression ()
 		{
 			if (IsUnbound) {
-				if (!CheckUnbound (loc))
+				if (!CheckUnbound (Location))
 					return null;
 
-				return new UnboundTypeExpression (GetTypeName ());
+				return new UnboundTypeExpression (this, Location);
 			}
 
-			if (Left != null) {
-				Expression lexpr = Left.GetTypeExpression (loc);
-
-				return new MemberAccess (lexpr, Name, TypeArguments, loc);
-			} else {
+			if (Left == null) {
 				if (TypeArguments != null)
-					return new ConstructedType (Name, TypeArguments, loc);
+					return new SimpleName (Basename, TypeArguments, Location);
 				else
-					return new SimpleName (Name, loc);
+					return new SimpleName (Name, Location);
+			}
+
+			if (is_double_colon) {
+				if (Left.Left != null)
+					throw new InternalErrorException ("The left side of a :: should be an identifier");
+				return new QualifiedAliasMember (Left.Name, Name, Location);
 			}
+
+			Expression lexpr = Left.GetTypeExpression ();
+			return new MemberAccess (lexpr, Name, TypeArguments, Location);
 		}
 
 		public MemberName Clone ()
 		{
-			if (Left != null)
-				return new MemberName (Left.Clone (), Name, TypeArguments);
-			else
-				return new MemberName (Name, TypeArguments);
+			MemberName left_clone = Left == null ? null : Left.Clone ();
+			return new MemberName (left_clone, Name, is_double_colon, TypeArguments, Location);
 		}
 
 		public string Basename {
@@ -181,18 +234,63 @@ namespace Mono.CSharp {
 			}
 		}
 
+		public string FullName {
+			get {
+				if (TypeArguments != null)
+					return Name + "<" + TypeArguments + ">";
+				else
+					return Name;
+			}
+		}
+
 		public override string ToString ()
 		{
-			string full_name;
-			if (TypeArguments != null)
-				full_name = Name + "<" + TypeArguments + ">";
-			else
-				full_name = Name;
-
+			string connect = is_double_colon ? "::" : ".";
 			if (Left != null)
-				return Left + "." + full_name;
+				return Left.FullName + connect + FullName;
 			else
-				return full_name;
+				return FullName;
+		}
+
+		public override bool Equals (object other)
+		{
+			return Equals (other as MemberName);
+		}
+
+		public bool Equals (MemberName other)
+		{
+			if (this == other)
+				return true;
+			if (other == null || Name != other.Name)
+				return false;
+			if (is_double_colon != other.is_double_colon)
+				return false;
+
+			if ((TypeArguments != null) &&
+			    (other.TypeArguments == null || TypeArguments.Count != other.TypeArguments.Count))
+				return false;
+
+			if ((TypeArguments == null) && (other.TypeArguments != null))
+				return false;
+
+			if (Left == null)
+				return other.Left == null;
+
+			return Left.Equals (other.Left);
+		}
+
+		public override int GetHashCode ()
+		{
+			int hash = Name.GetHashCode ();
+			for (MemberName n = Left; n != null; n = n.Left)
+				hash ^= n.Name.GetHashCode ();
+			if (is_double_colon)
+				hash ^= 0xbadc01d;
+
+			if (TypeArguments != null)
+				hash ^= TypeArguments.Count << 5;
+
+			return hash & 0x7FFFFFFF;
 		}
 	}
 
@@ -200,30 +298,39 @@ namespace Mono.CSharp {
 	///   Base representation for members.  This is used to keep track
 	///   of Name, Location and Modifier flags, and handling Attributes.
 	/// </summary>
-	public abstract class MemberCore : Attributable {
+	public abstract class MemberCore : Attributable, IResolveContext {
 		/// <summary>
 		///   Public name
 		/// </summary>
+
+		protected string cached_name;
 		public string Name {
 			get {
-				return MemberName.GetName (!(this is GenericMethod) && !(this is Method));
+				if (cached_name == null)
+					cached_name = MemberName.GetName (!(this is GenericMethod) && !(this is Method));
+				return cached_name;
 			}
 		}
 
                 // Is not readonly because of IndexerName attribute
-		public MemberName MemberName;
+		private MemberName member_name;
+		public MemberName MemberName {
+			get { return member_name; }
+		}
 
 		/// <summary>
 		///   Modifier flags that the user specified in the source code
 		/// </summary>
 		public int ModFlags;
 
-		public readonly TypeContainer Parent;
+		public /*readonly*/ DeclSpace Parent;
 
 		/// <summary>
 		///   Location where this declaration happens
 		/// </summary>
-		public readonly Location Location;
+		public Location Location {
+			get { return member_name.Location; }
+		}
 
 		/// <summary>
 		///   XML documentation comment
@@ -248,37 +355,31 @@ namespace Mono.CSharp {
 			ClsCompliantAttributeTrue = 1 << 7,			// Type has CLSCompliant (true)
 			Excluded_Undetected = 1 << 8,		// Conditional attribute has not been detected yet
 			Excluded = 1 << 9,					// Method is conditional
-			TestMethodDuplication = 1 << 10		// Test for duplication must be performed
+			TestMethodDuplication = 1 << 10,		// Test for duplication must be performed
+			IsUsed = 1 << 11,
+			IsAssigned = 1 << 12				// Field is assigned
 		}
-  
+
 		/// <summary>
 		///   MemberCore flags at first detected then cached
- 		/// </summary>
+		/// </summary>
 		internal Flags caching_flags;
 
-		public MemberCore (TypeContainer parent, MemberName name, Attributes attrs,
-				   Location loc)
+		public MemberCore (DeclSpace parent, MemberName name, Attributes attrs)
 			: base (attrs)
 		{
+			if (parent is PartialContainer && !(this is PartialContainer))
+				throw new InternalErrorException ("A PartialContainer cannot be the direct parent of a member");
+
 			Parent = parent;
-			MemberName = name;
-			Location = loc;
+			member_name = name;
 			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)
+		protected virtual void SetMemberName (MemberName new_name)
 		{
-			if (type == null)
-				return;
-
-			ObsoleteAttribute obsolete_attr = AttributeTester.GetObsoleteAttribute (type);
-			if (obsolete_attr == null)
-				return;
-
-			AttributeTester.Report_ObsoleteMessage (obsolete_attr, type.FullName, Location);
+			member_name = new_name;
+			cached_name = null;
 		}
 
 		public abstract bool Define ();
@@ -288,15 +389,10 @@ namespace Mono.CSharp {
 		//
 		public virtual string GetSignatureForError ()
 		{
-			return Name;
-		}
+			if (Parent == null || Parent.Parent == null)
+				return Name;
 
-		/// <summary>
-		/// Use this method when MethodBuilder is null
-		/// </summary>
-		public virtual string GetSignatureForError (TypeContainer tc)
-		{
-			return Name;
+			return String.Concat (Parent.GetSignatureForError (), '.', Name);
 		}
 
 		/// <summary>
@@ -304,44 +400,29 @@ namespace Mono.CSharp {
 		/// </summary>
 		public virtual void Emit ()
 		{
-			// Hack with Parent == null is for EnumMember
-			if (Parent == null || (GetObsoleteAttribute (Parent) == null && Parent.GetObsoleteAttribute (Parent) == null))
-				VerifyObsoleteAttribute ();
-
 			if (!RootContext.VerifyClsCompliance)
 				return;
 
 			VerifyClsCompliance (Parent);
 		}
 
-		public bool InUnsafe {
-			get {
-				return ((ModFlags & Modifiers.UNSAFE) != 0) || Parent.UnsafeContext;
-			}
+		public virtual EmitContext EmitContext {
+			get { return Parent.EmitContext; }
 		}
 
-		// 
-		// Whehter is it ok to use an unsafe pointer in this type container
-		//
-		public bool UnsafeOK (DeclSpace parent)
-		{
-			//
-			// First check if this MemberCore modifier flags has unsafe set
-			//
-			if ((ModFlags & Modifiers.UNSAFE) != 0)
-				return true;
-
-			if (parent.UnsafeContext)
-				return true;
+		public virtual bool IsUsed {
+			get { return (caching_flags & Flags.IsUsed) != 0; }
+		}
 
-			Expression.UnsafeError (Location);
-			return false;
+		public void SetMemberIsUsed ()
+		{
+			caching_flags |= Flags.IsUsed;
 		}
 
 		/// <summary>
 		/// Returns instance of ObsoleteAttribute for this MemberCore
 		/// </summary>
-		public ObsoleteAttribute GetObsoleteAttribute (DeclSpace ds)
+		public virtual ObsoleteAttribute GetObsoleteAttribute ()
 		{
 			// ((flags & (Flags.Obsolete_Undetected | Flags.Obsolete)) == 0) is slower, but why ?
 			if ((caching_flags & Flags.Obsolete_Undetected) == 0 && (caching_flags & Flags.Obsolete) == 0) {
@@ -354,11 +435,11 @@ namespace Mono.CSharp {
 				return null;
 
 			Attribute obsolete_attr = OptAttributes.Search (
-				TypeManager.obsolete_attribute_type, ds.EmitContext);
+				TypeManager.obsolete_attribute_type);
 			if (obsolete_attr == null)
 				return null;
 
-			ObsoleteAttribute obsolete = obsolete_attr.GetObsoleteAttribute (ds.EmitContext);
+			ObsoleteAttribute obsolete = obsolete_attr.GetObsoleteAttribute ();
 			if (obsolete == null)
 				return null;
 
@@ -366,15 +447,43 @@ namespace Mono.CSharp {
 			return obsolete;
 		}
 
+		/// <summary>
+		/// Checks for ObsoleteAttribute presence. It's used for testing of all non-types elements
+		/// </summary>
+		public virtual void CheckObsoleteness (Location loc)
+		{
+			if (Parent != null)
+				Parent.CheckObsoleteness (loc);
+
+			ObsoleteAttribute oa = GetObsoleteAttribute ();
+			if (oa == null) {
+				return;
+			}
+
+			AttributeTester.Report_ObsoleteMessage (oa, GetSignatureForError (), loc);
+		}
+
+		protected void CheckObsoleteType (Expression type)
+		{
+			ObsoleteAttribute obsolete_attr = AttributeTester.GetObsoleteAttribute (type.Type);
+			if (obsolete_attr == null)
+				return;
+
+			if (GetObsoleteAttribute () != null || Parent.GetObsoleteAttribute () != null)
+				return;
+
+			AttributeTester.Report_ObsoleteMessage (obsolete_attr, TypeManager.CSharpName (type.Type), type.Location);
+		}
+
 		/// <summary>
 		/// Analyze whether CLS-Compliant verification must be execute for this MemberCore.
 		/// </summary>
-		public override bool IsClsCompliaceRequired (DeclSpace container)
+		public override bool IsClsComplianceRequired ()
 		{
 			if ((caching_flags & Flags.ClsCompliance_Undetected) == 0)
 				return (caching_flags & Flags.ClsCompliant) != 0;
 
-			if (GetClsCompliantAttributeValue (container) && IsExposedFromAssembly (container)) {
+			if (GetClsCompliantAttributeValue (Parent) && IsExposedFromAssembly (Parent)) {
 				caching_flags &= ~Flags.ClsCompliance_Undetected;
 				caching_flags |= Flags.ClsCompliant;
 				return true;
@@ -408,10 +517,10 @@ namespace Mono.CSharp {
 		{
 			if (OptAttributes != null) {
 				Attribute cls_attribute = OptAttributes.Search (
-					TypeManager.cls_compliant_attribute_type, ds.EmitContext);
+					TypeManager.cls_compliant_attribute_type);
 				if (cls_attribute != null) {
 					caching_flags |= Flags.HasClsCompliantAttribute;
-					return cls_attribute.GetClsCompliantAttributeValue (ds.EmitContext);
+					return cls_attribute.GetClsCompliantAttributeValue ();
 				}
 			}
 			return ds.GetClsCompliantAttributeValue ();
@@ -426,6 +535,14 @@ namespace Mono.CSharp {
 			}
 		}
 
+		/// <summary>
+		/// It helps to handle error 102 & 111 detection
+		/// </summary>
+		public virtual bool MarkForDuplicationCheck ()
+		{
+			return false;
+		}
+
 		/// <summary>
 		/// The main virtual method for CLS-Compliant verifications.
 		/// The method returns true if member is CLS-Compliant and false if member is not
@@ -434,32 +551,31 @@ namespace Mono.CSharp {
 		/// </summary>
 		protected virtual bool VerifyClsCompliance (DeclSpace ds)
 		{
-			if (!IsClsCompliaceRequired (ds)) {
+			if (!IsClsComplianceRequired ()) {
 				if (HasClsCompliantAttribute && RootContext.WarningLevel >= 2) {
 					if (!IsExposedFromAssembly (ds))
-						Report.Warning (3019, Location, "CLS compliance checking will not be performed on '{0}' because it is private or internal", GetSignatureForError ());
+						Report.Warning (3019, 2, Location, "CLS compliance checking will not be performed on `{0}' because it is not visible from outside this assembly", GetSignatureForError ());
 					if (!CodeGen.Assembly.IsClsCompliant)
-						Report.Warning (3021, Location, "'{0}' does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute", GetSignatureForError ());
+						Report.Warning (3021, 2, Location, "`{0}' does not need a CLSCompliant attribute because the assembly is not marked as CLS-compliant", GetSignatureForError ());
 				}
 				return false;
 			}
 
 			if (!CodeGen.Assembly.IsClsCompliant) {
 				if (HasClsCompliantAttribute) {
-					Report.Error (3014, Location, "'{0}' cannot be marked as CLS-compliant because the assembly does not have a CLSCompliant attribute", GetSignatureForError ());
+					Report.Error (3014, Location,
+						"`{0}' cannot be marked as CLS-compliant because the assembly is not marked as CLS-compliant",
+						GetSignatureForError ());
 				}
 				return false;
 			}
 
-			int index = Name.LastIndexOf ('.');
-			if (Name [index > 0 ? index + 1 : 0] == '_') {
-				Report.Error (3008, Location, "Identifier '{0}' is not CLS-compliant", GetSignatureForError () );
+			if (member_name.Name [0] == '_') {
+				Report.Error (3008, Location, "Identifier `{0}' is not CLS-compliant", GetSignatureForError () );
 			}
 			return true;
 		}
 
-		protected abstract void VerifyObsoleteAttribute ();
-
 		//
 		// Raised (and passed an XmlElement that contains the comment)
 		// when GenerateDocComment is writing documentation expectedly.
@@ -488,6 +604,40 @@ namespace Mono.CSharp {
 		{
 			DocUtil.GenerateDocComment (this, ds);
 		}
+
+		public override IResolveContext ResolveContext {
+			get {
+				return this;
+			}
+		}
+
+		#region IResolveContext Members
+
+		public virtual DeclSpace DeclContainer {
+			get {
+				return Parent;
+			}
+		}
+
+		public bool IsInObsoleteScope {
+			get {
+				if (GetObsoleteAttribute () != null)
+					return true;
+
+				return Parent == null ? false : Parent.IsInObsoleteScope;
+			}
+		}
+
+		public bool IsInUnsafeScope {
+			get {
+				if ((ModFlags & Modifiers.UNSAFE) != 0)
+					return true;
+
+				return Parent == null ? false : Parent.IsInUnsafeScope;
+			}
+		}
+
+		#endregion
 	}
 
 	/// <summary>
@@ -498,7 +648,7 @@ namespace Mono.CSharp {
 	///   provides the common foundation for managing those name
 	///   spaces.
 	/// </remarks>
-	public abstract class DeclSpace : MemberCore, IAlias {
+	public abstract class DeclSpace : MemberCore {
 		/// <summary>
 		///   This points to the actual definition that is being
 		///   created with System.Reflection.Emit
@@ -518,19 +668,20 @@ namespace Mono.CSharp {
 		//
 		public NamespaceEntry NamespaceEntry;
 
-		public Hashtable Cache = new Hashtable ();
+		private Hashtable Cache = new Hashtable ();
 		
-		public string Basename;
+		public readonly string Basename;
 		
 		protected Hashtable defined_names;
 
 		readonly bool is_generic;
 		readonly int count_type_params;
+		readonly int count_current_type_params;
 
 		// The emit context for toplevel objects.
 		protected EmitContext ec;
 		
-		public EmitContext EmitContext {
+		public override EmitContext EmitContext {
 			get { return ec; }
 		}
 
@@ -550,66 +701,79 @@ namespace Mono.CSharp {
 
 		static string[] attribute_targets = new string [] { "type" };
 
-		public DeclSpace (NamespaceEntry ns, TypeContainer parent, MemberName name,
-				  Attributes attrs, Location l)
-			: base (parent, name, attrs, l)
+		public DeclSpace (NamespaceEntry ns, DeclSpace parent, MemberName name,
+				  Attributes attrs)
+			: base (parent, name, attrs)
 		{
 			NamespaceEntry = ns;
-			Basename = name.Name;
+			Basename = name.Basename;
 			defined_names = new Hashtable ();
 			if (name.TypeArguments != null) {
 				is_generic = true;
-				count_type_params = name.TypeArguments.Count;
+				count_type_params = count_current_type_params = name.TypeArguments.Count;
 			}
 			if (parent != null)
 				count_type_params += parent.count_type_params;
 		}
 
+		public override DeclSpace DeclContainer {
+			get {
+				return this;
+			}
+		}
+
 		/// <summary>
 		/// Adds the member to defined_names table. It tests for duplications and enclosing name conflicts
 		/// </summary>
-		protected bool AddToContainer (MemberCore symbol, bool is_method, string fullname, string basename)
+		protected bool AddToContainer (MemberCore symbol, string name)
 		{
-			if (basename == Basename && !(this is Interface)) {
+			if (name == MemberName.Name && !(this is Interface) && !(this is Enum)) {
 				if (symbol is TypeParameter)
-					Report.Error (694, "Type parameter `{0}' has same name as " +
-						      "containing type or method", basename);
+					Report.Error (694, symbol.Location,
+						      "Type parameter `{0}' has same name as " +
+						      "containing type, or method", name);
 				else {
 					Report.SymbolRelatedToPreviousError (this);
-					Report.Error (542, "'{0}': member names cannot be the same as their " +
-						      "enclosing type", symbol.Location, symbol.GetSignatureForError ());
+					Report.Error (542,  symbol.Location,
+						      "`{0}': member names cannot be the same " +
+						      "as their enclosing type",
+						      symbol.GetSignatureForError ());
+					return false;
 				}
-				return false;
 			}
 
-			MemberCore mc = (MemberCore)defined_names [fullname];
+			MemberCore mc = (MemberCore) defined_names [name];
 
-			if (is_method && (mc is MethodCore || mc is IMethodData)) {
-				symbol.caching_flags |= Flags.TestMethodDuplication;
-				mc.caching_flags |= Flags.TestMethodDuplication;
+			if (mc == null) {
+				defined_names.Add (name, symbol);
 				return true;
 			}
 
-			if (mc != null) {
-				if (symbol is TypeParameter)
-					Report.Error (692, symbol.Location, "Duplicate type parameter `{0}'", basename);
-				else {
-					Report.SymbolRelatedToPreviousError (mc);
-					Report.Error (102, symbol.Location,
-						      "The type '{0}' already contains a definition for '{1}'",
-						      GetSignatureForError (), basename);
-				}
+			if (symbol.MarkForDuplicationCheck () && mc.MarkForDuplicationCheck ())
+				return true;
+
+			Report.SymbolRelatedToPreviousError (mc);
+			if (symbol is PartialContainer || mc is PartialContainer) {
+				Report.Error (260, symbol.Location,
+					"Missing partial modifier on declaration of type `{0}'. Another partial declaration of this type exists",
+					name);
 				return false;
 			}
 
-			defined_names.Add (fullname, symbol);
-			return true;
-		}
+			if (this is RootTypes) {
+				Report.Error (101, symbol.Location, 
+					"The namespace `{0}' already contains a definition for `{1}'",
+					((DeclSpace)symbol).NamespaceEntry.GetSignatureForError (), symbol.MemberName.Name);
+			} else if (symbol is TypeParameter) {
+				Report.Error (692, symbol.Location,
+					      "Duplicate type parameter `{0}'", name);
+			} else {
+				Report.Error (102, symbol.Location,
+					      "The type `{0}' already contains a definition for `{1}'",
+					      GetSignatureForError (), symbol.MemberName.Name);
+			}
 
-		public void RecordDecl ()
-		{
-			if ((NamespaceEntry != null) && (Parent == RootContext.Tree.Types))
-				NamespaceEntry.DefineName (MemberName.Basename, this);
+			return false;
 		}
 
 		/// <summary>
@@ -622,46 +786,13 @@ namespace Mono.CSharp {
 			return (MemberCore)defined_names [name];
 		}
 
-		bool in_transit = false;
-		
-		/// <summary>
-		///   This function is used to catch recursive definitions
-		///   in declarations.
-		/// </summary>
-		public bool InTransit {
-			get {
-				return in_transit;
-			}
-
-			set {
-				in_transit = value;
-			}
-		}
-
-		/// <summary>
-		///   Looks up the alias for the name
-		/// </summary>
-		public IAlias LookupAlias (string name)
-		{
-			if (NamespaceEntry != null)
-				return NamespaceEntry.LookupAlias (name);
-			else
-				return null;
-		}
-		
 		// 
 		// root_types contains all the types.  All TopLevel types
 		// hence have a parent that points to `root_types', that is
 		// why there is a non-obvious test down here.
 		//
 		public bool IsTopLevel {
-			get {
-				if (Parent != null){
-					if (Parent.Parent == null)
-						return true;
-				}
-				return false;
-			}
+			get { return (Parent != null && Parent.Parent == null); }
 		}
 
 		public virtual void CloseType ()
@@ -685,6 +816,10 @@ namespace Mono.CSharp {
 			}
 		}
 
+		protected virtual TypeAttributes TypeAttr {
+			get { return CodeGen.Module.DefaultCharSetType; }
+		}
+
 		/// <remarks>
 		///  Should be overriten by the appropriate declaration space
 		/// </remarks>
@@ -694,84 +829,50 @@ namespace Mono.CSharp {
 		///   Define all members, but don't apply any attributes or do anything which may
 		///   access not-yet-defined classes.  This method also creates the MemberCache.
 		/// </summary>
-		public abstract bool DefineMembers (TypeContainer parent);
-
-		//
-		// Whether this is an `unsafe context'
-		//
-		public bool UnsafeContext {
-			get {
-				if ((ModFlags & Modifiers.UNSAFE) != 0)
-					return true;
-				if (Parent != null)
-					return Parent.UnsafeContext;
+		public virtual bool DefineMembers ()
+		{
+			if (((ModFlags & Modifiers.NEW) != 0) && IsTopLevel) {
+				Report.Error (1530, Location, "Keyword `new' is not allowed on namespace elements");
 				return false;
 			}
+			return true;
 		}
 
-		public static string MakeFQN (string nsn, string name)
+		public override string GetSignatureForError ()
 		{
-			if (nsn == "")
-				return name;
-			return String.Concat (nsn, ".", name);
+			if (IsGeneric) {
+				return SimpleName.RemoveGenericArity (Name) + TypeParameter.GetSignatureForError (CurrentTypeParameters);
+			}
+			// Parent.GetSignatureForError
+			return Name;
 		}
 
 		EmitContext type_resolve_ec;
-
-		public Type ResolveNestedType (Type t, Location loc)
-		{
-			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;
+		protected EmitContext TypeResolveEmitContext {
+			get {
+				if (type_resolve_ec == null) {
+					// FIXME: I think this should really be one of:
+					//
+					// a. type_resolve_ec = Parent.EmitContext;
+					// b. type_resolve_ec = new EmitContext (Parent, Parent, loc, null, null, ModFlags, false);
+					//
+					// However, if Parent == RootContext.Tree.Types, its NamespaceEntry will be null.
+					//
+					type_resolve_ec = new EmitContext (this, Parent, this, Location.Null, null, null, ModFlags, false);
 				}
-
-				TypeParameter[] args;
-				if (this is GenericMethod)
-					args = Parent.TypeParameters;
-				else
-					args = TypeParameters;
-
-				TypeExpr ctype = new ConstructedType (t, args, loc);
-				ctype = ctype.ResolveAsTypeTerminal (ec);
-				if (ctype == null)
-					return null;
-
-				t = ctype.Type;
+				return type_resolve_ec;
 			}
-
-			return t;
 		}
 
 		// <summary>
 		//    Resolves the expression `e' for a type, and will recursively define
 		//    types.  This should only be used for resolving base types.
 		// </summary>
-		public TypeExpr ResolveBaseTypeExpr (Expression e, bool silent, Location loc)
+		protected TypeExpr ResolveBaseTypeExpr (Expression e)
 		{
-			if (type_resolve_ec == null) {
-				// FIXME: I think this should really be one of:
-				//
-				// a. type_resolve_ec = Parent.EmitContext;
-				// b. type_resolve_ec = new EmitContext (Parent, Parent, loc, null, null, ModFlags, false);
-				//
-				// However, if Parent == RootContext.Tree.Types, its NamespaceEntry will be null.
-				//
-				type_resolve_ec = new EmitContext (Parent, this, loc, null, null, ModFlags, false);
-				type_resolve_ec.ResolvingTypeTree = true;
-			}
-			type_resolve_ec.loc = loc;
 			if (this is GenericMethod)
-				type_resolve_ec.ContainerType = Parent.TypeBuilder;
-			else
-				type_resolve_ec.ContainerType = TypeBuilder;
-
-			return e.ResolveAsTypeTerminal (type_resolve_ec);
+				TypeResolveEmitContext.ContainerType = Parent.TypeBuilder;
+			return e.ResolveAsTypeTerminal (TypeResolveEmitContext, false);
 		}
 		
 		public bool CheckAccessLevel (Type check_type) 
@@ -782,9 +883,7 @@ namespace Mono.CSharp {
 			else
 				tb = TypeBuilder;
 
-			if (check_type.IsGenericInstance)
-				check_type = check_type.GetGenericTypeDefinition ();
-
+			check_type = TypeManager.DropGenericTypeArguments (check_type);
 			if (check_type == tb)
 				return true;
 
@@ -821,7 +920,8 @@ namespace Mono.CSharp {
   				//
   				// This test should probably use the declaringtype.
   				//
-				return check_type.Assembly == TypeBuilder.Assembly;
+				return check_type.Assembly == TypeBuilder.Assembly ||
+					TypeManager.IsFriendAssembly (check_type.Assembly);
 
 			case TypeAttributes.NestedPublic:
 				return true;
@@ -836,15 +936,18 @@ namespace Mono.CSharp {
 				return FamilyAccessible (tb, check_type);
 
 			case TypeAttributes.NestedFamANDAssem:
-				return (check_type.Assembly == tb.Assembly) &&
+				return ((check_type.Assembly == tb.Assembly) || 
+						TypeManager.IsFriendAssembly (check_type.Assembly)) && 
 					FamilyAccessible (tb, check_type);
 
 			case TypeAttributes.NestedFamORAssem:
 				return (check_type.Assembly == tb.Assembly) ||
-					FamilyAccessible (tb, check_type);
+					FamilyAccessible (tb, check_type) ||
+					TypeManager.IsFriendAssembly (check_type.Assembly);
 
 			case TypeAttributes.NestedAssembly:
-				return check_type.Assembly == tb.Assembly;
+				return check_type.Assembly == tb.Assembly ||
+					TypeManager.IsFriendAssembly (check_type.Assembly);
 			}
 
 			Console.WriteLine ("HERE: " + check_attr);
@@ -854,29 +957,15 @@ namespace Mono.CSharp {
 
 		protected bool NestedAccessible (Type tb, Type check_type)
 		{
-			string check_type_name = check_type.FullName;
-			
-			// At this point, we already know check_type is a nested class.
-			int cio = check_type_name.LastIndexOf ('+');
-			
-			// Ensure that the string 'container' has a '+' in it to avoid false matches
-			string container = check_type_name.Substring (0, cio + 1);
-
-			// Ensure that type_name ends with a '+' so that it can match 'container', if necessary
-			string type_name = tb.FullName + "+";
-
-			// If the current class is nested inside the container of check_type,
-			// we can access check_type even if it is private or protected.
-			return type_name.StartsWith (container);
+			Type declaring = check_type.DeclaringType;
+			return TypeBuilder == declaring ||
+				TypeManager.IsNestedChildOf (TypeBuilder, declaring);
 		}
 
 		protected bool FamilyAccessible (Type tb, Type check_type)
 		{
 			Type declaring = check_type.DeclaringType;
-			if (tb == declaring || TypeManager.IsFamilyAccessible (tb, declaring))
-				return true;
-
-			return NestedAccessible (tb, check_type);
+			return TypeManager.IsNestedFamilyAccessible (TypeBuilder, declaring);
 		}
 
 		// Access level of a type.
@@ -979,224 +1068,71 @@ namespace Mono.CSharp {
 
 			return ~ (~ mAccess | pAccess) == 0;
 		}
-		
-		static DoubleHash dh = new DoubleHash (1000);
-
-		Type DefineTypeAndParents (DeclSpace tc)
-		{
-			DeclSpace container = tc.Parent;
-
-			if (container.TypeBuilder == null && container.Name != "")
-				DefineTypeAndParents (container);
-
-			return tc.DefineType ();
-		}
-		
-		Type LookupInterfaceOrClass (string ns, string name, out bool error)
-		{
-			DeclSpace parent;
-			Type t;
-			object r;
-			
-			error = false;
-
-			if (dh.Lookup (ns, name, out r))
-				return (Type) r;
-			else {
-				if (ns != ""){
-					if (Namespace.IsNamespace (ns)){
-						string fullname = (ns != "") ? ns + "." + name : name;
-						t = TypeManager.LookupType (fullname);
-					} else
-						t = null;
-				} else
-					t = TypeManager.LookupType (name);
-			}
-			
-			if (t != null) {
-				dh.Insert (ns, name, t);
-				return t;
-			}
-
-			//
-			// In case we are fed a composite name, normalize it.
-			//
-			int p = name.LastIndexOf ('.');
-			if (p != -1){
-				ns = MakeFQN (ns, name.Substring (0, p));
-				name = name.Substring (p+1);
-			}
-			
-			parent = RootContext.Tree.LookupByNamespace (ns, name);
-			if (parent == null) {
-				dh.Insert (ns, name, null);
-				return null;
-			}
-
-			t = DefineTypeAndParents (parent);
-			if (t == null){
-				error = true;
-				return null;
-			}
-			
-			dh.Insert (ns, name, t);
-			return t;
-		}
 
-		public static void Error_AmbiguousTypeReference (Location loc, string name, string t1, string t2)
+		//
+		// Return the nested type with name @name.  Ensures that the nested type
+		// is defined if necessary.  Do _not_ use this when you have a MemberCache handy.
+		//
+		public virtual Type FindNestedType (string name)
 		{
-			Report.Error (104, loc,
-				      "`{0}' is an ambiguous reference ({1} or {2})",
-				      name, t1, t2);
+			return null;
 		}
 
-		public Type FindNestedType (Location loc, string name,
-					    out DeclSpace containing_ds)
-		{
-			Type t;
-			bool error;
-
-			containing_ds = this;
-			while (containing_ds != null){
-				Type container_type = containing_ds.TypeBuilder;
-				Type current_type = container_type;
-
-				while (current_type != null && current_type != TypeManager.object_type) {
-					string pre = current_type.FullName;
-
-					t = LookupInterfaceOrClass (pre, name, out error);
-					if (error)
-						return null;
-
-					if ((t != null) && containing_ds.CheckAccessLevel (t))
-						return t;
-
-					current_type = current_type.BaseType;
+		private Type LookupNestedTypeInHierarchy (string name)
+		{
+			// if the member cache has been created, lets use it.
+			// the member cache is MUCH faster.
+			if (MemberCache != null)
+				return MemberCache.FindNestedType (name);
+
+			// no member cache. Do it the hard way -- reflection
+			Type t = null;
+			for (Type current_type = TypeBuilder;
+			     current_type != null && current_type != TypeManager.object_type;
+			     current_type = current_type.BaseType) {
+				current_type = TypeManager.DropGenericTypeArguments (current_type);
+				if (current_type is TypeBuilder) {
+					DeclSpace decl = this;
+					if (current_type != TypeBuilder)
+						decl = TypeManager.LookupDeclSpace (current_type);
+					t = decl.FindNestedType (name);
+				} else {
+					t = TypeManager.GetNestedType (current_type, name);
 				}
-				containing_ds = containing_ds.Parent;
+
+				if (t != null && CheckAccessLevel (t))
+					return t;
 			}
 
 			return null;
 		}
 
-		/// <summary>
-		///   GetType is used to resolve type names at the DeclSpace level.
-		///   Use this to lookup class/struct bases, interface bases or 
-		///   delegate type references
-		/// </summary>
-		///
-		/// <remarks>
-		///   Contrast this to LookupType which is used inside method bodies to 
-		///   lookup types that have already been defined.  GetType is used
-		///   during the tree resolution process and potentially define
-		///   recursively the type
-		/// </remarks>
-		public Type FindType (Location loc, string name)
+		//
+		// Public function used to locate types.
+		//
+		// Set 'ignore_cs0104' to true if you want to ignore cs0104 errors.
+		//
+		// Returns: Type or null if they type can not be found.
+		//
+		public FullNamedExpression LookupType (string name, Location loc, bool ignore_cs0104)
 		{
-			Type t;
-			bool error;
-
-			//
-			// For the case the type we are looking for is nested within this one
-			// or is in any base class
-			//
-			DeclSpace containing_ds = this;
-
-			while (containing_ds != null){
-				Type container_type = containing_ds.TypeBuilder;
-				Type current_type = container_type;
+			if (this is PartialContainer)
+				throw new InternalErrorException ("Should not get here");
 
-				while (current_type != null && current_type != TypeManager.object_type) {
-					string pre = current_type.FullName;
+			if (Cache.Contains (name))
+				return (FullNamedExpression) Cache [name];
 
-					t = LookupInterfaceOrClass (pre, name, out error);
-					if (error)
-						return null;
-
-					if ((t != null) && containing_ds.CheckAccessLevel (t))
-						return ResolveNestedType (t, loc);
-
-					current_type = current_type.BaseType;
-				}
-				containing_ds = containing_ds.Parent;
-			}
-
-			//
-			// Attempt to lookup the class on our namespace and all it's implicit parents
-			//
-			for (NamespaceEntry ns = NamespaceEntry; ns != null; ns = ns.ImplicitParent) {
-				t = LookupInterfaceOrClass (ns.FullName, name, out error);
-				if (error)
-					return null;
-
-				if (t != null)
-					return t;
-			}
-			
-			//
-			// Attempt to do a direct unqualified lookup
-			//
-			t = LookupInterfaceOrClass ("", name, out error);
-			if (error)
-				return null;
-			
+			FullNamedExpression e;
+			Type t = LookupNestedTypeInHierarchy (name);
 			if (t != null)
-				return t;
-			
-			//
-			// Attempt to lookup the class on any of the `using'
-			// namespaces
-			//
-
-			for (NamespaceEntry ns = NamespaceEntry; ns != null; ns = ns.Parent){
-
-				t = LookupInterfaceOrClass (ns.FullName, name, out error);
-				if (error)
-					return null;
-
-				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
-				//
-				Type match = null;
-				foreach (Namespace using_ns in ns.GetUsingTable ()) {
-					match = LookupInterfaceOrClass (using_ns.Name, name, out error);
-					if (error)
-						return null;
-
-					if (match != null) {
-						if (t != null){
-							if (CheckAccessLevel (match)) {
-								Error_AmbiguousTypeReference (loc, name, t.FullName, match.FullName);
-								return null;
-							}
-							continue;
-						}
-						
-						t = match;
-					}
-				}
-				if (t != null)
-					return t;
-			}
+				e = new TypeExpression (t, Location.Null);
+			else if (Parent != null && Parent != RootContext.Tree.Types)
+				e = Parent.LookupType (name, loc, ignore_cs0104);
+			else
+				e = NamespaceEntry.LookupNamespaceOrType (this, name, loc, ignore_cs0104);
 
-			//Report.Error (246, Location, "Can not find type `"+name+"'");
-			return null;
+			Cache [name] = e;
+			return e;
 		}
 
 		/// <remarks>
@@ -1217,17 +1153,11 @@ namespace Mono.CSharp {
 
 		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);
+			if (a.Type == TypeManager.required_attr_type) {
+				Report.Error (1608, a.Location, "The RequiredAttribute attribute is not permitted on C# types");
+				return;
 			}
+			TypeBuilder.SetCustomAttribute (cb);
 		}
 
 		/// <summary>
@@ -1242,10 +1172,10 @@ namespace Mono.CSharp {
 			caching_flags &= ~Flags.HasCompliantAttribute_Undetected;
 
 			if (OptAttributes != null) {
-				Attribute cls_attribute = OptAttributes.Search (TypeManager.cls_compliant_attribute_type, ec);
+				Attribute cls_attribute = OptAttributes.Search (TypeManager.cls_compliant_attribute_type);
 				if (cls_attribute != null) {
 					caching_flags |= Flags.HasClsCompliantAttribute;
-					if (cls_attribute.GetClsCompliantAttributeValue (ec)) {
+					if (cls_attribute.GetClsCompliantAttributeValue ()) {
 						caching_flags |= Flags.ClsCompliantAttributeTrue;
 						return true;
 					}
@@ -1295,12 +1225,9 @@ namespace Mono.CSharp {
 				if (param.Name != name)
 					continue;
 
-				if (RootContext.WarningLevel >= 3)
-					Report.Warning (
-						693, Location,
-						"Type parameter `{0}' has same name " +
-						"as type parameter from outer type `{1}'",
-						name, Parent.GetInstantiationName ());
+				Report.Warning (693, 3, Location,
+					"Type parameter `{0}' has same name as type parameter from outer type `{1}'",
+					name, Parent.GetInstantiationName ());
 
 				return false;
 			}
@@ -1340,41 +1267,44 @@ namespace Mono.CSharp {
 			return type_param_list;
 		}
 
-		public void SetParameterInfo (ArrayList constraints_list)
+		public virtual void SetParameterInfo (ArrayList constraints_list)
 		{
 			if (!is_generic) {
 				if (constraints_list != null) {
 					Report.Error (
-						80, Location, "Contraints are not allowed " +
+						80, Location, "Constraints are not allowed " +
 						"on non-generic declarations");
 				}
 
 				return;
 			}
 
-			string[] names = MemberName.TypeArguments.GetDeclarations ();
+			TypeParameterName[] names = MemberName.TypeArguments.GetDeclarations ();
 			type_params = new TypeParameter [names.Length];
 
 			//
 			// Register all the names
 			//
 			for (int i = 0; i < type_params.Length; i++) {
-				string name = names [i];
+				TypeParameterName name = names [i];
 
 				Constraints constraints = null;
 				if (constraints_list != null) {
 					foreach (Constraints constraint in constraints_list) {
-						if (constraint.TypeParameter == name) {
+						if (constraint == null)
+							continue;
+						if (constraint.TypeParameter == name.Name) {
 							constraints = constraint;
 							break;
 						}
 					}
 				}
 
-				type_params [i] = new TypeParameter (Parent, name, constraints, Location);
+				type_params [i] = new TypeParameter (
+					Parent, this, name.Name, constraints, name.OptAttributes,
+					Location);
 
-				string full_name = Name + "." + name;
-				AddToContainer (type_params [i], false, full_name, name);
+				AddToContainer (type_params [i], name.Name);
 			}
 		}
 
@@ -1389,7 +1319,7 @@ namespace Mono.CSharp {
 			}
 		}
 
-		protected TypeParameter[] CurrentTypeParameters {
+		public TypeParameter[] CurrentTypeParameters {
 			get {
 				if (!IsGeneric)
 					throw new InvalidOperationException ();
@@ -1406,6 +1336,12 @@ namespace Mono.CSharp {
 			}
 		}
 
+		public int CountCurrentTypeParameters {
+			get {
+				return count_current_type_params;
+			}
+		}
+
 		public TypeParameterExpr LookupGeneric (string name, Location loc)
 		{
 			if (!IsGeneric)
@@ -1424,29 +1360,38 @@ namespace Mono.CSharp {
 			return null;
 		}
 
-		bool IAlias.IsType {
-			get { return true; }
-		}
-
-		string IAlias.Name {
-			get { return Name; }
+		public override string[] ValidAttributeTargets {
+			get { return attribute_targets; }
 		}
 
-		TypeExpr IAlias.ResolveAsType (EmitContext ec)
+		protected override bool VerifyClsCompliance (DeclSpace ds)
 		{
-			if (TypeBuilder == null)
-				throw new InvalidOperationException ();
+			if (!base.VerifyClsCompliance (ds)) {
+				return false;
+			}
 
-			if (CurrentType != null)
-				return new TypeExpression (CurrentType, Location);
-			else
-				return new TypeExpression (TypeBuilder, Location);
-		}
+			IDictionary cache = TypeManager.AllClsTopLevelTypes;
+			string lcase = Name.ToLower (System.Globalization.CultureInfo.InvariantCulture);
+			if (!cache.Contains (lcase)) {
+				cache.Add (lcase, this);
+				return true;
+			}
 
-		public override string[] ValidAttributeTargets {
-			get {
-				return attribute_targets;
+			object val = cache [lcase];
+			if (val == null) {
+				Type t = AttributeTester.GetImportedIgnoreCaseClsType (lcase);
+				if (t == null)
+					return true;
+				Report.SymbolRelatedToPreviousError (t);
 			}
+			else {
+				if (val is PartialContainer)
+					return true;
+
+				Report.SymbolRelatedToPreviousError ((DeclSpace)val);
+			}
+			Report.Warning (3005, 1, Location, "Identifier `{0}' differing only in case is not CLS-compliant", GetSignatureForError ());
+			return true;
 		}
 	}
 
@@ -1697,7 +1642,10 @@ namespace Mono.CSharp {
 			// 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 && !type.IsGenericParameter) {
+			if (!(type is TypeBuilder) && !type.IsInterface &&
+			    // !(type.IsGenericType && (type.GetGenericTypeDefinition () is TypeBuilder)) &&
+			    !type.IsGenericType &&
+			    (Container.BaseCache == null || Container.BaseCache.method_hash != null)) {
 				method_hash = new Hashtable ();
 				AddMethods (type);
 			}
@@ -1772,8 +1720,8 @@ namespace Mono.CSharp {
 			// We need to call AddMembers() with a single member type at a time
 			// to get the member type part of CacheEntry.EntryType right.
 			if (!container.IsInterface) {
-			AddMembers (MemberTypes.Constructor, container);
-			AddMembers (MemberTypes.Field, container);
+				AddMembers (MemberTypes.Constructor, container);
+				AddMembers (MemberTypes.Field, container);
 			}
 			AddMembers (MemberTypes.Method, container);
 			AddMembers (MemberTypes.Property, container);
@@ -1838,9 +1786,11 @@ namespace Mono.CSharp {
 			AddMethods (BindingFlags.Instance | BindingFlags.NonPublic, type);
 		}
 
+		static ArrayList overrides = new ArrayList ();
+
 		void AddMethods (BindingFlags bf, Type type)
 		{
-			MemberInfo [] members = type.GetMethods (bf);
+			MethodBase [] members = type.GetMethods (bf);
 
 			Array.Reverse (members);
 
@@ -1854,6 +1804,25 @@ namespace Mono.CSharp {
 					method_hash.Add (name, list);
 				}
 
+				MethodInfo curr = (MethodInfo) member;
+				while (curr.IsVirtual && (curr.Attributes & MethodAttributes.NewSlot) == 0) {
+					MethodInfo base_method = curr.GetBaseDefinition ();
+
+					if (base_method == curr)
+						// Not every virtual function needs to have a NewSlot flag.
+						break;
+
+					overrides.Add (curr);
+					list.Add (new CacheEntry (null, base_method, MemberTypes.Method, bf));
+					curr = base_method;
+				}
+
+				if (overrides.Count > 0) {
+					for (int i = 0; i < overrides.Count; ++i)
+						TypeManager.RegisterOverride ((MethodBase) overrides [i], curr);
+					overrides.Clear ();
+				}
+
 				// Unfortunately, the elements returned by Type.GetMethods() aren't
 				// sorted so we need to do this check for every member.
 				BindingFlags new_bf = bf;
@@ -1949,7 +1918,7 @@ namespace Mono.CSharp {
 			MaskType	= Constructor|Event|Field|Method|Property|NestedType
 		}
 
-		protected struct CacheEntry {
+		protected class CacheEntry {
 			public readonly IMemberContainer Container;
 			public readonly EntryType EntryType;
 			public readonly MemberInfo Member;
@@ -2017,7 +1986,7 @@ namespace Mono.CSharp {
 		static MemberInfo [] emptyMemberInfo = new MemberInfo [0];
 		
 		public MemberInfo [] FindMembers (MemberTypes mt, BindingFlags bf, string name,
-					       MemberFilter filter, object criteria)
+						  MemberFilter filter, object criteria)
 		{
 			if (using_global)
 				throw new Exception ();
@@ -2113,6 +2082,22 @@ namespace Mono.CSharp {
 			return copy;
 		}
 		
+		// find the nested type @name in @this.
+		public Type FindNestedType (string name)
+		{
+			ArrayList applicable = (ArrayList) member_hash [name];
+			if (applicable == null)
+				return null;
+			
+			for (int i = applicable.Count-1; i >= 0; i--) {
+				CacheEntry entry = (CacheEntry) applicable [i];
+				if ((entry.EntryType & EntryType.NestedType & EntryType.MaskType) != 0)
+					return (Type) entry.Member;
+			}
+			
+			return null;
+		}
+		
 		//
 		// This finds the method or property for us to override. invocationType is the type where
 		// the override is going to be declared, name is the name of the method/property, and
@@ -2121,7 +2106,7 @@ namespace Mono.CSharp {
 		// Because the MemberCache holds members from this class and all the base classes,
 		// we can avoid tons of reflection stuff.
 		//
-		public MemberInfo FindMemberToOverride (Type invocationType, string name, Type [] paramTypes, bool is_property)
+		public MemberInfo FindMemberToOverride (Type invocationType, string name, Type [] paramTypes, GenericMethod genericMethod, bool is_property)
 		{
 			ArrayList applicable;
 			if (method_hash != null && !is_property)
@@ -2158,7 +2143,7 @@ namespace Mono.CSharp {
 					}
 				} else {
 					mi = (MethodInfo) entry.Member;
-					cmpAttrs = TypeManager.GetArgumentTypes (mi);
+					cmpAttrs = TypeManager.GetParameterData (mi).Types;
 				}
 
 				if (fi != null) {
@@ -2197,7 +2182,20 @@ namespace Mono.CSharp {
 					if (!TypeManager.IsEqual (paramTypes [j], cmpAttrs [j]))
 						goto next;
 				}
-				
+
+				//
+				// check generic arguments for methods
+				//
+				if (mi != null) {
+					Type [] cmpGenArgs = mi.GetGenericArguments ();
+					if (genericMethod != null && cmpGenArgs.Length > 0) {
+						if (genericMethod.TypeParameters.Length != cmpGenArgs.Length)
+							goto next;
+					}
+					else if (! (genericMethod == null && cmpGenArgs.Length == 0))
+						goto next;
+				}
+
 				//
 				// get one of the methods because this has the visibility info.
 				//
@@ -2370,18 +2368,30 @@ namespace Mono.CSharp {
  					continue;
  		
 				MethodBase method_to_compare = (MethodBase)entry.Member;
- 				if (AttributeTester.AreOverloadedMethodParamsClsCompliant (method.ParameterTypes, TypeManager.GetArgumentTypes (method_to_compare)))
+				AttributeTester.Result result = AttributeTester.AreOverloadedMethodParamsClsCompliant (
+					method.ParameterTypes, TypeManager.GetParameterData (method_to_compare).Types);
+
+ 				if (result == AttributeTester.Result.Ok)
  					continue;
 
 				IMethodData md = TypeManager.GetMethod (method_to_compare);
 
 				// TODO: now we are ignoring CLSCompliance(false) on method from other assembly which is buggy.
 				// However it is exactly what csc does.
-				if (md != null && !md.IsClsCompliaceRequired (method.Parent))
+				if (md != null && !md.IsClsComplianceRequired ())
 					continue;
  		
  				Report.SymbolRelatedToPreviousError (entry.Member);
- 				Report.Error (3006, method.Location, "Overloaded method '{0}' differing only in ref or out, or in array rank, is not CLS-compliant", method.GetSignatureForError ());
+				switch (result) {
+					case AttributeTester.Result.RefOutArrayError:
+						Report.Error (3006, method.Location, "Overloaded method `{0}' differing only in ref or out, or in array rank, is not CLS-compliant", method.GetSignatureForError ());
+						continue;
+					case AttributeTester.Result.ArrayArrayError:
+						Report.Error (3007, method.Location, "Overloaded method `{0}' differing only by unnamed array types is not CLS-compliant", method.GetSignatureForError ());
+						continue;
+				}
+
+				throw new NotImplementedException (result.ToString ());
  			}
   		}
 	}