public static void AddNamespace(INamespace ns)
        {
            if (ns == null)
                throw new ArgumentNullException("ns");

            namespaces[ns.Identifier] = ns;
        }

		public static IEntity ResolveQualifiedNameToSingle(INamespace root, string qualifiedName)
		{
			IEntity current = root;
			foreach (string part in qualifiedName.Split('.'))
				current = ResolveSingle((INamespace) current, part);
			return current;
		}

		public void AddNamespace (INamespace ns)
		{
			if (usedNamespaces.Contains (ns.Name))
				return;
			usedNamespaces.Add (ns.Name);
			result.Add (Factory.CreateNamespaceCompletionData (ns));
		}

 public CodeNamespace(CodeModelContext context, INamespace ns)
     : base(context)
 {
     this.ns = ns;
     this.InfoLocation = global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationExternal;
     this.Language = context.CurrentProject.GetCodeModelLanguage();
 }

		public static bool ResolveCoalescingNamespaces(INamespace parent, INamespace namespaceToResolveAgainst, string name, EntityType typesToConsider, ICollection<IEntity> resultingSet)
		{
			var resolved = new Set<IEntity>();
			if (!namespaceToResolveAgainst.Resolve(resolved, name, typesToConsider))
				return false;
			return CoalesceResolved(resolved, parent, name, resultingSet);
		}

		public static IEntity ResolveSingle(INamespace root, string name)
		{
			var resolved = new List<IEntity>();
			Assert.IsTrue(root.Resolve(resolved, name, EntityType.Any), "Failed to resolve '{0}' against '{1}'", name, root);
			Assert.AreEqual(1, resolved.Count);
			return resolved[0];
		}

		AstNode[] FindReferences(INamespace ns)
		{
			var result = new List<AstNode>();
			var searchScopes = findReferences.GetSearchScopes(ns);
			findReferences.FindReferencesInFile(searchScopes, unresolvedFile, syntaxTree, compilation,
			                                    (node, rr) => result.Add(node), CancellationToken.None);
			return result.OrderBy(n => n.StartLocation).ToArray();
		}

 public void SetChild(string name, INamespace entity)
 {
     _children[name] = entity;
     if (name == "")
     {
         _empty = entity;
     }
 }

 public NamespaceDelegator(INamespace parent, params INamespace[] namespaces)
 {
     if (null == namespaces)
     {
         throw new ArgumentNullException("namespaces");
     }
     _parent = parent;
     _namespaces = namespaces;
 }

        public NamespaceEntity(INamespace parent, TypeSystemServices tagManager, string name)
        {
            _parent = parent;
            _typeSystemServices = tagManager;
            _name = name;
			_assemblies = new Dictionary<Assembly, Dictionary<string, List<Type>>>(AssemblyEqualityComparer.Default);
            _childrenNamespaces = new Dictionary<string, NamespaceEntity>();
            _internalModules = new List<ModuleEntity>();
            _externalModules = new List<ExternalType>();

 public GlobalNamespace(IDictionary children)
     : base(null, children)
 {
     _empty = (INamespace)children[""];
     if (null == _empty)
     {
         _empty = NullNamespace.Default;
     }
 }

 public SimpleNamespace(INamespace parent, IDictionary children)
 {
     if (null == children)
     {
         throw new ArgumentNullException("children");
     }
     _parent = parent;
     _children = children;
 }

		bool IsAccessible(MemberLookup lookup, INamespace ns)
		{
			if (ns.Types.Any (t => lookup.IsAccessible (t, false)))
				return true;
			foreach (var child in ns.ChildNamespaces)
				if (IsAccessible (lookup, child))
					return true;
			return false;
		}

		/// <summary>
		/// Creates a new merged root namespace.
		/// </summary>
		/// <param name="compilation">The main compilation.</param>
		/// <param name="namespaces">The individual namespaces being merged.</param>
		/// <param name="externAlias">The extern alias for this namespace.</param>
		public MergedNamespace(ICompilation compilation, INamespace[] namespaces, string externAlias = null)
		{
			if (compilation == null)
				throw new ArgumentNullException("compilation");
			if (namespaces == null)
				throw new ArgumentNullException("namespaces");
			this.compilation = compilation;
			this.namespaces = namespaces;
			this.externAlias = externAlias;
		}

		public static Set<IEntity> ResolveQualifiedName(INamespace root, string qualifiedName)
		{
			INamespace current = root;
			string[] parts = qualifiedName.Split('.');
			for (int i=0; i < parts.Length - 1; ++i)
				current = (INamespace) ResolveSingle(current, parts[i]);
			var result = new Set<IEntity>();
			current.Resolve(result, parts[parts.Length - 1], EntityType.Any);
			return result;
		}

		public void AddNamespace (MemberLookup lookup, INamespace ns)
		{
			if (usedNamespaces.Contains (ns.Name))
				return;
			if (!IsAccessible (lookup, ns)) {
				usedNamespaces.Add (ns.Name);
				return;
			}
			usedNamespaces.Add (ns.Name);
			result.Add (Factory.CreateNamespaceCompletionData (ns));
		}

 public static INamespace CoalescedNamespaceFor(INamespace parent, string name, List<INamespace> namespaces)
 {
     switch (namespaces.Count)
     {
         case 0:
             return null;
         case 1:
             return namespaces.First();
         default:
             return new ResolvedNamespaces(name, parent, namespaces.ToArray());
     }
 }

 public static bool ResolveCoalescingNamespaces(INamespace parent, INamespace namespaceToResolveAgainst, string name, EntityType typesToConsider, ICollection<IEntity> resultingSet)
 {
     var resolved = AcquireSet();
     try {
         if (!namespaceToResolveAgainst.Resolve(resolved, name, typesToConsider))
             return false;
         return CoalesceResolved(resolved, parent, name, resultingSet);
     }
     finally {
         ReleaseSet(resolved);
     }
 }

 private static void CollectAllMembers(List<IEntity> members, INamespace entity)
 {
     var type = entity as IType;
     if (null != type)
     {
         members.ExtendUnique(type.GetMembers());
         CollectBaseTypeMembers(members, type.BaseType);
     }
     else
     {
         members.Extend(entity.GetMembers());
     }
 }

 public void WriteNamespace(INamespace namespaceDeclaration)
 {
     if (_injectXmlDoc)
     {
         // inject XML documentation into generated namespace
         string nsStr = GetNamespaceAsString(namespaceDeclaration);
         _formatter.Write(nsStr);
     }
     else
     {
         // write it as the original implementor does it
         _writer.WriteNamespace(namespaceDeclaration);
     }
 }