Basic evaluation - first level

Debugger/Debugger.Core/NRefactory/Ast/ExpressionExtensionMethods.cs

@@ -95,7 +95,7 @@ namespace ICSharpCode.NRefactory.Ast
 			if (memberInfo.IsStatic) {
 				target = new TypeReferenceExpression() { Type = memberInfo.DeclaringType.GetTypeReference() };
 			} else {
-				target = expresion.CastTo((DebugType)memberInfo.DeclaringType);
+				target = expresion.Clone().CastTo((DebugType)memberInfo.DeclaringType);
 			}
 			
 			if (memberInfo is DebugFieldInfo) {
@@ -141,7 +141,7 @@ namespace ICSharpCode.NRefactory.Ast
 				throw new DebuggerException("Incorrect number of arguments");
 			List<Expression> typedArgs = new List<Expression>(args.Length);
 			for(int i = 0; i < args.Length; i++) {
-				typedArgs.Add(args[i].CastTo((DebugType)method.GetParameters()[i].ParameterType));
+				typedArgs.Add(args[i].Clone().CastTo((DebugType)method.GetParameters()[i].ParameterType));
 			}
 			return typedArgs;
 		}
@@ -260,24 +260,24 @@ namespace ICSharpCode.NRefactory.Ast
 				//newRef.ArraySpecifiers = typeRef.ArraySpecifiers;
 				return newRef;
 			}
-//			else if (expr is SimpleType) {
-//				var typeRef = (SimpleType)expr;
-//				string[] names = typeRef.Identifier.Split('.');
-//				if (names.Length == 1)
-//					return typeRef;
-//				SimpleType newRef = null;
-//				foreach(string name in names) {
-//					if (newRef == null) {
-//						newRef = new SimpleType() { Identifier = name, TypeArguments = new List<AstType>() };
-//					} else {
-//						newRef = new MemberType() { Target = newRef, MemberName = name, TypeArguments = new List<AstType>() };
-//					}
-//				}
+			else if (expr is SimpleType) {
+				var typeRef = (SimpleType)expr;
+				string[] names = typeRef.Identifier.Split('.');
+				if (names.Length == 1)
+					return typeRef;
+				AstType newRef = null;
+				foreach(string name in names) {
+					if (newRef == null) {
+						newRef = new SimpleType() { Identifier = name/*, TypeArguments = new List<AstType>()*/ };
+					} else {
+						newRef = new MemberType() { Target = newRef, MemberName = name/*, TypeArguments = new List<AstType>() */};
+					}
+				}
 				//((List<AstType>)newRef.TypeArguments).AddRange(typeRef.TypeArguments);
 				//newRef.PointerNestingLevel = typeRef.PointerNestingLevel;
 				//newRef.RankSpecifier = typeRef.RankSpecifier;
-//				return newRef;
-//			}
+				return newRef;
+			}
 			else {
 				throw new EvaluateException(expr, "Type expected. {0} seen.", expr.GetType().FullName);
 			}

Debugger/Debugger.Core/NRefactory/Visitors/ExpressionEvaluator.cs

@@ -286,7 +286,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			return new TypedValue(val, val.Type);
 		}
 		
