Rename CompilationUnit to SyntaxTree.

ICSharpCode.NRefactory.CSharp.AstVerifier/Main.cs

@@ -59,7 +59,7 @@ namespace ICSharpCode.NRefactory.CSharp.AstVerifier
 				if (!file.EndsWith (".cs"))
 					continue;
 				string text = File.ReadAllText (file);
-				var unit = CompilationUnit.Parse (text, file);
+				var unit = SyntaxTree.Parse (text, file);
 				if (unit == null)
 					continue;
 				string generated = unit.GetText ();

ICSharpCode.NRefactory.CSharp/Ast/AstNode.cs

@@ -195,12 +195,12 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		/// <summary>
 		/// Gets the region from StartLocation to EndLocation for this node.
-		/// The file name of the region is set based on the parent CompilationUnit's file name.
+		/// The file name of the region is set based on the parent SyntaxTree's file name.
 		/// If this node is not connected to a whole compilation, the file name will be null.
 		/// </summary>
 		public ICSharpCode.NRefactory.TypeSystem.DomRegion GetRegion()
 		{
-			var cu = (this.Ancestors.LastOrDefault() ?? this) as CompilationUnit;
+			var cu = (this.Ancestors.LastOrDefault() ?? this) as SyntaxTree;
 			string fileName = (cu != null ? cu.FileName : null);
 			return new ICSharpCode.NRefactory.TypeSystem.DomRegion(fileName, this.StartLocation, this.EndLocation);
 		}

ICSharpCode.NRefactory.CSharp/Ast/DepthFirstAstVisitor.cs

@@ -44,9 +44,9 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
-		public virtual void VisitCompilationUnit (CompilationUnit unit)
+		public virtual void VisitSyntaxTree (SyntaxTree syntaxTree)
 		{
-			VisitChildren (unit);
+			VisitChildren (syntaxTree);
 		}
 		
 		public virtual void VisitComment(Comment comment)
@@ -642,7 +642,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			return default (T);
 		}
 		
-		public virtual T VisitCompilationUnit (CompilationUnit unit)
+		public virtual T VisitSyntaxTree (SyntaxTree unit)
 		{
 			return VisitChildren (unit);
 		}
@@ -1240,7 +1240,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			return default (S);
 		}
 		
-		public virtual S VisitCompilationUnit (CompilationUnit unit, T data)
+		public virtual S VisitSyntaxTree (SyntaxTree unit, T data)
 		{
 			return VisitChildren (unit, data);
 		}

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/NamespaceDeclaration.cs

