Fixed SD2-1572 - operators are shown as nameless methods in code completion

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/3.0@4740 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

data/resources/image/BitmapResources/BitmapResources.res

@@ -267,6 +267,7 @@ Icons.16x16.SharpQuery.Remove                   = SharpQueryIcons\Icons.16x16.Sh
 Icons.16x16.NameSpace                             = ClassBrowserIcons\Icons.16x16.NameSpace.png
 Icons.16x16.Literal                               = ClassBrowserIcons\Icons.16x16.Literal.png
 Icons.16x16.Reference                             = ClassBrowserIcons\Icons.16x16.Reference.png
+Icons.16x16.Keyword                               = ClassBrowserIcons\Icons.16x16.Keyword.png
 
 
 Icons.16x16.Class                                 = ClassBrowserIcons\Icons.16x16.Class.png
@@ -275,6 +276,7 @@ Icons.16x16.Enum                                  = ClassBrowserIcons\Icons.16x1
 Icons.16x16.Interface                             = ClassBrowserIcons\Icons.16x16.Interface.png
 Icons.16x16.Delegate                              = ClassBrowserIcons\Icons.16x16.Delegate.png
 Icons.16x16.Method                                = ClassBrowserIcons\Icons.16x16.Method.png
+Icons.16x16.Operator                              = ClassBrowserIcons\Icons.16x16.Operator.png
 Icons.16x16.Property                              = ClassBrowserIcons\Icons.16x16.Property.png
 Icons.16x16.Indexer                               = ClassBrowserIcons\Icons.16x16.Indexer.png
 Icons.16x16.Field                                 = ClassBrowserIcons\Icons.16x16.Field.png

src/Libraries/NRefactory/Project/Src/Ast/Enums.cs

@@ -310,6 +310,9 @@ namespace ICSharpCode.NRefactory.Ast
 		Modulus,
 		Concat,
 		
+		UnaryPlus,
+		UnaryMinus,
+		
 		Not,
 		BitNot,
 		

src/Libraries/NRefactory/Project/Src/Parser/CSharp/CSharpParser.cs

@@ -610,5 +610,70 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 				item.Parent = parent;
 			}
 		}
+		
+		internal static string GetReflectionNameForOperator(OverloadableOperatorType op)
+		{
+			switch (op) {
+				case OverloadableOperatorType.Add:
+					return "op_Addition";
+				case OverloadableOperatorType.BitNot:
+					return "op_OnesComplement";
+				case OverloadableOperatorType.BitwiseAnd:
+					return "op_BitwiseAnd";
+				case OverloadableOperatorType.BitwiseOr:
+					return "op_BitwiseOr";
+				case OverloadableOperatorType.Concat:
+				case OverloadableOperatorType.CType:
+					return "op_unknown";
+				case OverloadableOperatorType.Decrement:
+					return "op_Decrement";
+				case OverloadableOperatorType.Divide:
+					return "op_Division";
+				case OverloadableOperatorType.DivideInteger:
+					return "op_unknown";
+				case OverloadableOperatorType.Equality:
+					return "op_Equality";
+				case OverloadableOperatorType.ExclusiveOr:
+					return "op_ExclusiveOr";
+				case OverloadableOperatorType.GreaterThan:
+					return "op_GreaterThan";
+				case OverloadableOperatorType.GreaterThanOrEqual:
+					return "op_GreaterThanOrEqual";
+				case OverloadableOperatorType.Increment:
+					return "op_Increment";
+				case OverloadableOperatorType.InEquality:
+					return "op_Inequality";
+				case OverloadableOperatorType.IsFalse:
+					return "op_False";
+				case OverloadableOperatorType.IsTrue:
+					return "op_True";
+				case OverloadableOperatorType.LessThan:
+					return "op_LessThan";
+				case OverloadableOperatorType.LessThanOrEqual:
+					return "op_LessThanOrEqual";
+				case OverloadableOperatorType.Like:
+					return "op_unknown";
+				case OverloadableOperatorType.Modulus:
+					return "op_Modulus";
+				case OverloadableOperatorType.Multiply:
+					return "op_Multiply";
+				case OverloadableOperatorType.Not:
+					return "op_LogicalNot";
+				case OverloadableOperatorType.Power:
+					return "op_unknown";
+				case OverloadableOperatorType.ShiftLeft:
+					return "op_LeftShift";
+				case OverloadableOperatorType.ShiftRight:
+					return "op_RightShift";
+				case OverloadableOperatorType.Subtract:
+					return "op_Subtraction";
+				case OverloadableOperatorType.UnaryMinus:
+					return "op_UnaryNegation";
+				case OverloadableOperatorType.UnaryPlus:
+					return "op_UnaryPlus";
+				default:
+					throw new NotSupportedException();
+			}
+		}
 	}
 }

