2009-08-17 Marek Safar <marek.safar@gmail.com>

	* *.cs: Removed DeclContainer from EmitContext.

svn path=/trunk/mcs/; revision=140072

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index 99dbae224c046ef6c4772cb8059a6a09d50052d8..f89f71e237e30d8b016f18562318517eb8a15775 100644 (file)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,3 +1,7 @@
+2009-08-17  Marek Safar  <marek.safar@gmail.com>
+
+       * *.cs: Removed DeclContainer from EmitContext.
+
 2009-08-17  Marek Safar  <marek.safar@gmail.com>
 
        * *.cs: Add IResolveContext::CurrentTypeParameters.

diff --git a/mcs/mcs/anonymous.cs b/mcs/mcs/anonymous.cs
index 20663f3a9a552a39f09c00e446b85f498e9e4db0..025adccc34d661d9dd608ce90ae7fe2408daa680 100644 (file)
--- a/mcs/mcs/anonymous.cs
+++ b/mcs/mcs/anonymous.cs
@@ -299,7 +299,7 @@ namespace Mono.CSharp {
                                TypeArguments targs = new TypeArguments ();
 
                                if (tparams.Length < CountTypeParameters) {
-                                       TypeParameter[] parent_tparams = ec.DeclContainer.Parent.PartialContainer.TypeParameters;
+                                       TypeParameter[] parent_tparams = ec.GenericDeclContainer.Parent.PartialContainer.TypeParameters;
                                        for (int i = 0; i < parent_tparams.Length; ++i)
                                                targs.Add (new TypeParameterExpr (parent_tparams[i], Location));
                                }
@@ -1298,7 +1298,7 @@ namespace Mono.CSharp {
                {
                        // TODO: Implement clone
                        aec = new EmitContext (
-                               ec.ResolveContext, ec.DeclContainer,
+                               ec.ResolveContext, ec.GenericDeclContainer,
                                Location, null, ReturnType,
                                (ec.InUnsafe ? Modifiers.UNSAFE : 0), /* No constructor */ false);
 

diff --git a/mcs/mcs/assign.cs b/mcs/mcs/assign.cs
index 8be80e55a9fec7178c889b2a2162124eebdc2410..13f13a421c0cf37cf37d87b3cc657e8d2d7b59f4 100644 (file)
--- a/mcs/mcs/assign.cs
+++ b/mcs/mcs/assign.cs
@@ -358,10 +358,7 @@ namespace Mono.CSharp {
                                return null;
                        }
 
-                       if ((source.eclass == ExprClass.Type) && (source is TypeExpr)) {
-                               source.Error_UnexpectedKind (ec.DeclContainer, "variable or value", loc);
-                               return null;
-                       } else if ((RootContext.Version == LanguageVersion.ISO_1) &&
+                       if ((RootContext.Version == LanguageVersion.ISO_1) &&
                                   (source is MethodGroupExpr)){
                                ((MethodGroupExpr) source).ReportUsageError ();
                                return null;
@@ -489,7 +486,7 @@ namespace Mono.CSharp {
                                //
 
                                // TODO: Use ResolveContext only
-                               EmitContext f_ec = new EmitContext (rc, rc.DeclContainer, loc, null, TypeManager.void_type, 0, true);
+                               EmitContext f_ec = new EmitContext (rc, rc.GenericDeclContainer, loc, null, TypeManager.void_type, 0, true);
                                f_ec.IsStatic = ec.IsStatic;
                                f_ec.CurrentBlock = ec.CurrentBlock;
 

diff --git a/mcs/mcs/class.cs b/mcs/mcs/class.cs
index 7be47f55af9c4951147909bebc08a7a7ed5e7126..7ecbe52da50093005949787a181fe6f8fc845892 100644 (file)
--- a/mcs/mcs/class.cs
+++ b/mcs/mcs/class.cs
@@ -199,6 +199,11 @@ namespace Mono.CSharp {
                                return null;
                        }
 
+                       public FullNamedExpression LookupNamespaceAlias (string name)
+                       {
+                               return tc.Parent.LookupNamespaceAlias (name);
+                       }
+
                        public FullNamedExpression LookupNamespaceOrType (string name, Location loc, bool ignore_cs0104)
                        {
                                TypeParameter[] tp = CurrentTypeParameters;

diff --git a/mcs/mcs/codegen.cs b/mcs/mcs/codegen.cs
index fe7383df895217371f25f197c48ae9609dfd9c05..2a26b3672e5c00e19eeeb85d65ca79b2be694eb0 100644 (file)
--- a/mcs/mcs/codegen.cs
+++ b/mcs/mcs/codegen.cs
@@ -271,14 +271,12 @@ namespace Mono.CSharp {
                //
                TypeContainer CurrentTypeDefinition { get; }
 
-               // Obsolete
-               DeclSpace DeclContainer { get; }
-
                bool IsInObsoleteScope { get; }
                bool IsInUnsafeScope { get; }
 
                ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc);
                FullNamedExpression LookupNamespaceOrType (string name, Location loc, bool ignore_cs0104);
+               FullNamedExpression LookupNamespaceAlias (string name);
 
                // the declcontainer to lookup for type-parameters.  Should only use LookupGeneric on it.
                //
@@ -517,14 +515,9 @@ namespace Mono.CSharp {
                        get { return ResolveContext.CurrentTypeDefinition; }
                }
 
-               // IResolveContext.DeclContainer
-               public DeclSpace DeclContainer { 
-                       get { return decl_space; }
-               }
-
                // IResolveContext.GenericDeclContainer
                public DeclSpace GenericDeclContainer {
-                       get { return DeclContainer; }
+                       get { return decl_space; }
                }
 
                public bool CheckState {
@@ -1074,6 +1067,11 @@ namespace Mono.CSharp {
                        return ResolveContext.LookupNamespaceOrType (name, loc, ignore_cs0104);
                }
 
+               public FullNamedExpression LookupNamespaceAlias (string name)
+               {
+                       return ResolveContext.LookupNamespaceAlias (name);
+               }
+
                #endregion
        }
 
@@ -1149,6 +1147,11 @@ namespace Mono.CSharp {
                        return RootContext.ToplevelTypes.LookupNamespaceOrType (name, loc, ignore_cs0104);
                }
 
+               public FullNamedExpression LookupNamespaceAlias (string name)
+               {
+                       throw new NotImplementedException ();
+               }
+
                #endregion
        }
                 

diff --git a/mcs/mcs/decl.cs b/mcs/mcs/decl.cs
index facf8da7a93adf0e2940dce88d8c5f87ed78d68b..a139ca85058f901c03249f0e823d16454d3d3f12 100644 (file)
--- a/mcs/mcs/decl.cs
+++ b/mcs/mcs/decl.cs
@@ -675,6 +675,11 @@ namespace Mono.CSharp {
                        return Parent.LookupExtensionMethod (extensionType, name, loc);
                }
 
+               public virtual FullNamedExpression LookupNamespaceAlias (string name)
+               {
+                       return Parent.NamespaceEntry.LookupNamespaceAlias (name);
+               }
+
                public virtual FullNamedExpression LookupNamespaceOrType (string name, Location loc, bool ignore_cs0104)
                {
                        return Parent.LookupNamespaceOrType (name, loc, ignore_cs0104);

diff --git a/mcs/mcs/ecore.cs b/mcs/mcs/ecore.cs
index 3770dc26bd83bed45776f04d4377ccde19820d00..55fda9b9df90621f27a0092d1259907bb810c1d4 100644 (file)
--- a/mcs/mcs/ecore.cs
+++ b/mcs/mcs/ecore.cs
@@ -1040,16 +1040,18 @@ namespace Mono.CSharp {
                /// <summary>
                ///   Reports that we were expecting `expr' to be of class `expected'
                /// </summary>
-               public void Error_UnexpectedKind (DeclSpace ds, string expected, Location loc)
+               public void Error_UnexpectedKind (MemberCore mc, string expected, Location loc)
                {
-                       Error_UnexpectedKind (ds, expected, ExprClassName, loc);
+                       Error_UnexpectedKind (mc, expected, ExprClassName, loc);
                }
 
-               public void Error_UnexpectedKind (DeclSpace ds, string expected, string was, Location loc)
+               public void Error_UnexpectedKind (MemberCore mc, string expected, string was, Location loc)
                {
-                       string name = GetSignatureForError ();
-                       if (ds != null)
-                               name = ds.GetSignatureForError () + '.' + name;
+                       string name;
+                       if (mc != null)
+                               name = mc.GetSignatureForError ();
+                       else
+                               name = GetSignatureForError ();
 
                        Report.Error (118, loc, "`{0}' is a `{1}' but a `{2}' was expected",
                              name, was, expected);
@@ -2497,7 +2499,10 @@ namespace Mono.CSharp {
                        if (!TypeManager.IsGenericTypeDefinition (t) && !TypeManager.IsGenericType (t))
                                return null;
 
-                       DeclSpace ds = ec.DeclContainer;
+                       if (ec.CurrentType == null)
+                               return null;
+
+                       DeclSpace ds = ec.CurrentTypeDefinition;
                        while (ds != null && !IsNestedChild (t, ds.TypeBuilder))
                                ds = ds.Parent;
 
@@ -2557,31 +2562,37 @@ namespace Mono.CSharp {
 
                protected virtual void Error_TypeOrNamespaceNotFound (IResolveContext ec)
                {
-                       MemberCore mc = ec.DeclContainer.GetDefinition (Name);
-                       if (mc != null) {
-                               Error_UnexpectedKind (ec.DeclContainer, "type", GetMemberType (mc), loc);
-                               return;
-                       }
+                       if (ec.CurrentType != null) {
+                               if (ec.CurrentTypeDefinition != null) {
+                                       MemberCore mc = ec.CurrentTypeDefinition.GetDefinition (Name);
+                                       if (mc != null) {
+                                               Error_UnexpectedKind (mc, "type", GetMemberType (mc), loc);
+                                               return;
+                                       }
+                               }
 
-                       string ns = ec.DeclContainer.NamespaceEntry.NS.Name;
-                       string fullname = (ns.Length > 0) ? ns + "." + Name : Name;
-                       foreach (Assembly a in GlobalRootNamespace.Instance.Assemblies) {
-                               Type type = a.GetType (fullname);
-                               if (type != null) {
-                                       Report.SymbolRelatedToPreviousError (type);
-                                       Expression.ErrorIsInaccesible (loc, TypeManager.CSharpName (type));
-                                       return;
+                               string ns = ec.CurrentType.Namespace;
+                               string fullname = (ns.Length > 0) ? ns + "." + Name : Name;
+                               foreach (Assembly a in GlobalRootNamespace.Instance.Assemblies) {
+                                       Type type = a.GetType (fullname);
+                                       if (type != null) {
+                                               Report.SymbolRelatedToPreviousError (type);
+                                               Expression.ErrorIsInaccesible (loc, TypeManager.CSharpName (type));
+                                               return;
+                                       }
                                }
-                       }
 
-                       Type t = ec.DeclContainer.LookupAnyGeneric (Name);
-                       if (t != null) {
-                               Namespace.Error_InvalidNumberOfTypeArguments (t, loc);
-                               return;
+                               if (ec.CurrentTypeDefinition != null) {
+                                       Type t = ec.CurrentTypeDefinition.LookupAnyGeneric (Name);
+                                       if (t != null) {
+                                               Namespace.Error_InvalidNumberOfTypeArguments (t, loc);
+                                               return;
+                                       }
+                               }
                        }
 
                        if (targs != null) {
-                               FullNamedExpression retval = ec.DeclContainer.LookupNamespaceOrType (SimpleName.RemoveGenericArity (Name), loc, true);
+                               FullNamedExpression retval = ec.LookupNamespaceOrType (SimpleName.RemoveGenericArity (Name), loc, true);
                                if (retval != null) {
                                        Namespace.Error_TypeArgumentsCannotBeUsed (retval, loc);
                                        return;
@@ -2683,12 +2694,8 @@ namespace Mono.CSharp {
 
                        Type almost_matched_type = null;
                        ArrayList almost_matched = null;
-                       for (DeclSpace lookup_ds = ec.DeclContainer; lookup_ds != null; lookup_ds = lookup_ds.Parent) {
-                               // either RootDeclSpace or GenericMethod
-                               if (lookup_ds.TypeBuilder == null)
-                                       continue;
-
-                               e = MemberLookup (ec.CurrentType, lookup_ds.TypeBuilder, Name, loc);
+                       for (Type lookup_ds = ec.CurrentType; lookup_ds != null; lookup_ds = lookup_ds.DeclaringType) {
+                               e = MemberLookup (ec.CurrentType, lookup_ds, Name, loc);
                                if (e != null) {
                                        PropertyExpr pe = e as PropertyExpr;
                                        if (pe != null) {
@@ -2711,7 +2718,7 @@ namespace Mono.CSharp {
                                }
 
                                if (almost_matched == null && almost_matched_members.Count > 0) {
-                                       almost_matched_type = lookup_ds.TypeBuilder;
+                                       almost_matched_type = lookup_ds;
                                        almost_matched = (ArrayList) almost_matched_members.Clone ();
                                }
                        }
@@ -2748,8 +2755,10 @@ namespace Mono.CSharp {
                                        almost_matched_members = almost_matched;
                                if (almost_matched_type == null)
                                        almost_matched_type = ec.CurrentType;
+
+                               string type_name = ec.ResolveContext.CurrentType == null ? null : ec.ResolveContext.CurrentType.Name;
                                return Error_MemberLookupFailed (ec.CurrentType, null, almost_matched_type, Name,
-                                       ec.DeclContainer.Name, AllMemberTypes, AllBindingFlags);
+                                       type_name, AllMemberTypes, AllBindingFlags);
                        }
 
                        if (e is MemberExpr) {
@@ -5052,7 +5061,7 @@ namespace Mono.CSharp {
 
                                // Optimization for build-in types
                                // TODO: Iterators don't set current container
-                               if (TypeManager.IsStruct (type) && type == ec.DeclContainer.TypeBuilder && ec.CurrentIterator == null) {
+                               if (TypeManager.IsStruct (type) && TypeManager.IsEqual (type, ec.ResolveContext.CurrentType) && ec.CurrentIterator == null) {
                                        LoadFromPtr (ig, type);
                                } else {
                                        IFixedBuffer ff = AttributeTester.GetFixedBuffer (FieldInfo);

diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index 48b6db0a4230c108104b11b1bab7f24e69a5d8df..596eadb273ab7beb2b4dd41a91a2d1980d2d04ed 100644 (file)
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -5437,7 +5437,7 @@ namespace Mono.CSharp {
 
                        method = ml as MethodGroupExpr;
                        if (method == null) {
-                               ml.Error_UnexpectedKind (ec.DeclContainer, "method group", loc);
+                               ml.Error_UnexpectedKind (ResolveFlags.MethodGroup, loc);
                                return null;
                        }
 
@@ -7223,9 +7223,7 @@ namespace Mono.CSharp {
                        }
 
                        int errors = Report.Errors;
-                       // TODO: Implement ec.Namespace
-
-                       expr = ec.DeclContainer.NamespaceEntry.LookupAlias (alias);
+                       expr = ec.LookupNamespaceAlias (alias);
                        if (expr == null) {
                                if (errors == Report.Errors)
                                        Report.Error (432, loc, "Alias `{0}' not found", alias);
@@ -7408,7 +7406,7 @@ namespace Mono.CSharp {
                                        return null;
                                }
 
-                               if (!texpr.CheckAccessLevel (ec.DeclContainer)) {
+                               if (!texpr.CheckAccessLevel (ec.GenericDeclContainer)) {
                                        Report.SymbolRelatedToPreviousError (member_lookup.Type);
                                        ErrorIsInaccesible (loc, TypeManager.CSharpName (member_lookup.Type));
                                        return null;
@@ -7506,7 +7504,7 @@ namespace Mono.CSharp {
                        }
 
                        Expression member_lookup = MemberLookup (
-                               rc.DeclContainer.TypeBuilder, expr_type, expr_type, LookupIdentifier,
+                               rc.CurrentType, expr_type, expr_type, LookupIdentifier,
                                MemberTypes.NestedType, BindingFlags.Public | BindingFlags.NonPublic, loc);
                        if (member_lookup == null) {
                                if (silent)
@@ -7548,7 +7546,7 @@ namespace Mono.CSharp {
                protected virtual void Error_IdentifierNotFound (IResolveContext rc, FullNamedExpression expr_type, string identifier)
                {
                        Expression member_lookup = MemberLookup (
-                               rc.DeclContainer.TypeBuilder, expr_type.Type, expr_type.Type, SimpleName.RemoveGenericArity (identifier),
+                               rc.CurrentType, expr_type.Type, expr_type.Type, SimpleName.RemoveGenericArity (identifier),
                                MemberTypes.NestedType, BindingFlags.Public | BindingFlags.NonPublic, loc);
 
                        if (member_lookup != null) {
@@ -7561,7 +7559,7 @@ namespace Mono.CSharp {
                        }
 
                        member_lookup = MemberLookup (
-                               rc.DeclContainer.TypeBuilder, expr_type.Type, expr_type.Type, identifier,
+                               rc.CurrentType, expr_type.Type, expr_type.Type, identifier,
                                        MemberTypes.All, BindingFlags.Public | BindingFlags.NonPublic, loc);
 
                        if (member_lookup == null) {

diff --git a/mcs/mcs/namespace.cs b/mcs/mcs/namespace.cs
index c9030b5f9541b2ab33cae9dbc4576d83a904533f..37acce92fe30bbd6b7399a9f36bea837acc8a7d7 100644 (file)
--- a/mcs/mcs/namespace.cs
+++ b/mcs/mcs/namespace.cs
@@ -1114,7 +1114,7 @@ namespace Mono.CSharp {
                }
 
                // Looks-up a alias named @name in this and surrounding namespace declarations
-               public FullNamedExpression LookupAlias (string name)
+               public FullNamedExpression LookupNamespaceAlias (string name)
                {
                        for (NamespaceEntry n = this; n != null; n = n.ImplicitParent) {
                                if (n.using_aliases == null)

diff --git a/mcs/mcs/roottypes.cs b/mcs/mcs/roottypes.cs
index 504907a6a2a7b9b3a52cf1f568f4829f830cd024..e9d2d26bebf1cbdd38c219b296da8b2f7215ccce 100644 (file)
--- a/mcs/mcs/roottypes.cs
+++ b/mcs/mcs/roottypes.cs
@@ -260,5 +260,10 @@ namespace Mono.CSharp
                {
                        return PartialContainer.IsClsComplianceRequired ();
                }
+
+               public override FullNamedExpression LookupNamespaceAlias (string name)
+               {
+                       return NamespaceEntry.LookupNamespaceAlias (name);
+               }
        }
 }