@@ -35,7 +35,7 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class NamespaceDeclaration : AstNode
 	{
-		public static readonly Role<AstNode> MemberRole = CompilationUnit.MemberRole;
+		public static readonly Role<AstNode> MemberRole = SyntaxTree.MemberRole;
 		
 		public override NodeType NodeType {
 			get {

ICSharpCode.NRefactory.CSharp/Ast/IAstVisitor.cs

@@ -129,7 +129,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		void VisitFixedFieldDeclaration(FixedFieldDeclaration fixedFieldDeclaration);
 		void VisitFixedVariableInitializer(FixedVariableInitializer fixedVariableInitializer);
 		
-		void VisitCompilationUnit(CompilationUnit compilationUnit);
+		void VisitSyntaxTree(SyntaxTree syntaxTree);
 		void VisitSimpleType(SimpleType simpleType);
 		void VisitMemberType(MemberType memberType);
 		void VisitComposedType(ComposedType composedType);
@@ -260,7 +260,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		S VisitFixedFieldDeclaration(FixedFieldDeclaration fixedFieldDeclaration);
 		S VisitFixedVariableInitializer(FixedVariableInitializer fixedVariableInitializer);
 		
-		S VisitCompilationUnit(CompilationUnit compilationUnit);
+		S VisitSyntaxTree(SyntaxTree syntaxTree);
 		S VisitSimpleType(SimpleType simpleType);
 		S VisitMemberType(MemberType memberType);
 		S VisitComposedType(ComposedType composedType);
@@ -391,7 +391,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		S VisitFixedFieldDeclaration(FixedFieldDeclaration fixedFieldDeclaration, T data);
 		S VisitFixedVariableInitializer(FixedVariableInitializer fixedVariableInitializer, T data);
 		
-		S VisitCompilationUnit(CompilationUnit compilationUnit, T data);
+		S VisitSyntaxTree(SyntaxTree syntaxTree, T data);
 		S VisitSimpleType(SimpleType simpleType, T data);
 		S VisitMemberType(MemberType memberType, T data);
 		S VisitComposedType(ComposedType composedType, T data);

ICSharpCode.NRefactory.CSharp/Ast/ObservableAstVisitor.cs

@@ -45,11 +45,11 @@ namespace ICSharpCode.NRefactory.CSharp
 				leave(node);
 		}
 		
-		public event Action<CompilationUnit> EnterCompilationUnit, LeaveCompilationUnit;
+		public event Action<SyntaxTree> EnterSyntaxTree, LeaveSyntaxTree;
 		
-		void IAstVisitor.VisitCompilationUnit(CompilationUnit unit)
+		void IAstVisitor.VisitSyntaxTree(SyntaxTree unit)
 		{
-			Visit(EnterCompilationUnit, LeaveCompilationUnit, unit);
+			Visit(EnterSyntaxTree, LeaveSyntaxTree, unit);
 		}
 		
 		public event Action<Comment> EnterComment, LeaveComment;

ICSharpCode.NRefactory.CSharp/Ast/SyntaxTree.cs

@@ -1,5 +1,5 @@
 // 
-// CompilationUnit.cs
+// SyntaxTree.cs
 //
 // Author:
 //       Mike Krüger <mkrueger@novell.com>
@@ -23,6 +23,7 @@
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
+
 using System;
 using System.Collections.Generic;
 using ICSharpCode.NRefactory.CSharp.Resolver;
@@ -35,7 +36,10 @@ using ICSharpCode.NRefactory.Editor;
 
 namespace ICSharpCode.NRefactory.CSharp
 {
-	public class CompilationUnit : AstNode
+	[Obsolete("CompilationUnit was renamed to SyntaxTree", true)]
+	public class CompilationUnit {}
+	
+	public class SyntaxTree : AstNode
 	{
 		public static readonly Role<AstNode> MemberRole = new Role<AstNode>("Member", AstNode.Null);
 		
@@ -48,7 +52,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		string fileName;
 		
 		/// <summary>
-		/// Gets/Sets the file name of this compilation unit.
+		/// Gets/Sets the file name of this syntax tree.
 		/// </summary>
 		public string FileName {
 			get { return fileName; }
@@ -97,7 +101,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			internal set;
 		}
 		
-		public CompilationUnit ()
+		public SyntaxTree ()
 		{
 		}
 		
@@ -120,56 +124,56 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
 		{
-			CompilationUnit o = other as CompilationUnit;
+			SyntaxTree o = other as SyntaxTree;
 			return o != null && GetChildrenByRole(MemberRole).DoMatch(o.GetChildrenByRole(MemberRole), match);
 		}
 		
 		public override void AcceptVisitor (IAstVisitor visitor)
 		{
-			visitor.VisitCompilationUnit (this);
+			visitor.VisitSyntaxTree (this);
 		}
 		
 		public override T AcceptVisitor<T> (IAstVisitor<T> visitor)
 		{
-			return visitor.VisitCompilationUnit (this);
+			return visitor.VisitSyntaxTree (this);
 		}
 		
 		public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
 		{
-			return visitor.VisitCompilationUnit (this, data);
+			return visitor.VisitSyntaxTree (this, data);
 		}
 		
 		/// <summary>
-		/// Converts this compilation unit into a parsed file that can be stored in the type system.
+		/// Converts this syntax tree into a parsed file that can be stored in the type system.
 		/// </summary>
 		public CSharpParsedFile ToTypeSystem ()
 		{
 			if (string.IsNullOrEmpty (this.FileName))
-				throw new InvalidOperationException ("Cannot use ToTypeSystem() on a compilation unit without file name.");
+				throw new InvalidOperationException ("Cannot use ToTypeSystem() on a syntax tree without file name.");
 			var v = new TypeSystemConvertVisitor (this.FileName);
-			v.VisitCompilationUnit (this);
+			v.VisitSyntaxTree (this);
 			return v.ParsedFile;
 		}
 		
-		public static CompilationUnit Parse (string text, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default (CancellationToken))
+		public static SyntaxTree Parse (string text, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default (CancellationToken))
 		{
 			var parser = new CSharpParser (settings);
 			return parser.Parse (text, fileName);
 		}
 		
-		public static CompilationUnit Parse (TextReader reader, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default (CancellationToken))
+		public static SyntaxTree Parse (TextReader reader, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default (CancellationToken))
 		{
 			var parser = new CSharpParser (settings);
 			return parser.Parse (reader, fileName, 0);
 		}
 		
-		public static CompilationUnit Parse (Stream stream, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default (CancellationToken))
+		public static SyntaxTree Parse (Stream stream, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default (CancellationToken))
 		{
 			var parser = new CSharpParser (settings);
 			return parser.Parse (stream, fileName, 0);
 		}
 		
-		public static CompilationUnit Parse (ITextSource textSource, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default (CancellationToken))
+		public static SyntaxTree Parse (ITextSource textSource, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default (CancellationToken))
 		{
 			var parser = new CSharpParser (settings);
 			return parser.Parse (textSource, fileName, 0);

ICSharpCode.NRefactory.CSharp/Ast/old_ObservableAstVisitor.cs

@@ -42,9 +42,9 @@ namespace ICSharpCode.NRefactory.CSharp
 			return default (S);
 		}
 		
-		public event Action<CompilationUnit, T> CompilationUnitVisited;
+		public event Action<SyntaxTree, T> CompilationUnitVisited;
 	
-		S IAstVisitor<T, S>.VisitCompilationUnit (CompilationUnit unit, T data)
+		S IAstVisitor<T, S>.VisitSyntaxTree (SyntaxTree unit, T data)
 		{
 			var handler = CompilationUnitVisited;
 			if (handler != null)

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // CSharpCompletionEngine.cs
 //  
 // Author:
@@ -230,7 +230,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			return miniLexer.IsInPreprocessorDirective;
 		}
 		
-		IEnumerable<ICompletionData> HandleObjectInitializer(CompilationUnit unit, AstNode n)
+		IEnumerable<ICompletionData> HandleObjectInitializer(SyntaxTree unit, AstNode n)
 		{
 			var p = n.Parent;
 			while (p != null && !(p is ObjectCreateExpression)) {
@@ -1102,7 +1102,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				xp = GetExpressionAtCursor();
 			}
 			AstNode node;
-			CompilationUnit unit;
+			SyntaxTree unit;
 			Tuple<ResolveResult, CSharpResolver> rr;
 			if (xp != null) {
 				node = xp.Node;
@@ -2151,7 +2151,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				return null;
 			}
 			var exprParent = resolvedNode.GetParent<Expression>();
-			var unit = exprParent != null ? exprParent.GetParent<CompilationUnit>() : null;
+			var unit = exprParent != null ? exprParent.GetParent<SyntaxTree>() : null;
 			
 			var astResolver = unit != null ? CompletionContextProvider.GetResolver(state, unit) : null;
 			IType hintType = exprParent != null && astResolver != null ? 
@@ -2198,7 +2198,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			}
 		}
 		
-		IEnumerable<ICompletionData> CreateParameterCompletion(MethodGroupResolveResult resolveResult, CSharpResolver state, AstNode invocation, CompilationUnit unit, int parameter, bool controlSpace)
+		IEnumerable<ICompletionData> CreateParameterCompletion(MethodGroupResolveResult resolveResult, CSharpResolver state, AstNode invocation, SyntaxTree unit, int parameter, bool controlSpace)
 		{
 			var result = new CompletionDataWrapper(this);
 			var addedEnums = new HashSet<string>();
@@ -2520,7 +2520,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 		#region Parsing methods
 		ExpressionResult GetExpressionBeforeCursor()
 		{
-			CompilationUnit baseUnit;
+			SyntaxTree baseUnit;
 			if (currentMember == null) {
 				baseUnit = ParseStub("a", false);
 				var type = baseUnit.GetNodeAt<MemberType>(location);

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngineBase.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // CSharpCompletionEngineBase.cs
 //  
 // Author:
@@ -655,7 +655,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				wrapper.Append (';');
 		}
 
-		protected CompilationUnit ParseStub(string continuation, bool appendSemicolon = true, string afterContinuation = null)
+		protected SyntaxTree ParseStub(string continuation, bool appendSemicolon = true, string afterContinuation = null)
 		{
 			var mt = GetMemberTextToCaret();
 			if (mt == null) {
@@ -708,7 +708,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 		
 		protected ExpressionResult GetInvocationBeforeCursor(bool afterBracket)
 		{
-			CompilationUnit baseUnit;
+			SyntaxTree baseUnit;
 			baseUnit = ParseStub("a", false);
 			
 			var section = baseUnit.GetNodeAt<AttributeSection>(location.Line, location.Column - 2);
@@ -763,10 +763,10 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 		public class ExpressionResult
 		{
 			public AstNode Node { get; private set; }
-			public CompilationUnit Unit  { get; private set; }
+			public SyntaxTree Unit  { get; private set; }
 			
 			
-			public ExpressionResult (AstNode item2, CompilationUnit item3)
+			public ExpressionResult (AstNode item2, SyntaxTree item3)
 			{
 				this.Node = item2;
 				this.Unit = item3;
@@ -797,7 +797,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				resolveNode = expr;
 			}
 			try {
-				var root = expr.AncestorsAndSelf.FirstOrDefault(n => n is EntityDeclaration || n is CompilationUnit);
+				var root = expr.AncestorsAndSelf.FirstOrDefault(n => n is EntityDeclaration || n is SyntaxTree);
 				if (root == null) {
 					return null;
 				}

ICSharpCode.NRefactory.CSharp/Completion/CSharpParameterCompletionEngine.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // CSharpParameterCompletionEngine.cs
 //  
 // Author:
@@ -53,7 +53,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 
 		public ExpressionResult GetIndexerBeforeCursor()
 		{
-			CompilationUnit baseUnit;
+			SyntaxTree baseUnit;
 			if (currentMember == null && currentType == null) { 
 				return null;
 			}
@@ -73,7 +73,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 		
 		public ExpressionResult GetConstructorInitializerBeforeCursor()
 		{
-			CompilationUnit baseUnit;
+			SyntaxTree baseUnit;
 			if (currentMember == null && currentType == null) { 
 				return null;
 			}
@@ -88,7 +88,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 		
 		public ExpressionResult GetTypeBeforeCursor()
 		{
-			CompilationUnit baseUnit;
+			SyntaxTree baseUnit;
 			if (currentMember == null && currentType == null) { 
 				return null;
 			}

ICSharpCode.NRefactory.CSharp/Formatter/AstFormattingVisitor.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // AstFormattingVisitor.cs
 //
 // Author:
@@ -199,9 +199,9 @@ namespace ICSharpCode.NRefactory.CSharp
 			changes.Clear();
 		}
 
-		public override void VisitCompilationUnit(CompilationUnit unit)
+		public override void VisitSyntaxTree(SyntaxTree unit)
 		{
-			base.VisitCompilationUnit(unit);
+			base.VisitSyntaxTree(unit);
 		}
 
 		public void EnsureBlankLinesAfter(AstNode node, int blankLines)

ICSharpCode.NRefactory.CSharp/ICSharpCode.NRefactory.CSharp.csproj

@@ -90,7 +90,7 @@
     <Compile Include="Ast\AstType.cs" />
     <Compile Include="Ast\DocumentationReference.cs" />
     <Compile Include="Ast\IdentifierExpressionBackreference.cs" />
-    <Compile Include="Ast\CompilationUnit.cs" />
+    <Compile Include="Ast\SyntaxTree.cs" />
     <Compile Include="Ast\ComposedType.cs" />
     <Compile Include="Ast\CSharpModifierToken.cs" />
     <Compile Include="Ast\CSharpTokenNode.cs" />

ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpOutputVisitor.cs

@@ -2305,10 +2305,10 @@ namespace ICSharpCode.NRefactory.CSharp
 			EndNode(variableInitializer);
 		}
 		
-		public void VisitCompilationUnit(CompilationUnit compilationUnit)
+		public void VisitSyntaxTree(SyntaxTree syntaxTree)
 		{
 			// don't do node tracking as we visit all children directly
-			foreach (AstNode node in compilationUnit.Children) {
+			foreach (AstNode node in syntaxTree.Children) {
 				node.AcceptVisitor(this);
 			}
 		}

ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs

@@ -60,24 +60,24 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		/// <summary>
-		/// Converts a compilation unit to CodeDom.
+		/// Converts a syntax tree to CodeDom.
 		/// </summary>
-		/// <param name="compilationUnit">The input compilation unit.</param>
+		/// <param name="syntaxTree">The input syntax tree.</param>
 		/// <param name="compilation">The current compilation.</param>
 		/// <param name="parsedFile">CSharpParsedFile, used for resolving.</param>
 		/// <returns>Converted CodeCompileUnit</returns>
 		/// <remarks>
 		/// This conversion process requires a resolver because it needs to distinguish field/property/event references etc.
 		/// </remarks>
-		public CodeCompileUnit Convert(ICompilation compilation, CompilationUnit compilationUnit, CSharpParsedFile parsedFile)
+		public CodeCompileUnit Convert(ICompilation compilation, SyntaxTree syntaxTree, CSharpParsedFile parsedFile)
 		{
-			if (compilationUnit == null)
-				throw new ArgumentNullException("compilationUnit");
+			if (syntaxTree == null)
+				throw new ArgumentNullException("syntaxTree");
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
 			
-			CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
-			return (CodeCompileUnit)Convert(compilationUnit, resolver);
+			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, parsedFile);
+			return (CodeCompileUnit)Convert(syntaxTree, resolver);
 		}
 		
 		/// <summary>
@@ -1236,10 +1236,10 @@ namespace ICSharpCode.NRefactory.CSharp
 			throw new NotSupportedException(); // should be handled by the parent node
 		}
 		
-		CodeObject IAstVisitor<CodeObject>.VisitCompilationUnit(CompilationUnit compilationUnit)
+		CodeObject IAstVisitor<CodeObject>.VisitSyntaxTree(SyntaxTree syntaxTree)
 		{
 			CodeCompileUnit cu = new CodeCompileUnit();
-			foreach (AstNode node in compilationUnit.Children) {
+			foreach (AstNode node in syntaxTree.Children) {
 				CodeObject o = node.AcceptVisitor(this);
 				
 				CodeNamespace ns = o as CodeNamespace;

ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs

@@ -40,10 +40,10 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		class ConversionVisitor : StructuralVisitor
 		{
-			CompilationUnit unit = new CompilationUnit ();
+			SyntaxTree unit = new SyntaxTree ();
 			internal bool convertTypeSystemMode;
 			
-			public CompilationUnit Unit {
+			public SyntaxTree Unit {
 				get {
 					return unit;
 				}
@@ -668,7 +668,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				if (namespaceStack.Count > 0) {
 					namespaceStack.Peek ().AddChild (child, NamespaceDeclaration.MemberRole);
 				} else {
-					unit.AddChild (child, CompilationUnit.MemberRole);
+					unit.AddChild (child, SyntaxTree.MemberRole);
 				}
 			}
 			
@@ -3709,12 +3709,12 @@ namespace ICSharpCode.NRefactory.CSharp
 			get { return errorReportPrinter.Errors; }
 		}
 		
-		public CompilationUnit Parse (ITextSource textSource, string fileName, int lineModifier = 0)
+		public SyntaxTree Parse (ITextSource textSource, string fileName, int lineModifier = 0)
 		{
 			return Parse (textSource.CreateReader (), fileName, lineModifier);
 		}
 		
-		public CompilationUnit Parse (TextReader reader, string fileName, int lineModifier = 0)
+		public SyntaxTree Parse (TextReader reader, string fileName, int lineModifier = 0)
 		{
 			// TODO: can we optimize this to avoid the text->stream->text roundtrip?
 			using (MemoryStream stream = new MemoryStream ()) {
@@ -3730,7 +3730,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 
-		public CompilationUnit Parse(CompilerCompilationUnit top, string fileName, int lineModifier = 0)
+		public SyntaxTree Parse(CompilerCompilationUnit top, string fileName, int lineModifier = 0)
 		{
 			if (top == null) {
 				return null;
@@ -3769,14 +3769,14 @@ namespace ICSharpCode.NRefactory.CSharp
 			set;
 		}
 		
-		public CompilationUnit Parse (string program, string fileName)
+		public SyntaxTree Parse (string program, string fileName)
 		{
 			return Parse (new StringReader (program), fileName);
 		}
 		
 		internal static object parseLock = new object ();
 		
-		public CompilationUnit Parse(Stream stream, string fileName, int lineModifier = 0)
+		public SyntaxTree Parse(Stream stream, string fileName, int lineModifier = 0)
 		{
 			lock (parseLock) {
 				errorReportPrinter = new ErrorReportPrinter ("");
@@ -3864,7 +3864,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		/// <summary>
-		/// Parses a file snippet; guessing what the code snippet represents (compilation unit, type members, block, type reference, expression).
+		/// Parses a file snippet; guessing what the code snippet represents (whole file, type members, block, type reference, expression).
 		/// </summary>
 		public AstNode ParseSnippet (TextReader reader)
 		{

ICSharpCode.NRefactory.CSharp/Refactoring/CodeActions/InlineLocalVariableAction.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // InlineLocalVariableAction.cs
 //  
 // Author:
@@ -53,7 +53,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			if (resolveResult == null || resolveResult.IsError) {
 				yield break;
 			}
-			var unit = context.RootNode as CompilationUnit;
+			var unit = context.RootNode as SyntaxTree;
 			if (unit == null) {
 				yield break;
 			}

ICSharpCode.NRefactory.CSharp/Refactoring/DocumentScript.cs

@@ -98,7 +98,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		public override void FormatText(AstNode node)
 		{
 			var segment = GetSegment(node);
-			var cu = CompilationUnit.Parse(currentDocument, "dummy.cs");
+			var cu = SyntaxTree.Parse(currentDocument, "dummy.cs");
 			var formatter = new AstFormattingVisitor(FormattingOptions, currentDocument, Options);
 			cu.AcceptVisitor(formatter);
 			formatter.ApplyChanges(segment.Offset, segment.Length);

ICSharpCode.NRefactory.CSharp/Refactoring/ICodeIssueProvider.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // IInspector.cs
 //  
 // Author:
@@ -29,12 +29,12 @@ using System.Collections.Generic;
 namespace ICSharpCode.NRefactory.CSharp.Refactoring
 {
 	/// <summary>
-	/// The code issue provider gets a list of all code issues in a compilation unit.
+	/// The code issue provider gets a list of all code issues in a syntax tree.
 	/// </summary>
 	public interface ICodeIssueProvider
 	{
 		/// <summary>
-		/// Gets all code issues inside a compilation unit.
+		/// Gets all code issues inside a syntax tree.
 		/// </summary>
 		/// <param name='context'>
 		/// The refactoring context of the issues to get.

ICSharpCode.NRefactory.CSharp/Resolver/CSharpAstResolver.cs

@@ -42,7 +42,7 @@ namespace ICSharpCode.NRefactory.CSharp.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="syntaxTree">The syntax tree corresponding to the specified parsed file.</param>
 		/// <param name="parsedFile">
 		/// Optional: Result of the <see cref="TypeSystemConvertVisitor"/> for the file being resolved.
 		/// <para>
@@ -55,14 +55,14 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// member's signature in the AST with the signature in the type system.
 		/// </para>
 		/// </param>
-		public CSharpAstResolver(ICompilation compilation, CompilationUnit compilationUnit, CSharpParsedFile parsedFile = null)
+		public CSharpAstResolver(ICompilation compilation, SyntaxTree syntaxTree, CSharpParsedFile parsedFile = null)
 		{
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
-			if (compilationUnit == null)
-				throw new ArgumentNullException("compilationUnit");
+			if (syntaxTree == null)
+				throw new ArgumentNullException("syntaxTree");
 			this.initialResolverState = new CSharpResolver(compilation);
-			this.rootNode = compilationUnit;
+			this.rootNode = syntaxTree;
 			this.parsedFile = parsedFile;
 			this.resolveVisitor = new ResolveVisitor(initialResolverState, parsedFile);
 		}
@@ -71,7 +71,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// Creates a new C# AST resolver.
 		/// Use this overload if you are resolving code snippets (not necessarily complete files).
 		/// </summary>
-		/// <param name="resolver">The resolver state at the root node (to be more precise: outside the root node).</param>
+		/// <param name="resolver">The resolver state at the root node (to be more precise: just outside the root node).</param>
 		/// <param name="rootNode">The root node of the resolved tree.</param>
 		/// <param name="parsedFile">
 		/// Optional: Result of the <see cref="TypeSystemConvertVisitor"/> for the file being resolved.

ICSharpCode.NRefactory.CSharp/Resolver/DetectSkippableNodesNavigator.cs

@@ -25,7 +25,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 {
 	/// <summary>
 	/// When an <see cref="IResolveVisitorNavigator"/> is searching for specific nodes
-	/// (e.g. all IdentifierExpressions), it has to scan the whole compilation unit for those nodes.
+	/// (e.g. all IdentifierExpressions), it has to scan the whole syntax tree for those nodes.
 	/// However, scanning in the ResolveVisitor is expensive (e.g. any lambda that is scanned must be resolved),
 	/// so it makes sense to detect when a whole subtree is scan-only, and skip that tree instead.
 	/// 

ICSharpCode.NRefactory.CSharp/Resolver/FindReferences.cs

@@ -353,16 +353,16 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// </summary>
 		/// <param name="searchScope">The search scope for which to look.</param>
 		/// <param name="parsedFile">The type system representation of the file being searched.</param>
-		/// <param name="compilationUnit">The compilation unit of the file being searched.</param>
+		/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
 		/// <param name="compilation">The compilation for the project that contains the file.</param>
 		/// <param name="callback">Callback used to report the references that were found.</param>
 		/// <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
-		public void FindReferencesInFile(IFindReferenceSearchScope searchScope, CSharpParsedFile parsedFile, CompilationUnit compilationUnit,
+		public void FindReferencesInFile(IFindReferenceSearchScope searchScope, CSharpParsedFile parsedFile, SyntaxTree syntaxTree,
 		                                 ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
 		{
 			if (searchScope == null)
 				throw new ArgumentNullException("searchScope");
-			FindReferencesInFile(new[] { searchScope }, parsedFile, compilationUnit, compilation, callback, cancellationToken);
+			FindReferencesInFile(new[] { searchScope }, parsedFile, syntaxTree, compilation, callback, cancellationToken);
 		}
 		
 		/// <summary>
@@ -370,19 +370,19 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// </summary>
 		/// <param name="searchScopes">The search scopes for which to look.</param>
 		/// <param name="parsedFile">The type system representation of the file being searched.</param>
-		/// <param name="compilationUnit">The compilation unit of the file being searched.</param>
+		/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
 		/// <param name="compilation">The compilation for the project that contains the file.</param>
 		/// <param name="callback">Callback used to report the references that were found.</param>
 		/// <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
-		public void FindReferencesInFile(IList<IFindReferenceSearchScope> searchScopes, CSharpParsedFile parsedFile, CompilationUnit compilationUnit,
+		public void FindReferencesInFile(IList<IFindReferenceSearchScope> searchScopes, CSharpParsedFile parsedFile, SyntaxTree syntaxTree,
 		                                 ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
 		{
 			if (searchScopes == null)
 				throw new ArgumentNullException("searchScopes");
 			if (parsedFile == null)
 				throw new ArgumentNullException("parsedFile");
-			if (compilationUnit == null)
-				throw new ArgumentNullException("compilationUnit");
+			if (syntaxTree == null)
+				throw new ArgumentNullException("syntaxTree");
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
 			if (callback == null)
@@ -402,9 +402,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 			
 			cancellationToken.ThrowIfCancellationRequested();
-			combinedNavigator = new DetectSkippableNodesNavigator(combinedNavigator, compilationUnit);
+			combinedNavigator = new DetectSkippableNodesNavigator(combinedNavigator, syntaxTree);
 			cancellationToken.ThrowIfCancellationRequested();
-			CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
+			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, parsedFile);
 			resolver.ApplyNavigator(combinedNavigator, cancellationToken);
 			foreach (var n in navigators) {
 				var frn = n as FindReferenceNavigator;
@@ -1172,18 +1172,18 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// </summary>
 		/// <param name="variable">The variable for which to look.</param>
 		/// <param name="parsedFile">The type system representation of the file being searched.</param>
-		/// <param name="compilationUnit">The compilation unit of the file being searched.</param>
+		/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
 		/// <param name="compilation">The compilation.</param>
 		/// <param name="callback">Callback used to report the references that were found.</param>
 		/// <param name="cancellationToken">Cancellation token that may be used to cancel the operation.</param>
-		public void FindLocalReferences(IVariable variable, CSharpParsedFile parsedFile, CompilationUnit compilationUnit,
+		public void FindLocalReferences(IVariable variable, CSharpParsedFile parsedFile, SyntaxTree syntaxTree,
 		                                ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
 		{
 			if (variable == null)
 				throw new ArgumentNullException("variable");
 			var searchScope = new SearchScope(c => new FindLocalReferencesNavigator(variable));
 			searchScope.declarationCompilation = compilation;
-			FindReferencesInFile(searchScope, parsedFile, compilationUnit, compilation, callback, cancellationToken);
+			FindReferencesInFile(searchScope, parsedFile, syntaxTree, compilation, callback, cancellationToken);
 		}
 		
 		class FindLocalReferencesNavigator : FindReferenceNavigator
@@ -1226,11 +1226,11 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// </summary>
 		/// <param name="typeParameter">The type parameter for which to look.</param>
 		/// <param name="parsedFile">The type system representation of the file being searched.</param>
-		/// <param name="compilationUnit">The compilation unit of the file being searched.</param>
+		/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
 		/// <param name="compilation">The compilation.</param>
 		/// <param name="callback">Callback used to report the references that were found.</param>
 		/// <param name="cancellationToken">Cancellation token that may be used to cancel the operation.</param>
-		public void FindTypeParameterReferences(IType typeParameter, CSharpParsedFile parsedFile, CompilationUnit compilationUnit,
+		public void FindTypeParameterReferences(IType typeParameter, CSharpParsedFile parsedFile, SyntaxTree syntaxTree,
 		                                ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
 		{
 			if (typeParameter == null)
@@ -1240,7 +1240,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			var searchScope = new SearchScope(c => new FindTypeParameterReferencesNavigator((ITypeParameter)typeParameter));
 			searchScope.declarationCompilation = compilation;
 			searchScope.accessibility = Accessibility.Private;
-			FindReferencesInFile(searchScope, parsedFile, compilationUnit, compilation, callback, cancellationToken);
+			FindReferencesInFile(searchScope, parsedFile, syntaxTree, compilation, callback, cancellationToken);
 		}
 		
 		class FindTypeParameterReferencesNavigator : FindReferenceNavigator

ICSharpCode.NRefactory.CSharp/Resolver/ResolveAtLocation.cs

@@ -30,24 +30,24 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	/// </summary>
 	public static class ResolveAtLocation
 	{
-		public static ResolveResult Resolve (ICompilation compilation, CSharpParsedFile parsedFile, CompilationUnit cu, TextLocation location,
+		public static ResolveResult Resolve (ICompilation compilation, CSharpParsedFile parsedFile, SyntaxTree cu, TextLocation location,
 		                                    CancellationToken cancellationToken = default(CancellationToken))
 		{
 			return Resolve (new Lazy<ICompilation>(() => compilation), parsedFile, cu, location, cancellationToken);
 		}
-		public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpParsedFile parsedFile, CompilationUnit cu, TextLocation location,
+		public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpParsedFile parsedFile, SyntaxTree cu, TextLocation location,
 		                                    CancellationToken cancellationToken = default(CancellationToken))
 		{
 			AstNode node;
 			return Resolve(compilation, parsedFile, cu, location, out node, cancellationToken);
 		}
 		
-		public static ResolveResult Resolve (ICompilation compilation, CSharpParsedFile parsedFile, CompilationUnit cu, TextLocation location, out AstNode node,
+		public static ResolveResult Resolve (ICompilation compilation, CSharpParsedFile parsedFile, SyntaxTree cu, TextLocation location, out AstNode node,
 		                                    CancellationToken cancellationToken = default(CancellationToken))
 		{
 			return Resolve (new Lazy<ICompilation>(() => compilation), parsedFile, cu, location, out node, cancellationToken);
 		}
-		public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpParsedFile parsedFile, CompilationUnit cu, TextLocation location, out AstNode node,
+		public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpParsedFile parsedFile, SyntaxTree cu, TextLocation location, out AstNode node,
 		                                    CancellationToken cancellationToken = default(CancellationToken))
 		{
 			node = cu.GetNodeAt(location);

ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

@@ -93,16 +93,6 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// <summary>
 		/// Creates a new ResolveVisitor instance.
 		/// </summary>
-		/// <param name="resolver">
-		/// The CSharpResolver, describing the initial resolve context.
-		/// If you visit a whole CompilationUnit with the resolve visitor, you can simply pass
-		/// <c>new CSharpResolver(typeResolveContext)</c> without setting up the context.
-		/// If you only visit a subtree, you need to pass a CSharpResolver initialized to the context for that subtree.
-		/// </param>
-		/// <param name="parsedFile">
-		/// Result of the <see cref="TypeSystemConvertVisitor"/> for the file being passed. This is used for setting up the context on the resolver.
-		/// You may pass <c>null</c> if you are only visiting a part of a method body and have already set up the context in the <paramref name="resolver"/>.
-		/// </param>
 		public ResolveVisitor(CSharpResolver resolver, CSharpParsedFile parsedFile)
 		{
 			if (resolver == null)
@@ -210,7 +200,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// Equivalent to 'Scan', but also resolves the node at the same time.
 		/// This method should be only used if the CSharpResolver passed to the ResolveVisitor was manually set
 		/// to the correct state.
-		/// Otherwise, use <c>resolver.Scan(compilationUnit); var result = resolver.GetResolveResult(node);</c>
+		/// Otherwise, use <c>resolver.Scan(syntaxTree); var result = resolver.GetResolveResult(node);</c>
 		/// instead.
 		/// --
 		/// This method now is internal, because it is difficult to use correctly.
@@ -531,7 +521,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		#endregion
 		
 		#region Track UsingScope
-		ResolveResult IAstVisitor<ResolveResult>.VisitCompilationUnit(CompilationUnit unit)
+		ResolveResult IAstVisitor<ResolveResult>.VisitSyntaxTree(SyntaxTree unit)
 		{
 			CSharpResolver previousResolver = resolver;
 			try {

ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs

@@ -120,10 +120,10 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 		}
 		
 		#region Compilation Unit
-		public override IUnresolvedEntity VisitCompilationUnit (CompilationUnit unit)
+		public override IUnresolvedEntity VisitSyntaxTree (SyntaxTree unit)
 		{
 			parsedFile.Errors = unit.Errors;
-			return base.VisitCompilationUnit (unit);
+			return base.VisitSyntaxTree (unit);
 		}
 		#endregion
 		

ICSharpCode.NRefactory.ConsistencyCheck/CSharpProject.cs

@@ -158,7 +158,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 		
 		public readonly ITextSource Content;
 		public readonly int LinesOfCode;
-		public CompilationUnit CompilationUnit;
+		public SyntaxTree SyntaxTree;
 		public CSharpParsedFile ParsedFile;
 		
 		public CSharpFile(CSharpProject project, string fileName)
@@ -169,14 +169,14 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			this.LinesOfCode = 1 + this.Content.Text.Count(c => c == '\n');
 			
 			CSharpParser p = new CSharpParser(project.CompilerSettings);
-			this.CompilationUnit = p.Parse(Content.CreateReader(), fileName);
+			this.SyntaxTree = p.Parse(Content.CreateReader(), fileName);
 			if (p.HasErrors) {
 				Console.WriteLine("Error parsing " + fileName + ":");
 				foreach (var error in p.ErrorsAndWarnings) {
 					Console.WriteLine("  " + error.Region + " " + error.Message);
 				}
 			}
-			this.ParsedFile = this.CompilationUnit.ToTypeSystem();
+			this.ParsedFile = this.SyntaxTree.ToTypeSystem();
 		}
 	}
 }

ICSharpCode.NRefactory.ConsistencyCheck/FindReferencesConsistencyCheck.cs

@@ -59,7 +59,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 							}
 						}
 					);
-					var resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile);
+					var resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.ParsedFile);
 					resolver.ApplyNavigator(navigator);
 				}
 			}
@@ -114,7 +114,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 					}
 				}
 				foreach (var file in interestingFiles) {
-					fr.FindReferencesInFile(searchScopes, file.ParsedFile, file.CompilationUnit, project.Compilation,
+					fr.FindReferencesInFile(searchScopes, file.ParsedFile, file.SyntaxTree, project.Compilation,
 					                        delegate(AstNode node, ResolveResult result) {
 					                        	foundReferences.Add(node);
 					                        }, CancellationToken.None);

ICSharpCode.NRefactory.ConsistencyCheck/Program.cs

@@ -57,7 +57,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			                  solution.AllFiles.Count(),
 			                  solution.Projects.Count);
 			
-			VisitorBenchmark.Run(solution.AllFiles.Select(f => f.CompilationUnit));
+			VisitorBenchmark.Run(solution.AllFiles.Select(f => f.SyntaxTree));
 			
 			using (new Timer("ID String test... ")) TypeSystemTests.IDStringConsistencyCheck(solution);
 			using (new Timer("Resolve unresolved members... ")) TypeSystemTests.ResolvedUnresolvedMembers(solution);

ICSharpCode.NRefactory.ConsistencyCheck/RandomizedOrderResolverTest.cs

@@ -45,9 +45,9 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			Random rnd = new Random(seed);
 			var test = new RandomizedOrderResolverTest();
 			// Resolve all nodes, but in a random order without using a navigator.
-			test.resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile);
+			test.resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.ParsedFile);
 			// For comparing whether the results are equivalent, we also use a normal 'resolve all' resolver:
-			test.resolveAllResolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile);
+			test.resolveAllResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.ParsedFile);
 			test.resolveAllResolver.ApplyNavigator(new ResolveAllNavigator(), CancellationToken.None);
 			// Prepare list of actions that we need to verify:
 			var actions = new List<Func<bool>>();
@@ -56,7 +56,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			bool checkStateAfter = rnd.Next(0, 2) == 0;
 			bool checkConversion = rnd.Next(0, 2) == 0;
 			bool checkExpectedType = rnd.Next(0, 2) == 0;
-			foreach (var _node in file.CompilationUnit.DescendantsAndSelf) {
+			foreach (var _node in file.SyntaxTree.DescendantsAndSelf) {
 				var node = _node;
 				if (CSharpAstResolver.IsUnresolvableNode(node))
 					continue;

ICSharpCode.NRefactory.ConsistencyCheck/ResolverTest.cs

@@ -35,10 +35,10 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 	{
 		public static void RunTest(CSharpFile file)
 		{
-			CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile);
+			CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.ParsedFile);
 			var navigator = new ValidatingResolveAllNavigator(file.FileName);
 			resolver.ApplyNavigator(navigator, CancellationToken.None);
-			navigator.Validate(resolver, file.CompilationUnit);
+			navigator.Validate(resolver, file.SyntaxTree);
 		}
 		
 		class ValidatingResolveAllNavigator : IResolveVisitorNavigator
@@ -88,7 +88,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 				}
 			}
 			
-			public virtual void Validate(CSharpAstResolver resolver, CompilationUnit cu)
+			public virtual void Validate(CSharpAstResolver resolver, SyntaxTree cu)
 			{
 				foreach (AstNode node in cu.DescendantsAndSelf.Except(resolvedNodes.Keys)) {
 					if (!CSharpAstResolver.IsUnresolvableNode(node)) {
@@ -104,13 +104,13 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 		
 		public static void RunTestWithoutParsedFile(CSharpFile file)
 		{
-			CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit);
+			CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree);
 			var navigator = new ValidatingResolveAllNavigator(file.FileName);
 			resolver.ApplyNavigator(navigator, CancellationToken.None);
-			navigator.Validate(resolver, file.CompilationUnit);
+			navigator.Validate(resolver, file.SyntaxTree);
 			
-			CSharpAstResolver originalResolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile);
-			foreach (var node in file.CompilationUnit.DescendantsAndSelf) {
+			CSharpAstResolver originalResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.ParsedFile);
+			foreach (var node in file.SyntaxTree.DescendantsAndSelf) {
 				var originalResult = originalResolver.Resolve(node);
 				var result = resolver.Resolve(node);
 				if (!RandomizedOrderResolverTest.IsEqualResolveResult(result, originalResult)) {

ICSharpCode.NRefactory.ConsistencyCheck/RoundtripTest.cs

@@ -63,7 +63,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 		public static void Roundtrip(CSharpParser parser, string fileName, string code)
 		{
 			// 1. Parse
-			CompilationUnit cu = parser.Parse(code, fileName);
+			SyntaxTree cu = parser.Parse(code, fileName);
 			if (parser.HasErrors)
 				throw new InvalidOperationException("There were parse errors.");
 			
@@ -94,7 +94,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 				throw new InvalidOperationException(@"Got lone \r in " + fileName);
 			
 			// 4. Parse generated output
-			CompilationUnit generatedCU;
+			SyntaxTree generatedCU;
 			try {
 				generatedCU = parser.Parse(generatedCode, fileName);
 			} catch {

ICSharpCode.NRefactory.ConsistencyCheck/VisitorBenchmark.cs

@@ -26,11 +26,11 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 {
 	/// <summary>
 	/// Determines the fastest way to retrieve a List{IdentifierExpression} of all identifiers
-	/// in a compilation unit.
+	/// in a syntax tree.
 	/// </summary>
 	public class VisitorBenchmark
 	{
-		public static void Run(IEnumerable<CompilationUnit> files)
+		public static void Run(IEnumerable<SyntaxTree> files)
 		{
 			files = files.ToList();
 			
@@ -125,7 +125,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			}
 		}
 		
-		static void RunTest(string text, IEnumerable<CompilationUnit> files, Action<CompilationUnit, List<IdentifierExpression>> action)
+		static void RunTest(string text, IEnumerable<SyntaxTree> files, Action<SyntaxTree, List<IdentifierExpression>> action)
 		{
 			// validation:
 			var list = new List<IdentifierExpression>();

ICSharpCode.NRefactory.Demo/CSDemo.cs

@@ -61,14 +61,14 @@ namespace ICSharpCode.NRefactory.Demo
 			}
 		}
 		
-		CompilationUnit compilationUnit;
+		SyntaxTree syntaxTree;
 		
 		void CSharpParseButtonClick(object sender, EventArgs e)
 		{
 			CSharpParser parser = new CSharpParser();
-			compilationUnit = parser.Parse(new StringReader(csharpCodeTextBox.Text), "dummy.cs");
+			syntaxTree = parser.Parse(new StringReader(csharpCodeTextBox.Text), "dummy.cs");
 			csharpTreeView.Nodes.Clear();
-			foreach (var element in compilationUnit.Children) {
+			foreach (var element in syntaxTree.Children) {
 				csharpTreeView.Nodes.Add(MakeTreeNode(element));
 			}
 			SelectCurrentNode(csharpTreeView.Nodes);
@@ -147,7 +147,7 @@ namespace ICSharpCode.NRefactory.Demo
 		
 		void CSharpGenerateCodeButtonClick(object sender, EventArgs e)
 		{
-			csharpCodeTextBox.Text = compilationUnit.GetText();
+			csharpCodeTextBox.Text = syntaxTree.GetText();
 		}
 		
 		int GetOffset(TextBox textBox, TextLocation location)
@@ -205,7 +205,7 @@ namespace ICSharpCode.NRefactory.Demo
 		void ResolveButtonClick(object sender, EventArgs e)
 		{
 			IProjectContent project = new CSharpProjectContent();
-			var parsedFile = compilationUnit.ToTypeSystem();
+			var parsedFile = syntaxTree.ToTypeSystem();
 			project = project.UpdateProjectContent(null, parsedFile);
 			project = project.AddAssemblyReferences(builtInLibs.Value);
 			
@@ -214,12 +214,12 @@ namespace ICSharpCode.NRefactory.Demo
 			ResolveResult result;
 			if (csharpTreeView.SelectedNode != null) {
 				var selectedNode = (AstNode)csharpTreeView.SelectedNode.Tag;
-				CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
+				CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, parsedFile);
 				result = resolver.Resolve(selectedNode);
 				// CSharpAstResolver.Resolve() never returns null
 			} else {
 				TextLocation location = GetTextLocation(csharpCodeTextBox, csharpCodeTextBox.SelectionStart);
-				result = ResolveAtLocation.Resolve(compilation, parsedFile, compilationUnit, location);
+				result = ResolveAtLocation.Resolve(compilation, parsedFile, syntaxTree, location);
 				if (result == null) {
 					MessageBox.Show("Could not find a resolvable node at the caret location.");
 					return;
@@ -249,12 +249,12 @@ namespace ICSharpCode.NRefactory.Demo
 				return;
 			
 			IProjectContent project = new CSharpProjectContent();
-			var parsedFile = compilationUnit.ToTypeSystem();
+			var parsedFile = syntaxTree.ToTypeSystem();
 			project = project.UpdateProjectContent(null, parsedFile);
 			project = project.AddAssemblyReferences(builtInLibs.Value);
 			
 			ICompilation compilation = project.CreateCompilation();
-			CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
+			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, parsedFile);
 			
 			AstNode node = (AstNode)csharpTreeView.SelectedNode.Tag;
 			IEntity entity;
@@ -277,7 +277,7 @@ namespace ICSharpCode.NRefactory.Demo
 			
 			var searchScopes = fr.GetSearchScopes(entity);
 			Debug.WriteLine("Find references to " + entity.ReflectionName);
-			fr.FindReferencesInFile(searchScopes, parsedFile, compilationUnit, compilation, callback, CancellationToken.None);
+			fr.FindReferencesInFile(searchScopes, parsedFile, syntaxTree, compilation, callback, CancellationToken.None);
 			
 			MessageBox.Show("Found " + referenceCount + " references to " + entity.FullName);
 		}

ICSharpCode.NRefactory.GtkDemo/MainWindow.cs

@@ -46,7 +46,7 @@ namespace ICSharpCode.NRefactory.GtkDemo
 		TreeStore store = new TreeStore (typeof (string), typeof (string), typeof (AstNode), typeof (Pixbuf));
 		Dictionary<AstNode, TreeIter> iterDict = new Dictionary<AstNode, TreeIter> ();
 //		TextEditor editor = new TextEditor ();
-		CompilationUnit unit;
+		SyntaxTree unit;
 		
 		Pixbuf comment = new Pixbuf (typeof (MainWindow).Assembly, "comment.png");
 		Pixbuf classPixbuf = new Pixbuf (typeof (MainWindow).Assembly, "class.png");
@@ -129,7 +129,7 @@ namespace ICSharpCode.NRefactory.GtkDemo
 		}
 
 
-		public void ShowUnit (CompilationUnit unit, CSharpAstResolver visitor)
+		public void ShowUnit (SyntaxTree unit, CSharpAstResolver visitor)
 		{
 			this.unit = unit;
 			store.Clear ();

ICSharpCode.NRefactory.Tests/CSharp/CSharpOutputVisitorTests.cs

@@ -47,7 +47,7 @@ namespace ICSharpCode.NRefactory.CSharp
 	}
 }
 ";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			AssertOutput("class Test\n{\n$void Foo ()\n${\n$$Action<int> act = delegate (int testMe) {\n$$};\n$}\n}\n", unit);
 		}
 		

ICSharpCode.NRefactory.Tests/CSharp/CodeActions/TestRefactoringContext.cs

@@ -159,7 +159,7 @@ namespace ICSharpCode.NRefactory.CSharp.CodeActions
 				FindReferences refFinder = new FindReferences ();
 				refFinder.FindReferencesInFile (refFinder.GetSearchScopes (entity), 
 				                               context.ParsedFile, 
-				                               context.RootNode as CompilationUnit, 
+				                               context.RootNode as SyntaxTree, 
 				                               context.Compilation, (n, r) => Rename (n, name), 
 				                               context.CancellationToken);
 			}
@@ -169,7 +169,7 @@ namespace ICSharpCode.NRefactory.CSharp.CodeActions
 				FindReferences refFinder = new FindReferences ();
 				refFinder.FindLocalReferences (variable, 
 				                               context.ParsedFile, 
-				                               context.RootNode as CompilationUnit, 
+				                               context.RootNode as SyntaxTree, 
 				                               context.Compilation, (n, r) => Rename (n, name), 
 				                               context.CancellationToken);
 			}
@@ -179,7 +179,7 @@ namespace ICSharpCode.NRefactory.CSharp.CodeActions
 				FindReferences refFinder = new FindReferences ();
 				refFinder.FindTypeParameterReferences (type, 
 				                               context.ParsedFile, 
-				                               context.RootNode as CompilationUnit, 
+				                               context.RootNode as SyntaxTree, 
 				                               context.Compilation, (n, r) => Rename (n, name), 
 				                               context.CancellationToken);
 			}

ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/CodeCompletionBugTests.cs

@@ -1,4 +1,4 @@
-//
+//
 // CodeCompletionBugTests.cs
 //
 // Author:
@@ -222,10 +222,10 @@ namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 
 			pctx = pctx.AddAssemblyReferences(refs);
 
-			var compilationUnit = new CSharpParser().Parse(parsedText, "program.cs");
-			compilationUnit.Freeze();
+			var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs");
+			syntaxTree.Freeze();
 
-			var parsedFile = compilationUnit.ToTypeSystem();
+			var parsedFile = syntaxTree.ToTypeSystem();
 			pctx = pctx.UpdateProjectContent(null, parsedFile);
 
 			var cmp = pctx.CreateCompilation();
@@ -265,12 +265,12 @@ namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 			};
 		}
 		
-		Tuple<ReadOnlyDocument, CSharpCompletionEngine> GetContent(string text, CompilationUnit compilationUnit)
+		Tuple<ReadOnlyDocument, CSharpCompletionEngine> GetContent(string text, SyntaxTree syntaxTree)
 		{
 			var doc = new ReadOnlyDocument(text);
 			IProjectContent pctx = new CSharpProjectContent();
 			pctx = pctx.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore });
-			var parsedFile = compilationUnit.ToTypeSystem();
+			var parsedFile = syntaxTree.ToTypeSystem();
 			
 			pctx = pctx.UpdateProjectContent(null, parsedFile);
 			var cmp = pctx.CreateCompilation();
@@ -282,7 +282,7 @@ namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 			return Tuple.Create (doc, engine);
 		}
 		
-		static CompletionDataList CreateProvider (string text, CompilationUnit compilationUnit, CSharpCompletionEngine engine, ReadOnlyDocument doc, TextLocation loc)
+		static CompletionDataList CreateProvider (string text, SyntaxTree syntaxTree, CSharpCompletionEngine engine, ReadOnlyDocument doc, TextLocation loc)
 		{
 			var cursorPosition = doc.GetOffset (loc);
 			

ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/ParameterCompletionTests.cs

@@ -1,4 +1,4 @@
-//
+//
 // ParameterCompletionTests.cs
 //
 // Author:
@@ -272,10 +272,10 @@ namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 			IProjectContent pctx = new CSharpProjectContent();
 			pctx = pctx.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore });
 			
-			var compilationUnit = new CSharpParser().Parse(parsedText, "program.cs");
-			compilationUnit.Freeze();
+			var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs");
+			syntaxTree.Freeze();
 			
-			var parsedFile = compilationUnit.ToTypeSystem();
+			var parsedFile = syntaxTree.ToTypeSystem();
 			pctx = pctx.UpdateProjectContent(null, parsedFile);
 			var cmp = pctx.CreateCompilation();
 			var loc = doc.GetLocation(cursorPosition);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Bugs/ParserBugTests.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // ParserBugTests.cs
 //  
 // Author:
@@ -53,7 +53,7 @@ class Foo
     {
     }
 }";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			var type = unit.Members.First() as TypeDeclaration;
 			var constructor = type.Members.Skip(1).First() as ConstructorDeclaration;
 			var passed = !constructor.HasModifier(Modifiers.Override);
@@ -78,7 +78,7 @@ class Stub
         return new Test ()
     }
 }";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			var type = unit.Members.First() as TypeDeclaration;
 			var method = type.Members.First() as MethodDeclaration;
 			bool passed = method.Body.Statements.FirstOrDefault() is ReturnStatement;
@@ -102,7 +102,7 @@ class TestClass
   {
   }
 }";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			var type = unit.Members.First() as TypeDeclaration;
 			var constructor = type.Members.First() as ConstructorDeclaration;
@@ -131,7 +131,7 @@ class Foo
 		Test(new Foo (
 	}
 }";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			var type = unit.Members.First() as TypeDeclaration;
 			var method = type.Members.First() as MethodDeclaration;
@@ -157,7 +157,7 @@ class Foo
 		for (int i = 0; i < foo.bar)
 	}
 }";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			bool passed = @"class Foo
 {
@@ -187,7 +187,7 @@ class Foo
 		a = cond ? expr
 	}
 }";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			var type = unit.Members.First() as TypeDeclaration;
 			var method = type.Members.First() as MethodDeclaration;
@@ -213,7 +213,7 @@ class Foo
 		a = cond ? expr :
 	}
 }";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			var type = unit.Members.First() as TypeDeclaration;
 			var method = type.Members.First() as MethodDeclaration;
@@ -242,7 +242,7 @@ class Foo
         string str = 
     }
 }";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			var type = unit.Members.First() as TypeDeclaration;
 			var method = type.Members.First() as MethodDeclaration;
@@ -269,7 +269,7 @@ class Foo
 		} catch (Exception name)
 	}
 }";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			var type = unit.Members.First() as TypeDeclaration;
 			var method = type.Members.First() as MethodDeclaration;
@@ -300,7 +300,7 @@ class Test
     }
 }
 ";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			bool passed = unit.GetText().Trim() == @"using System;
 class Test
@@ -336,7 +336,7 @@ class Foo
     }
 }
 ";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			var type = unit.Members.First() as TypeDeclaration;
 			var method = type.Members.First() as MethodDeclaration;
