[CodeIssue] Added ExpressionIsNeverOfProvidedTypeIssue

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

@@ -270,6 +270,7 @@
     <Compile Include="Refactoring\CodeIssues\CompareFloatWithEqualityOperatorIssue.cs" />
     <Compile Include="Refactoring\CodeIssues\ConstantConditionIssue.cs" />
     <Compile Include="Refactoring\CodeIssues\ExpressionIsAlwaysOfProvidedTypeIssue.cs" />
+    <Compile Include="Refactoring\CodeIssues\ExpressionIsNeverOfProvidedTypeIssue.cs" />
     <Compile Include="Refactoring\CodeIssues\NegativeRelationalExpressionIssue.cs" />
     <Compile Include="Refactoring\CodeIssues\ExplicitConversionInForEachIssue.cs" />
     <Compile Include="Refactoring\CodeIssues\ForControlVariableNotModifiedIssue.cs" />

ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/ExpressionIsNeverOfProvidedTypeIssue.cs

@@ -0,0 +1,152 @@
+// 
+// ExpressionIsNeverOfProvidedTypeIssue.cs
+// 
+// Author:
+//      Mansheng Yang <lightyang0@gmail.com>
+// 
+// Copyright (c) 2012 Mansheng Yang <lightyang0@gmail.com>
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// 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.Collections.Generic;
+using System.Linq;
+using ICSharpCode.NRefactory.TypeSystem;
+
+namespace ICSharpCode.NRefactory.CSharp.Refactoring
+{
+	[IssueDescription ("CS0184:Given expression is never of the provided type",
+					   Description = "CS0184:Given expression is never of the provided type.",
+					   Category = IssueCategories.CompilerWarnings,
+					   Severity = Severity.Warning,
+					   IssueMarker = IssueMarker.Underline)]
+	public class ExpressionIsNeverOfProvidedTypeIssue : ICodeIssueProvider
+	{
+		public IEnumerable<CodeIssue> GetIssues (BaseRefactoringContext context)
+		{
+			return new GatherVisitor (context).GetIssues ();
+		}
+
+		class GatherVisitor : GatherVisitorBase
+		{
+			public GatherVisitor (BaseRefactoringContext ctx)
+				: base (ctx)
+			{
+			}
+
+			void AddIssue(IsExpression isExpression)
+			{
+				AddIssue (isExpression, ctx.TranslateString ("Given expression is never of the provided type"));
+			}
+
+			static bool CheckTypeParameterConstraints (IType type, IEnumerable<IType> baseTypes, 
+				ITypeParameter typeParameter)
+			{
+				if (!typeParameter.DirectBaseTypes.All (t => baseTypes.Any (t2 => t2.Equals (t))))
+					return false;
+				if (typeParameter.HasDefaultConstructorConstraint &&
+					!type.GetConstructors (c => c.IsPublic && c.Parameters.Count == 0).Any ())
+					return false;
+				return true;
+			}
+
+			public override void VisitIsExpression (IsExpression isExpression)
+			{
+				base.VisitIsExpression (isExpression);
+
+				var exprType = ctx.Resolve (isExpression.Expression).Type;
+				var providedType = ctx.ResolveType (isExpression.Type);
+
+				var exprBaseTypes = exprType.GetAllBaseTypes ().ToArray ();
+
+				// providedType is a base type of exprType
+				if (exprBaseTypes.Any (t => t.Equals (providedType)))
+					return;
+
+				if ((exprType.IsReferenceType == true && providedType.IsReferenceType == false) ||
+					(exprType.IsReferenceType == false && providedType.IsReferenceType == true)) {
+					AddIssue (isExpression);
+					return;
+				}
+
+				var typeParameter = exprType as ITypeParameter;
+				var providedTypeParameter = providedType as ITypeParameter;
+
+				if (typeParameter != null) {
+					// check if providedType can be a derived type
+					var providedBaseTypes = providedType.GetAllBaseTypes ().ToArray ();
+					var providedTypeDef = providedType.GetDefinition ();
+					// if providedType is sealed, check if it fullfills all the type parameter constraints,
+					// otherwise, only check if it is derived from EffectiveBaseClass
+					if (providedTypeParameter == null && (providedTypeDef == null || providedTypeDef.IsSealed)) {
+						if (CheckTypeParameterConstraints (providedType, providedBaseTypes, typeParameter))
+							return;
+					} else if (providedBaseTypes.Any (t => t.Equals (typeParameter.EffectiveBaseClass))) {
+						return;
+					}
+
+					// if providedType is also a type parameter, check if base classes are compatible
+					if (providedTypeParameter != null &&
+						exprBaseTypes.Any (t => t.Equals (providedTypeParameter.EffectiveBaseClass)))
+						return;
+
+					AddIssue (isExpression);
+					return;
+				}
+				// check if exprType fullfills all the type parameter constraints
+				if (providedTypeParameter != null &&
+					CheckTypeParameterConstraints (exprType, exprBaseTypes, providedTypeParameter))
+					return;
+
+				switch (exprType.Kind) {
+					case TypeKind.Class:
+						var exprTypeDef = exprType.GetDefinition ();
+						if (exprTypeDef == null)
+							return;
+						// exprType is sealed, but providedType is not a base type of it or it does not
+						// fullfill all the type parameter constraints
+						if (exprTypeDef.IsSealed)
+							break;
+
+						// check if providedType can be a derived type
+						if (providedType.Kind == TypeKind.Interface ||
+							providedType.GetAllBaseTypes ().Any (t => t.Equals (exprType)))
+							return;
+
+						if (providedTypeParameter != null &&
+							exprBaseTypes.Any (t => t.Equals (providedTypeParameter.EffectiveBaseClass)))
+							return;
+
+						break;
+
+					case TypeKind.Struct:
+					case TypeKind.Delegate:
+					case TypeKind.Enum:
+					case TypeKind.Array:
+					case TypeKind.Anonymous:
+					case TypeKind.Null:
+						break;
+
+					default:
+						return;
+				}
+				AddIssue (isExpression);
+			}
+		}
+	}
+}

