public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
 {
     currentNamepace = namespaceDeclaration.Name;
     base.VisitNamespaceDeclaration(namespaceDeclaration, data);
     currentNamepace = string.Empty;
     return null;
 }

 NamespaceDeclaration CreateNamespace(DependencyRelation relation, NamespaceDeclaration originalNamespace)
 {
     var ns = new NamespaceDeclaration(originalNamespace.Name);
     ns.Children.AddRange(originalNamespace.Children.OfType<UsingDeclaration>());
     ns.Children.Add(CreatePartialClass(relation));
     return ns;
 }

 NamespaceDeclaration CreateNamespace(ValueObjectDescriptor valueObject, NamespaceDeclaration originalNamespace)
 {
     var ns = new NamespaceDeclaration(originalNamespace.Name);
     ns.Children.AddRange(originalNamespace.Children.OfType<UsingDeclaration>());
     ns.Children.Add(CreatePartialClass(valueObject));
     return ns;
 }

		public override object VisitCompilationUnit(CompilationUnit compilationUnit, object data)
		{
			base.VisitCompilationUnit(compilationUnit, data);
			if (!string.IsNullOrEmpty(NamespacePrefixToAdd)) {
				for (int i = 0; i < compilationUnit.Children.Count; i++) {
					NamespaceDeclaration ns = compilationUnit.Children[i] as NamespaceDeclaration;
					if (ns != null) {
						ns.Name = NamespacePrefixToAdd + "." + ns.Name;
					}
					if (compilationUnit.Children[i] is TypeDeclaration || compilationUnit.Children[i] is DelegateDeclaration) {
						ns = new NamespaceDeclaration(NamespacePrefixToAdd);
						ns.AddChild(compilationUnit.Children[i]);
						compilationUnit.Children[i] = ns;
					}
				}
			}
			
			ToCSharpConvertVisitor v = new ToCSharpConvertVisitor();
			compilationUnit.AcceptVisitor(v, data);
			if (projectContent != null && projectContent.DefaultImports != null) {
				int index = 0;
				foreach (string u in projectContent.DefaultImports.Usings) {
					compilationUnit.Children.Insert(index++, new UsingDeclaration(u));
				}
			}
			return null;
		}

 public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
 {
     CSharpLanguage.VisitorData data2 = (CSharpLanguage.VisitorData) data;
     data2.CurrentNamespaces.Push(namespaceDeclaration.Name);
     namespaceDeclaration.AcceptChildren(this, data2);
     data2.CurrentNamespaces.Pop();
     return null;
 }

 public virtual object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
 {
   CSharpLanguage.VisitorData visitorData = (CSharpLanguage.VisitorData) data;
   visitorData.CurrentNamespaces.Push(namespaceDeclaration.get_Name());
   ((AbstractNode) namespaceDeclaration).AcceptChildren((IAstVisitor) this, (object) visitorData);
   visitorData.CurrentNamespaces.Pop();
   return (object) null;
 }

 public static NamespaceDeclaration add_Namespace(this CompilationUnit compilationUnit, string @namespace)
 {
     var newNamespace = compilationUnit.namespaces(@namespace);		// check if already exists and if it does return it
     if (newNamespace != null)
         return newNamespace;
     newNamespace = new NamespaceDeclaration(@namespace);
     compilationUnit.Children.Add(newNamespace);
     return newNamespace;
 }

        public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
        {
            NamespaceDeclaration replacedNamespace = namespaceDeclaration;
            UsingDeclaration usingDeclaration = new UsingDeclaration("java.lang.*");
            replacedNamespace.Children.Insert(0, usingDeclaration);

            ReplaceCurrentNode(replacedNamespace);

            return base.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
        }

		public void Setup()
		{
			mocks = new MockRepository();
			typeResolver = mocks.DynamicMock<ITypeResolver>();
			visitor = new TypeInspectionVisitor(typeResolver);

			type = new TypeDeclaration(Modifiers.Public, new List<AttributeSection>()) {Name = "SomeType"};
			@namespace = new NamespaceDeclaration("SomeNamespace");
			@namespace.AddChild(type);
			type.Parent = @namespace;
		}

		public void VisitingNamespace_MustAddParentNamespacesToTypeResolver()
		{
			var typeTables = new List<TypeTableEntry>();
			var usings = new List<String>();
			var aliases = new Dictionary<string, string>();
			var resolver = new TypeResolver(typeTables, usings, aliases);
			var nsDecl = new NamespaceDeclaration("System.Collections.Specialized");
			var visitor = new TypeResolvingVisitor(resolver);

			visitor.VisitNamespaceDeclaration(nsDecl, null);

			Assert.AreEqual(3, usings.Count);
		}

        public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
        {
            Removeables.Clear();
            UsedTypes.Clear();

            NamespaceDeclaration replaced = namespaceDeclaration;
            IList types = AstUtil.GetChildrenWithType(replaced, typeof(TypeDeclaration));
            foreach (TypeDeclaration typeDeclaration in types)
            {
                VisitTypeDeclaration(typeDeclaration, data);
            }
            ReplaceCurrentNode(replaced);
            return base.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
        }

        private void CreateTypeDeclarations(string jarFile)
        {
            LoadClasses(Path.GetFullPath(jarFile));

            foreach (string package in classes.Keys)
            {
                if (!IsIncluded(package))
                    continue;
                Console.WriteLine(package);
                IDictionary types = new Hashtable();
                IList packageClasses = (IList) classes[package];
                foreach (ClassFile cf in packageClasses)
                {
                    if (cf.IsPublic)
                    {
                        TypeDeclaration type = GetTypeDeclaration(cf);
                        types.Add(type.Name, type);
                    }
                }

                foreach (TypeDeclaration type in types.Values)
                {
                    if (type.Name.IndexOf("$") == -1)
                    {
                        NamespaceDeclaration nameSpace = new NamespaceDeclaration(package);
                        type.Parent = nameSpace;
                        nameSpace.AddChild(type);

                        CompilationUnit cu = new CompilationUnit();
                        cu.Children.Add(nameSpace);
                        compilationUnits.Add(cu);
                    }
                    else
                    {
                        string parentName = type.Name.Substring(0, type.Name.IndexOf("$"));
                        TypeDeclaration parent = (TypeDeclaration) types[GetTypeName(parentName)];
                        if (parent != null)
                        {
                            type.Name = GetTypeName(type.Name);
                            parent.AddChild(type);
                        }
                    }
                }
            }
        }

 public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
 {
     similarTypes = new Hashtable();
     IList usings = AstUtil.GetChildrenWithType(namespaceDeclaration, typeof(UsingDeclaration));
     foreach (UsingDeclaration usingDeclaration in usings)
     {
         Using usi = (Using) usingDeclaration.Usings[0];
         string fullName = GetFullyQualifiedName(usi);
         string type = GetShortReferenceTypeName(usi);
         string projectType = namespaceDeclaration.Name + "." + type;
         if (CodeBase.Types.Contains(projectType))
             similarTypes.Add(type, fullName);
     }
     if (similarTypes.Count < 1)
         return null;
     else
         return base.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
 }

 public override object VisitNamespaceDeclaration (NamespaceDeclaration node, object data)
 {
     if (!String.IsNullOrEmpty (Namespace))
         throw CreateException (node, "Nested namespaces are not supported");
     
     string prevNamespace = Namespace;
     //var prevUsings = Usings;
     
     Namespace = node.Name;
     //Usings = new HashSet<string> ();
     
     node.AcceptChildren (this, null);
     
     Namespace = prevNamespace;
     //Usings = prevUsings;
     
     return null;
 }

		public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
		{
			if (RootNamespaceToRemove != null) {
				if (namespaceDeclaration.Name == RootNamespaceToRemove) {
					// remove namespace declaration
					INode insertAfter = namespaceDeclaration;
					foreach (INode child in namespaceDeclaration.Children) {
						InsertAfterSibling(insertAfter, child);
						insertAfter = child;
					}
					namespaceDeclaration.Children.Clear();
					RemoveCurrentNode();
				} else if (namespaceDeclaration.Name.StartsWith(RootNamespaceToRemove + ".")) {
					namespaceDeclaration.Name = namespaceDeclaration.Name.Substring(RootNamespaceToRemove.Length + 1);
				}
			}
			base.VisitNamespaceDeclaration(namespaceDeclaration, data);
			return null;
		}

        public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
        {
            IList addingUsings = new ArrayList();

            base.TrackedVisitNamespaceDeclaration(namespaceDeclaration, addingUsings);

            if (addingUsings.Count > 0)
            {
                NamespaceDeclaration replaceNamespace = namespaceDeclaration;
                List<INode> children = namespaceDeclaration.Children;
                INode[] childMembers = new INode[children.Count];
                children.CopyTo(childMembers);
                replaceNamespace.Children.Clear();
                foreach (UsingDeclaration usi in addingUsings)
                    replaceNamespace.Children.Add(usi);
                foreach (INode node in childMembers)
                {
                    replaceNamespace.Children.Add(node);
                }
                ReplaceCurrentNode(replaceNamespace);
            }
            return null;
        }

        public void AddUsing(NamespaceDeclaration namespaceDeclaration, IList usings, UsingDeclaration usingDeclaration)
        {
            Using usin = (Using) usingDeclaration.Usings[0];
            string alias = null;
            string name = usin.Name;

            if (!usin.IsAlias)
                name = name.Substring(name.LastIndexOf('.') + 1);
            else
                alias = usin.Alias.Type;

            if (CodeBase.References.Contains(name))
            {
                string reference = (string) CodeBase.References[name];
                alias = alias.Replace("." + name, "." + reference);
                TypeReference typeReference = AstUtil.GetTypeReference(alias, namespaceDeclaration);
                UsingDeclaration addingUsingDeclaration = new UsingDeclaration(reference, typeReference);
                if (!Contains(usings, addingUsingDeclaration))
                {
                    namespaceDeclaration.Children.Insert(0, addingUsingDeclaration);
                }
            }
        }

		public sealed override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
			this.BeginVisit(namespaceDeclaration);
			object result = this.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
			this.EndVisit(namespaceDeclaration);
			return result;
		}

		public virtual object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
			return base.VisitNamespaceDeclaration(namespaceDeclaration, data);
		}

		public override List<Change> PerformChanges (RefactoringOptions options, object prop)
		{
			IResolver resolver = options.GetResolver ();
			List<Change> result = new List<Change> ();
			INRefactoryASTProvider provider = options.GetASTProvider ();
			if (resolver == null || provider == null)
				return result;

			TypeDeclaration newType = new TypeDeclaration (ICSharpCode.NRefactory.Ast.Modifiers.None, null);
			newType.Name = createExpression.CreateType.Type;
			newType.Type = GetNewTypeType ();

			ConstructorDeclaration constructor = new ConstructorDeclaration (newType.Name, ICSharpCode.NRefactory.Ast.Modifiers.Public, null, null);
			constructor.Body = new BlockStatement ();
			int i = 0;
			foreach (Expression expression in createExpression.Parameters) {
				i++;
				string output = provider.OutputNode (options.Dom, expression);
				string parameterName;
				if (Char.IsLetter (output[0]) || output[0] == '_') {
					parameterName = output;
				} else {
					parameterName = "par" + i;
				}

				ResolveResult resolveResult2 = resolver.Resolve (new ExpressionResult (output), options.ResolveResult.ResolvedExpression.Region.Start);
				TypeReference typeReference = new TypeReference (resolveResult2.ResolvedType.ToInvariantString ());
				typeReference.IsKeyword = true;
				ParameterDeclarationExpression pde = new ParameterDeclarationExpression (typeReference, parameterName);
				constructor.Parameters.Add (pde);
			}
			ICSharpCode.NRefactory.Ast.INode node = newType;
			IType curType = options.Document.CompilationUnit.GetTypeAt (options.Document.TextEditor.CursorLine, options.Document.TextEditor.CursorColumn);
			if (curType != null && !string.IsNullOrEmpty (curType.Namespace)) {
				NamespaceDeclaration namespaceDeclaration = new NamespaceDeclaration (curType.Namespace);
				namespaceDeclaration.Children.Add (newType);
				node = namespaceDeclaration;
			}
			newType.Children.Add (constructor);
			string fileName = GetName (Path.Combine (Path.GetDirectoryName (options.Document.FileName), newType.Name + Path.GetExtension (options.Document.FileName)));
			string header = options.Dom.Project is DotNetProject ? StandardHeaderService.GetHeader (options.Dom.Project, fileName, true) + Environment.NewLine : "";
			CreateFileChange createFile = new CreateFileChange (fileName, header + provider.OutputNode (options.Dom, node));
			result.Add (createFile);
			result.Add (new OpenFileChange (fileName));
			return result;
		}