-		public object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
+		public override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
 		{
 			BinaryOperatorType op;
 			switch (assignmentExpression.Operator) {
@@ -328,7 +328,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			return right;
 		}
 		
-		public object VisitBlockStatement(BlockStatement blockStatement, object data)
+		public override object VisitBlockStatement(BlockStatement blockStatement, object data)
 		{
 			foreach(var statement in blockStatement.Children) {
 				Evaluate(statement);
@@ -336,21 +336,21 @@ namespace ICSharpCode.NRefactory.Visitors
 			return null;
 		}
 		
-		public object VisitEmptyStatement(EmptyStatement emptyStatement, object data)
+		public override object VisitEmptyStatement(EmptyStatement emptyStatement, object data)
 		{
 			return null;
 		}
 		
-		public object VisitExpressionStatement(ExpressionStatement expressionStatement, object data)
+		public override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data)
 		{
 			Evaluate(expressionStatement.Expression);
 			return null;
 		}
 		
-		public object VisitCastExpression(CastExpression castExpression, object data)
+		public override object VisitCastExpression(CastExpression castExpression, object data)
 		{
 			TypedValue val = Evaluate(castExpression.Expression);
-			DebugType castTo = null;// FIXME castExpression.CastTo().ResolveType(context.AppDomain);
+			DebugType castTo = castExpression.Type.ResolveType(context.AppDomain);
 			if (castTo.IsPrimitive && val.Type.IsPrimitive && castTo != val.Type) {
 				object oldVal = val.PrimitiveValue;
 				object newVal;
@@ -368,7 +368,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			return new TypedValue(val.Value, castTo);
 		}
 		
-		public object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
+		public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
 		{
 			string identifier = identifierExpression.Identifier;
 			
@@ -410,7 +410,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			throw new GetValueException("Identifier \"" + identifier + "\" not found in this context");
 		}
 		
-		public object VisitIndexerExpression(IndexerExpression indexerExpression, object data)
+		public override object VisitIndexerExpression(IndexerExpression indexerExpression, object data)
 		{
 			TypedValue target = Evaluate(indexerExpression.Target);
 			
@@ -444,7 +444,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			}
 		}
 		
-		public object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
+		public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
 		{
 			TypedValue target;
 			DebugType targetType;
@@ -482,7 +482,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			return new TypedValue(retVal, (DebugType)method.ReturnType);
 		}
 		
-		public object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
+		public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
 		{
 			if (!objectCreateExpression.Initializer.IsNull)
 				throw new EvaluateException(objectCreateExpression.Initializer, "Object initializers not supported");
@@ -496,7 +496,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			return new TypedValue(val, type);
 		}
 		
-		public object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)
+		public override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)
 		{
 			if (arrayCreateExpression.AdditionalArraySpecifiers.Count() != 0)
 				throw new EvaluateException(arrayCreateExpression, "Multi-dimensional arrays are not suppored");
@@ -523,7 +523,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			return new TypedValue(array, type);
 		}
 		
-		public object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
+		public override object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
 		{
 			TypedValue target;
 			DebugType targetType;
@@ -549,12 +549,12 @@ namespace ICSharpCode.NRefactory.Visitors
 			);
 		}
 		
-		public object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)
+		public override object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)
 		{
 			return Evaluate(parenthesizedExpression.Expression);
 		}
 		
-		public object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
+		public override object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
 		{
 			return CreateValue(primitiveExpression.Value);
 		}
@@ -568,7 +568,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			return null;
 		}
 		
