Merge remote-tracking branch 'upstream/master' into mansheng

ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssue.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // InspectionIssue.cs
 //
 // Author:

ICSharpCode.NRefactory.CSharp/Resolver/CSharpInvocationResolveResult.cs

@@ -25,7 +25,8 @@ using ICSharpCode.NRefactory.TypeSystem;
 namespace ICSharpCode.NRefactory.CSharp.Resolver
 {
 	/// <summary>
-	/// Represents the result of a method invocation.
+	/// Represents the result of a method, constructor or indexer invocation.
+	/// Provides additional C#-specific information for InvocationResolveResult.
 	/// </summary>
 	public class CSharpInvocationResolveResult : InvocationResolveResult
 	{

ICSharpCode.NRefactory.CSharp/Resolver/LambdaResolveResult.cs

@@ -25,6 +25,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 {
 	/// <summary>
 	/// Represents an anonymous method or lambda expression.
+	/// Note: the lambda has no type.
+	/// To retrieve the delegate type, look at the anonymous function conversion.
 	/// </summary>
 	public abstract class LambdaResolveResult : ResolveResult
 	{

ICSharpCode.NRefactory.CSharp/Resolver/MethodGroupResolveResult.cs

@@ -51,6 +51,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	
 	/// <summary>
 	/// Represents a group of methods.
+	/// A method reference used to create a delegate is resolved to a MethodGroupResolveResult.
+	/// The MethodGroupResolveResult has no type.
+	/// To retrieve the delegate type or the chosen overload, look at the method group conversion.
 	/// </summary>
 	public class MethodGroupResolveResult : ResolveResult
 	{

ICSharpCode.NRefactory.Demo/CSDemo.Designer.cs

@@ -142,7 +142,7 @@ namespace ICSharpCode.NRefactory.Demo
 			this.csharpGenerateCodeButton.Name = "csharpGenerateCodeButton";
 			this.csharpGenerateCodeButton.Size = new System.Drawing.Size(100, 23);
 			this.csharpGenerateCodeButton.TabIndex = 1;
-			this.csharpGenerateCodeButton.Text = "Generate";
+			this.csharpGenerateCodeButton.Text = "\u2191 Generate \u2191";
 			this.csharpGenerateCodeButton.UseVisualStyleBackColor = true;
 			this.csharpGenerateCodeButton.Click += new System.EventHandler(this.CSharpGenerateCodeButtonClick);
 			// 

ICSharpCode.NRefactory.Demo/CSDemo.cs

@@ -152,9 +152,17 @@ namespace ICSharpCode.NRefactory.Demo
 		
 		int GetOffset(TextBox textBox, TextLocation location)
 		{
+			// TextBox uses 0-based coordinates, TextLocation is 1-based
 			return textBox.GetFirstCharIndexFromLine(location.Line - 1) + location.Column - 1;
 		}
 		
+		TextLocation GetTextLocation(TextBox textBox, int offset)
+		{
+			int line = textBox.GetLineFromCharIndex(offset);
+			int col = offset - textBox.GetFirstCharIndexFromLine(line);
+			return new TextLocation(line + 1, col + 1);
+		}
+		
 		void CSharpTreeViewAfterSelect(object sender, TreeViewEventArgs e)
 		{
 			AstNode node = e.Node.Tag as AstNode;
@@ -203,74 +211,22 @@ namespace ICSharpCode.NRefactory.Demo
 			
 			ICompilation compilation = project.CreateCompilation();
 			
-			AstNode selectedNode = null;
-			StoreInDictionaryNavigator navigator;
+			ResolveResult result;
 			if (csharpTreeView.SelectedNode != null) {
-				selectedNode = (AstNode)csharpTreeView.SelectedNode.Tag;
-				navigator = new StoreInDictionaryNavigator(selectedNode);
+				var selectedNode = (AstNode)csharpTreeView.SelectedNode.Tag;
+				CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
+				result = resolver.Resolve(selectedNode);
+				// CSharpAstResolver.Resolve() never returns null
 			} else {
-				navigator = new StoreInDictionaryNavigator();
-			}
-			CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
-			resolver.ApplyNavigator(navigator);
-			csharpTreeView.BeginUpdate();
-			ShowResolveResultsInTree(csharpTreeView.Nodes, navigator);
-			csharpTreeView.EndUpdate();
-			if (csharpTreeView.SelectedNode != null) {
-				using (var dlg = new SemanticTreeDialog(resolver.Resolve(selectedNode)))
-					dlg.ShowDialog();
-			}
-		}
-		
-		sealed class StoreInDictionaryNavigator : NodeListResolveVisitorNavigator
-		{
-			internal Dictionary<AstNode, ResolveResult> resolveResults = new Dictionary<AstNode, ResolveResult>();
-			internal Dictionary<AstNode, Conversion> conversions = new Dictionary<AstNode, Conversion>();
-			internal Dictionary<AstNode, IType> conversionTargetTypes = new Dictionary<AstNode, IType>();
-			bool resolveAll;
-			
-			public StoreInDictionaryNavigator(params AstNode[] nodes)
-				: base(nodes)
-			{
-				resolveAll = (nodes.Length == 0);
-			}
-			
-			public override ResolveVisitorNavigationMode Scan(AstNode node)
-			{
-				if (resolveAll)
-					return ResolveVisitorNavigationMode.Resolve;
-				else
-					return base.Scan(node);
-			}
-			
-			public override void Resolved(AstNode node, ResolveResult result)
-			{
-				resolveResults.Add(node, result);
-			}
-			
-			public override void ProcessConversion(Expression expression, ResolveResult result, Conversion conversion, IType targetType)
-			{
-				conversions.Add(expression, conversion);
-				conversionTargetTypes.Add(expression, targetType);
-			}
-		}
-		
-		void ShowResolveResultsInTree(TreeNodeCollection c, StoreInDictionaryNavigator n)
-		{
-			foreach (TreeNode t in c) {
-				AstNode node = t.Tag as AstNode;
-				if (node != null) {
-					ResolveResult rr;
-					string text = GetNodeTitle(node);
-					if (n.resolveResults.TryGetValue(node, out rr))
-						text += " " + rr.ToString();
-					if (n.conversions.ContainsKey(node)) {
-						text += " [" + n.conversions[node] + " to " + n.conversionTargetTypes[node] + "]";
-					}
-					t.Text = text;
+				TextLocation location = GetTextLocation(csharpCodeTextBox, csharpCodeTextBox.SelectionStart);
+				result = ResolveAtLocation.Resolve(compilation, parsedFile, compilationUnit, location);
+				if (result == null) {
+					MessageBox.Show("Could not find a resolvable node at the caret location.");
+					return;
 				}
-				ShowResolveResultsInTree(t.Nodes, n);
 			}
+			using (var dlg = new SemanticTreeDialog(result))
+				dlg.ShowDialog();
 		}
 		
 		void CSharpCodeTextBoxKeyDown(object sender, KeyEventArgs e)

ICSharpCode.NRefactory.VB/Lexer/PushParser.frame

@@ -42,6 +42,7 @@ partial class ExpressionFinder {
 	bool isMissingModifier = false;
 	bool isAlreadyInExpr = false;
 	bool wasNormalAttribute = false;
+	int lambdaNestingDepth = 0;
 	int activeArgument = 0;
 	List<Token> errors = new List<Token>();
 	

ICSharpCode.NRefactory.Xml/AXmlObject.cs

@@ -26,7 +26,7 @@ using ICSharpCode.NRefactory.Utils;
 namespace ICSharpCode.NRefactory.Xml
 {
 	/// <summary>
-	/// XML object.
+	/// XML object. Base class for all nodes in the XML document.
 	/// </summary>
 	public abstract class AXmlObject : ISegment
 	{

ICSharpCode.NRefactory/Semantics/AmbiguousResolveResult.cs

@@ -35,6 +35,9 @@ namespace ICSharpCode.NRefactory.Semantics
 		}
 	}
 	
+	/// <summary>
+	/// Represents an ambiguous field/property/event access.
+	/// </summary>
 	public class AmbiguousMemberResolveResult : MemberResolveResult
 	{
 		public AmbiguousMemberResolveResult(ResolveResult targetResult, IMember member) : base(targetResult, member)

ICSharpCode.NRefactory/Semantics/ConstantResolveResult.cs

@@ -24,6 +24,11 @@ namespace ICSharpCode.NRefactory.Semantics
 {
 	/// <summary>
 	/// ResolveResult representing a compile-time constant.
+	/// Note: this class is mainly used for literals; there may be other ResolveResult classes
+	/// which are compile-time constants as well.
+	/// For example, a reference to a <c>const</c> field results in a <see cref="MemberResolveResult"/>.
+	/// 
+	/// Check <see cref="ResolveResult.IsCompileTimeConstant"/> to determine is a resolve result is a constant.
 	/// </summary>
 	public class ConstantResolveResult : ResolveResult
 	{

ICSharpCode.NRefactory/Semantics/ConversionResolveResult.cs

@@ -22,6 +22,12 @@ using ICSharpCode.NRefactory.TypeSystem;
 
 namespace ICSharpCode.NRefactory.Semantics
 {
+	/// <summary>
+	/// Represents an implicit or explicit type conversion.
+	/// <c>conversionResolveResult.Input.Type</c> is the source type;
+	/// <c>conversionResolveResult.Type</c> is the target type.
+	/// The <see cref="Conversion"/> property provides details about the type of conversion.
+	/// </summary>
 	public class ConversionResolveResult : ResolveResult
 	{
 		public readonly ResolveResult Input;

ICSharpCode.NRefactory/Semantics/ErrorResolveResult.cs

@@ -23,11 +23,15 @@ namespace ICSharpCode.NRefactory.Semantics
 {
 	/// <summary>
 	/// Represents a resolve error.
+	/// 
+	/// Note: some errors are represented by other classes; for example a <see cref="ConversionResolveResult"/> may
+	/// be erroneous if the conversion is invalid.
 	/// </summary>
+	/// <seealso cref="ResolveResult.IsError"/>.
 	public class ErrorResolveResult : ResolveResult
 	{
 		/// <summary>
-		/// Gets an ErrorResolveResult instance with Type = SharedTypes.UnknownType.
+		/// Gets an ErrorResolveResult instance with <c>Type</c> = <c>SpecialType.UnknownType</c>.
 		/// </summary>
 		public static readonly ErrorResolveResult UnknownError = new ErrorResolveResult(SpecialType.UnknownType);
 		

ICSharpCode.NRefactory/Semantics/InvocationResolveResult.cs

@@ -26,7 +26,7 @@ using ICSharpCode.NRefactory.TypeSystem.Implementation;
 namespace ICSharpCode.NRefactory.Semantics
 {
 	/// <summary>
-	/// Represents the result of a method invocation.
+	/// Represents the result of a method, constructor or indexer invocation.
 	/// </summary>
 	public class InvocationResolveResult : MemberResolveResult
 	{

ICSharpCode.NRefactory/Semantics/LocalResolveResult.cs

@@ -23,7 +23,7 @@ using ICSharpCode.NRefactory.TypeSystem;
 namespace ICSharpCode.NRefactory.Semantics
 {
 	/// <summary>
-	/// Represents a local variable.
+	/// Represents a local variable or parameter.
 	/// </summary>
 	public class LocalResolveResult : ResolveResult
 	{

ICSharpCode.NRefactory/Semantics/MemberResolveResult.cs

@@ -27,6 +27,8 @@ namespace ICSharpCode.NRefactory.Semantics
 {
 	/// <summary>
 	/// Represents the result of a member invocation.
+	/// Used for field/property/event access.
+	/// Also, <see cref="InvocationResultResult"/> derives from MemberResolveResult.
 	/// </summary>
 	public class MemberResolveResult : ResolveResult
 	{

ICSharpCode.NRefactory/Semantics/ResolveResult.cs

@@ -29,7 +29,7 @@ namespace ICSharpCode.NRefactory.Semantics
 	/// </summary>
 	public class ResolveResult
 	{
-		IType type;
+		readonly IType type;
 		
 		public ResolveResult(IType type)
 		{

ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs

@@ -161,6 +161,16 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			return result;
 		}
 		
+		/// <summary>
+		/// Sets the current module.
+		/// This causes ReadTypeReference() to use <see cref="DefaultAssemblyReference.CurrentAssembly"/> for references
+		/// in that module.
+		/// </summary>
+		public void SetCurrentModule(ModuleDefinition module)
+		{
+			this.currentModule = module;
+		}
+		
 		/// <summary>
 		/// Loads a type from Cecil.
 		/// </summary>

ICSharpCode.NRefactory/TypeSystem/ICompilation.cs

@@ -43,7 +43,6 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// Gets the referenced assemblies.
 		/// This list does not include the main assembly.
 		/// </summary>
-		[ObsoleteAttribute("Use compilation.Assemblies.Where(asm != compilation.MainAssembly) instead.")]
 		IList<IAssembly> ReferencedAssemblies { get; }
 		
 		/// <summary>

README

@@ -7,7 +7,10 @@ Features:
 	- Code Completion for C#
 	- Pretty Printer for C#
 	- Lots of C# refactorings
+	
+Non-Features:
 	- VB support is not implemented yet.
+	- NRefactory cannot generate IL code
 
 How to download:
 	- Binaries are provided as a NuGet package (http://nuget.org/packages/ICSharpCode.NRefactory)
@@ -110,6 +113,13 @@ Null-Object pattern:
 	Null nodes are not considered to be part of the AST (e.g. they don't have a parent).
 
 FAQ:
+Q:  What is the difference between NRefactory and Roslyn?
+	- NRefactory is ready and stable, Roslyn is only a CTP at this point of time.
+	- NRefactory does not have VB support.
+	- NRefactory cannot compile code to IL; it's not a full compiler, just a frontend.
+	- NRefactory C# AST is mutable and supports pattern matching; Roslyn is immutable and does not have built-in pattern matching.
+	- NRefactory is Open Source, if you somehow can't get at the information you need, you can modify the code.
+
 Q:	What is the difference between types and type definitions?
 
 A:	Basically, a type (IType) is any type in the .NET type system: