Merge branch 'master' of git://github.com/icsharpcode/ILSpy into Debugger

ICSharpCode.NRefactory.Tests/CSharp/InsertParenthesesVisitorTests.cs

@@ -85,6 +85,33 @@ namespace ICSharpCode.NRefactory.CSharp
 			Assert.AreEqual("(MyType)(!a)", InsertReadable(expr));
 		}
 		
+		[Test]
+		public void TrickyCast4()
+		{
+			Expression expr = new PrimitiveExpression(int.MinValue).CastTo(new SimpleType("MyType"));
+			
+			Assert.AreEqual("(MyType)(-2147483648)", InsertRequired(expr));
+			Assert.AreEqual("(MyType)(-2147483648)", InsertReadable(expr));
+		}
+		
+		[Test]
+		public void TrickyCast5()
+		{
+			Expression expr = new PrimitiveExpression(-1.0).CastTo(new SimpleType("MyType"));
+			
+			Assert.AreEqual("(MyType)(-1.0)", InsertRequired(expr));
+			Assert.AreEqual("(MyType)(-1.0)", InsertReadable(expr));
+		}
+		
+		[Test]
+		public void TrickyCast6()
+		{
+			Expression expr = new PrimitiveExpression(int.MinValue).CastTo(new PrimitiveType("double"));
+			
+			Assert.AreEqual("(double)-2147483648", InsertRequired(expr));
+			Assert.AreEqual("(double)-2147483648", InsertReadable(expr));
+		}
+		
 		[Test]
 		public void CastAndInvoke()
 		{

ICSharpCode.NRefactory/CSharp/OutputVisitor/InsertParenthesesVisitor.cs

@@ -156,6 +156,41 @@ namespace ICSharpCode.NRefactory.CSharp
 					Parenthesize(castExpression.Expression);
 				}
 			}
+			// The above issue can also happen with PrimitiveExpressions representing negative values:
+			PrimitiveExpression pe = castExpression.Expression as PrimitiveExpression;
+			if (pe != null && pe.Value != null && TypeCanBeMisinterpretedAsExpression(castExpression.Type)) {
+				TypeCode typeCode = Type.GetTypeCode(pe.Value.GetType());
+				switch (typeCode) {
+					case TypeCode.SByte:
+						if ((sbyte)pe.Value < 0)
+							Parenthesize(castExpression.Expression);
+						break;
+					case TypeCode.Int16:
+						if ((short)pe.Value < 0)
+							Parenthesize(castExpression.Expression);
+						break;
+					case TypeCode.Int32:
+						if ((int)pe.Value < 0)
+							Parenthesize(castExpression.Expression);
+						break;
+					case TypeCode.Int64:
+						if ((long)pe.Value < 0)
+							Parenthesize(castExpression.Expression);
+						break;
+					case TypeCode.Single:
+						if ((float)pe.Value < 0)
+							Parenthesize(castExpression.Expression);
+						break;
+					case TypeCode.Double:
+						if ((double)pe.Value < 0)
+							Parenthesize(castExpression.Expression);
+						break;
+					case TypeCode.Decimal:
+						if ((decimal)pe.Value < 0)
+							Parenthesize(castExpression.Expression);
+						break;
+				}
+			}
 			return base.VisitCastExpression(castExpression, data);
 		}
 		

ICSharpCode.NRefactory/CSharp/OutputVisitor/OutputVisitor.cs

@@ -747,7 +747,12 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			StartNode(namedArgumentExpression);
 			WriteIdentifier(namedArgumentExpression.Identifier);
-			WriteToken(":", NamedArgumentExpression.Roles.Colon);
+			if (namedArgumentExpression.Parent is ArrayInitializerExpression) {
+				Space();
+				WriteToken("=", NamedArgumentExpression.Roles.Assign);
+			} else {
+				WriteToken(":", NamedArgumentExpression.Roles.Colon);
+			}
 			Space();
 			namedArgumentExpression.Expression.AcceptVisitor(this, data);
 			return EndNode(namedArgumentExpression);
@@ -765,8 +770,14 @@ namespace ICSharpCode.NRefactory.CSharp
 			StartNode(objectCreateExpression);
 			WriteKeyword("new");
 			objectCreateExpression.Type.AcceptVisitor(this, data);
-			Space(policy.SpaceBeforeMethodCallParentheses);
-			WriteCommaSeparatedListInParenthesis(objectCreateExpression.Arguments, policy.SpaceWithinMethodCallParentheses);
+			bool useParenthesis = objectCreateExpression.Arguments.Any() || objectCreateExpression.Initializer.IsNull;
+			// also use parenthesis if there is an '(' token and this isn't an anonymous type
+			if (!objectCreateExpression.LParToken.IsNull && !objectCreateExpression.Type.IsNull)
+				useParenthesis = true;
+			if (useParenthesis) {
+				Space(policy.SpaceBeforeMethodCallParentheses);
+				WriteCommaSeparatedListInParenthesis(objectCreateExpression.Arguments, policy.SpaceWithinMethodCallParentheses);
+			}
 			objectCreateExpression.Initializer.AcceptVisitor(this, data);
 			return EndNode(objectCreateExpression);
 		}
@@ -1021,15 +1032,21 @@ namespace ICSharpCode.NRefactory.CSharp
 		public object VisitQueryExpression(QueryExpression queryExpression, object data)
 		{
 			StartNode(queryExpression);
+			bool indent = !(queryExpression.Parent is QueryContinuationClause);
+			if (indent) {
+				formatter.Indent();
+				NewLine();
+			}
 			bool first = true;
 			foreach (var clause in queryExpression.Clauses) {
-				if (first) {
+				if (first)
 					first = false;
-				} else {
+				else
 					NewLine();
-				}
 				clause.AcceptVisitor(this, data);
 			}
+			if (indent)
+				formatter.Unindent();
 			return EndNode(queryExpression);
 		}
 		

ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs

@@ -1761,9 +1761,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			return
 				from c in context.GetClasses(namespaceName, StringComparer.Ordinal)
-				where c.IsStatic
+				where c.IsStatic && c.HasExtensionMethods
 				from m in c.Methods
-				where (m.IsExtensionMethod)
+				where m.IsExtensionMethod
 				select m;
 		}
 		#endregion