2 // namespace.cs: Tracks namespaces
5 // Miguel de Icaza (miguel@ximian.com)
6 // Marek Safar (marek.safar@seznam.cz)
8 // Copyright 2001 Ximian, Inc.
9 // Copyright 2003-2008 Novell, Inc.
12 using System.Collections.Generic;
13 using System.Reflection;
16 namespace Mono.CSharp {
18 public class RootNamespace : Namespace {
20 protected readonly string alias_name;
21 protected Assembly [] referenced_assemblies;
23 Dictionary<string, Namespace> all_namespaces;
25 public RootNamespace (string alias_name)
26 : base (null, String.Empty)
28 this.alias_name = alias_name;
29 referenced_assemblies = new Assembly [0];
31 all_namespaces = new Dictionary<string, Namespace> ();
32 all_namespaces.Add ("", this);
35 public void AddAssemblyReference (Assembly a)
37 foreach (Assembly assembly in referenced_assemblies) {
42 int top = referenced_assemblies.Length;
43 Assembly [] n = new Assembly [top + 1];
44 referenced_assemblies.CopyTo (n, 0);
46 referenced_assemblies = n;
49 public virtual void ImportTypes (CompilerContext ctx)
51 foreach (Assembly a in referenced_assemblies) {
53 ctx.MetaImporter.ImportAssembly (a, this);
54 } catch (TypeLoadException e) {
55 ctx.Report.Error (11, Location.Null, e.Message);
56 } catch (System.IO.FileNotFoundException) {
57 ctx.Report.Error (12, Location.Null, "An assembly `{0}' is used without being referenced",
63 public void RegisterNamespace (Namespace child)
66 all_namespaces.Add (child.Name, child);
69 public bool IsNamespace (string name)
71 return all_namespaces.ContainsKey (name);
74 protected void RegisterNamespace (string dotted_name)
76 if (dotted_name != null && dotted_name.Length != 0 && ! IsNamespace (dotted_name))
77 GetNamespace (dotted_name, true);
80 public override string GetSignatureForError ()
82 return alias_name + "::";
86 // TODO: It should go to AssemblyClass or AssemblySpec
87 public class GlobalRootNamespace : RootNamespace {
89 Dictionary<string, RootNamespace> root_namespaces;
91 public GlobalRootNamespace ()
94 root_namespaces = new Dictionary<string, RootNamespace> ();
95 root_namespaces.Add (alias_name, this);
98 public Assembly [] Assemblies {
99 get { return referenced_assemblies; }
102 public Module [] Modules {
103 get { return modules; }
106 public void AddModuleReference (Module m)
108 int top = modules != null ? modules.Length : 0;
109 Module [] n = new Module [top + 1];
111 modules.CopyTo (n, 0);
115 if (m == RootContext.ToplevelTypes.Builder)
118 foreach (var t in m.GetTypes ())
119 RegisterNamespace (t.Namespace);
122 public void ComputeNamespaces (CompilerContext ctx)
124 foreach (RootNamespace rn in root_namespaces.Values) {
125 rn.ImportTypes (ctx);
129 public void DefineRootNamespace (string alias, Assembly assembly, CompilerContext ctx)
131 if (alias == alias_name) {
132 NamespaceEntry.Error_GlobalNamespaceRedefined (Location.Null, ctx.Report);
136 RootNamespace retval = GetRootNamespace (alias);
137 if (retval == null) {
138 retval = new RootNamespace (alias);
139 root_namespaces.Add (alias, retval);
142 retval.AddAssemblyReference (assembly);
145 public override void Error_NamespaceDoesNotExist (Location loc, string name, int arity, IMemberContext ctx)
147 ctx.Compiler.Report.Error (400, loc,
148 "The type or namespace name `{0}' could not be found in the global namespace (are you missing an assembly reference?)",
152 public RootNamespace GetRootNamespace (string name)
155 if (!root_namespaces.TryGetValue (name, out rn))
161 public override void ImportTypes (CompilerContext ctx)
163 base.ImportTypes (ctx);
165 if (modules != null) {
167 for (int i = 1; i < modules.Length; ++i) {
168 ctx.MetaImporter.ImportModule (modules[i], this);
175 /// Keeps track of the namespaces defined in the C# code.
177 /// This is an Expression to allow it to be referenced in the
178 /// compiler parse/intermediate tree during name resolution.
180 public class Namespace : FullNamedExpression {
184 protected Dictionary<string, Namespace> namespaces;
185 protected Dictionary<string, IList<TypeSpec>> types;
186 Dictionary<string, TypeExpr> cached_types;
190 public readonly MemberName MemberName;
193 /// Constructor Takes the current namespace and the
194 /// name. This is bootstrapped with parent == null
197 public Namespace (Namespace parent, string name)
199 // Expression members.
200 this.eclass = ExprClass.Namespace;
201 this.Type = InternalType.FakeInternalType;
202 this.loc = Location.Null;
204 this.parent = parent;
207 this.root = parent.root;
209 this.root = this as RootNamespace;
211 if (this.root == null)
212 throw new InternalErrorException ("Root namespaces must be created using RootNamespace");
214 string pname = parent != null ? parent.fullname : "";
219 fullname = parent.fullname + "." + name;
221 if (fullname == null)
222 throw new InternalErrorException ("Namespace has a null fullname");
224 if (parent != null && parent.MemberName != MemberName.Null)
225 MemberName = new MemberName (parent.MemberName, name);
226 else if (name.Length == 0)
227 MemberName = MemberName.Null;
229 MemberName = new MemberName (name);
231 namespaces = new Dictionary<string, Namespace> ();
232 cached_types = new Dictionary<string, TypeExpr> ();
234 root.RegisterNamespace (this);
240 /// The qualified name of the current namespace
243 get { return fullname; }
247 /// The parent of this namespace, used by the parser to "Pop"
248 /// the current namespace declaration
250 public Namespace Parent {
251 get { return parent; }
256 protected override Expression DoResolve (ResolveContext ec)
261 public virtual void Error_NamespaceDoesNotExist (Location loc, string name, int arity, IMemberContext ctx)
263 FullNamedExpression retval = Lookup (ctx.Compiler, name, -System.Math.Max (1, arity), loc);
264 if (retval != null) {
265 Error_TypeArgumentsCannotBeUsed (ctx.Compiler.Report, loc, retval.Type, arity);
270 if (arity > 0 && namespaces.TryGetValue (name, out ns)) {
271 ns.Error_TypeArgumentsCannotBeUsed (ctx.Compiler.Report, loc, null, arity);
275 ctx.Compiler.Report.Error (234, loc,
276 "The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
277 name, GetSignatureForError ());
280 public override string GetSignatureForError ()
285 public Namespace GetNamespace (string name, bool create)
287 int pos = name.IndexOf ('.');
292 first = name.Substring (0, pos);
296 if (!namespaces.TryGetValue (first, out ns)) {
300 ns = new Namespace (this, first);
301 namespaces.Add (first, ns);
305 ns = ns.GetNamespace (name.Substring (pos + 1), create);
310 public TypeExpr LookupType (CompilerContext ctx, string name, int arity, bool silent, Location loc)
316 if (arity == 0 && cached_types.TryGetValue (name, out te))
319 IList<TypeSpec> found;
320 if (!types.TryGetValue (name, out found))
323 TypeSpec best = null;
324 foreach (var ts in found) {
325 if (ts.Arity == arity) {
331 var pts = best as PredefinedTypeSpec;
333 pts = ts as PredefinedTypeSpec;
336 ctx.Report.SymbolRelatedToPreviousError (best);
337 ctx.Report.SymbolRelatedToPreviousError (ts);
339 // TODO: This should use different warning number but we want to be csc compatible
340 ctx.Report.Warning (1685, 1, loc,
341 "The predefined type `{0}.{1}' is redefined in the source code. Ignoring the local type definition",
342 pts.Namespace, pts.Name);
347 if (best.MemberDefinition.IsImported && ts.MemberDefinition.IsImported) {
348 ctx.Report.SymbolRelatedToPreviousError (best);
349 ctx.Report.SymbolRelatedToPreviousError (ts);
351 ctx.Report.Warning (1685, 1, loc,
352 "The predefined type `{0}' is defined in multiple assemblies. Using definition from `{1}'",
353 ts.GetSignatureForError (), best.Assembly.GetName ().Name);
355 ctx.Report.Error (433, loc, "The imported type `{0}' is defined multiple times", ts.GetSignatureForError ());
361 if (best.MemberDefinition.IsImported)
364 if ((best.Modifiers & Modifiers.INTERNAL) != 0 && !TypeManager.IsThisOrFriendAssembly (CodeGen.Assembly.Builder, best.MemberDefinition.Assembly))
370 if (ts.MemberDefinition.IsImported)
371 ctx.Report.SymbolRelatedToPreviousError (ts);
373 ctx.Report.Warning (436, 2, loc,
374 "The type `{0}' conflicts with the imported type of same name'. Ignoring the imported type definition",
375 best.GetSignatureForError ());
379 // Lookup for the best candidate with closest arity match
384 } else if (System.Math.Abs (ts.Arity + arity) < System.Math.Abs (best.Arity + arity)) {
393 if ((best.Modifiers & Modifiers.INTERNAL) != 0 && !TypeManager.IsThisOrFriendAssembly (CodeGen.Assembly.Builder, best.MemberDefinition.Assembly))
396 te = new TypeExpression (best, Location.Null);
398 // TODO MemberCache: Cache more
399 if (arity == 0 && !silent)
400 cached_types.Add (name, te);
405 TypeSpec LookupType (string name, int arity)
410 IList<TypeSpec> found;
411 if (types.TryGetValue (name, out found)) {
412 TypeSpec best = null;
414 foreach (var ts in found) {
415 if (ts.Arity == arity)
419 // Lookup for the best candidate with closest arity match
424 } else if (System.Math.Abs (ts.Arity + arity) < System.Math.Abs (best.Arity + arity)) {
436 public FullNamedExpression Lookup (CompilerContext ctx, string name, int arity, Location loc)
438 if (arity == 0 && namespaces.ContainsKey (name))
439 return namespaces [name];
441 return LookupType (ctx, name, arity, false, loc);
445 // Completes types with the given `prefix'
447 public IEnumerable<string> CompletionGetTypesStartingWith (string prefix)
450 return Enumerable.Empty<string> ();
452 var res = from item in types
453 where item.Key.StartsWith (prefix) && item.Value.Any (l => (l.Modifiers & Modifiers.PUBLIC) != 0)
456 if (namespaces != null)
457 res = res.Concat (from item in namespaces where item.Key.StartsWith (prefix) select item.Key);
463 /// Looks for extension method in this namespace
465 public List<MethodSpec> LookupExtensionMethod (TypeSpec extensionType, ClassOrStruct currentClass, string name, int arity)
470 List<MethodSpec> found = null;
472 var invocation_type = currentClass == null ? InternalType.FakeInternalType : currentClass.CurrentType;
474 // TODO: Add per namespace flag when at least 1 type has extension
476 foreach (var tgroup in types.Values) {
477 foreach (var ts in tgroup) {
478 if ((ts.Modifiers & Modifiers.METHOD_EXTENSION) == 0)
481 var res = ts.MemberCache.FindExtensionMethods (invocation_type, extensionType, name, arity);
488 found.AddRange (res);
496 public void AddType (TypeSpec ts)
499 types = new Dictionary<string, IList<TypeSpec>> (64);
503 IList<TypeSpec> existing;
504 if (types.TryGetValue (name, out existing)) {
505 TypeSpec better_type;
507 if (existing.Count == 1) {
509 if (ts.Arity == found.Arity) {
510 better_type = IsImportedTypeOverride (ts, found);
511 if (better_type == found)
514 if (better_type != null) {
515 existing [0] = better_type;
520 existing = new List<TypeSpec> ();
521 existing.Add (found);
522 types[name] = existing;
524 for (int i = 0; i < existing.Count; ++i) {
526 if (ts.Arity != found.Arity)
529 better_type = IsImportedTypeOverride (ts, found);
530 if (better_type == found)
533 if (better_type != null) {
534 existing.RemoveAt (i);
543 types.Add (name, new TypeSpec[] { ts });
548 // We import any types but in the situation there are same types
549 // but one has better visibility (either public or internal with friend)
550 // the less visible type is removed from the namespace cache
552 public static TypeSpec IsImportedTypeOverride (TypeSpec ts, TypeSpec found)
554 var ts_accessible = (ts.Modifiers & Modifiers.PUBLIC) != 0 || TypeManager.IsThisOrFriendAssembly (CodeGen.Assembly.Builder, ts.MemberDefinition.Assembly);
555 var found_accessible = (found.Modifiers & Modifiers.PUBLIC) != 0 || TypeManager.IsThisOrFriendAssembly (CodeGen.Assembly.Builder, found.MemberDefinition.Assembly);
557 if (ts_accessible && !found_accessible)
560 // found is better always better for accessible or inaccessible ts
567 public void RemoveDeclSpace (string name)
572 public void ReplaceTypeWithPredefined (TypeSpec ts, PredefinedTypeSpec pts)
574 var found = types [ts.Name];
575 cached_types.Remove (ts.Name);
576 if (found.Count == 1) {
577 types[ts.Name][0] = pts;
579 throw new NotImplementedException ();
583 public void VerifyClsCompliance ()
585 if (types == null || cls_checked)
590 // TODO: This is quite ugly way to check for CLS compliance at namespace level
592 var locase_types = new Dictionary<string, List<TypeSpec>> (StringComparer.OrdinalIgnoreCase);
593 foreach (var tgroup in types.Values) {
594 foreach (var tm in tgroup) {
595 if ((tm.Modifiers & Modifiers.PUBLIC) == 0 || !tm.IsCLSCompliant ())
598 List<TypeSpec> found;
599 if (!locase_types.TryGetValue (tm.Name, out found)) {
600 found = new List<TypeSpec> ();
601 locase_types.Add (tm.Name, found);
608 foreach (var locase in locase_types.Values) {
609 if (locase.Count < 2)
612 bool all_same = true;
613 foreach (var notcompliant in locase) {
614 all_same = notcompliant.Name == locase[0].Name;
622 TypeContainer compiled = null;
623 foreach (var notcompliant in locase) {
624 if (!notcompliant.MemberDefinition.IsImported) {
625 if (compiled != null)
626 compiled.Compiler.Report.SymbolRelatedToPreviousError (compiled);
628 compiled = notcompliant.MemberDefinition as TypeContainer;
630 compiled.Compiler.Report.SymbolRelatedToPreviousError (notcompliant);
634 compiled.Compiler.Report.Warning (3005, 1, compiled.Location,
635 "Identifier `{0}' differing only in case is not CLS-compliant", compiled.GetSignatureForError ());
641 // Namespace container as created by the parser
643 public class NamespaceEntry : IMemberContext {
645 public class UsingEntry {
646 readonly MemberName name;
649 public UsingEntry (MemberName name)
654 public string GetSignatureForError ()
656 return name.GetSignatureForError ();
659 public Location Location {
660 get { return name.Location; }
663 public MemberName MemberName {
668 get { return GetSignatureForError (); }
671 public Namespace Resolve (IMemberContext rc)
673 if (resolved != null)
676 FullNamedExpression fne = name.GetTypeExpression ().ResolveAsTypeStep (rc, false);
680 resolved = fne as Namespace;
681 if (resolved == null) {
682 rc.Compiler.Report.SymbolRelatedToPreviousError (fne.Type);
683 rc.Compiler.Report.Error (138, Location,
684 "`{0}' is a type not a namespace. A using namespace directive can only be applied to namespaces",
685 GetSignatureForError ());
690 public override string ToString ()
696 public class UsingAliasEntry {
697 public readonly string Alias;
698 public Location Location;
700 public UsingAliasEntry (string alias, Location loc)
706 public virtual FullNamedExpression Resolve (IMemberContext rc, bool local)
708 FullNamedExpression fne = rc.Compiler.GlobalRootNamespace.GetRootNamespace (Alias);
710 rc.Compiler.Report.Error (430, Location,
711 "The extern alias `{0}' was not specified in -reference option",
718 public override string ToString ()
725 class LocalUsingAliasEntry : UsingAliasEntry {
726 FullNamedExpression resolved;
729 public LocalUsingAliasEntry (string alias, MemberName name, Location loc)
735 public override FullNamedExpression Resolve (IMemberContext rc, bool local)
737 if (resolved != null || value == null)
743 resolved = value.GetTypeExpression ().ResolveAsTypeStep (rc, false);
744 if (resolved == null) {
749 if (resolved is TypeExpr)
750 resolved = resolved.ResolveAsTypeTerminal (rc, false);
755 public override string ToString ()
757 return String.Format ("{0} = {1}", Alias, value.GetSignatureForError ());
762 NamespaceEntry parent, implicit_parent;
763 CompilationUnit file;
766 // Namespace using import block
767 List<UsingAliasEntry> using_aliases;
768 List<UsingEntry> using_clauses;
769 public bool DeclarationFound;
772 public readonly bool IsImplicit;
773 public readonly DeclSpace SlaveDeclSpace;
774 static readonly Namespace [] empty_namespaces = new Namespace [0];
775 Namespace [] namespace_using_table;
778 static List<NamespaceEntry> entries = new List<NamespaceEntry> ();
780 public static void Reset ()
782 entries = new List<NamespaceEntry> ();
785 // TODO: ctx should be a module
786 public NamespaceEntry (CompilerContext ctx, NamespaceEntry parent, CompilationUnit file, string name)
789 this.parent = parent;
794 ns = parent.NS.GetNamespace (name, true);
795 else if (name != null)
796 ns = Compiler.GlobalRootNamespace.GetNamespace (name, true);
798 ns = Compiler.GlobalRootNamespace;
799 SlaveDeclSpace = new RootDeclSpace (this);
802 private NamespaceEntry (CompilerContext ctx, NamespaceEntry parent, CompilationUnit file, Namespace ns, bool slave)
805 this.parent = parent;
807 this.IsImplicit = true;
809 this.SlaveDeclSpace = slave ? new RootDeclSpace (this) : null;
813 // Populates the Namespace with some using declarations, used by the
816 public void Populate (List<UsingAliasEntry> source_using_aliases, List<UsingEntry> source_using_clauses)
818 foreach (UsingAliasEntry uae in source_using_aliases){
819 if (using_aliases == null)
820 using_aliases = new List<UsingAliasEntry> ();
822 using_aliases.Add (uae);
825 foreach (UsingEntry ue in source_using_clauses){
826 if (using_clauses == null)
827 using_clauses = new List<UsingEntry> ();
829 using_clauses.Add (ue);
834 // Extracts the using alises and using clauses into a couple of
835 // arrays that might already have the same information; Used by the
838 public void Extract (List<UsingAliasEntry> out_using_aliases, List<UsingEntry> out_using_clauses)
840 if (using_aliases != null){
841 foreach (UsingAliasEntry uae in using_aliases){
842 bool replaced = false;
844 for (int i = 0; i < out_using_aliases.Count; i++){
845 UsingAliasEntry out_uea = (UsingAliasEntry) out_using_aliases [i];
847 if (out_uea.Alias == uae.Alias){
848 out_using_aliases [i] = uae;
854 out_using_aliases.Add (uae);
858 if (using_clauses != null){
859 foreach (UsingEntry ue in using_clauses){
862 foreach (UsingEntry out_ue in out_using_clauses)
863 if (out_ue.Name == ue.Name){
868 out_using_clauses.Add (ue);
874 // According to section 16.3.1 (using-alias-directive), the namespace-or-type-name is
875 // resolved as if the immediately containing namespace body has no using-directives.
877 // Section 16.3.2 says that the same rule is applied when resolving the namespace-name
878 // in the using-namespace-directive.
880 // To implement these rules, the expressions in the using directives are resolved using
881 // the "doppelganger" (ghostly bodiless duplicate).
883 NamespaceEntry doppelganger;
884 NamespaceEntry Doppelganger {
886 if (!IsImplicit && doppelganger == null) {
887 doppelganger = new NamespaceEntry (ctx, ImplicitParent, file, ns, true);
888 doppelganger.using_aliases = using_aliases;
894 public Namespace NS {
898 public NamespaceEntry Parent {
899 get { return parent; }
902 public NamespaceEntry ImplicitParent {
906 if (implicit_parent == null) {
907 implicit_parent = (parent.NS == ns.Parent)
909 : new NamespaceEntry (ctx, parent, file, ns.Parent, false);
911 return implicit_parent;
916 /// Records a new namespace for resolving name references
918 public void AddUsing (MemberName name, Location loc)
920 if (DeclarationFound){
921 Compiler.Report.Error (1529, loc, "A using clause must precede all other namespace elements except extern alias declarations");
924 if (using_clauses == null) {
925 using_clauses = new List<UsingEntry> ();
927 foreach (UsingEntry old_entry in using_clauses) {
928 if (name.Equals (old_entry.MemberName)) {
929 Compiler.Report.SymbolRelatedToPreviousError (old_entry.Location, old_entry.GetSignatureForError ());
930 Compiler.Report.Warning (105, 3, loc, "The using directive for `{0}' appeared previously in this namespace", name.GetSignatureForError ());
936 using_clauses.Add (new UsingEntry (name));
939 public void AddUsingAlias (string alias, MemberName name, Location loc)
941 // TODO: This is parser bussines
942 if (DeclarationFound){
943 Compiler.Report.Error (1529, loc, "A using clause must precede all other namespace elements except extern alias declarations");
946 if (RootContext.Version != LanguageVersion.ISO_1 && alias == "global")
947 Compiler.Report.Warning (440, 2, loc, "An alias named `global' will not be used when resolving 'global::';" +
948 " the global namespace will be used instead");
950 AddUsingAlias (new LocalUsingAliasEntry (alias, name, loc));
953 public void AddUsingExternalAlias (string alias, Location loc, Report Report)
955 // TODO: Do this in parser
956 bool not_first = using_clauses != null || DeclarationFound;
957 if (using_aliases != null && !not_first) {
958 foreach (UsingAliasEntry uae in using_aliases) {
959 if (uae is LocalUsingAliasEntry) {
967 Report.Error (439, loc, "An extern alias declaration must precede all other elements");
969 if (alias == "global") {
970 Error_GlobalNamespaceRedefined (loc, Report);
974 AddUsingAlias (new UsingAliasEntry (alias, loc));
977 void AddUsingAlias (UsingAliasEntry uae)
979 if (using_aliases == null) {
980 using_aliases = new List<UsingAliasEntry> ();
982 foreach (UsingAliasEntry entry in using_aliases) {
983 if (uae.Alias == entry.Alias) {
984 Compiler.Report.SymbolRelatedToPreviousError (uae.Location, uae.Alias);
985 Compiler.Report.Error (1537, entry.Location, "The using alias `{0}' appeared previously in this namespace",
992 using_aliases.Add (uae);
996 /// Does extension methods look up to find a method which matches name and extensionType.
997 /// Search starts from this namespace and continues hierarchically up to top level.
999 public IList<MethodSpec> LookupExtensionMethod (TypeSpec extensionType, string name, int arity, ref NamespaceEntry scope)
1001 List<MethodSpec> candidates = null;
1002 foreach (Namespace n in GetUsingTable ()) {
1003 var a = n.LookupExtensionMethod (extensionType, null, name, arity);
1007 if (candidates == null)
1010 candidates.AddRange (a);
1014 if (candidates != null)
1021 // Inspect parent namespaces in namespace expression
1023 Namespace parent_ns = ns.Parent;
1025 candidates = parent_ns.LookupExtensionMethod (extensionType, null, name, arity);
1026 if (candidates != null)
1029 parent_ns = parent_ns.Parent;
1030 } while (parent_ns != null);
1033 // Continue in parent scope
1035 return parent.LookupExtensionMethod (extensionType, name, arity, ref scope);
1038 public FullNamedExpression LookupNamespaceOrType (string name, int arity, Location loc, bool ignore_cs0104)
1040 // Precondition: Only simple names (no dots) will be looked up with this function.
1041 FullNamedExpression resolved = null;
1042 for (NamespaceEntry curr_ns = this; curr_ns != null; curr_ns = curr_ns.ImplicitParent) {
1043 if ((resolved = curr_ns.Lookup (name, arity, loc, ignore_cs0104)) != null)
1050 public IList<string> CompletionGetTypesStartingWith (string prefix)
1052 IEnumerable<string> all = Enumerable.Empty<string> ();
1054 for (NamespaceEntry curr_ns = this; curr_ns != null; curr_ns = curr_ns.ImplicitParent){
1055 foreach (Namespace using_ns in GetUsingTable ()){
1056 if (prefix.StartsWith (using_ns.Name)){
1057 int ld = prefix.LastIndexOf ('.');
1059 string rest = prefix.Substring (ld+1);
1061 all = all.Concat (using_ns.CompletionGetTypesStartingWith (rest));
1064 all = all.Concat (using_ns.CompletionGetTypesStartingWith (prefix));
1068 return all.Distinct ().ToList ();
1071 // Looks-up a alias named @name in this and surrounding namespace declarations
1072 public FullNamedExpression LookupNamespaceAlias (string name)
1074 for (NamespaceEntry n = this; n != null; n = n.ImplicitParent) {
1075 if (n.using_aliases == null)
1078 foreach (UsingAliasEntry ue in n.using_aliases) {
1079 if (ue.Alias == name)
1080 return ue.Resolve (Doppelganger ?? this, Doppelganger == null);
1087 private FullNamedExpression Lookup (string name, int arity, Location loc, bool ignore_cs0104)
1090 // Check whether it's in the namespace.
1092 FullNamedExpression fne = ns.Lookup (Compiler, name, arity, loc);
1097 if (using_aliases != null && arity == 0) {
1098 foreach (UsingAliasEntry ue in using_aliases) {
1099 if (ue.Alias == name) {
1101 if (Doppelganger != null) {
1102 // TODO: Namespace has broken location
1103 //Report.SymbolRelatedToPreviousError (fne.Location, null);
1104 Compiler.Report.SymbolRelatedToPreviousError (ue.Location, null);
1105 Compiler.Report.Error (576, loc,
1106 "Namespace `{0}' contains a definition with same name as alias `{1}'",
1107 GetSignatureForError (), name);
1113 return ue.Resolve (Doppelganger ?? this, Doppelganger == null);
1119 if (!((fne.Type.Modifiers & Modifiers.INTERNAL) != 0 && !TypeManager.IsThisOrFriendAssembly (CodeGen.Assembly.Builder, fne.Type.Assembly)))
1127 // Check using entries.
1129 FullNamedExpression match = null;
1130 foreach (Namespace using_ns in GetUsingTable ()) {
1131 // A using directive imports only types contained in the namespace, it
1132 // does not import any nested namespaces
1133 fne = using_ns.LookupType (Compiler, name, arity, false, loc);
1137 if (match == null) {
1142 // Prefer types over namespaces
1143 var texpr_fne = fne as TypeExpr;
1144 var texpr_match = match as TypeExpr;
1145 if (texpr_fne != null && texpr_match == null) {
1148 } else if (texpr_fne == null) {
1155 // It can be top level accessibility only
1156 var better = Namespace.IsImportedTypeOverride (texpr_match.Type, texpr_fne.Type);
1157 if (better == null) {
1158 Compiler.Report.SymbolRelatedToPreviousError (texpr_match.Type);
1159 Compiler.Report.SymbolRelatedToPreviousError (texpr_fne.Type);
1160 Compiler.Report.Error (104, loc, "`{0}' is an ambiguous reference between `{1}' and `{2}'",
1161 name, texpr_match.GetSignatureForError (), texpr_fne.GetSignatureForError ());
1165 if (better == texpr_fne.Type)
1172 Namespace [] GetUsingTable ()
1174 if (namespace_using_table != null)
1175 return namespace_using_table;
1177 if (using_clauses == null) {
1178 namespace_using_table = empty_namespaces;
1179 return namespace_using_table;
1182 var list = new List<Namespace> (using_clauses.Count);
1184 foreach (UsingEntry ue in using_clauses) {
1185 Namespace using_ns = ue.Resolve (Doppelganger);
1186 if (using_ns == null)
1189 list.Add (using_ns);
1192 namespace_using_table = list.ToArray ();
1193 return namespace_using_table;
1196 static readonly string [] empty_using_list = new string [0];
1198 public int SymbolFileID {
1200 if (symfile_id == 0 && file.SourceFileEntry != null) {
1201 int parent_id = parent == null ? 0 : parent.SymbolFileID;
1203 string [] using_list = empty_using_list;
1204 if (using_clauses != null) {
1205 using_list = new string [using_clauses.Count];
1206 for (int i = 0; i < using_clauses.Count; i++)
1207 using_list [i] = ((UsingEntry) using_clauses [i]).MemberName.GetName ();
1210 symfile_id = SymbolWriter.DefineNamespace (ns.Name, file.CompileUnitEntry, using_list, parent_id);
1216 static void MsgtryRef (string s)
1218 Console.WriteLine (" Try using -r:" + s);
1221 static void MsgtryPkg (string s)
1223 Console.WriteLine (" Try using -pkg:" + s);
1226 public static void Error_GlobalNamespaceRedefined (Location loc, Report Report)
1228 Report.Error (1681, loc, "You cannot redefine the global extern alias");
1231 public static void Error_NamespaceNotFound (Location loc, string name, Report Report)
1233 Report.Error (246, loc, "The type or namespace name `{0}' could not be found. Are you missing a using directive or an assembly reference?",
1237 case "Gtk": case "GtkSharp":
1238 MsgtryPkg ("gtk-sharp");
1241 case "Gdk": case "GdkSharp":
1242 MsgtryPkg ("gdk-sharp");
1245 case "Glade": case "GladeSharp":
1246 MsgtryPkg ("glade-sharp");
1249 case "System.Drawing":
1250 case "System.Web.Services":
1253 case "System.Windows.Forms":
1260 /// Used to validate that all the using clauses are correct
1261 /// after we are finished parsing all the files.
1265 if (using_aliases != null) {
1266 foreach (UsingAliasEntry ue in using_aliases)
1267 ue.Resolve (Doppelganger, Doppelganger == null);
1270 if (using_clauses != null) {
1271 foreach (UsingEntry ue in using_clauses)
1272 ue.Resolve (Doppelganger);
1277 /// Used to validate that all the using clauses are correct
1278 /// after we are finished parsing all the files.
1280 static public void VerifyAllUsing ()
1282 foreach (NamespaceEntry entry in entries)
1283 entry.VerifyUsing ();
1286 public string GetSignatureForError ()
1288 return ns.GetSignatureForError ();
1291 public override string ToString ()
1293 return ns.ToString ();
1296 #region IMemberContext Members
1298 public CompilerContext Compiler {
1302 public TypeSpec CurrentType {
1303 get { return SlaveDeclSpace.CurrentType; }
1306 public MemberCore CurrentMemberDefinition {
1307 get { return SlaveDeclSpace.CurrentMemberDefinition; }
1310 public TypeParameter[] CurrentTypeParameters {
1311 get { return SlaveDeclSpace.CurrentTypeParameters; }
1314 // FIXME: It's false for expression types
1315 public bool HasUnresolvedConstraints {
1316 get { return true; }
1319 public bool IsObsolete {
1320 get { return SlaveDeclSpace.IsObsolete; }
1323 public bool IsUnsafe {
1324 get { return SlaveDeclSpace.IsUnsafe; }
1327 public bool IsStatic {
1328 get { return SlaveDeclSpace.IsStatic; }