ICSharpCode.NRefactory.Tests/CSharp/CodeIssues/ExpressionIsNeverOfProvidedTypeIssueTests.cs

@@ -0,0 +1,263 @@
+// 
+// ExpressionIsNeverOfProvidedTypeIssueTests.cs
+// 
+// Author:
+//      Mansheng Yang <lightyang0@gmail.com>
+// 
+// Copyright (c) 2012 Mansheng Yang <lightyang0@gmail.com>
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// 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 ICSharpCode.NRefactory.CSharp.Refactoring;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.CodeIssues
+{
+	[TestFixture]
+	public class ExpressionIsNeverOfProvidedTypeIssueTests : InspectionActionTestBase
+	{
+		[Test]
+		public void TestClass ()
+		{
+			var input = @"
+class AnotherClass { }
+class TestClass
+{
+	void TestMethod (AnotherClass x)
+	{
+		if (x is TestClass) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 1);
+		}
+
+		[Test]
+		public void TestClassNoIssue ()
+		{
+			var input = @"
+interface ITest { }
+class TestClass
+{
+	void TestMethod (object x)
+	{
+		if (x is ITest) ;
+		if (x is TestClass) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 0);
+		}
+
+		[Test]
+		public void TestSealedClass ()
+		{
+			var input = @"
+interface ITest { }
+sealed class TestClass
+{
+	void TestMethod (TestClass x)
+	{
+		if (x is ITest) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 1);
+		}
+
+		[Test]
+		public void TestNull ()
+		{
+			var input = @"
+class TestClass
+{
+	void TestMethod ()
+	{
+		if (null is object) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 1);
+		}
+
+		[Test]
+		public void TestClassIsTypeParameter ()
+		{
+			var input = @"
+class TestClass2 { }
+class TestClass
+{
+	void TestMethod<T, T2> (TestClass x) where T : TestClass2 where T2 : struct
+	{
+		if (x is T) ;
+		if (x is T2) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 2);
+		}
+
+		[Test]
+		public void TestClassIsTypeParameter2 ()
+		{
+			var input = @"
+interface ITest { }
+class TestBase { }
+class TestClass2 : TestClass { }
+class TestClass : TestBase
+{
+	void TestMethod<T, T2, T3> (TestClass x) where T : TestBase where T2 : ITest where T3 : TestClass2
+	{
+		if (x is T3) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 0);
+		}
+
+		[Test]
+		public void TestStructIsTypeParameter ()
+		{
+			var input = @"
+interface ITest { }
+struct TestStruct : ITest { }
+class TestClass
+{
+	void TestMethod<T> (TestStruct x) where T : ITest
+	{
+		if (x is T) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 0);
+		}
+
+		[Test]
+		public void TestStructIsTypeParameter2 ()
+		{
+			var input = @"
+struct TestStruct { }
+class TestClass
+{
+	void TestMethod<T> (TestStruct x) where T : class
+	{
+		if (x is T) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 1);
+		}
+
+		[Test]
+		public void TestTypeParameter ()
+		{
+			var input = @"
+class TestClass2 { }
+class TestClass
+{
+	void TestMethod<T> (T x) where T : TestClass2
+	{
+		if (x is TestClass) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 1);
+		}
+
+		[Test]
+		public void TestTypeParameter2 ()
+		{
+			var input = @"
+class TestClass
+{
+	void TestMethod<T> (T x) where T : struct
+	{
+		if (x is TestClass) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 1);
+		}
+
+		[Test]
+		public void TestTypeParameter3 ()
+		{
+			var input = @"
+interface ITest { }
+class TestClass
+{
+	void TestMethod<T> (T x) where T : ITest, new()
+	{
+		if (x is TestClass) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 0);
+		}
+
+		[Test]
+		public void TestTypeParameter4 ()
+		{
+			var input = @"
+interface ITest { }
+sealed class TestClass
+{
+	void TestMethod<T> (T x) where T : ITest
+	{
+		if (x is TestClass) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 1);
+		}
+
+		[Test]
+		public void TestTypeParameter5 ()
+		{
+			var input = @"
+sealed class TestClass
+{
+	public TestClass (int i) { }
+	void TestMethod<T> (T x) where T : new()
+	{
+		if (x is TestClass) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 1);
+		}
+
+		[Test]
+		public void TestTypeParameterIsTypeParameter ()
+		{
+			var input = @"
+class TestClass2 { }
+class TestClass
+{
+	void TestMethod<T, T2> (T x) where T : TestClass where T2 : TestClass2
+	{
+		if (x is T2) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 1);
+		}
+
+		[Test]
+		public void TestTypeParameterIsTypeParameter2 ()
+		{
+			var input = @"
+interface ITest { }
+class TestClass
+{
+	void TestMethod<T, T2> (T x) where T : TestClass where T2 : ITest, new()
+	{
+		if (x is T2) ;
+	}
+}";
+			Test<ExpressionIsNeverOfProvidedTypeIssue> (input, 0);
+		}
+	}
+}

ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj

@@ -109,6 +109,7 @@
     <Compile Include="CSharp\CodeIssues\ConstantConditionIssueTests.cs" />
     <Compile Include="CSharp\CodeIssues\ExplicitConversionInForEachIssueTests.cs" />
     <Compile Include="CSharp\CodeIssues\ExpressionIsAlwaysOfProvidedTypeIssueTests.cs" />
+    <Compile Include="CSharp\CodeIssues\ExpressionIsNeverOfProvidedTypeIssueTests.cs" />
     <Compile Include="CSharp\CodeIssues\ForControlVariableNotModifiedIssueTests.cs" />
     <Compile Include="CSharp\CodeIssues\IdenticalConditionalBranchIssueTests.cs" />
     <Compile Include="CSharp\CodeIssues\LocalVariableHidesMemberIssueTests.cs" />