src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG

@@ -880,6 +880,7 @@ StructMemberDecl<ModifierList m, List<AttributeSection> attributes>
 		List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
 		parameters.Add(new ParameterDeclarationExpression(type, varName));
 		OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
+			Name = (isImplicit ? "op_Implicit" : "op_Explicit"),
 			Modifier = m.Modifier,
 			Attributes = attributes, 
 			Parameters = parameters, 
@@ -915,11 +916,16 @@ StructMemberDecl<ModifierList m, List<AttributeSection> attributes>
 		(. Location endPos = t.Location; .)
 		")" ( Block<out stmt> | ";" )
 		(.
+			if (op == OverloadableOperatorType.Add && secondType == null)
+				op = OverloadableOperatorType.UnaryPlus;
+			if (op == OverloadableOperatorType.Subtract && secondType == null)
+				op = OverloadableOperatorType.UnaryMinus;
 			OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
 				Modifier = m.Modifier,
 				Attributes = attributes,
 				TypeReference = type,
 				OverloadableOperator = op,
+				Name = GetReflectionNameForOperator(op),
 				Body = (BlockStatement)stmt,
 				StartLocation = m.GetDeclarationLocation(startPos),
 				EndLocation = endPos

src/Libraries/NRefactory/Test/Parser/TypeLevel/OperatorDeclarationTests.cs

@@ -36,12 +36,25 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		}
 		
 		[Test]
-		public void CSharpPlusOperatorDeclarationTest()
+		public void CSharpBinaryPlusOperatorDeclarationTest()
 		{
 			OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static MyObject operator +(MyObject a, MyObject b)  {}");
 			Assert.IsTrue(!od.IsConversionOperator);
+			Assert.AreEqual(OverloadableOperatorType.Add, od.OverloadableOperator);
 			Assert.AreEqual(2, od.Parameters.Count);
 			Assert.AreEqual("MyObject", od.TypeReference.Type);
+			Assert.AreEqual("op_Addition", od.Name);
+		}
+		
+		[Test]
+		public void CSharpUnaryPlusOperatorDeclarationTest()
+		{
+			OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static MyObject operator +(MyObject a)  {}");
+			Assert.IsTrue(!od.IsConversionOperator);
+			Assert.AreEqual(OverloadableOperatorType.UnaryPlus, od.OverloadableOperator);
+			Assert.AreEqual(1, od.Parameters.Count);
+			Assert.AreEqual("MyObject", od.TypeReference.Type);
+			Assert.AreEqual("op_UnaryPlus", od.Name);
 		}
 		#endregion
 		

src/Main/Base/Project/Src/Services/ClassBrowserIcons/ClassBrowserIconService.cs

@@ -23,10 +23,11 @@ namespace ICSharpCode.SharpDevelop
 		
 		public const int LocalVariableIndex = 16;
 		public const int ParameterIndex = 17;
-		public const int KeywordIndex = NamespaceIndex; // TODO: give keywords their own icon
-		public const int CodeTemplateIndex = 18;
+		public const int OperatorIndex = 18;
+		public const int KeywordIndex = NamespaceIndex; //19;
+		public const int CodeTemplateIndex = 20;
 		