@@ -363,7 +363,7 @@ class Foo
         yield return new Foo { }
     }
 }";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			bool passed = unit.GetText().Trim() == @"public class Bar
 {
@@ -398,7 +398,7 @@ class Foo
 	}
 }
 ";
-			var unit = CompilationUnit.Parse(code);
+			var unit = SyntaxTree.Parse(code);
 			
 			var type = unit.Members.First() as TypeDeclaration;
 			var method = type.Members.First() as MethodDeclaration;

ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/UsingDeclarationTests.cs

@@ -31,7 +31,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 		{
 			string program = "using\n";
 			CSharpParser parser = new CSharpParser();
-			CompilationUnit cu = parser.Parse (program, "parsed.cs");
+			SyntaxTree cu = parser.Parse (program, "parsed.cs");
 			Assert.AreEqual(0, cu.Children.Count());
 			Assert.IsTrue(parser.HasErrors);
 		}
@@ -42,7 +42,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 			string program = "using System;\n" +
 				"using My.Name.Space;\n";
 			CSharpParser parser = new CSharpParser();
-			CompilationUnit cu = parser.Parse(new StringReader(program), "parsed.cs");
+			SyntaxTree cu = parser.Parse(new StringReader(program), "parsed.cs");
 			Assert.IsFalse(parser.HasErrors);
 			
 			Assert.AreEqual(2, cu.Children.Count());