-		public object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)
+		public override object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)
 		{
 			TypedValue thisValue = GetThisValue();
 			if (thisValue == null)
@@ -578,7 +578,7 @@ namespace ICSharpCode.NRefactory.Visitors
 		
 		#region Binary and unary expressions
 		
-		public object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
+		public override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
 		{
 			TypedValue value = Evaluate(unaryOperatorExpression.Expression);
 			UnaryOperatorType op = unaryOperatorExpression.Operator;
@@ -723,7 +723,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			return null;
 		}
 		
-		public object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
+		public override object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
 		{
 			BinaryOperatorType op = binaryOperatorExpression.Operator;
 			

Debugger/ILSpy.Debugger/ILSpy.Debugger.csproj

@@ -101,6 +101,7 @@
     </Compile>
   </ItemGroup>
   <ItemGroup>
+    <Folder Include="Images" />
     <Folder Include="Models\TreeModel" />
     <Folder Include="ToolTips" />
     <Folder Include="ToolTips\Models" />
@@ -136,6 +137,57 @@
   <ItemGroup>
     <Resource Include="Images\Breakpoint.png" />
     <Resource Include="Images\CurrentLine.png" />
+    <Resource Include="Images\Icons.16x16.Class.png"/>
+    <Resource Include="Images\Icons.16x16.Delegate.png" />
+    <Resource Include="Images\Icons.16x16.Enum.png" />
+    <Resource Include="Images\Icons.16x16.Event.png" />
+    <Resource Include="Images\Icons.16x16.ExtensionMethod.png" />
+    <Resource Include="Images\Icons.16x16.Field.png" />
+    <Resource Include="Images\Icons.16x16.Indexer.png" />
+    <Resource Include="Images\Icons.16x16.Interface.png" />
+    <Resource Include="Images\Icons.16x16.InternalClass.png" />
+    <Resource Include="Images\Icons.16x16.InternalDelegate.png" />
+    <Resource Include="Images\Icons.16x16.InternalEnum.png" />
+    <Resource Include="Images\Icons.16x16.InternalEvent.png" />
+    <Resource Include="Images\Icons.16x16.InternalExtensionMethod.png" />
+    <Resource Include="Images\Icons.16x16.InternalField.png" />
+    <Resource Include="Images\Icons.16x16.InternalIndexer.png" />
+    <Resource Include="Images\Icons.16x16.InternalInterface.png" />
+    <Resource Include="Images\Icons.16x16.InternalMethod.png" />
+    <Resource Include="Images\Icons.16x16.InternalProperty.png" />
+    <Resource Include="Images\Icons.16x16.InternalStruct.png" />
+    <Resource Include="Images\Icons.16x16.Keyword.png" />
+    <Resource Include="Images\Icons.16x16.Literal.png" />
+    <Resource Include="Images\Icons.16x16.Local.png" />
+    <Resource Include="Images\Icons.16x16.Method.png" />
+    <Resource Include="Images\Icons.16x16.NameSpace.png" />
+    <Resource Include="Images\Icons.16x16.Operator.png" />
+    <Resource Include="Images\Icons.16x16.Parameter.png" />
+    <Resource Include="Images\Icons.16x16.PrivateClass.png" />
+    <Resource Include="Images\Icons.16x16.PrivateDelegate.png" />
+    <Resource Include="Images\Icons.16x16.PrivateEnum.png" />
+    <Resource Include="Images\Icons.16x16.PrivateEvent.png" />
+    <Resource Include="Images\Icons.16x16.PrivateExtensionMethod.png" />
+    <Resource Include="Images\Icons.16x16.PrivateField.png" />
+    <Resource Include="Images\Icons.16x16.PrivateIndexer.png" />
+    <Resource Include="Images\Icons.16x16.PrivateInterface.png" />
+    <Resource Include="Images\Icons.16x16.PrivateMethod.png" />
+    <Resource Include="Images\Icons.16x16.PrivateProperty.png" />
+    <Resource Include="Images\Icons.16x16.PrivateStruct.png" />
+    <Resource Include="Images\Icons.16x16.Property.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedClass.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedDelegate.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedEnum.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedEvent.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedExtensionMethod.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedField.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedIndexer.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedInterface.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedMethod.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedProperty.png" />
+    <Resource Include="Images\Icons.16x16.ProtectedStruct.png" />
+    <Resource Include="Images\Icons.16x16.Reference.png" />
+    <Resource Include="Images\Icons.16x16.Struct.png" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
 </Project>

Debugger/ILSpy.Debugger/Models/TreeModel/ChildNodesOfObject.cs

@@ -89,7 +89,7 @@ namespace ILSpy.Debugger.Models.TreeModel
 				exp.ImageName = imageName;
 				nodes.Add(exp);
 			}
-			nodes.Sort();
+			
 			return nodes;
 		}
 

Debugger/ILSpy.Debugger/Models/TreeModel/ExpressionNode.cs

@@ -13,6 +13,7 @@ using Debugger.MetaData;
 using ICSharpCode.NRefactory.Ast;
 using ICSharpCode.NRefactory.CSharp;
 using ILSpy.Debugger.Services;
+using ILSpy.Debugger.Services.Debugger;
 
 namespace ILSpy.Debugger.Models.TreeModel
 {
@@ -121,10 +122,10 @@ namespace ILSpy.Debugger.Models.TreeModel
 				// no visualizers if evaluated value is null
 				yield break;
 			}
-			/*if (this.expressionType.IsPrimitive || this.expressionType.IsSystemDotObject() || this.expressionType.IsEnum()) {
+			if (this.expressionType.IsPrimitive || this.expressionType.IsSystemDotObject() || this.expressionType.IsEnum()) {
 				// no visualizers for primitive types
 				yield break;
-			}*/
+			}
 			
 			yield break;
 //			foreach (var descriptor in VisualizerDescriptors.GetAllDescriptors()) {
@@ -180,10 +181,10 @@ namespace ILSpy.Debugger.Models.TreeModel
 				}
 			}
 			