-		public const int ClassIndex     = 19;
+		public const int ClassIndex     = 21;
 		public const int StructIndex    = ClassIndex + 1 * 4;
 		public const int InterfaceIndex = ClassIndex + 2 * 4;
 		public const int EnumIndex      = ClassIndex + 3 * 4;
@@ -79,7 +80,10 @@ namespace ICSharpCode.SharpDevelop
 		
 		public static int GetIcon(IMethod method)
 		{
-			return MethodIndex + GetModifierOffset(method.Modifiers);
+			if (method.GetIsOperator())
+				return OperatorIndex;
+			else
+				return MethodIndex + GetModifierOffset(method.Modifiers);
 		}
 		
 		public static int GetIcon(IProperty property)
@@ -242,9 +246,11 @@ namespace ICSharpCode.SharpDevelop
 			
 			imglist.Images.Add(WinFormsResourceService.GetBitmap("Icons.16x16.Local"));
 			imglist.Images.Add(WinFormsResourceService.GetBitmap("Icons.16x16.Parameter"));
+			imglist.Images.Add(WinFormsResourceService.GetBitmap("Icons.16x16.Operator"));
+			imglist.Images.Add(WinFormsResourceService.GetBitmap("Icons.16x16.Keyword"));
 			imglist.Images.Add(WinFormsResourceService.GetBitmap("Icons.16x16.TextFileIcon"));
 			
-			imglist.Images.Add(WinFormsResourceService.GetBitmap("Icons.16x16.Class")); //19
+			imglist.Images.Add(WinFormsResourceService.GetBitmap("Icons.16x16.Class")); //21
 			imglist.Images.Add(WinFormsResourceService.GetBitmap("Icons.16x16.InternalClass"));
 			imglist.Images.Add(WinFormsResourceService.GetBitmap("Icons.16x16.ProtectedClass"));
 			imglist.Images.Add(WinFormsResourceService.GetBitmap("Icons.16x16.PrivateClass"));

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/DefaultMethod.cs

@@ -52,7 +52,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	}
 	
 	[Serializable]
-	public class DefaultMethod : AbstractMember, IMethod
+	public class DefaultMethod : AbstractMember, IMethod, IMethod2
 	{
 		IList<IParameter> parameters;
 		IList<ITypeParameter> typeParameters;
@@ -166,6 +166,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		public virtual bool IsOperator {
+			get {
+				return Name.StartsWith("op_", StringComparison.Ordinal);
+			}
+		}
+		
 		public DefaultMethod(IClass declaringType, string name) : base(declaringType, name)
 		{
 		}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Interfaces/IMethod.cs

@@ -35,4 +35,23 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get;
 		}
 	}
+	
+	public interface IMethod2 : IMethod
+	{
+		bool IsOperator {
+			get;
+		}
+	}
+	
+	public static class Method2Compatibility
+	{
+		public static bool GetIsOperator(this IMethod method)
+		{
+			IMethod2 method2 = method as IMethod2;
+			if (method2 != null)
+				return method2.IsOperator;
+			else
+				return false;
+		}
+	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/LanguageProperties.cs

@@ -222,10 +222,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public virtual bool ShowMember(IMember member, bool showStatic)
 		{
-			if (member is IProperty && ((IProperty)member).IsIndexer) {
+			IProperty property = member as IProperty;
+			if (property != null && property.IsIndexer) {
 				return false;
 			}
-			if (member is IMethod && ((IMethod)member).IsConstructor) {
+			IMethod method = member as IMethod;
+			if (method != null && (method.IsConstructor || method.GetIsOperator())) {
 				return false;
 			}
 			return member.IsStatic == showStatic;
@@ -335,7 +337,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 				if (member is ArrayReturnType.ArrayIndexer) {
 					return false;
 				}
-				if (member is IMethod && ((IMethod)member).IsConstructor) {
+				IMethod method = member as IMethod;
+				if (method != null && (method.IsConstructor || method.GetIsOperator())) {
 					return false;
 				}
 				return member.IsStatic || !showStatic;