Put the merging back.

[mono.git] / mcs / gmcs / namespace.cs

diff --git a/mcs/gmcs/namespace.cs b/mcs/gmcs/namespace.cs
index 138c318527b70bd4d7914182536509e7cf7c001f..03322aa35a8b12ce805f11a39a5aaca660f7134e 100755 (executable)
--- a/mcs/gmcs/namespace.cs
+++ b/mcs/gmcs/namespace.cs
@@ -241,11 +241,11 @@ namespace Mono.CSharp {
 
                public class AliasEntry {
                        public readonly string Name;
-                       public readonly TypeName Alias;
+                       public readonly MemberName Alias;
                        public readonly NamespaceEntry NamespaceEntry;
                        public readonly Location Location;
                        
-                       public AliasEntry (NamespaceEntry entry, string name, TypeName alias, Location loc)
+                       public AliasEntry (NamespaceEntry entry, string name, MemberName alias, Location loc)
                        {
                                Name = name;
                                Alias = alias;
@@ -260,18 +260,24 @@ namespace Mono.CSharp {
                                if (resolved != null)
                                        return resolved;
 
-                               NamespaceEntry curr_ns = NamespaceEntry;
-
                                //
                                // GENERICS: Cope with the expression and not with the string
                                // this will fail with `using A = Stack<int>'
                                //
                                
                                string alias = Alias.GetTypeName ();
+
+                               // According to section 16.3.1, the namespace-or-type-name is resolved
+                               // as if the immediately containing namespace body has no using-directives.
+                               resolved = NamespaceEntry.Lookup (
+                                       null, alias, Alias.CountTypeArguments, true, false, Location);
+
+                               NamespaceEntry curr_ns = NamespaceEntry.Parent;
+
                                while ((curr_ns != null) && (resolved == null)) {
                                        resolved = curr_ns.Lookup (
                                                null, alias, Alias.CountTypeArguments,
-                                               Location);
+                                               false, false, Location);
 
                                        if (resolved == null)
                                                curr_ns = curr_ns.Parent;
@@ -359,11 +365,11 @@ namespace Mono.CSharp {
                        if (using_clauses == null)
                                using_clauses = new ArrayList ();
 
-                       foreach (UsingEntry old_entry in using_clauses){
-                               if (old_entry.Name == ns){
-                                       Report.Warning (105, loc, "The using directive for '" + ns +
-                                                       "' appeared previously in this namespace");
-                                       return;
+                       foreach (UsingEntry old_entry in using_clauses) {
+                               if (old_entry.Name == ns) {
+                                       if (RootContext.WarningLevel >= 3)
+                                               Report.Warning (105, loc, "The using directive for '{0}' appeared previously in this namespace", ns);
+                                               return;
                                }
                        }
                        
@@ -371,8 +377,13 @@ namespace Mono.CSharp {
                        using_clauses.Add (ue);
                }
 
-               public void UsingAlias (string name, TypeName alias, Location loc)
+               public void UsingAlias (string name, MemberName alias, Location loc)
                {
+                       if (DeclarationFound){
+                               Report.Error (1529, loc, "A using clause must precede all other namespace elements");
+                               return;
+                       }
+
                        if (aliases == null)
                                aliases = new Hashtable ();
 
@@ -408,7 +419,7 @@ namespace Mono.CSharp {
                }
 
                public IAlias Lookup (DeclSpace ds, string name, int num_type_params,
-                                     Location loc)
+                                     bool ignore_using, bool silent, Location loc)
                {
                        IAlias o;
                        Namespace ns;
@@ -421,7 +432,7 @@ namespace Mono.CSharp {
                                string first = name.Substring (0, pos);
                                string last = name.Substring (pos + 1);
 
-                               o = Lookup (ds, first, 0, loc);
+                               o = Lookup (ds, first, 0, ignore_using, silent, loc);
                                if (o == null)
                                        return null;
 
@@ -445,6 +456,9 @@ namespace Mono.CSharp {
                        if (o != null)
                                return o;
 
+                       if (ignore_using)
+                               return null;
+
                        //
                        // Check aliases.
                        //
@@ -455,6 +469,9 @@ namespace Mono.CSharp {
                                        return alias;
                        }
 
+                       if (name.IndexOf ('.') > 0)
+                               return null;
+
                        //
                        // Check using entries.
                        //
@@ -463,7 +480,8 @@ namespace Mono.CSharp {
                                match = using_ns.Lookup (ds, name, loc);
                                if ((match != null) && match.IsType){
                                        if (t != null) {
-                                               DeclSpace.Error_AmbiguousTypeReference (loc, name, t.Name, match.Name);
+                                               if (!silent)
+                                                       DeclSpace.Error_AmbiguousTypeReference (loc, name, t.Name, match.Name);
                                                return null;
                                        } else {
                                                t = match;
@@ -516,7 +534,11 @@ namespace Mono.CSharp {
                        }
 
                        int parent_id = parent != null ? parent.symfile_id : 0;
-                       symfile_id = symwriter.DefineNamespace (ns.Name, file, using_list, parent_id);
+                       if (file.SourceFileEntry == null)
+                               return;
+
+                       symfile_id = symwriter.DefineNamespace (
+                               ns.Name, file.SourceFileEntry, using_list, parent_id);
                }
 
                public int SymbolFileID {
@@ -581,7 +603,7 @@ namespace Mono.CSharp {
                /// </summary>
                public void VerifyUsing ()
                {
-                       TypeContainer dummy = new TypeContainer ();
+                       TypeContainer dummy = new RootTypes ();
                        EmitContext ec = new EmitContext (
                                dummy, Location.Null, null, null, 0, false);