Less static is good for my health.

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

diff --git a/mcs/mcs/attribute.cs b/mcs/mcs/attribute.cs
index e888600547272aacb85dd234b5d3db6638592921..a5fcfc5d8ba8a36329b6bb5208e7e37fc31143cf 100644 (file)
--- a/mcs/mcs/attribute.cs
+++ b/mcs/mcs/attribute.cs
@@ -1691,7 +1691,7 @@ namespace Mono.CSharp {
 
                public static void VerifyModulesClsCompliance ()
                {
-                       Module[] modules = RootNamespace.Global.Modules;
+                       Module[] modules = GlobalRootNamespace.Instance.Modules;
                        if (modules == null)
                                return;
 
@@ -1708,7 +1708,7 @@ namespace Mono.CSharp {
 
                public static Type GetImportedIgnoreCaseClsType (string name)
                {
-                       foreach (Assembly a in RootNamespace.Global.Assemblies) {
+                       foreach (Assembly a in GlobalRootNamespace.Instance.Assemblies) {
                                Type t = a.GetType (name, false, true);
                                if (t == null)
                                        continue;

diff --git a/mcs/mcs/codegen.cs b/mcs/mcs/codegen.cs
index 68ab895b42d0bcb5c7ada6da2f6e6733fb2cfb40..1978d37d732c5d3102e4058a4472299a26bb8a5b 100644 (file)
--- a/mcs/mcs/codegen.cs
+++ b/mcs/mcs/codegen.cs
@@ -118,7 +118,7 @@ namespace Mono.CSharp {
                        if (an.KeyPair != null) {
                                // If we are going to strong name our assembly make
                                // sure all its refs are strong named
-                               foreach (Assembly a in RootNamespace.Global.Assemblies) {
+                               foreach (Assembly a in GlobalRootNamespace.Instance.Assemblies) {
                                        AssemblyName ref_name = a.GetName ();
                                        byte [] b = ref_name.GetPublicKeyToken ();
                                        if (b == null || b.Length == 0) {

diff --git a/mcs/mcs/doc.cs b/mcs/mcs/doc.cs
index 39fb16528d7b04ea04c1f9f286e2a8c70b67264f..a8c163e7e0d78ed094a9b730636a7a00e685fbd6 100644 (file)
--- a/mcs/mcs/doc.cs
+++ b/mcs/mcs/doc.cs
@@ -724,7 +724,7 @@ namespace Mono.CSharp {
                                xref.SetAttribute ("cref", "N:" + ns.GetSignatureForError ());
                                return; // a namespace
                        }
-                       if (RootNamespace.Global.IsNamespace (name)) {
+                       if (GlobalRootNamespace.Instance.IsNamespace (name)) {
                                xref.SetAttribute ("cref", "N:" + name);
                                return; // a namespace
                        }

diff --git a/mcs/mcs/driver.cs b/mcs/mcs/driver.cs
index f1875c005de2faa99b525473677fa64b2d89bc57..a126d04977f428c0e278b14c2e76dbda18344cf3 100644 (file)
--- a/mcs/mcs/driver.cs
+++ b/mcs/mcs/driver.cs
@@ -402,9 +402,9 @@ namespace Mono.CSharp
 
                                // Extern aliased refs require special handling
                                if (alias == null)
-                                       RootNamespace.Global.AddAssemblyReference (a);
+                                       GlobalRootNamespace.Instance.AddAssemblyReference (a);
                                else
-                                       RootNamespace.DefineRootNamespace (alias, a);
+                                       GlobalRootNamespace.Instance.DefineRootNamespace (alias, a);
 
                        } catch (BadImageFormatException f) {
                                // .NET 2.0 throws this if we try to load a module without an assembly manifest ...
@@ -444,7 +444,7 @@ namespace Mono.CSharp
                                        }
                                }
 
-                               RootNamespace.Global.AddModuleReference (m);
+                               GlobalRootNamespace.Instance.AddModuleReference (m);
 
                        } catch (BadImageFormatException f) {
                                Error9 ("module", f.FileName, f.FusionLog);
@@ -476,7 +476,7 @@ namespace Mono.CSharp
                        foreach (DictionaryEntry entry in external_aliases)
                                LoadAssembly ((string) entry.Value, (string) entry.Key, false);
                                
-                       RootNamespace.ComputeNamespaces ();
+                       GlobalRootNamespace.Instance.ComputeNamespaces ();
                }
 
                static string [] LoadArgs (string file)
@@ -1638,7 +1638,7 @@ namespace Mono.CSharp
                                set_method.Invoke (CodeGen.Assembly.Builder, BindingFlags.Default, null, new object[]{true}, null);
                        }
 
-                       RootNamespace.Global.AddModuleReference (CodeGen.Module.Builder);
+                       GlobalRootNamespace.Instance.AddModuleReference (CodeGen.Module.Builder);
 
                        //
                        // Load assemblies required
@@ -1991,7 +1991,7 @@ namespace Mono.CSharp
                        TypeHandle.Reset ();
 
                        if (full_flag)
-                               RootNamespace.Reset ();
+                               GlobalRootNamespace.Reset ();
                        
                        NamespaceEntry.Reset ();
                        CodeGen.Reset ();

diff --git a/mcs/mcs/ecore.cs b/mcs/mcs/ecore.cs
index 35e8a4b469b7f5128ea257d59627c2ff4f2602fa..87f44473ab08d3d9a16ad87c1038df1f60a0add4 100644 (file)
--- a/mcs/mcs/ecore.cs
+++ b/mcs/mcs/ecore.cs
@@ -2533,7 +2533,7 @@ namespace Mono.CSharp {
 
                        string ns = ec.DeclContainer.NamespaceEntry.NS.Name;
                        string fullname = (ns.Length > 0) ? ns + "." + Name : Name;
-                       foreach (Assembly a in RootNamespace.Global.Assemblies) {
+                       foreach (Assembly a in GlobalRootNamespace.Instance.Assemblies) {
                                Type type = a.GetType (fullname);
                                if (type != null) {
                                        Report.SymbolRelatedToPreviousError (type);
@@ -2937,7 +2937,7 @@ namespace Mono.CSharp {
                        // DeclSpace instead of Type
                        //
                        if (type == null) {
-                               Namespace ns = RootNamespace.Global.GetNamespace (ns_name, false);
+                               Namespace ns = GlobalRootNamespace.Instance.GetNamespace (ns_name, false);
                                FullNamedExpression fne = ns.Lookup (null, name, loc);
                                if (fne != null)
                                        type = fne.Type;

diff --git a/mcs/mcs/eval.cs b/mcs/mcs/eval.cs
index 555c80d5d6db733b07591e5709d57dc2215bf32d..e89078ba3e3bd9420dac1f813fe6e0e58267d2dd 100644 (file)
--- a/mcs/mcs/eval.cs
+++ b/mcs/mcs/eval.cs
@@ -739,7 +739,7 @@ namespace Mono.CSharp {
                {
                        lock (evaluator_lock){
                                Driver.LoadAssembly (file, false);
-                               RootNamespace.ComputeNamespaces ();
+                               GlobalRootNamespace.Instance.ComputeNamespaces ();
                        }
                }
 
@@ -749,8 +749,8 @@ namespace Mono.CSharp {
                static public void ReferenceAssembly (Assembly a)
                {
                        lock (evaluator_lock){
-                               RootNamespace.Global.AddAssemblyReference (a);
-                               RootNamespace.ComputeNamespaces ();
+                               GlobalRootNamespace.Instance.AddAssemblyReference (a);
+                               GlobalRootNamespace.Instance.ComputeNamespaces ();
                        }
                }
                

diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index 6009f790e92e9addade2aebc20102cded919a3ba..bca2707dab25f1be1d37ce1fe63a6c97dde35190 100644 (file)
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -7242,7 +7242,7 @@ namespace Mono.CSharp {
                public override FullNamedExpression ResolveAsTypeStep (IResolveContext ec, bool silent)
                {
                        if (alias == GlobalAlias) {
-                               expr = RootNamespace.Global;
+                               expr = GlobalRootNamespace.Instance;
                                return base.ResolveAsTypeStep (ec, silent);
                        }
 

diff --git a/mcs/mcs/namespace.cs b/mcs/mcs/namespace.cs
index 60fcfc7562271963cfa964b2dad897b74661579a..94443abe5477decfbcdf846a4e7a8f42e0a19964 100644 (file)
--- a/mcs/mcs/namespace.cs
+++ b/mcs/mcs/namespace.cs
@@ -15,7 +15,7 @@ using System.Reflection;
 
 namespace Mono.CSharp {
 
-       public class RootNamespace : Namespace {
+       class RootNamespace : Namespace {
                //
                // Points to Mono's GetNamespaces method, an
                // optimization when running on Mono to fetch all the
@@ -23,29 +23,17 @@ namespace Mono.CSharp {
                //
                static MethodInfo get_namespaces_method;
 
-               string alias_name;
+               protected readonly string alias_name;
                protected Assembly [] referenced_assemblies;
 
                Hashtable all_namespaces;
 
-               static ListDictionary root_namespaces;
-               public static GlobalRootNamespace Global;
-               
                static RootNamespace ()
                {
                        get_namespaces_method = typeof (Assembly).GetMethod ("GetNamespaces", BindingFlags.Instance | BindingFlags.NonPublic);
-
-                       Reset ();
                }
 
-               public static void Reset ()
-               {
-                       root_namespaces = new ListDictionary ();
-                       Global = new GlobalRootNamespace ();
-                       root_namespaces ["global"] = Global;
-               }
-
-               protected RootNamespace (string alias_name)
+               public RootNamespace (string alias_name)
                        : base (null, String.Empty)
                {
                        this.alias_name = alias_name;
@@ -69,45 +57,16 @@ namespace Mono.CSharp {
                        referenced_assemblies = n;
                }
 
-               public static void DefineRootNamespace (string alias, Assembly assembly)
-               {
-                       if (alias == "global") {
-                               NamespaceEntry.Error_GlobalNamespaceRedefined (Location.Null);
-                               return;
-                       }
-
-                       RootNamespace retval = GetRootNamespace (alias);
-                       if (retval == null) {
-                               retval = new RootNamespace (alias);
-                               root_namespaces.Add (alias, retval);
-                       }
-
-                       retval.AddAssemblyReference (assembly);
-               }
-
-               public static RootNamespace GetRootNamespace (string name)
+               public void ComputeNamespace ()
                {
-                       return (RootNamespace) root_namespaces [name];
-               }
-
-               public static void ComputeNamespaces ()
-               {
-                       //
-                       // Do very early lookup because type is required when we cache
-                       // imported extension types in ComputeNamespaces
-                       //
-                       TypeManager.extension_attribute_type = TypeManager.CoreLookupType ("System.Runtime.CompilerServices", "ExtensionAttribute", Kind.Class, false);
-                       
-                       foreach (RootNamespace rn in root_namespaces.Values) {
-                               foreach (Assembly a in rn.referenced_assemblies) {
-                                       try {
-                                               rn.ComputeNamespaces (a);
-                                       } catch (TypeLoadException e) {
-                                               Report.Error (11, Location.Null, e.Message);
-                                       } catch (System.IO.FileNotFoundException) {
-                                               Report.Error (12, Location.Null, "An assembly `{0}' is used without being referenced",
-                                                       a.FullName);
-                                       }
+                       foreach (Assembly a in referenced_assemblies) {
+                               try {
+                                       ComputeNamespaces (a);
+                               } catch (TypeLoadException e) {
+                                       Report.Error (11, Location.Null, e.Message);
+                               } catch (System.IO.FileNotFoundException) {
+                                       Report.Error (12, Location.Null, "An assembly `{0}' is used without being referenced",
+                                               a.FullName);
                                }
                        }
                }
@@ -156,14 +115,14 @@ namespace Mono.CSharp {
                void RegisterExtensionMethodClass (Type t)
                {
                        string n = t.Namespace;
-                       Namespace ns = n == null ? Global : (Namespace)all_namespaces [n];
+                       Namespace ns = n == null ? GlobalRootNamespace.Instance : (Namespace) all_namespaces[n];
                        if (ns == null)
                                ns = GetNamespace (n, true);
  
                        ns.RegisterExternalExtensionMethodClass (t);
                }
 
-               protected void ComputeNamespaces (Assembly assembly)
+               void ComputeNamespaces (Assembly assembly)
                {
                        bool contains_extension_methods = TypeManager.extension_attribute_type != null &&
                                        assembly.IsDefined(TypeManager.extension_attribute_type, false);
@@ -220,12 +179,22 @@ namespace Mono.CSharp {
                }
        }
 
-       public class GlobalRootNamespace : RootNamespace {
+       class GlobalRootNamespace : RootNamespace {
                Module [] modules;
+               ListDictionary root_namespaces;
 
-               public GlobalRootNamespace ()
+               public static GlobalRootNamespace Instance = new GlobalRootNamespace ();
+
+               GlobalRootNamespace ()
                        : base ("global")
                {
+                       root_namespaces = new ListDictionary ();
+                       root_namespaces.Add (alias_name, this);
+               }
+
+               public static void Reset ()
+               {
+                       Instance = new GlobalRootNamespace ();
                }
 
                public Assembly [] Assemblies {
@@ -252,12 +221,46 @@ namespace Mono.CSharp {
                                RegisterNamespace (t.Namespace);
                }
 
+               public void ComputeNamespaces ()
+               {
+                       //
+                       // Do very early lookup because type is required when we cache
+                       // imported extension types in ComputeNamespaces
+                       //
+                       TypeManager.extension_attribute_type = TypeManager.CoreLookupType ("System.Runtime.CompilerServices", "ExtensionAttribute", Kind.Class, false);
+
+                       foreach (RootNamespace rn in root_namespaces.Values) {
+                               rn.ComputeNamespace ();
+                       }
+               }
+
+               public void DefineRootNamespace (string alias, Assembly assembly)
+               {
+                       if (alias == alias_name) {
+                               NamespaceEntry.Error_GlobalNamespaceRedefined (Location.Null);
+                               return;
+                       }
+
+                       RootNamespace retval = GetRootNamespace (alias);
+                       if (retval == null) {
+                               retval = new RootNamespace (alias);
+                               root_namespaces.Add (alias, retval);
+                       }
+
+                       retval.AddAssemblyReference (assembly);
+               }
+
                public override void Error_NamespaceDoesNotExist(DeclSpace ds, Location loc, string name)
                {
                        Report.Error (400, loc, "The type or namespace name `{0}' could not be found in the global namespace (are you missing an assembly reference?)",
                                name);
                }
 
+               public RootNamespace GetRootNamespace (string name)
+               {
+                       return (RootNamespace) root_namespaces[name];
+               }
+
                public override Type LookupTypeReflection (string name, Location loc)
                {
                        Type found_type = base.LookupTypeReflection (name, loc);
@@ -672,7 +675,7 @@ namespace Mono.CSharp {
 
                        public virtual FullNamedExpression Resolve (IResolveContext rc)
                        {
-                               FullNamedExpression fne = RootNamespace.GetRootNamespace (Alias);
+                               FullNamedExpression fne = GlobalRootNamespace.Instance.GetRootNamespace (Alias);
                                if (fne == null) {
                                        Report.Error (430, Location,
                                                "The extern alias `{0}' was not specified in -reference option",
@@ -759,9 +762,9 @@ namespace Mono.CSharp {
                        if (parent != null)
                                ns = parent.NS.GetNamespace (name, true);
                        else if (name != null)
-                               ns = RootNamespace.Global.GetNamespace (name, true);
+                               ns = GlobalRootNamespace.Instance.GetNamespace (name, true);
                        else
-                               ns = RootNamespace.Global;
+                               ns = GlobalRootNamespace.Instance;
                        SlaveDeclSpace = new RootDeclSpace (this);
                }
 

diff --git a/mcs/mcs/typemanager.cs b/mcs/mcs/typemanager.cs
index 3491e27702de2e64f44589fb0a4a52cad8960e98..4f9ae079c375900469df1ee4745d12770007c301 100644 (file)
--- a/mcs/mcs/typemanager.cs
+++ b/mcs/mcs/typemanager.cs
@@ -572,7 +572,7 @@ namespace Mono.CSharp {
        public static void LoadAllImportedTypes ()
        {
                AllClsTopLevelTypes = new Hashtable (1500);
-               foreach (Assembly a in RootNamespace.Global.Assemblies) {
+               foreach (Assembly a in GlobalRootNamespace.Instance.Assemblies) {
                        foreach (Type t in a.GetExportedTypes ()) {
                                AllClsTopLevelTypes [t.FullName.ToLower (System.Globalization.CultureInfo.InvariantCulture)] = null;
                        }
@@ -581,7 +581,7 @@ namespace Mono.CSharp {
 
        public static bool NamespaceClash (string name, Location loc)
        {
-               if (! RootNamespace.Global.IsNamespace (name))
+               if (!GlobalRootNamespace.Instance.IsNamespace (name))
                        return false;
 
                Report.Error (519, loc, String.Format ("`{0}' clashes with a predefined namespace", name));
@@ -875,7 +875,7 @@ namespace Mono.CSharp {
        //
        public static Type CoreLookupType (string ns_name, string name, Kind type_kind, bool required)
        {
-               Namespace ns = RootNamespace.Global.GetNamespace (ns_name, true);
+               Namespace ns = GlobalRootNamespace.Instance.GetNamespace (ns_name, true);
                Expression expr = ns.Lookup (RootContext.ToplevelTypes, name, Location.Null);
 
                if (expr == null) {