public ToolTipData (ICSharpCode.NRefactory.CSharp.CompilationUnit unit, ICSharpCode.NRefactory.Semantics.ResolveResult result, ICSharpCode.NRefactory.CSharp.AstNode node, CSharpAstResolver file)
			{
				this.Unit = unit;
				this.Result = result;
				this.Node = node;
				this.Resolver = file;
			}

 private string Translate(CompilationUnit typedCompilationUnit)
 {
     var code = new CodeWriter();
     WriteAction write = typedCompilationUnit.Visit(csTranslator);
     write(code);
     return code.ToString();
 }

		public void TestGetNamespaceContentsCase2 ()
		{
			CompilationUnit unit = new CompilationUnit ("file.cs");
			unit.Add (new DomType ("ANamespace.AnotherNamespace.AClass"));
			unit.Add (new DomType ("ANamespace.AnotherNamespace.BClass"));
			unit.Add (new DomType ("ANamespace.AnotherNamespace.CClass"));
			unit.Add (new DomType ("ANamespace.AClass2"));
			unit.Add (new DomType ("ANamespace.BClass2"));
			unit.Add (new DomType ("CClass3"));
			
			List<IMember> member = new List<IMember> ();
			unit.GetNamespaceContents (member, "ANamespace", true);
			
			Assert.AreEqual (3, member.Count);
			Namespace ns = member[0] as Namespace;
			Assert.IsNotNull (ns);
			Assert.AreEqual ("AnotherNamespace", ns.Name);
			
			IType type = member[1] as IType;
			Assert.IsNotNull (type);
			Assert.AreEqual ("AClass2", type.Name);
			
			type = member[2] as IType;
			Assert.IsNotNull (type);
			Assert.AreEqual ("BClass2", type.Name);
		}

        public void ReplaceJumpToWhile()
        {
            var cu = new CompilationUnit().AddStatements(new Statement[]
                {
                    new ExpressionStatement(new MethodInvocation("Delay").AddArgument(60)){ StartOffset = 0, EndOffset = 4 },
                    new ExpressionStatement(new BinaryExpression(new ElementAccess("LocalVariables", 0), Operator.Assignment, new MethodInvocation("GetRandomNumber").AddArgument(10))){ StartOffset = 4, EndOffset = 8 },
                    new ExpressionStatement(new BinaryExpression(new ElementAccess("Variables", 103), Operator.Assignment, 0.ToLiteral())){ StartOffset = 8, EndOffset = 13 },
                    new JumpStatement(true.ToLiteral(), 0){ StartOffset = 13, EndOffset = 16 },
                    new ExpressionStatement(new MethodInvocation("StopObjectCode")){ StartOffset = 16, EndOffset = 17 },
                });
            var expectedCu = new CompilationUnit().AddStatements(new Statement[]
                {
                    new DoWhileStatement(true.ToLiteral(), new BlockStatement().AddStatements(
                            new Statement[]
                            {
                                new ExpressionStatement(new MethodInvocation("Delay").AddArgument(60)){ StartOffset = 0, EndOffset = 4 },
                                new ExpressionStatement(new BinaryExpression(new ElementAccess("LocalVariables", 0), Operator.Assignment, new MethodInvocation("GetRandomNumber").AddArgument(10))){ StartOffset = 4, EndOffset = 8 },
                                new ExpressionStatement(new BinaryExpression(new ElementAccess("Variables", 103), Operator.Assignment, 0.ToLiteral())){ StartOffset = 8, EndOffset = 13 },
                            })),
                    new ExpressionStatement(new MethodInvocation("StopObjectCode")){ StartOffset = 16, EndOffset = 17 },
                });

            var actualCu = new ReplaceJumpToWhile().Replace(cu);
            AstHelper.AstEquals(expectedCu, actualCu);
        }

        public PsiVisitor(CompilationUnit cu, CompilerDTO dto)
        {
            DTO = dto;
            CurrentCompilationUnit = cu;

            InitHelpers();
        }

        public void ReplaceJumpToIf()
        {
            var cu = new CompilationUnit().AddStatements(new Statement[]
                {
                    new JumpStatement(
                        new BinaryExpression(
                            new SimpleName("Var1"), Operator.Greater, 0.ToLiteral()),
                        10){ StartOffset = 0, EndOffset = 5 },
                    new ExpressionStatement(
                        new MethodInvocation("Print").AddArgument("Var1 is lower or equals to 0".ToLiteral())) { StartOffset = 5, EndOffset = 10 },
                    new ExpressionStatement(
                        new MethodInvocation("Print").AddArgument("End".ToLiteral())) { StartOffset = 10, EndOffset = 15 }
                });
            var expectedCu = new CompilationUnit().AddStatements(new Statement[]
                {
                    new IfStatement(
                        new BinaryExpression(
                            new SimpleName("Var1"), Operator.LowerOrEquals, 0.ToLiteral()),
                        new BlockStatement().AddStatement(
                            new ExpressionStatement(
                                new MethodInvocation("Print").AddArgument("Var1 is lower or equals to 0".ToLiteral())) { StartOffset = 5, EndOffset = 10 })
                    ){ StartOffset = 0, EndOffset = 10 },
                    new ExpressionStatement(
                        new MethodInvocation("Print").AddArgument("End".ToLiteral())) { StartOffset = 10, EndOffset = 15 }
                });

            var actualCu = new ReplaceJumpToIf().Replace(cu);

            AstHelper.AstEquals(expectedCu, actualCu);
        }

			public GatherVisitor (BaseRefactoringContext context, CompilationUnit unit,
								  AccessToClosureIssue issueProvider)
				: base (context)
			{
				this.title = context.TranslateString (issueProvider.Title);
				this.unit = unit;
				this.issueProvider = issueProvider;
			}

			public void Validate(CompilationUnit cu)
			{
				foreach (AstNode node in cu.DescendantsAndSelf.Except(resolvedNodes)) {
					if (!CSharpAstResolver.IsUnresolvableNode(node)) {
						Console.WriteLine("Forgot to resolve " + node);
					}
				}
			}

        public PsiSemanticAnaliserVisitor(CompilationUnit cu, CompilerDTO dto)
            : base(cu, dto)
        {
            CurrentCompilationUnit = cu;
            DTO = dto;

            InitHelpers();
        }

		public override object VisitCompilationUnit(CompilationUnit compilationUnit, object data)
		{
			base.VisitCompilationUnit(compilationUnit, data);
			for (int i = 0; i < nodesToMoveToCompilationUnit.Count; i++) {
				compilationUnit.Children.Insert(i, nodesToMoveToCompilationUnit[i]);
				nodesToMoveToCompilationUnit[i].Parent = compilationUnit;
			}
			return null;
		}

 public CompilationUnit Replace(CompilationUnit cu)
 {
     var visitor = new JumpAstVisitor();
     cu.Accept(visitor);
     var jumps = visitor.Jumps.Where(AcceptJump).ToList();
     var newCu = cu.Accept(new JumpReplacer());
     newCu.Accept(new LabelInserter(jumps));
     return (CompilationUnit)newCu;
 }

 public DynamicallyCompiledLibraries(ErrorCollector collector)
 {
     this.collector = collector;
     var name = "DynamicallyCompiledLibraries" + GetHashCode();
     var assembly_builder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(name), AssemblyBuilderAccess.Run);
     CompilationUnit.MakeDebuggable(assembly_builder);
     var module_builder = assembly_builder.DefineDynamicModule(name, true);
     unit = new CompilationUnit(module_builder, true);
 }

		public CSharpParameterCompletionEngine (IDocument document, IParameterCompletionDataFactory factory, IProjectContent content, CSharpTypeResolveContext ctx, CompilationUnit unit, CSharpParsedFile parsedFile) : base (content, ctx, unit, parsedFile)
		{
			if (document == null)
				throw new ArgumentNullException ("document");
			if (factory == null)
				throw new ArgumentNullException ("factory");
			this.document = document;
			this.factory = factory;
		}

		public static ResolveResult Resolve(ICompilation compilation, CSharpParsedFile parsedFile, CompilationUnit cu, TextLocation location,
		                                    CancellationToken cancellationToken = default(CancellationToken))
		{
			AstNode node = cu.GetNodeAt(location);
			if (node == null)
				return null;
			AstNode resolvableNode;
			if (node is AstType) {
				resolvableNode = node;
				if (resolvableNode.Parent is ComposedType) {
					while (resolvableNode.Parent is ComposedType)
						resolvableNode = resolvableNode.Parent;
					//node is preffered over the resolvable node. Which shouldn't be done in the case of nullables, arrays etc.
					node = resolvableNode;
				}
			} else if (node is Identifier) {
				resolvableNode = node.Parent;
			} else if (node.NodeType == NodeType.Token) {
				if (node.Parent is ConstructorInitializer) {
					resolvableNode = node.Parent;
				} else {
					return null;
				}
			} else {
				// don't resolve arbitrary nodes - we don't want to show tooltips for everything
				return null;
			}
			
			if (resolvableNode != null && resolvableNode.Parent is ObjectCreateExpression) {
				resolvableNode = resolvableNode.Parent;
			}
			
			InvocationExpression parentInvocation = null;
			if ((resolvableNode is IdentifierExpression || resolvableNode is MemberReferenceExpression || resolvableNode is PointerReferenceExpression)) {
				// we also need to resolve the invocation
				parentInvocation = resolvableNode.Parent as InvocationExpression;
			}
			
			IResolveVisitorNavigator navigator;
			if (parentInvocation != null)
				navigator = new NodeListResolveVisitorNavigator(new[] { resolvableNode, parentInvocation });
			else
				navigator = new NodeListResolveVisitorNavigator(new[] { resolvableNode });
			
			CSharpResolver resolver = new CSharpResolver(compilation);
			ResolveVisitor v = new ResolveVisitor(resolver, parsedFile, navigator);
			v.Scan(cu);
			
			// Prefer the RR from the token itself, if it was assigned a ResolveResult
			// (this can happen with the identifiers in various nodes such as catch clauses or foreach statements)
			ResolveResult rr = v.GetResolveResult(node) ?? v.GetResolveResult(resolvableNode);
			if (rr is MethodGroupResolveResult && parentInvocation != null)
				return v.GetResolveResult(parentInvocation);
			else
				return rr;
		}

		public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpParsedFile parsedFile, CompilationUnit cu, TextLocation location, out AstNode node,
		                                    CancellationToken cancellationToken = default(CancellationToken))
		{
			node = cu.GetNodeAt(location);
			if (node == null || node is ArrayInitializerExpression)
				return null;
			if (CSharpAstResolver.IsUnresolvableNode(node)) {
				if (node is Identifier) {
					node = node.Parent;
				} else if (node.NodeType == NodeType.Token) {
					if (node.Parent is IndexerExpression || node.Parent is ConstructorInitializer) {
						Console.WriteLine (2);
						// There's no other place where one could hover to see the indexer's tooltip,
						// so we need to resolve it when hovering over the '[' or ']'.
						// For constructor initializer, the same applies to the 'base'/'this' token.
						node = node.Parent;
					} else {
						return null;
					}
				} else {
					// don't resolve arbitrary nodes - we don't want to show tooltips for everything
					return null;
				}
			} else {
				// It's a resolvable node.
				// However, we usually don't want to show the tooltip everywhere
				// For example, hovering with the mouse over an empty line between two methods causes
				// node==TypeDeclaration, but we don't want to show any tooltip.
				
				if (!node.GetChildByRole(Roles.Identifier).IsNull) {
					// We'll suppress the tooltip for resolvable nodes if there is an identifier that
					// could be hovered over instead:
					return null;
				}
			}
			if (node == null)
				return null;
			
			if (node.Parent is ObjectCreateExpression && node.Role == Roles.Type) {
				node = node.Parent;
			}
			
			InvocationExpression parentInvocation = null;
			if ((node is IdentifierExpression || node is MemberReferenceExpression || node is PointerReferenceExpression) && node.Role != Roles.Argument) {
				// we also need to resolve the invocation
				parentInvocation = node.Parent as InvocationExpression;
			}
			
			// TODO: I think we should provide an overload so that an existing CSharpAstResolver can be reused
			CSharpAstResolver resolver = new CSharpAstResolver(compilation.Value, cu, parsedFile);
			ResolveResult rr = resolver.Resolve(node, cancellationToken);
			if (rr is MethodGroupResolveResult && parentInvocation != null)
				return resolver.Resolve(parentInvocation);
			else
				return rr;
		}

 public CompilationUnit Replace(CompilationUnit cu)
 {
     var visitor = new JumpAstVisitor();
     cu.Accept(visitor);
     var jumps = visitor.Jumps.Where(jump => jump.JumpOffset < jump.StartOffset).OrderByDescending(jmp => jmp.JumpOffset).ThenByDescending(jmp => jmp.StartOffset).ToList();
     foreach (var jump in jumps)
     {
         cu = new CompilationUnit().AddStatements(ReplaceJump(jump, cu.Statement));
     }
     return cu;
 }

		/// <summary>
		/// Creates a new C# AST resolver.
		/// Use this overload if you are resolving within a complete C# file.
		/// </summary>
		/// <param name="compilation">The current compilation.</param>
		/// <param name="compilationUnit">The compilation unit corresponding to the specified parsed file.</param>
		/// <param name="parsedFile">
		/// Optional: Result of the <see cref="TypeSystemConvertVisitor"/> for the file being resolved.
		/// <para>
		/// This is used for setting up the context on the resolver. The parsed file must be registered in the compilation.
		/// </para>
		/// <para>
		/// When a parsedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
		/// member declarations in the AST with members in the type system.
		/// When no parsedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
		/// member's signature in the AST with the signature in the type system.
		/// </para>
		/// </param>
		public CSharpAstResolver(ICompilation compilation, CompilationUnit compilationUnit, CSharpParsedFile parsedFile = null)
		{
			if (compilation == null)
				throw new ArgumentNullException("compilation");
			if (compilationUnit == null)
				throw new ArgumentNullException("compilationUnit");
			this.initialResolverState = new CSharpResolver(compilation);
			this.rootNode = compilationUnit;
			this.parsedFile = parsedFile;
			this.resolveVisitor = new ResolveVisitor(initialResolverState, parsedFile);
		}

        public CompilerResult Build(CompilationUnit compilationUnit)
        {
            var typeChecker = new TypeChecker();
            var typedCompilationUnit = typeChecker.TypeCheck(compilationUnit);

            if (typeChecker.HasErrors)
                return new CompilerResult(Language.Rook, typeChecker.Errors);

            string translatedCode = Translate(typedCompilationUnit);
            return csCompiler.Build(translatedCode);
        }

 public void InitializeTest()
 {
     _compilationUnit = new CompilationUnit();
     _compilation = new Compilation(new SourceAssembly("TestAssembly")
     {
         SourceFiles = { new SourceFile("dummy") { CompilationUnit = _compilationUnit } }
     })
     {
         Assemblies = { _mscorlibAssembly },
     };
 }

		protected static bool FindUsage (BaseRefactoringContext context, CompilationUnit unit,
										 ITypeParameter typaParameter, AstNode declaration)
		{
			var found = false;
			refFinder.FindTypeParameterReferences (typaParameter, context.ParsedFile, unit, context.Compilation,
				(node, resolveResult) =>
				{
					found = found || node != declaration;
				}, context.CancellationToken);
			return found;
		}