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 void ImportTypes (CompilerContext ctx)
51 foreach (Assembly a in referenced_assemblies) {
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 void ImportAssembly (Assembly assembly)
82 Type extension_type = null;
83 var all_attributes = CustomAttributeData.GetCustomAttributes (assembly);
84 foreach (var attr in all_attributes) {
85 var dt = attr.Constructor.DeclaringType;
86 if (dt.Name == "ExtensionAttribute" && dt.Namespace == "System.Runtime.CompilerServices") {
93 // This part tries to simulate loading of top-level
94 // types only, any missing dependencies are ignores here.
95 // Full error report is reported later when the type is
100 all_types = assembly.GetTypes ();
101 } catch (ReflectionTypeLoadException e) {
106 string prev_namespace = null;
107 foreach (var t in all_types) {
108 if (t == null || t.IsNested)
111 if (t.Name[0] == '<')
114 var it = Import.CreateType (t, null);
118 if (prev_namespace != t.Namespace) {
119 ns = t.Namespace == null ? this : GetNamespace (t.Namespace, true);
120 prev_namespace = t.Namespace;
125 if (it.IsStatic && extension_type != null && t.IsDefined (extension_type, false)) {
126 it.SetExtensionMethodContainer ();
131 public override string GetSignatureForError ()
133 return alias_name + "::";
137 public class GlobalRootNamespace : RootNamespace {
139 Dictionary<string, RootNamespace> root_namespaces;
141 public static GlobalRootNamespace Instance = new GlobalRootNamespace ();
143 GlobalRootNamespace ()
146 root_namespaces = new Dictionary<string, RootNamespace> ();
147 root_namespaces.Add (alias_name, this);
150 public static void Reset ()
152 Instance = new GlobalRootNamespace ();
155 public Assembly [] Assemblies {
156 get { return referenced_assemblies; }
159 public Module [] Modules {
160 get { return modules; }
163 public void AddModuleReference (Module m)
165 int top = modules != null ? modules.Length : 0;
166 Module [] n = new Module [top + 1];
168 modules.CopyTo (n, 0);
172 if (m == RootContext.ToplevelTypes.Builder)
175 foreach (var t in m.GetTypes ())
176 RegisterNamespace (t.Namespace);
179 public void ComputeNamespaces (CompilerContext ctx)
181 foreach (RootNamespace rn in root_namespaces.Values) {
182 rn.ImportTypes (ctx);
186 public void DefineRootNamespace (string alias, Assembly assembly, CompilerContext ctx)
188 if (alias == alias_name) {
189 NamespaceEntry.Error_GlobalNamespaceRedefined (Location.Null, ctx.Report);
193 RootNamespace retval = GetRootNamespace (alias);
194 if (retval == null) {
195 retval = new RootNamespace (alias);
196 root_namespaces.Add (alias, retval);
199 retval.AddAssemblyReference (assembly);
202 public override void Error_NamespaceDoesNotExist (Location loc, string name, int arity, IMemberContext ctx)
204 ctx.Compiler.Report.Error (400, loc,
205 "The type or namespace name `{0}' could not be found in the global namespace (are you missing an assembly reference?)",
209 public RootNamespace GetRootNamespace (string name)
212 if (!root_namespaces.TryGetValue (name, out rn))
220 /// Keeps track of the namespaces defined in the C# code.
222 /// This is an Expression to allow it to be referenced in the
223 /// compiler parse/intermediate tree during name resolution.
225 public class Namespace : FullNamedExpression {
229 protected Dictionary<string, Namespace> namespaces;
230 protected Dictionary<string, IList<TypeSpec>> types;
231 Dictionary<string, TypeExpr> cached_types;
235 public readonly MemberName MemberName;
238 /// Constructor Takes the current namespace and the
239 /// name. This is bootstrapped with parent == null
242 public Namespace (Namespace parent, string name)
244 // Expression members.
245 this.eclass = ExprClass.Namespace;
246 this.Type = InternalType.FakeInternalType;
247 this.loc = Location.Null;
249 this.parent = parent;
252 this.root = parent.root;
254 this.root = this as RootNamespace;
256 if (this.root == null)
257 throw new InternalErrorException ("Root namespaces must be created using RootNamespace");
259 string pname = parent != null ? parent.fullname : "";
264 fullname = parent.fullname + "." + name;
266 if (fullname == null)
267 throw new InternalErrorException ("Namespace has a null fullname");
269 if (parent != null && parent.MemberName != MemberName.Null)
270 MemberName = new MemberName (parent.MemberName, name);
271 else if (name.Length == 0)
272 MemberName = MemberName.Null;
274 MemberName = new MemberName (name);
276 namespaces = new Dictionary<string, Namespace> ();
277 cached_types = new Dictionary<string, TypeExpr> ();
279 root.RegisterNamespace (this);
285 /// The qualified name of the current namespace
288 get { return fullname; }
292 /// The parent of this namespace, used by the parser to "Pop"
293 /// the current namespace declaration
295 public Namespace Parent {
296 get { return parent; }
301 protected override Expression DoResolve (ResolveContext ec)
306 public virtual void Error_NamespaceDoesNotExist (Location loc, string name, int arity, IMemberContext ctx)
308 FullNamedExpression retval = Lookup (ctx.Compiler, name, -System.Math.Max (1, arity), loc);
309 if (retval != null) {
310 Error_TypeArgumentsCannotBeUsed (ctx.Compiler.Report, loc, retval.Type, arity);
315 if (arity > 0 && namespaces.TryGetValue (name, out ns)) {
316 ns.Error_TypeArgumentsCannotBeUsed (ctx.Compiler.Report, loc, null, arity);
320 ctx.Compiler.Report.Error (234, loc,
321 "The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
322 name, GetSignatureForError ());
325 public override string GetSignatureForError ()
330 public Namespace GetNamespace (string name, bool create)
332 int pos = name.IndexOf ('.');
337 first = name.Substring (0, pos);
341 if (!namespaces.TryGetValue (first, out ns)) {
345 ns = new Namespace (this, first);
346 namespaces.Add (first, ns);
350 ns = ns.GetNamespace (name.Substring (pos + 1), create);
355 public TypeExpr LookupType (CompilerContext ctx, string name, int arity, bool silent, Location loc)
361 if (arity == 0 && cached_types.TryGetValue (name, out te))
364 IList<TypeSpec> found;
365 if (!types.TryGetValue (name, out found))
368 TypeSpec best = null;
369 foreach (var ts in found) {
370 if (ts.Arity == arity) {
376 var pts = best as PredefinedTypeSpec;
378 pts = ts as PredefinedTypeSpec;
381 ctx.Report.SymbolRelatedToPreviousError (best);
382 ctx.Report.SymbolRelatedToPreviousError (ts);
384 // TODO: This should use different warning number but we want to be csc compatible
385 ctx.Report.Warning (1685, 1, loc,
386 "The predefined type `{0}.{1}' is redefined in the source code. Ignoring the local type definition",
387 pts.Namespace, pts.Name);
392 if (best.MemberDefinition.IsImported && ts.MemberDefinition.IsImported) {
393 ctx.Report.SymbolRelatedToPreviousError (best);
394 ctx.Report.SymbolRelatedToPreviousError (ts);
396 ctx.Report.Warning (1685, 1, loc,
397 "The predefined type `{0}' is defined in multiple assemblies. Using definition from `{1}'",
398 ts.GetSignatureForError (), best.Assembly.GetName ().Name);
400 ctx.Report.Error (433, loc, "The imported type `{0}' is defined multiple times", ts.GetSignatureForError ());
406 if (best.MemberDefinition.IsImported)
409 if ((best.Modifiers & Modifiers.INTERNAL) != 0 && !TypeManager.IsThisOrFriendAssembly (CodeGen.Assembly.Builder, best.MemberDefinition.Assembly))
415 if (ts.MemberDefinition.IsImported)
416 ctx.Report.SymbolRelatedToPreviousError (ts);
418 ctx.Report.Warning (436, 2, loc,
419 "The type `{0}' conflicts with the imported type of same name'. Ignoring the imported type definition",
420 best.GetSignatureForError ());
424 // Lookup for the best candidate with closest arity match
429 } else if (System.Math.Abs (ts.Arity + arity) < System.Math.Abs (best.Arity + arity)) {
438 te = new TypeExpression (best, Location.Null);
440 // TODO MemberCache: Cache more
441 if (arity == 0 && !silent)
442 cached_types.Add (name, te);
447 TypeSpec LookupType (string name, int arity)
452 IList<TypeSpec> found;
453 if (types.TryGetValue (name, out found)) {
454 TypeSpec best = null;
456 foreach (var ts in found) {
457 if (ts.Arity == arity)
461 // Lookup for the best candidate with closest arity match
466 } else if (System.Math.Abs (ts.Arity + arity) < System.Math.Abs (best.Arity + arity)) {
478 public FullNamedExpression Lookup (CompilerContext ctx, string name, int arity, Location loc)
480 if (arity == 0 && namespaces.ContainsKey (name))
481 return namespaces [name];
483 return LookupType (ctx, name, arity, false, loc);
487 // Completes types with the given `prefix'
489 public IEnumerable<string> CompletionGetTypesStartingWith (string prefix)
492 return Enumerable.Empty<string> ();
494 var res = from item in types
495 where item.Key.StartsWith (prefix) && item.Value.Any (l => (l.Modifiers & Modifiers.PUBLIC) != 0)
498 if (namespaces != null)
499 res = res.Concat (from item in namespaces where item.Key.StartsWith (prefix) select item.Key);
505 /// Looks for extension method in this namespace
507 public List<MethodSpec> LookupExtensionMethod (TypeSpec extensionType, ClassOrStruct currentClass, string name, int arity)
512 List<MethodSpec> found = null;
514 var invocation_type = currentClass == null ? InternalType.FakeInternalType : currentClass.CurrentType;
516 // TODO: Add per namespace flag when at least 1 type has extension
518 foreach (var tgroup in types.Values) {
519 foreach (var ts in tgroup) {
520 if ((ts.Modifiers & Modifiers.METHOD_EXTENSION) == 0)
523 var res = ts.MemberCache.FindExtensionMethods (invocation_type, extensionType, name, arity);
530 found.AddRange (res);
538 public void AddType (TypeSpec ts)
541 types = new Dictionary<string, IList<TypeSpec>> (64);
545 IList<TypeSpec> existing;
546 if (types.TryGetValue (name, out existing)) {
547 TypeSpec better_type;
549 if (existing.Count == 1) {
551 if (ts.Arity == found.Arity) {
552 better_type = IsImportedTypeOverride (ts, found);
553 if (better_type == found)
556 if (better_type != null) {
557 existing [0] = better_type;
562 existing = new List<TypeSpec> ();
563 existing.Add (found);
564 types[name] = existing;
566 for (int i = 0; i < existing.Count; ++i) {
568 if (ts.Arity != found.Arity)
571 better_type = IsImportedTypeOverride (ts, found);
572 if (better_type == found)
575 if (better_type != null) {
576 existing.RemoveAt (i);
585 types.Add (name, new TypeSpec[] { ts });
590 // We import any types but in the situation there are same types
591 // but one has better visibility (either public or internal with friend)
592 // the less visible type is removed from the namespace cache
594 public static TypeSpec IsImportedTypeOverride (TypeSpec ts, TypeSpec found)
596 var ts_accessible = (ts.Modifiers & Modifiers.PUBLIC) != 0 || TypeManager.IsThisOrFriendAssembly (CodeGen.Assembly.Builder, ts.MemberDefinition.Assembly);
597 var found_accessible = (found.Modifiers & Modifiers.PUBLIC) != 0 || TypeManager.IsThisOrFriendAssembly (CodeGen.Assembly.Builder, found.MemberDefinition.Assembly);
599 if (ts_accessible && !found_accessible)
602 // found is better always better for accessible or inaccessible ts
609 public void RemoveDeclSpace (string name)
614 public void ReplaceTypeWithPredefined (TypeSpec ts, PredefinedTypeSpec pts)
616 var found = types [ts.Name];
617 cached_types.Remove (ts.Name);
618 if (found.Count == 1) {
619 types[ts.Name][0] = pts;
621 throw new NotImplementedException ();
625 public void VerifyClsCompliance ()
627 if (types == null || cls_checked)
632 // TODO: This is quite ugly way to check for CLS compliance at namespace level
634 var locase_types = new Dictionary<string, List<TypeSpec>> (StringComparer.OrdinalIgnoreCase);
635 foreach (var tgroup in types.Values) {
636 foreach (var tm in tgroup) {
637 if ((tm.Modifiers & Modifiers.PUBLIC) == 0 || !tm.IsCLSCompliant ())
640 List<TypeSpec> found;
641 if (!locase_types.TryGetValue (tm.Name, out found)) {
642 found = new List<TypeSpec> ();
643 locase_types.Add (tm.Name, found);
650 foreach (var locase in locase_types.Values) {
651 if (locase.Count < 2)
654 bool all_same = true;
655 foreach (var notcompliant in locase) {
656 all_same = notcompliant.Name == locase[0].Name;
664 TypeContainer compiled = null;
665 foreach (var notcompliant in locase) {
666 if (!notcompliant.MemberDefinition.IsImported) {
667 if (compiled != null)
668 compiled.Compiler.Report.SymbolRelatedToPreviousError (compiled);
670 compiled = notcompliant.MemberDefinition as TypeContainer;
672 compiled.Compiler.Report.SymbolRelatedToPreviousError (notcompliant);
676 compiled.Compiler.Report.Warning (3005, 1, compiled.Location,
677 "Identifier `{0}' differing only in case is not CLS-compliant", compiled.GetSignatureForError ());
683 // Namespace container as created by the parser
685 public class NamespaceEntry : IMemberContext {
687 public class UsingEntry {
688 readonly MemberName name;
691 public UsingEntry (MemberName name)
696 public string GetSignatureForError ()
698 return name.GetSignatureForError ();
701 public Location Location {
702 get { return name.Location; }
705 public MemberName MemberName {
710 get { return GetSignatureForError (); }
713 public Namespace Resolve (IMemberContext rc)
715 if (resolved != null)
718 FullNamedExpression fne = name.GetTypeExpression ().ResolveAsTypeStep (rc, false);
722 resolved = fne as Namespace;
723 if (resolved == null) {
724 rc.Compiler.Report.SymbolRelatedToPreviousError (fne.Type);
725 rc.Compiler.Report.Error (138, Location,
726 "`{0}' is a type not a namespace. A using namespace directive can only be applied to namespaces",
727 GetSignatureForError ());
732 public override string ToString ()
738 public class UsingAliasEntry {
739 public readonly string Alias;
740 public Location Location;
742 public UsingAliasEntry (string alias, Location loc)
748 public virtual FullNamedExpression Resolve (IMemberContext rc)
750 FullNamedExpression fne = GlobalRootNamespace.Instance.GetRootNamespace (Alias);
752 rc.Compiler.Report.Error (430, Location,
753 "The extern alias `{0}' was not specified in -reference option",
760 public override string ToString ()
767 class LocalUsingAliasEntry : UsingAliasEntry {
768 FullNamedExpression resolved;
771 public LocalUsingAliasEntry (string alias, MemberName name, Location loc)
777 public override FullNamedExpression Resolve (IMemberContext rc)
779 if (resolved != null || value == null)
785 resolved = value.GetTypeExpression ().ResolveAsTypeStep (rc, false);
786 if (resolved == null) {
791 if (resolved is TypeExpr)
792 resolved = resolved.ResolveAsTypeTerminal (rc, false);
797 public override string ToString ()
799 return String.Format ("{0} = {1}", Alias, value.GetSignatureForError ());
804 NamespaceEntry parent, implicit_parent;
805 CompilationUnit file;
808 // Namespace using import block
809 List<UsingAliasEntry> using_aliases;
810 List<UsingEntry> using_clauses;
811 public bool DeclarationFound;
814 public readonly bool IsImplicit;
815 public readonly DeclSpace SlaveDeclSpace;
816 static readonly Namespace [] empty_namespaces = new Namespace [0];
817 Namespace [] namespace_using_table;
819 static List<NamespaceEntry> entries = new List<NamespaceEntry> ();
821 public static void Reset ()
823 entries = new List<NamespaceEntry> ();
826 public NamespaceEntry (NamespaceEntry parent, CompilationUnit file, string name)
828 this.parent = parent;
833 ns = parent.NS.GetNamespace (name, true);
834 else if (name != null)
835 ns = GlobalRootNamespace.Instance.GetNamespace (name, true);
837 ns = GlobalRootNamespace.Instance;
838 SlaveDeclSpace = new RootDeclSpace (this);
841 private NamespaceEntry (NamespaceEntry parent, CompilationUnit file, Namespace ns, bool slave)
843 this.parent = parent;
845 this.IsImplicit = true;
847 this.SlaveDeclSpace = slave ? new RootDeclSpace (this) : null;
851 // Populates the Namespace with some using declarations, used by the
854 public void Populate (List<UsingAliasEntry> source_using_aliases, List<UsingEntry> source_using_clauses)
856 foreach (UsingAliasEntry uae in source_using_aliases){
857 if (using_aliases == null)
858 using_aliases = new List<UsingAliasEntry> ();
860 using_aliases.Add (uae);
863 foreach (UsingEntry ue in source_using_clauses){
864 if (using_clauses == null)
865 using_clauses = new List<UsingEntry> ();
867 using_clauses.Add (ue);
872 // Extracts the using alises and using clauses into a couple of
873 // arrays that might already have the same information; Used by the
876 public void Extract (List<UsingAliasEntry> out_using_aliases, List<UsingEntry> out_using_clauses)
878 if (using_aliases != null){
879 foreach (UsingAliasEntry uae in using_aliases){
880 bool replaced = false;
882 for (int i = 0; i < out_using_aliases.Count; i++){
883 UsingAliasEntry out_uea = (UsingAliasEntry) out_using_aliases [i];
885 if (out_uea.Alias == uae.Alias){
886 out_using_aliases [i] = uae;
892 out_using_aliases.Add (uae);
896 if (using_clauses != null){
897 foreach (UsingEntry ue in using_clauses){
900 foreach (UsingEntry out_ue in out_using_clauses)
901 if (out_ue.Name == ue.Name){
906 out_using_clauses.Add (ue);
912 // According to section 16.3.1 (using-alias-directive), the namespace-or-type-name is
913 // resolved as if the immediately containing namespace body has no using-directives.
915 // Section 16.3.2 says that the same rule is applied when resolving the namespace-name
916 // in the using-namespace-directive.
918 // To implement these rules, the expressions in the using directives are resolved using
919 // the "doppelganger" (ghostly bodiless duplicate).
921 NamespaceEntry doppelganger;
922 NamespaceEntry Doppelganger {
924 if (!IsImplicit && doppelganger == null) {
925 doppelganger = new NamespaceEntry (ImplicitParent, file, ns, true);
926 doppelganger.using_aliases = using_aliases;
932 public Namespace NS {
936 public NamespaceEntry Parent {
937 get { return parent; }
940 public NamespaceEntry ImplicitParent {
944 if (implicit_parent == null) {
945 implicit_parent = (parent.NS == ns.Parent)
947 : new NamespaceEntry (parent, file, ns.Parent, false);
949 return implicit_parent;
954 /// Records a new namespace for resolving name references
956 public void AddUsing (MemberName name, Location loc)
958 if (DeclarationFound){
959 Compiler.Report.Error (1529, loc, "A using clause must precede all other namespace elements except extern alias declarations");
962 if (using_clauses == null) {
963 using_clauses = new List<UsingEntry> ();
965 foreach (UsingEntry old_entry in using_clauses) {
966 if (name.Equals (old_entry.MemberName)) {
967 Compiler.Report.SymbolRelatedToPreviousError (old_entry.Location, old_entry.GetSignatureForError ());
968 Compiler.Report.Warning (105, 3, loc, "The using directive for `{0}' appeared previously in this namespace", name.GetSignatureForError ());
974 using_clauses.Add (new UsingEntry (name));
977 public void AddUsingAlias (string alias, MemberName name, Location loc)
979 // TODO: This is parser bussines
980 if (DeclarationFound){
981 Compiler.Report.Error (1529, loc, "A using clause must precede all other namespace elements except extern alias declarations");
984 if (RootContext.Version != LanguageVersion.ISO_1 && alias == "global")
985 Compiler.Report.Warning (440, 2, loc, "An alias named `global' will not be used when resolving 'global::';" +
986 " the global namespace will be used instead");
988 AddUsingAlias (new LocalUsingAliasEntry (alias, name, loc));
991 public void AddUsingExternalAlias (string alias, Location loc, Report Report)
993 // TODO: Do this in parser
994 bool not_first = using_clauses != null || DeclarationFound;
995 if (using_aliases != null && !not_first) {
996 foreach (UsingAliasEntry uae in using_aliases) {
997 if (uae is LocalUsingAliasEntry) {
1005 Report.Error (439, loc, "An extern alias declaration must precede all other elements");
1007 if (alias == "global") {
1008 Error_GlobalNamespaceRedefined (loc, Report);
1012 AddUsingAlias (new UsingAliasEntry (alias, loc));
1015 void AddUsingAlias (UsingAliasEntry uae)
1017 if (using_aliases == null) {
1018 using_aliases = new List<UsingAliasEntry> ();
1020 foreach (UsingAliasEntry entry in using_aliases) {
1021 if (uae.Alias == entry.Alias) {
1022 Compiler.Report.SymbolRelatedToPreviousError (uae.Location, uae.Alias);
1023 Compiler.Report.Error (1537, entry.Location, "The using alias `{0}' appeared previously in this namespace",
1030 using_aliases.Add (uae);
1034 /// Does extension methods look up to find a method which matches name and extensionType.
1035 /// Search starts from this namespace and continues hierarchically up to top level.
1037 public IList<MethodSpec> LookupExtensionMethod (TypeSpec extensionType, string name, int arity, ref NamespaceEntry scope)
1039 List<MethodSpec> candidates = null;
1040 foreach (Namespace n in GetUsingTable ()) {
1041 var a = n.LookupExtensionMethod (extensionType, null, name, arity);
1045 if (candidates == null)
1048 candidates.AddRange (a);
1052 if (candidates != null)
1059 // Inspect parent namespaces in namespace expression
1061 Namespace parent_ns = ns.Parent;
1063 candidates = parent_ns.LookupExtensionMethod (extensionType, null, name, arity);
1064 if (candidates != null)
1067 parent_ns = parent_ns.Parent;
1068 } while (parent_ns != null);
1071 // Continue in parent scope
1073 return parent.LookupExtensionMethod (extensionType, name, arity, ref scope);
1076 public FullNamedExpression LookupNamespaceOrType (string name, int arity, Location loc, bool ignore_cs0104)
1078 // Precondition: Only simple names (no dots) will be looked up with this function.
1079 FullNamedExpression resolved = null;
1080 for (NamespaceEntry curr_ns = this; curr_ns != null; curr_ns = curr_ns.ImplicitParent) {
1081 if ((resolved = curr_ns.Lookup (name, arity, loc, ignore_cs0104)) != null)
1088 public IList<string> CompletionGetTypesStartingWith (string prefix)
1090 IEnumerable<string> all = Enumerable.Empty<string> ();
1092 for (NamespaceEntry curr_ns = this; curr_ns != null; curr_ns = curr_ns.ImplicitParent){
1093 foreach (Namespace using_ns in GetUsingTable ()){
1094 if (prefix.StartsWith (using_ns.Name)){
1095 int ld = prefix.LastIndexOf ('.');
1097 string rest = prefix.Substring (ld+1);
1099 all = all.Concat (using_ns.CompletionGetTypesStartingWith (rest));
1102 all = all.Concat (using_ns.CompletionGetTypesStartingWith (prefix));
1106 return all.Distinct ().ToList ();
1109 // Looks-up a alias named @name in this and surrounding namespace declarations
1110 public FullNamedExpression LookupNamespaceAlias (string name)
1112 for (NamespaceEntry n = this; n != null; n = n.ImplicitParent) {
1113 if (n.using_aliases == null)
1116 foreach (UsingAliasEntry ue in n.using_aliases) {
1117 if (ue.Alias == name)
1118 return ue.Resolve (Doppelganger);
1125 private FullNamedExpression Lookup (string name, int arity, Location loc, bool ignore_cs0104)
1128 // Check whether it's in the namespace.
1130 FullNamedExpression fne = ns.Lookup (Compiler, name, arity, loc);
1135 if (using_aliases != null && arity == 0) {
1136 foreach (UsingAliasEntry ue in using_aliases) {
1137 if (ue.Alias == name) {
1139 if (Doppelganger != null) {
1140 // TODO: Namespace has broken location
1141 //Report.SymbolRelatedToPreviousError (fne.Location, null);
1142 Compiler.Report.SymbolRelatedToPreviousError (ue.Location, null);
1143 Compiler.Report.Error (576, loc,
1144 "Namespace `{0}' contains a definition with same name as alias `{1}'",
1145 GetSignatureForError (), name);
1151 return ue.Resolve (Doppelganger);
1157 if (!((fne.Type.Modifiers & Modifiers.INTERNAL) != 0 && !TypeManager.IsThisOrFriendAssembly (CodeGen.Assembly.Builder, fne.Type.Assembly)))
1165 // Check using entries.
1167 FullNamedExpression match = null;
1168 foreach (Namespace using_ns in GetUsingTable ()) {
1169 // A using directive imports only types contained in the namespace, it
1170 // does not import any nested namespaces
1171 fne = using_ns.LookupType (Compiler, name, arity, false, loc);
1175 if (match == null) {
1180 // Prefer types over namespaces
1181 var texpr_fne = fne as TypeExpr;
1182 var texpr_match = match as TypeExpr;
1183 if (texpr_fne != null && texpr_match == null) {
1186 } else if (texpr_fne == null) {
1193 // It can be top level accessibility only
1194 var better = Namespace.IsImportedTypeOverride (texpr_match.Type, texpr_fne.Type);
1195 if (better == null) {
1196 Compiler.Report.SymbolRelatedToPreviousError (texpr_match.Type);
1197 Compiler.Report.SymbolRelatedToPreviousError (texpr_fne.Type);
1198 Compiler.Report.Error (104, loc, "`{0}' is an ambiguous reference between `{1}' and `{2}'",
1199 name, texpr_match.GetSignatureForError (), texpr_fne.GetSignatureForError ());
1203 if (better == texpr_fne.Type)
1210 Namespace [] GetUsingTable ()
1212 if (namespace_using_table != null)
1213 return namespace_using_table;
1215 if (using_clauses == null) {
1216 namespace_using_table = empty_namespaces;
1217 return namespace_using_table;
1220 var list = new List<Namespace> (using_clauses.Count);
1222 foreach (UsingEntry ue in using_clauses) {
1223 Namespace using_ns = ue.Resolve (Doppelganger);
1224 if (using_ns == null)
1227 list.Add (using_ns);
1230 namespace_using_table = list.ToArray ();
1231 return namespace_using_table;
1234 static readonly string [] empty_using_list = new string [0];
1236 public int SymbolFileID {
1238 if (symfile_id == 0 && file.SourceFileEntry != null) {
1239 int parent_id = parent == null ? 0 : parent.SymbolFileID;
1241 string [] using_list = empty_using_list;
1242 if (using_clauses != null) {
1243 using_list = new string [using_clauses.Count];
1244 for (int i = 0; i < using_clauses.Count; i++)
1245 using_list [i] = ((UsingEntry) using_clauses [i]).MemberName.GetName ();
1248 symfile_id = SymbolWriter.DefineNamespace (ns.Name, file.CompileUnitEntry, using_list, parent_id);
1254 static void MsgtryRef (string s)
1256 Console.WriteLine (" Try using -r:" + s);
1259 static void MsgtryPkg (string s)
1261 Console.WriteLine (" Try using -pkg:" + s);
1264 public static void Error_GlobalNamespaceRedefined (Location loc, Report Report)
1266 Report.Error (1681, loc, "You cannot redefine the global extern alias");
1269 public static void Error_NamespaceNotFound (Location loc, string name, Report Report)
1271 Report.Error (246, loc, "The type or namespace name `{0}' could not be found. Are you missing a using directive or an assembly reference?",
1275 case "Gtk": case "GtkSharp":
1276 MsgtryPkg ("gtk-sharp");
1279 case "Gdk": case "GdkSharp":
1280 MsgtryPkg ("gdk-sharp");
1283 case "Glade": case "GladeSharp":
1284 MsgtryPkg ("glade-sharp");
1287 case "System.Drawing":
1288 case "System.Web.Services":
1291 case "System.Windows.Forms":
1298 /// Used to validate that all the using clauses are correct
1299 /// after we are finished parsing all the files.
1303 if (using_aliases != null) {
1304 foreach (UsingAliasEntry ue in using_aliases)
1305 ue.Resolve (Doppelganger);
1308 if (using_clauses != null) {
1309 foreach (UsingEntry ue in using_clauses)
1310 ue.Resolve (Doppelganger);
1315 /// Used to validate that all the using clauses are correct
1316 /// after we are finished parsing all the files.
1318 static public void VerifyAllUsing ()
1320 foreach (NamespaceEntry entry in entries)
1321 entry.VerifyUsing ();
1324 public string GetSignatureForError ()
1326 return ns.GetSignatureForError ();
1329 public override string ToString ()
1331 return ns.ToString ();
1334 #region IMemberContext Members
1336 public CompilerContext Compiler {
1337 get { return RootContext.ToplevelTypes.Compiler; }
1340 public TypeSpec CurrentType {
1341 get { return SlaveDeclSpace.CurrentType; }
1344 public MemberCore CurrentMemberDefinition {
1345 get { return SlaveDeclSpace.CurrentMemberDefinition; }
1348 public TypeParameter[] CurrentTypeParameters {
1349 get { return SlaveDeclSpace.CurrentTypeParameters; }
1352 // FIXME: It's false for expression types
1353 public bool HasUnresolvedConstraints {
1354 get { return true; }
1357 public bool IsObsolete {
1358 get { return SlaveDeclSpace.IsObsolete; }
1361 public bool IsUnsafe {
1362 get { return SlaveDeclSpace.IsUnsafe; }
1365 public bool IsStatic {
1366 get { return SlaveDeclSpace.IsStatic; }