-			if (true) {
-				TreeNode info = ICorDebug.GetDebugInfoRoot(val.AppDomain, val.CorValue);
-				this.ChildNodes = Utils.PrependNode(info, this.ChildNodes);
-			}
+//			if (DebuggingOptions.Instance.ICorDebugVisualizerEnabled) {
+//				TreeNode info = ICorDebug.GetDebugInfoRoot(val.AppDomain, val.CorValue);
+//				this.ChildNodes = Utils.PrependNode(info, this.ChildNodes);
+//			}
 			
 			// Do last since it may expire the object
 			if (val.Type.IsInteger) {
@@ -229,6 +230,7 @@ namespace ILSpy.Debugger.Models.TreeModel
 		
 		string FormatInteger(object i)
 		{
+			// if (DebuggingOptions.Instance.ShowIntegersAs == ShowIntegersAs.Decimal)
 			if (true)
 				return i.ToString();
 			

Debugger/ILSpy.Debugger/Services/Debugger/DebuggerService.cs

@@ -207,7 +207,7 @@ namespace ILSpy.Debugger.Services
 				ParserService.SimpleParseAt(doc.Text, doc.GetOffset(new TextLocation(logicPos.Line, logicPos.Column)));
 			
 			if (currentDebugger == null || !currentDebugger.IsDebugging || !currentDebugger.CanEvaluate) {
-				e.ContentToShow = variable;
+				e.ContentToShow = null;
 			}
 			else {
 				e.ContentToShow = currentDebugger.GetTooltipControl(e.LogicalPosition, variable);

Debugger/ILSpy.Debugger/Services/Debugger/WindowsDebugger.cs

@@ -391,18 +391,19 @@ namespace ILSpy.Debugger.Services
 		/// </summary>
 		public object GetTooltipControl(AstLocation logicalPosition, string variableName)
 		{
-			return new DebuggerTooltipControl(logicalPosition, new ExpressionNode(null, variableName, null));
-			//FIXME
-//			try {
-//				var tooltipExpression = GetExpression(variableName);
-//				string imageName;
-//				var image = ExpressionNode.GetImageForLocalVariable(out imageName);
-//				ExpressionNode expressionNode = new ExpressionNode(image, variableName, tooltipExpression);
-//				expressionNode.ImageName = imageName;
-//				return new DebuggerTooltipControl(logicalPosition, expressionNode);
-//			} catch (GetValueException) {
-//				return null;
-//			}
+			try {
+				var tooltipExpression = GetExpression(variableName);
+				if (tooltipExpression == null) return null;
+				
+				string imageName;
+				var image = ExpressionNode.GetImageForLocalVariable(out imageName);
+				ExpressionNode expressionNode = new ExpressionNode(image, variableName, tooltipExpression);
+				expressionNode.ImageName = imageName;
+				
+				return new DebuggerTooltipControl(logicalPosition, expressionNode);
+			} catch (GetValueException) {
+				return null;
+			}
 		}
 		
 		public ITreeNode GetNode(string variable, string currentImageName = null)

Debugger/ILSpy.Debugger/Services/ImageService/ImageService.cs

@@ -26,10 +26,18 @@ namespace ILSpy.Debugger.Services
 	{
 		static BitmapImage LoadBitmap(string name)
 		{
+			try {
 				BitmapImage image = new BitmapImage(new Uri("pack://application:,,,/ILSpy.Debugger;component/Images/" + name + ".png"));
+				if (image == null)
+					return null;
 				image.Freeze();
 				return image;
 			}
+			catch {
+				// resource not found
+				return null;
+			}
+		}
 		
 		public static readonly BitmapImage Breakpoint = LoadBitmap("Breakpoint");
 		public static readonly BitmapImage CurrentLine = LoadBitmap("CurrentLine");

Debugger/ILSpy.Debugger/Services/ParserService/ParserService.cs

@@ -83,7 +83,7 @@ namespace ILSpy.Debugger.Services
 			
 			currentValue = fullText[offset].ToString();
 			// searh right
-			while(!mySet.Contains(currentValue) && offset < fullText.Length)
+			while(!mySet.Contains(currentValue) && offset < fullText.Length - 2)
 				currentValue = fullText[++right].ToString();
 			
 			return fullText.Substring(left + 1, right - 1 - left).Trim();

Debugger/ILSpy.Debugger/ToolTips/DebuggerTooltipControl.xaml.cs

@@ -84,6 +84,10 @@ namespace ILSpy.Debugger.Tooltips
 		}
 		
 		public void SetItemsSource(IEnumerable<ITreeNode> value) {
+			
+			if (value == null)
+				return;
+			
 			this.itemsSource = value;
 			this.lazyGrid = new LazyItemsControl<ITreeNode>(this.dataGrid, InitialItemsCount);
 			

ICSharpCode.Decompiler/CodeMappings.cs

@@ -146,7 +146,8 @@ namespace ICSharpCode.Decompiler
 					continue;
 				
 				var codeMapping = mapping.MethodCodeMappings.Find(
-					cm => cm.ILInstructionOffset.From <= ilOffset && ilOffset <= cm.ILInstructionOffset.To);
+					cm => (cm.ILInstructionOffset.From <= ilOffset && ilOffset <= cm.ILInstructionOffset.To - 1) || // for CSharp
+						  (cm.ILInstructionOffset.From == ilOffset && ilOffset == cm.ILInstructionOffset.To)); // for IL
 				if (codeMapping == null)
 					continue;
 				

ILSpy.sln

@@ -1,15 +1,15 @@
 
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
-# SharpDevelop 4.1.0.7279-alpha
+# SharpDevelop 4.1.0.7302-alpha
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Debugger", "Debugger", "{1DEB3B4E-03AC-437C-821D-B09FBFCC3E5B}"
 	ProjectSection(SolutionItems) = postProject
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ILSpy.Debugger", "Debugger\ILSpy.Debugger\ILSpy.Debugger.csproj", "{6D3D0F0D-348D-456A-A6ED-E9BD5EFABB6A}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Debugger.Core", "Debugger\Debugger.Core\Debugger.Core.csproj", "{1D18D788-F7EE-4585-A23B-34DC8EC63CB8}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ILSpy.Debugger", "Debugger\ILSpy.Debugger\ILSpy.Debugger.csproj", "{6D3D0F0D-348D-456A-A6ED-E9BD5EFABB6A}"
+EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ILSpy", "ILSpy\ILSpy.csproj", "{1E85EFF9-E370-4683-83E4-8A3D063FF791}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.TreeView", "SharpTreeView\ICSharpCode.TreeView.csproj", "{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}"
@@ -106,7 +106,7 @@ Global
 		{6D3D0F0D-348D-456A-A6ED-E9BD5EFABB6A}.Release|Any CPU.ActiveCfg = Release|x86
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
-		{1D18D788-F7EE-4585-A23B-34DC8EC63CB8} = {1DEB3B4E-03AC-437C-821D-B09FBFCC3E5B}
 		{6D3D0F0D-348D-456A-A6ED-E9BD5EFABB6A} = {1DEB3B4E-03AC-437C-821D-B09FBFCC3E5B}
+		{1D18D788-F7EE-4585-A23B-34DC8EC63CB8} = {1DEB3B4E-03AC-437C-821D-B09FBFCC3E5B}
 	EndGlobalSection
 EndGlobal

ILSpy/MainWindow.xaml.cs

@@ -310,6 +310,7 @@ namespace ICSharpCode.ILSpy
 				window.Owner = this;
 				if (window.ShowDialog() == true)
 				{
+					if (DebuggerService.CurrentDebugger.IsDebugging) {
 						AttachMenuItem.IsEnabled = AttachButton.IsEnabled = false;
 						ContinueDebuggingMenuItem.IsEnabled =
 							StepIntoMenuItem.IsEnabled =
@@ -319,6 +320,7 @@ namespace ICSharpCode.ILSpy
 					}
 				}
 			}
+		}
 		
 		void DetachFromProcessExecuted(object sender, ExecutedRoutedEventArgs e)
 		{

NRefactory/ICSharpCode.NRefactory/CSharp/Ast/NotImplementedAstVisitor.cs

@@ -7,522 +7,522 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class NotImplementedAstVisitor<T, S> : IAstVisitor<T, S>
 	{	
-		public S VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, T data)
+		public virtual S VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitArgListExpression(ArgListExpression argListExpression, T data)
+		public virtual S VisitArgListExpression(ArgListExpression argListExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, T data)
+		public virtual S VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitArrayInitializerExpression(ArrayInitializerExpression arrayInitializerExpression, T data)
+		public virtual S VisitArrayInitializerExpression(ArrayInitializerExpression arrayInitializerExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitAsExpression(AsExpression asExpression, T data)
+		public virtual S VisitAsExpression(AsExpression asExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitAssignmentExpression(AssignmentExpression assignmentExpression, T data)
+		public virtual S VisitAssignmentExpression(AssignmentExpression assignmentExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, T data)
+		public virtual S VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, T data)
+		public virtual S VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitCastExpression(CastExpression castExpression, T data)
+		public virtual S VisitCastExpression(CastExpression castExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitCheckedExpression(CheckedExpression checkedExpression, T data)
+		public virtual S VisitCheckedExpression(CheckedExpression checkedExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitConditionalExpression(ConditionalExpression conditionalExpression, T data)
+		public virtual S VisitConditionalExpression(ConditionalExpression conditionalExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, T data)
+		public virtual S VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitDirectionExpression(DirectionExpression directionExpression, T data)
+		public virtual S VisitDirectionExpression(DirectionExpression directionExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitIdentifierExpression(IdentifierExpression identifierExpression, T data)
+		public virtual S VisitIdentifierExpression(IdentifierExpression identifierExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitIndexerExpression(IndexerExpression indexerExpression, T data)
+		public virtual S VisitIndexerExpression(IndexerExpression indexerExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitInvocationExpression(InvocationExpression invocationExpression, T data)
+		public virtual S VisitInvocationExpression(InvocationExpression invocationExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitIsExpression(IsExpression isExpression, T data)
+		public virtual S VisitIsExpression(IsExpression isExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitLambdaExpression(LambdaExpression lambdaExpression, T data)
+		public virtual S VisitLambdaExpression(LambdaExpression lambdaExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, T data)
+		public virtual S VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, T data)
+		public virtual S VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitNullReferenceExpression(NullReferenceExpression nullReferenceExpression, T data)
+		public virtual S VisitNullReferenceExpression(NullReferenceExpression nullReferenceExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, T data)
+		public virtual S VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, T data)
+		public virtual S VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitPointerReferenceExpression(PointerReferenceExpression pointerReferenceExpression, T data)
+		public virtual S VisitPointerReferenceExpression(PointerReferenceExpression pointerReferenceExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, T data)
+		public virtual S VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitSizeOfExpression(SizeOfExpression sizeOfExpression, T data)
+		public virtual S VisitSizeOfExpression(SizeOfExpression sizeOfExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitStackAllocExpression(StackAllocExpression stackAllocExpression, T data)
+		public virtual S VisitStackAllocExpression(StackAllocExpression stackAllocExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, T data)
+		public virtual S VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitTypeOfExpression(TypeOfExpression typeOfExpression, T data)
+		public virtual S VisitTypeOfExpression(TypeOfExpression typeOfExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, T data)
+		public virtual S VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, T data)
+		public virtual S VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitUncheckedExpression(UncheckedExpression uncheckedExpression, T data)
+		public virtual S VisitUncheckedExpression(UncheckedExpression uncheckedExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitQueryExpression(QueryExpression queryExpression, T data)
+		public virtual S VisitQueryExpression(QueryExpression queryExpression, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitQueryContinuationClause(QueryContinuationClause queryContinuationClause, T data)
+		public virtual S VisitQueryContinuationClause(QueryContinuationClause queryContinuationClause, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitQueryFromClause(QueryFromClause queryFromClause, T data)
+		public virtual S VisitQueryFromClause(QueryFromClause queryFromClause, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitQueryLetClause(QueryLetClause queryLetClause, T data)
+		public virtual S VisitQueryLetClause(QueryLetClause queryLetClause, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitQueryWhereClause(QueryWhereClause queryWhereClause, T data)
+		public virtual S VisitQueryWhereClause(QueryWhereClause queryWhereClause, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitQueryJoinClause(QueryJoinClause queryJoinClause, T data)
+		public virtual S VisitQueryJoinClause(QueryJoinClause queryJoinClause, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitQueryOrderClause(QueryOrderClause queryOrderClause, T data)
+		public virtual S VisitQueryOrderClause(QueryOrderClause queryOrderClause, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitQueryOrdering(QueryOrdering queryOrdering, T data)
+		public virtual S VisitQueryOrdering(QueryOrdering queryOrdering, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitQuerySelectClause(QuerySelectClause querySelectClause, T data)
+		public virtual S VisitQuerySelectClause(QuerySelectClause querySelectClause, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitQueryGroupClause(QueryGroupClause queryGroupClause, T data)
+		public virtual S VisitQueryGroupClause(QueryGroupClause queryGroupClause, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitAttribute(Attribute attribute, T data)
+		public virtual S VisitAttribute(Attribute attribute, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitAttributeSection(AttributeSection attributeSection, T data)
+		public virtual S VisitAttributeSection(AttributeSection attributeSection, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, T data)
+		public virtual S VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, T data)
+		public virtual S VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitTypeDeclaration(TypeDeclaration typeDeclaration, T data)
+		public virtual S VisitTypeDeclaration(TypeDeclaration typeDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitUsingAliasDeclaration(UsingAliasDeclaration usingAliasDeclaration, T data)
+		public virtual S VisitUsingAliasDeclaration(UsingAliasDeclaration usingAliasDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitUsingDeclaration(UsingDeclaration usingDeclaration, T data)
+		public virtual S VisitUsingDeclaration(UsingDeclaration usingDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitBlockStatement(BlockStatement blockStatement, T data)
+		public virtual S VisitBlockStatement(BlockStatement blockStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitBreakStatement(BreakStatement breakStatement, T data)
+		public virtual S VisitBreakStatement(BreakStatement breakStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitCheckedStatement(CheckedStatement checkedStatement, T data)
+		public virtual S VisitCheckedStatement(CheckedStatement checkedStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitContinueStatement(ContinueStatement continueStatement, T data)
+		public virtual S VisitContinueStatement(ContinueStatement continueStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitDoWhileStatement(DoWhileStatement doWhileStatement, T data)
+		public virtual S VisitDoWhileStatement(DoWhileStatement doWhileStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitEmptyStatement(EmptyStatement emptyStatement, T data)
+		public virtual S VisitEmptyStatement(EmptyStatement emptyStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitExpressionStatement(ExpressionStatement expressionStatement, T data)
+		public virtual S VisitExpressionStatement(ExpressionStatement expressionStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitFixedStatement(FixedStatement fixedStatement, T data)
+		public virtual S VisitFixedStatement(FixedStatement fixedStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitForeachStatement(ForeachStatement foreachStatement, T data)
+		public virtual S VisitForeachStatement(ForeachStatement foreachStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitForStatement(ForStatement forStatement, T data)
+		public virtual S VisitForStatement(ForStatement forStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitGotoCaseStatement(GotoCaseStatement gotoCaseStatement, T data)
+		public virtual S VisitGotoCaseStatement(GotoCaseStatement gotoCaseStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitGotoDefaultStatement(GotoDefaultStatement gotoDefaultStatement, T data)
+		public virtual S VisitGotoDefaultStatement(GotoDefaultStatement gotoDefaultStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitGotoStatement(GotoStatement gotoStatement, T data)
+		public virtual S VisitGotoStatement(GotoStatement gotoStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitIfElseStatement(IfElseStatement ifElseStatement, T data)
+		public virtual S VisitIfElseStatement(IfElseStatement ifElseStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitLabelStatement(LabelStatement labelStatement, T data)
+		public virtual S VisitLabelStatement(LabelStatement labelStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitLockStatement(LockStatement lockStatement, T data)
+		public virtual S VisitLockStatement(LockStatement lockStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitReturnStatement(ReturnStatement returnStatement, T data)
+		public virtual S VisitReturnStatement(ReturnStatement returnStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitSwitchStatement(SwitchStatement switchStatement, T data)
+		public virtual S VisitSwitchStatement(SwitchStatement switchStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitSwitchSection(SwitchSection switchSection, T data)
+		public virtual S VisitSwitchSection(SwitchSection switchSection, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitCaseLabel(CaseLabel caseLabel, T data)
+		public virtual S VisitCaseLabel(CaseLabel caseLabel, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitThrowStatement(ThrowStatement throwStatement, T data)
+		public virtual S VisitThrowStatement(ThrowStatement throwStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitTryCatchStatement(TryCatchStatement tryCatchStatement, T data)
+		public virtual S VisitTryCatchStatement(TryCatchStatement tryCatchStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitCatchClause(CatchClause catchClause, T data)
+		public virtual S VisitCatchClause(CatchClause catchClause, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitUncheckedStatement(UncheckedStatement uncheckedStatement, T data)
+		public virtual S VisitUncheckedStatement(UncheckedStatement uncheckedStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitUnsafeStatement(UnsafeStatement unsafeStatement, T data)
+		public virtual S VisitUnsafeStatement(UnsafeStatement unsafeStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitUsingStatement(UsingStatement usingStatement, T data)
+		public virtual S VisitUsingStatement(UsingStatement usingStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, T data)
+		public virtual S VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitWhileStatement(WhileStatement whileStatement, T data)
+		public virtual S VisitWhileStatement(WhileStatement whileStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitYieldBreakStatement(YieldBreakStatement yieldBreakStatement, T data)
+		public virtual S VisitYieldBreakStatement(YieldBreakStatement yieldBreakStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitYieldStatement(YieldStatement yieldStatement, T data)
+		public virtual S VisitYieldStatement(YieldStatement yieldStatement, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitAccessor(Accessor accessor, T data)
+		public virtual S VisitAccessor(Accessor accessor, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, T data)
+		public virtual S VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitConstructorInitializer(ConstructorInitializer constructorInitializer, T data)
+		public virtual S VisitConstructorInitializer(ConstructorInitializer constructorInitializer, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, T data)
+		public virtual S VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration, T data)
+		public virtual S VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitEventDeclaration(EventDeclaration eventDeclaration, T data)
+		public virtual S VisitEventDeclaration(EventDeclaration eventDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitCustomEventDeclaration(CustomEventDeclaration customEventDeclaration, T data)
+		public virtual S VisitCustomEventDeclaration(CustomEventDeclaration customEventDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitFieldDeclaration(FieldDeclaration fieldDeclaration, T data)
+		public virtual S VisitFieldDeclaration(FieldDeclaration fieldDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, T data)
+		public virtual S VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitMethodDeclaration(MethodDeclaration methodDeclaration, T data)
+		public virtual S VisitMethodDeclaration(MethodDeclaration methodDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, T data)
+		public virtual S VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitParameterDeclaration(ParameterDeclaration parameterDeclaration, T data)
+		public virtual S VisitParameterDeclaration(ParameterDeclaration parameterDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, T data)
+		public virtual S VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitVariableInitializer(VariableInitializer variableInitializer, T data)
+		public virtual S VisitVariableInitializer(VariableInitializer variableInitializer, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitCompilationUnit(CompilationUnit compilationUnit, T data)
+		public virtual S VisitCompilationUnit(CompilationUnit compilationUnit, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitSimpleType(SimpleType simpleType, T data)
+		public virtual S VisitSimpleType(SimpleType simpleType, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitMemberType(MemberType memberType, T data)
+		public virtual S VisitMemberType(MemberType memberType, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitComposedType(ComposedType composedType, T data)
+		public virtual S VisitComposedType(ComposedType composedType, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitArraySpecifier(ArraySpecifier arraySpecifier, T data)
+		public virtual S VisitArraySpecifier(ArraySpecifier arraySpecifier, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitPrimitiveType(PrimitiveType primitiveType, T data)
+		public virtual S VisitPrimitiveType(PrimitiveType primitiveType, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitComment(Comment comment, T data)
+		public virtual S VisitComment(Comment comment, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitTypeParameterDeclaration(TypeParameterDeclaration typeParameterDeclaration, T data)
+		public virtual S VisitTypeParameterDeclaration(TypeParameterDeclaration typeParameterDeclaration, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitConstraint(Constraint constraint, T data)
+		public virtual S VisitConstraint(Constraint constraint, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitCSharpTokenNode(CSharpTokenNode cSharpTokenNode, T data)
+		public virtual S VisitCSharpTokenNode(CSharpTokenNode cSharpTokenNode, T data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public S VisitIdentifier(Identifier identifier, T data)
+		public virtual S VisitIdentifier(Identifier identifier, T data)
 		{
 			throw new NotImplementedException();
 		}