@@ -64,7 +64,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 				"using myAlias=My.Name.Space;\n" +
 				"using StringCollection = System.Collections.Generic.List<string>;\n";
 			CSharpParser parser = new CSharpParser();
-			CompilationUnit cu = parser.Parse(new StringReader(program), "parsed.cs");
+			SyntaxTree cu = parser.Parse(new StringReader(program), "parsed.cs");
 			Assert.IsFalse(parser.HasErrors);
 			
 			Assert.AreEqual(3, cu.Children.Count());
@@ -92,7 +92,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 				"using myAlias=global::My.Name.Space;\n" +
 				"using a::b.c;\n";
 			CSharpParser parser = new CSharpParser();
-			CompilationUnit cu = parser.Parse(new StringReader(program), "parsed.cs");
+			SyntaxTree cu = parser.Parse(new StringReader(program), "parsed.cs");
 			Assert.IsFalse(parser.HasErrors);
 			
 			Assert.AreEqual(3, cu.Children.Count());

ICSharpCode.NRefactory.Tests/CSharp/Parser/ParseSelfTests.cs

@@ -50,7 +50,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser
 			CSharpParser parser = new CSharpParser();
 			parser.GenerateTypeSystemMode = true;
 			foreach (string fileName in fileNames) {
-				CompilationUnit cu;
+				SyntaxTree cu;
 				using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan)) {
 					cu = parser.Parse(fs, fileName);
 				}
