Implement EnvDTE.CodeFunction2.OverrideKind

The T4MVC template checks that a method is an overridden method.

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeFunction.cs

@@ -8,7 +8,6 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 {
 	public class CodeFunction : CodeElement
 	{
-		IMethodOrProperty method;
 		IDocumentLoader documentLoader;
 		
 		public CodeFunction(IMethod method)
@@ -19,7 +18,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		public CodeFunction(IMethod method, IDocumentLoader documentLoader)
 			: base(method)
 		{
-			this.method = method;
+			this.Method = method;
 			this.documentLoader = documentLoader;
 		}
 		
@@ -32,6 +31,8 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		{
 		}
 		
+		protected IMethodOrProperty Method { get; private set; }
+		
 		public override vsCMElement Kind {
 			get { return vsCMElement.vsCMElementFunction; }
 		}
@@ -43,28 +44,28 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		
 		public override TextPoint GetStartPoint()
 		{
-			return new TextPoint(method.GetStartPosition(), documentLoader);
+			return new TextPoint(Method.GetStartPosition(), documentLoader);
 		}
 		
 		public override TextPoint GetEndPoint()
 		{
-			return new TextPoint(method.GetEndPosition(), documentLoader);
+			return new TextPoint(Method.GetEndPosition(), documentLoader);
 		}
 		
 		public virtual CodeElements Parameters {
-			get { return new CodeParameters(method.ProjectContent, method.Parameters); }
+			get { return new CodeParameters(Method.ProjectContent, Method.Parameters); }
 		}
 		
 		public virtual CodeTypeRef2 Type {
-			get { return new CodeTypeRef2(method.ProjectContent, this, method.ReturnType); }
+			get { return new CodeTypeRef2(Method.ProjectContent, this, Method.ReturnType); }
 		}
 		
 		public virtual CodeElements Attributes {
-			get { return new CodeAttributes(method); }
+			get { return new CodeAttributes(Method); }
 		}
 		
 		public virtual bool CanOverride {
-			get { return MustImplement || method.IsVirtual; }
+			get { return MustImplement || Method.IsVirtual; }
 			set { throw new NotImplementedException(); }
 		}
 		
@@ -74,18 +75,18 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		
 		vsCMFunction GetFunctionKind()
 		{
-			if (method.IsConstructor()) {
+			if (Method.IsConstructor()) {
 				return vsCMFunction.vsCMFunctionConstructor;
 			}
 			return vsCMFunction.vsCMFunctionFunction;
 		}
 		
 		public virtual bool IsShared {
-			get { return method.IsStatic; }
+			get { return Method.IsStatic; }
 		}
 		
 		public virtual bool MustImplement {
-			get { return method.IsAbstract; }
+			get { return Method.IsAbstract; }
 		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeFunction2.cs

@@ -18,7 +18,23 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		}
 		
 		public virtual vsCMOverrideKind OverrideKind {
-			get { throw new NotImplementedException(); }
+			get { return GetOverrideKind(); }
+		}
+		
+		vsCMOverrideKind GetOverrideKind()
+		{
+			if (Method.IsAbstract) {
+				return vsCMOverrideKind.vsCMOverrideKindAbstract;
+			} else if (Method.IsVirtual) {
+				return vsCMOverrideKind.vsCMOverrideKindVirtual;
+			} else if (Method.IsOverride) {
+				return vsCMOverrideKind.vsCMOverrideKindOverride;
+			} else if (Method.IsSealed) {
+				return vsCMOverrideKind.vsCMOverrideKindSealed;
+			} else if (Method.IsNew) {
+				return vsCMOverrideKind.vsCMOverrideKindNew;
+			}
+			return vsCMOverrideKind.vsCMOverrideKindNone;
 		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/vsCMOverrideKind.cs

@@ -7,6 +7,11 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 {
 	public enum vsCMOverrideKind
 	{
-		vsCMOverrideKindOverride = 4
+		vsCMOverrideKindNone     = 0,
+		vsCMOverrideKindAbstract = 1,
+		vsCMOverrideKindVirtual  = 2,
+		vsCMOverrideKindOverride = 4,
+		vsCMOverrideKindNew      = 8,
+		vsCMOverrideKindSealed   = 16
 	}
 }

src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj

@@ -82,6 +82,7 @@
     <Compile Include="Src\EnvDTE\CodeClass2Tests.cs" />
     <Compile Include="Src\EnvDTE\CodeDelegateTests.cs" />
     <Compile Include="Src\EnvDTE\CodeElementsInNamespaceTests.cs" />
+    <Compile Include="Src\EnvDTE\CodeFunction2Tests.cs" />
     <Compile Include="Src\EnvDTE\CodeFunctionTests.cs" />
     <Compile Include="Src\EnvDTE\CodeImportTests.cs" />
     <Compile Include="Src\EnvDTE\CodeInterfaceTests.cs" />

src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeFunction2Tests.cs

@@ -0,0 +1,99 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement.EnvDTE;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Tests.EnvDTE
+{
+	[TestFixture]
+	public class CodeFunction2Tests
+	{
+		CodeFunction2 codeFunction;
+		MethodHelper helper;
+		
+		[SetUp]
+		public void Init()
+		{
+			helper = new MethodHelper();
+		}
+		
+		void CreatePublicFunction(string name)
+		{
+			helper.CreatePublicMethod(name);
+			CreateFunction();
+		}
+		
+		void CreateFunction()
+		{
+			codeFunction = new CodeFunction2(helper.Method);
+		}
+		
+		[Test]
+		public void OverrideKind_OrdinaryMethod_ReturnsNone()
+		{
+			CreatePublicFunction("MyClass.MyFunction");
+			
+			vsCMOverrideKind kind = codeFunction.OverrideKind;
+			
+			Assert.AreEqual(vsCMOverrideKind.vsCMOverrideKindNone, kind);
+		}
+		
+		[Test]
+		public void OverrideKind_AbstractMethod_ReturnsAbstract()
+		{
+			CreatePublicFunction("MyClass.MyFunction");
+			helper.MakeMethodAbstract();
+			
+			vsCMOverrideKind kind = codeFunction.OverrideKind;
+			
+			Assert.AreEqual(vsCMOverrideKind.vsCMOverrideKindAbstract, kind);
+		}
+		
+		[Test]
+		public void OverrideKind_VirtualMethod_ReturnsVirtual()
+		{
+			CreatePublicFunction("MyClass.MyFunction");
+			helper.MakeMethodVirtual();
+			
+			vsCMOverrideKind kind = codeFunction.OverrideKind;
+			
+			Assert.AreEqual(vsCMOverrideKind.vsCMOverrideKindVirtual, kind);
+		}
+		
+		[Test]
+		public void OverrideKind_MethodOverride_ReturnsOverride()
+		{
+			CreatePublicFunction("MyClass.MyFunction");
+			helper.MakeMethodOverride();
+			
+			vsCMOverrideKind kind = codeFunction.OverrideKind;
+			
+			Assert.AreEqual(vsCMOverrideKind.vsCMOverrideKindOverride, kind);
+		}
+		
+		[Test]
+		public void OverrideKind_SealedMethod_ReturnsSealed()
+		{
+			CreatePublicFunction("MyClass.MyFunction");
+			helper.MakeMethodSealed();
+			
+			vsCMOverrideKind kind = codeFunction.OverrideKind;
+			
+			Assert.AreEqual(vsCMOverrideKind.vsCMOverrideKindSealed, kind);
+		}
+		
+		[Test]
+		public void OverrideKind_MethodHiddenByNewKeyword_ReturnsNew()
+		{
+			CreatePublicFunction("MyClass.MyFunction");
+			helper.MakeMethodNewOverride();
+			
+			vsCMOverrideKind kind = codeFunction.OverrideKind;
+			
+			Assert.AreEqual(vsCMOverrideKind.vsCMOverrideKindNew, kind);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/MethodHelper.cs

@@ -140,5 +140,20 @@ namespace PackageManagement.Tests.Helpers
 			attributeHelper.CreateAttribute(attributeTypeName);
 			attributeHelper.AddAttributeToMethod(Method);
 		}
+		
+		public void MakeMethodOverride()
+		{
+			Method.Stub(m => m.IsOverride).Return(true);
+		}
+		
+		public void MakeMethodSealed()
+		{
+			Method.Stub(m => m.IsSealed).Return(true);
+		}
+		
+		public void MakeMethodNewOverride()
+		{
+			Method.Stub(m => m.IsNew).Return(true);
+		}
 	}
 }