public GenerateNamespaceImport GetResult (ProjectDom dom, ICompilationUnit unit, IType type, TextEditorData data)
		{
			GenerateNamespaceImport result;
			if (cache.TryGetValue (type.Namespace, out result))
				return result;
			result = new GenerateNamespaceImport ();
			cache[type.Namespace] = result;
			
			result.InsertNamespace  = false;
			
			DomLocation location = new DomLocation (data.Caret.Line, data.Caret.Column);
			foreach (IUsing u in unit.Usings.Where (u => u.ValidRegion.Contains (location))) {
				if (u.Namespaces.Any (ns => type.Namespace == ns)) {
					result.GenerateUsing = false;
					return result;
				}
			}
			result.GenerateUsing = true;
			string name = type.DecoratedFullName.Substring (type.Namespace.Length + 1);
			
			foreach (IUsing u in unit.Usings.Where (u => u.ValidRegion.Contains (location))) {
				foreach (string ns in u.Namespaces) {
					if (dom.SearchType (unit, unit.GetTypeAt (location), unit.GetMemberAt (location), ns + "." + name) != null) {
						result.GenerateUsing = false;
						result.InsertNamespace = true;
						return result;
					}
				}
			}
			return result;
		}

		public static void AddImportedNamespaceContents(ArrayList result, ICompilationUnit cu, IClass callingClass)
		{
			IProjectContent projectContent = cu.ProjectContent;
			projectContent.AddNamespaceContents(result, "", projectContent.Language, true);
			foreach (IUsing u in cu.GetAllUsings()) {
				AddUsing(result, u, projectContent);
			}
			AddUsing(result, projectContent.DefaultImports, projectContent);
			
			if (callingClass != null) {
				string[] namespaceParts = callingClass.Namespace.Split('.');
				for (int i = 1; i <= namespaceParts.Length; i++) {
					foreach (object member in projectContent.GetNamespaceContents(string.Join(".", namespaceParts, 0, i))) {
						if (!result.Contains(member))
							result.Add(member);
					}
				}
				IClass currentClass = callingClass;
				do {
					foreach (IClass innerClass in currentClass.GetCompoundClass().GetAccessibleTypes(currentClass)) {
						if (!result.Contains(innerClass))
							result.Add(innerClass);
					}
					currentClass = currentClass.DeclaringType;
				} while (currentClass != null);
			}
		}

		static IClass CreateMyApplication(ICompilationUnit cu, VBNetProject project, string ns)
		{
			DefaultClass c = new DefaultClass(cu, ns + ".MyApplication");
			c.ClassType = ClassType.Class;
			c.Modifiers = ModifierEnum.Internal | ModifierEnum.Sealed | ModifierEnum.Partial | ModifierEnum.Synthetic;
			c.Attributes.Add(new DefaultAttribute(CreateTypeRef(cu, "Microsoft.VisualBasic.HideModuleNameAttribute")));
			switch (project.OutputType) {
				case OutputType.WinExe:
					c.BaseTypes.Add(CreateTypeRef(cu, "Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase"));
					if (project.GetEvaluatedProperty("MyType") == "WindowsForms") {
						c.Methods.Add(
							new DefaultMethod(c, "Main") {
								Modifiers = ModifierEnum.Internal | ModifierEnum.Static,
								ReturnType = c.ProjectContent.SystemTypes.Void,
								Parameters = new[] {
									new DefaultParameter(
										"args",
										new ArrayReturnType(c.ProjectContent, c.ProjectContent.SystemTypes.String, 1),
										DomRegion.Empty
									)
								}
							});
					}
					break;
				case OutputType.Exe:
					c.BaseTypes.Add(CreateTypeRef(cu, "Microsoft.VisualBasic.ApplicationServices.ConsoleApplicationBase"));
					break;
				default:
					c.BaseTypes.Add(CreateTypeRef(cu, "Microsoft.VisualBasic.ApplicationServices.ApplicationBase"));
					break;
			}
			return c;
		}

		public JavaScriptRegionWalker(
			JavaScriptAst ast,
			ICompilationUnit compilationUnit)
		{
			this.ast = ast;
			this.compilationUnit = compilationUnit;
		}

		void AddDefaultUsings(ICompilationUnit compilationUnit)
		{
			AddUsing("System.Web.Mvc", compilationUnit);
			AddUsing("System.Web.Mvc.Ajax", compilationUnit);
			AddUsing("System.Web.Mvc.Html", compilationUnit);
			AddUsing("System.Web.Routing", compilationUnit);
		}

		void AddNames (ICompilationUnit unit, int caretLine, int caretColumn)
		{
			foreach (IType cls in unit.Types) {
				if (cls.BodyRegion.Contains (caretLine, caretColumn)) {
					// Enclosing namespace:
					AddName (cls.Namespace, "");
					enclosingNamespace = cls.Namespace;
					// For inner classes:
					AddName (cls.FullName, "");
				}
			}
			
			foreach (IUsing u in unit.Usings) {
				if (u != null) {
					foreach (string us in u.Namespaces)
						AddName (us, "");
				}
			}
			
			// Namespace aliases
			foreach (IUsing u in unit.Usings) {
				if (u != null) {
					foreach (KeyValuePair<string, IReturnType> e in u.Aliases)
						AddName (e.Value.FullName, e.Key);
				}
			}
		}

		public ParseInformationEventArgs(string fileName, IProjectContent projectContent, ICompilationUnit oldCompilationUnit, ICompilationUnit newCompilationUnit)
		{
			this.fileName = fileName;
			this.projectContent = projectContent;
			this.oldCompilationUnit = oldCompilationUnit;
			this.newCompilationUnit = newCompilationUnit;
		}

		void RetrieveRegions(ICompilationUnit cu, ICSharpCode.NRefactory.Parser.SpecialTracker tracker)
		{
			for (int i = 0; i < tracker.CurrentSpecials.Count; ++i) {
				ICSharpCode.NRefactory.PreprocessingDirective directive = tracker.CurrentSpecials[i] as ICSharpCode.NRefactory.PreprocessingDirective;
				if (directive != null) {
					if (directive.Cmd == "#region") {
						int deep = 1;
						for (int j = i + 1; j < tracker.CurrentSpecials.Count; ++j) {
							ICSharpCode.NRefactory.PreprocessingDirective nextDirective = tracker.CurrentSpecials[j] as ICSharpCode.NRefactory.PreprocessingDirective;
							if (nextDirective != null) {
								switch (nextDirective.Cmd) {
									case "#region":
										++deep;
										break;
									case "#endregion":
										--deep;
										if (deep == 0) {
											cu.FoldingRegions.Add(new FoldingRegion(directive.Arg.Trim(), new DomRegion(directive.StartPosition, nextDirective.EndPosition)));
											goto end;
										}
										break;
								}
							}
						}
						end: ;
					}
				}
			}
		}

		static string GetModelTypeName(ICompilationUnit compilationUnit)
		{
			var originalRazorCompilationUnit = compilationUnit as RazorCompilationUnit;
			if (originalRazorCompilationUnit != null) {
				return originalRazorCompilationUnit.ModelTypeName;
			}
			return String.Empty;
		}

		public PythonClass(ICompilationUnit compilationUnit, ClassDefinition classDefinition)
			: base(compilationUnit, String.Empty)
		{
			GetFullyQualifiedName(classDefinition);
			GetClassRegions(classDefinition);
			AddBaseTypes(classDefinition.Bases);
			
			compilationUnit.Classes.Add(this);
		}

		public ParseInformation(ICompilationUnit unit)
		{
			if (unit == null)
				throw new ArgumentNullException("unit");
			unit.Freeze();
//			if (!unit.IsFrozen)
//				throw new ArgumentException("unit must be frozen for use in ParseInformation");
			this.unit = unit;
		}

		public CompilationUnitHelper()
		{
			CompilationUnit = MockRepository.GenerateStub<ICompilationUnit>();
			LanguageProperties language = MockRepository.GenerateStub<LanguageProperties>(StringComparer.InvariantCultureIgnoreCase);
			language.Stub(lang => lang.CodeGenerator).Return(FakeCodeGenerator);
			CompilationUnit.Stub(unit => unit.Language).Return(language);
			CompilationUnit.Stub(unit => unit.Classes).Return(Classes);
			CompilationUnit.Stub(unit => unit.UsingScope).Return(UsingScopeHelper.UsingScope);
		}

		IClass FindMatchingClass(ICompilationUnit unit)
		{
			foreach (IClass c in unit.Classes) {
				if (c.FullyQualifiedName == Class.FullyQualifiedName) {
					return c;
				}
			}
			return null;
		}

		/// <summary>
		/// Returns the class in which the carret currently is, returns null
		/// if the carret is outside the class boundaries.
		/// </summary>
		IClass GetCurrentClass(TextEditorControl textEditorControl, ICompilationUnit cu, string fileName)
		{
			IDocument document = textEditorControl.Document;
			if (cu != null) {
				int caretLineNumber = document.GetLineNumberForOffset(textEditorControl.ActiveTextAreaControl.Caret.Offset) + 1;
				int caretColumn     = textEditorControl.ActiveTextAreaControl.Caret.Offset - document.GetLineSegment(caretLineNumber - 1).Offset + 1;
				return FindClass(cu.Classes, caretLineNumber, caretColumn);
			}
			return null;
		}

		public FilePosition(ICompilationUnit compilationUnit, int line, int column)
		{
			this.position = new Location(column, line);
			this.compilationUnit = compilationUnit;
			if (compilationUnit != null) {
				this.filename = compilationUnit.FileName;
			} else {
				this.filename = null;
			}
		}

		public RefactoringMenuContext(ITextEditor editor, ExpressionResult expressionResult,
		                              ResolveResult resolveResult, bool isDefinition,
		                              IProjectContent projectContent, ICompilationUnit compilationUnit)
		{
			this.Editor = editor;
			this.ExpressionResult = expressionResult;
			this.ResolveResult = resolveResult;
			this.IsDefinition = isDefinition;
			this.ProjectContent = projectContent;
			this.CompilationUnit = compilationUnit;
		}

		public ParseInformationEventArgs(FileName fileName, IProjectContent projectContent, ICompilationUnit oldCompilationUnit, ParseInformation newParseInformation)
		{
			if (fileName == null)
				throw new ArgumentNullException("fileName");
			if (projectContent == null)
				throw new ArgumentNullException("projectContent");
			this.fileName = fileName;
			this.projectContent = projectContent;
			this.oldCompilationUnit = oldCompilationUnit;
			this.newParseInformation = newParseInformation;
		}

 public DefaultClass(ICompilationUnit compilationUnit, string fullyQualifiedName)
     : base(null)
 {
     if (compilationUnit == null)
         throw new ArgumentNullException("compilationUnit");
     if (fullyQualifiedName == null)
         throw new ArgumentNullException("fullyQualifiedName");
     this.compilationUnit = compilationUnit;
     this.FullyQualifiedName = fullyQualifiedName;
     this.UsingScope = compilationUnit.UsingScope;
 }

		public void SetUpFixture()
		{
			string python = "class Test:\r\n" +
							"\tdef foo(self):\r\n" +
							"\t\tpass";
			
			DefaultProjectContent projectContent = new DefaultProjectContent();
			PythonParser parser = new PythonParser();
			compilationUnit = parser.Parse(projectContent, @"C:\test.py", python);			
			if (compilationUnit.Classes.Count > 0) {
				c = compilationUnit.Classes[0];
				if (c.Methods.Count > 0) {
					method = c.Methods[0];
				}
				
				TextArea textArea = new TextArea();
				document = new TextDocument();
				textArea.Document = document;
				textArea.Document.Text = python;
				
				ParserFoldingStrategy foldingStrategy = new ParserFoldingStrategy(textArea);
				
				ParseInformation parseInfo = new ParseInformation(compilationUnit);
				foldingStrategy.UpdateFoldings(parseInfo);
				List<FoldingSection> folds = new List<FoldingSection>(foldingStrategy.FoldingManager.AllFoldings);
				
				if (folds.Count > 0) {
					classFold = folds[0];
				}
				if (folds.Count > 1) {
					methodFold = folds[1];
				}
			}
		}

		public ResolveVisitor(BooResolver resolver)
		{
			this.resolver = resolver;
			this.callingClass = resolver.CallingClass;
			this.projectContent = resolver.ProjectContent;
			this.cu = resolver.CompilationUnit;
		}