@@ -76,7 +76,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser
 			CSharpParser parser = new CSharpParser();
 			foreach (string fileName in fileNames) {
 				this.currentDocument = new ReadOnlyDocument(File.ReadAllText(fileName));
-				CompilationUnit cu = parser.Parse(currentDocument.CreateReader(), fileName);
+				SyntaxTree cu = parser.Parse(currentDocument.CreateReader(), fileName);
 				if (parser.HasErrors)
 					continue;
 				this.currentFileName = fileName;

ICSharpCode.NRefactory.Tests/CSharp/Parser/ParseUtil.cs

@@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser
 		public static T ParseGlobal<T>(string code, bool expectErrors = false) where T : AstNode
 		{
 			CSharpParser parser = new CSharpParser();
-			CompilationUnit cu = parser.Parse(new StringReader(code), "parsed.cs");
+			SyntaxTree cu = parser.Parse(new StringReader(code), "parsed.cs");
 			
 			foreach (var error in parser.Errors)
 				Console.WriteLine (error.Message);

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/PropertyDeclarationTests.cs

@@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers
 			int line4Pos = code.IndexOf("\t\tset");
 			
 			CSharpParser parser = new CSharpParser();
-			CompilationUnit cu = parser.Parse(new StringReader(code), "parsed.cs");
+			SyntaxTree cu = parser.Parse(new StringReader(code), "parsed.cs");
 			PropertyDeclaration pd = (PropertyDeclaration)cu.Children.Single().GetChildByRole(Roles.TypeMemberRole);
 			Assert.AreEqual(new TextLocation(2, code.IndexOf("{\n\t\tget") - line2Pos + 1), pd.GetChildByRole(Roles.LBrace).StartLocation);
 			Assert.AreEqual(new TextLocation(5, 3), pd.EndLocation);

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeSystemConvertVisitorTests.cs

@@ -42,7 +42,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser
 			const string fileName = "TypeSystemTests.TestCase.cs";
 			
 			CSharpParser parser = new CSharpParser();
-			CompilationUnit cu;
+			SyntaxTree cu;
 			using (Stream s = typeof(TypeSystemTests).Assembly.GetManifestResourceStream(typeof(TypeSystemTests), fileName)) {
 				cu = parser.Parse(s, fileName);
 			}

ICSharpCode.NRefactory.Tests/CSharp/Resolver/FindReferencesTest.cs

@@ -30,15 +30,15 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	[TestFixture]
 	public class FindReferencesTest
 	{
-		CompilationUnit compilationUnit;
+		SyntaxTree syntaxTree;
 		CSharpParsedFile parsedFile;
 		ICompilation compilation;
 		FindReferences findReferences;
 		
 		void Init(string code)
 		{
-			compilationUnit = new CSharpParser().Parse(new StringReader(code), "test.cs");
-			parsedFile = compilationUnit.ToTypeSystem();
+			syntaxTree = new CSharpParser().Parse(new StringReader(code), "test.cs");
+			parsedFile = syntaxTree.ToTypeSystem();
 			compilation = TypeSystemHelper.CreateCompilation(parsedFile);
 			findReferences = new FindReferences();
 		}
@@ -47,7 +47,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			var result = new List<AstNode>();
 			var searchScopes = findReferences.GetSearchScopes(entity);
-			findReferences.FindReferencesInFile(searchScopes, parsedFile, compilationUnit, compilation,
+			findReferences.FindReferencesInFile(searchScopes, parsedFile, syntaxTree, compilation,
 			                                    (node, rr) => result.Add(node), CancellationToken.None);
 			return result.OrderBy(n => n.StartLocation).ToArray();
 		}

ICSharpCode.NRefactory.Tests/CSharp/Resolver/MemberLookupTests.cs

@@ -40,7 +40,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		CSharpParsedFile Parse(string program)
 		{
-			CompilationUnit cu = new CSharpParser().Parse(new StringReader(program), "test.cs");
+			SyntaxTree cu = new CSharpParser().Parse(new StringReader(program), "test.cs");
 			CSharpParsedFile parsedFile = cu.ToTypeSystem();
 			project = project.UpdateProjectContent(null, parsedFile);
 			compilation = project.CreateCompilation();

ICSharpCode.NRefactory.Tests/CSharp/Resolver/ResolverTestBase.cs

@@ -161,7 +161,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		protected Tuple<CSharpAstResolver, AstNode> PrepareResolver(string code)
 		{
-			CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")), "code.cs");
+			SyntaxTree cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")), "code.cs");
 			
 			TextLocation[] dollars = FindDollarSigns(code).ToArray();
 			Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node");
@@ -212,7 +212,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return (T)rr;
 		}
 		
-		protected AstNode FindNode(CompilationUnit cu, TextLocation start, TextLocation end)
+		protected AstNode FindNode(SyntaxTree cu, TextLocation start, TextLocation end)
 		{
 			FindNodeVisitor fnv = new FindNodeVisitor(start, end);
 			cu.AcceptVisitor(fnv);
@@ -246,7 +246,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		protected ResolveResult ResolveAtLocation(string code)
 		{
-			CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")), "test.cs");
+			SyntaxTree cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")), "test.cs");
 			
 			TextLocation[] dollars = FindDollarSigns(code).ToArray();
 			Assert.AreEqual(1, dollars.Length, "Expected 1 dollar signs marking the location");

ICSharpCode.NRefactory.Tests/FormattingTests/TextEditorTestAdapter.cs

@@ -37,8 +37,8 @@ namespace ICSharpCode.NRefactory.CSharp.FormattingTests
 			options.WrapLineLength = 80;
 			var visitor = new AstFormattingVisitor (policy, document, options);
 			visitor.FormattingMode = mode;
-			var compilationUnit = new CSharpParser ().Parse (document, "test.cs");
-			compilationUnit.AcceptVisitor (visitor);
+			var syntaxTree = new CSharpParser ().Parse (document, "test.cs");
+			syntaxTree.AcceptVisitor (visitor);
 			visitor.ApplyChanges();
 			return document;
 		}
@@ -66,8 +66,8 @@ namespace ICSharpCode.NRefactory.CSharp.FormattingTests
 			options.EolMarker = "\n";
 			var visitior = new AstFormattingVisitor (policy, document, options);
 			visitior.FormattingMode = formattingMode;
-			var compilationUnit = new CSharpParser ().Parse (document, "test.cs");
-			compilationUnit.AcceptVisitor (visitior);
+			var syntaxTree = new CSharpParser ().Parse (document, "test.cs");
+			syntaxTree.AcceptVisitor (visitior);
 			visitior.ApplyChanges();
 			string newText = document.Text;
 			if (expectedOutput != newText) {