Worked on context actions.

ICSharpCode.NRefactory/CSharp/Refactoring/ContextAction/CreateEventInvocator.cs

@@ -26,6 +26,7 @@
 using System;
 using System.Linq;
 using System.Collections.Generic;
+using ICSharpCode.NRefactory.TypeSystem;
 
 namespace ICSharpCode.NRefactory.CSharp.Refactoring
 {
@@ -53,28 +54,21 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				return;
 			
 			bool hasSenderParam = false;
-/*			var pars = invokeMethod.Parameters;
+			IEnumerable<IParameter> pars = invokeMethod.Parameters;
 			if (invokeMethod.Parameters.Any ()) {
 				var first = invokeMethod.Parameters [0];
-				if (first.Name == "sender" && first.Type.FullName == "System.Object") {
+				if (first.Name == "sender" /*&& first.Type == "System.Object"*/) {
 					hasSenderParam = true;
 					pars = invokeMethod.Parameters.Skip (1);
 				}
 			}
-			
-			foreach (var par in pars) {
-				var typeName = ShortenTypeName (context.Document, par.ReturnType);
-				var decl = new ParameterDeclaration (typeName, par.Name);
-				methodDeclaration.Parameters.Add (decl);
-			}*/
-			
 			const string handlerName = "handler";
 					
 			var arguments = new List<Expression> ();
 			if (hasSenderParam)
 				arguments.Add (new ThisReferenceExpression ());
-//			foreach (var par in pars)
-//				arguments.Add (new IdentifierExpression (par.Name));
+			foreach (var par in pars)
+				arguments.Add (new IdentifierExpression (par.Name));
 			
 			var methodDeclaration = new MethodDeclaration () {
 				Name = "On" + initializer.Name,
@@ -89,6 +83,12 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				}
 			};
 			
+			foreach (var par in pars) {
+				var typeName = context.CreateShortType (par.Type.Resolve (context.TypeResolveContext));
+				var decl = new ParameterDeclaration (typeName, par.Name);
+				methodDeclaration.Parameters.Add (decl);
+			}
+			
 			using (var script = context.StartScript ()) {
 				script.InsertWithCursor ("Create event invocator", methodDeclaration, Script.InsertPosition.After);
 			}

ICSharpCode.NRefactory/CSharp/Refactoring/ContextAction/CreateLocalVariable.cs

@@ -120,7 +120,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				}
 				if (result.Parameters.Count < i)
 					return null;
-				return null; // context.CreateShortType (result.Parameters[i].Type);
+				return context.CreateShortType (result.Parameters[i].Type.Resolve (context.TypeResolveContext));
 			}
 			return null;
 		}

ICSharpCode.NRefactory/CSharp/Refactoring/ContextAction/SplitString.cs

@@ -35,7 +35,6 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				return false;
 			var pexpr = context.GetNode<PrimitiveExpression> ();
 			if (pexpr == null || !(pexpr.Value is string))
-
 				return false;
 			if (pexpr.LiteralValue.StartsWith ("@"))
 				return pexpr.StartLocation < new AstLocation (context.Location.Line, context.Location.Column - 2) &&

ICSharpCode.NRefactory/CSharp/Refactoring/RefactoringContext.cs

@@ -36,6 +36,12 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			get;
 			protected set;
 		}
+
+		public virtual ITypeResolveContext TypeResolveContext {
+			get {
+				return null;
+			}
+		}
 		
 		public AstLocation Location {
 			get;
@@ -53,10 +59,17 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		public abstract AstType CreateShortType (AstType fullType);
 		
 		public abstract AstType CreateShortType (string fullTypeName);
-
+		
+		
+		public AstType CreateShortType (IType type)
+		{
+			return CreateShortType (new TypeSystemAstBuilder ().ConvertType (type));
+		}
+		
+		
 		public abstract ITypeDefinition GetDefinition (AstType resolvedType);
 
-		public abstract void ReplaceReferences (IMember member, MemberDeclaration member);
+		public abstract void ReplaceReferences (IMember member, MemberDeclaration replaceWidth);
 		
 		public AstNode GetNode ()
 		{

ICSharpCode.NRefactory/CSharp/Refactoring/Script.cs

@@ -165,7 +165,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				result.NodeSegments [e.AstNode].EndOffset = stringWriter.GetStringBuilder ().Length;
 			};
 			node.AcceptVisitor (visitor, null);
-			result.Text = formatter.ToString ().TrimEnd ();
+			result.Text = stringWriter.ToString ().TrimEnd ();
 			if (node is FieldDeclaration)
 				result.Text += Context.EolMarker;
 

ICSharpCode.NRefactory/CSharp/Refactoring/TypeSystemAstBuilder.cs

@@ -1,6 +1,5 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 // This code is distributed under MIT license (for details please see \doc\license.txt)
-
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -24,32 +23,32 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		/// <param name="resolver">
 		/// A resolver initialized for the position where the type will be inserted.
 		/// </param>
-		public TypeSystemAstBuilder(CSharpResolver resolver = null)
+		public TypeSystemAstBuilder (CSharpResolver resolver = null)
 		{
 			this.resolver = resolver;
 		}
 		
-		public AstType ConvertType(IType type)
+		public AstType ConvertType (IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException ("type");
 			TypeWithElementType typeWithElementType = type as TypeWithElementType;
 			if (typeWithElementType != null) {
 				if (typeWithElementType is PointerType) {
-					return ConvertType(typeWithElementType.ElementType).MakePointerType();
+					return ConvertType (typeWithElementType.ElementType).MakePointerType ();
 				} else if (typeWithElementType is ArrayType) {
-					return ConvertType(typeWithElementType.ElementType).MakeArrayType(((ArrayType)type).Dimensions);
+					return ConvertType (typeWithElementType.ElementType).MakeArrayType (((ArrayType)type).Dimensions);
 				} else {
 					// e.g. ByReferenceType; not supported as type in C#
-					return ConvertType(typeWithElementType.ElementType);
+					return ConvertType (typeWithElementType.ElementType);
 				}
 			}
 			ParameterizedType pt = type as ParameterizedType;
 			if (pt != null) {
 				if (pt.Name == "Nullable" && pt.Namespace == "System" && pt.TypeParameterCount == 1) {
-					return ConvertType(pt.TypeArguments[0]).MakeNullableType();
+					return ConvertType (pt.TypeArguments [0]).MakeNullableType ();
 				}
-				return ConvertTypeDefinition(pt.GetDefinition(), pt.TypeArguments);
+				return ConvertTypeDefinition (pt.GetDefinition (), pt.TypeArguments);
 			}
 			ITypeDefinition typeDef = type as ITypeDefinition;
 			if (typeDef != null) {
@@ -57,77 +56,77 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					// Create an unbound type
 					IType[] typeArguments = new IType[typeDef.TypeParameterCount];
 					for (int i = 0; i < typeArguments.Length; i++) {
-						typeArguments[i] = SharedTypes.UnknownType;
+						typeArguments [i] = SharedTypes.UnknownType;
 					}
-					return ConvertTypeDefinition(typeDef, typeArguments);
+					return ConvertTypeDefinition (typeDef, typeArguments);
 				} else {
-					return ConvertTypeDefinition(typeDef, EmptyList<IType>.Instance);
+					return ConvertTypeDefinition (typeDef, EmptyList<IType>.Instance);
 				}
 			}
-			return new SimpleType(type.Name);
+			return new SimpleType (type.Name);
 		}
 		
-		AstType ConvertTypeDefinition(ITypeDefinition typeDef, IList<IType> typeArguments)
+		AstType ConvertTypeDefinition (ITypeDefinition typeDef, IList<IType> typeArguments)
 		{
-			Debug.Assert(typeArguments.Count >= typeDef.TypeParameterCount);
-			switch (ReflectionHelper.GetTypeCode(typeDef)) {
-				case TypeCode.Object:
-					return new PrimitiveType("object");
-				case TypeCode.Boolean:
-					return new PrimitiveType("bool");
-				case TypeCode.Char:
-					return new PrimitiveType("char");
-				case TypeCode.SByte:
-					return new PrimitiveType("sbyte");
-				case TypeCode.Byte:
-					return new PrimitiveType("byte");
-				case TypeCode.Int16:
-					return new PrimitiveType("short");
-				case TypeCode.UInt16:
-					return new PrimitiveType("ushort");
-				case TypeCode.Int32:
-					return new PrimitiveType("int");
-				case TypeCode.UInt32:
-					return new PrimitiveType("uint");
-				case TypeCode.Int64:
-					return new PrimitiveType("long");
-				case TypeCode.UInt64:
-					return new PrimitiveType("ulong");
-				case TypeCode.Single:
-					return new PrimitiveType("float");
-				case TypeCode.Double:
-					return new PrimitiveType("double");
-				case TypeCode.Decimal:
-					return new PrimitiveType("decimal");
-				case TypeCode.String:
-					return new PrimitiveType("string");
+			Debug.Assert (typeArguments.Count >= typeDef.TypeParameterCount);
+			switch (ReflectionHelper.GetTypeCode (typeDef)) {
+			case TypeCode.Object:
+				return new PrimitiveType ("object");
+			case TypeCode.Boolean:
+				return new PrimitiveType ("bool");
+			case TypeCode.Char:
+				return new PrimitiveType ("char");
+			case TypeCode.SByte:
+				return new PrimitiveType ("sbyte");
+			case TypeCode.Byte:
+				return new PrimitiveType ("byte");
+			case TypeCode.Int16:
+				return new PrimitiveType ("short");
+			case TypeCode.UInt16:
+				return new PrimitiveType ("ushort");
+			case TypeCode.Int32:
+				return new PrimitiveType ("int");
+			case TypeCode.UInt32:
+				return new PrimitiveType ("uint");
+			case TypeCode.Int64:
+				return new PrimitiveType ("long");
+			case TypeCode.UInt64:
+				return new PrimitiveType ("ulong");
+			case TypeCode.Single:
+				return new PrimitiveType ("float");
+			case TypeCode.Double:
+				return new PrimitiveType ("double");
+			case TypeCode.Decimal:
+				return new PrimitiveType ("decimal");
+			case TypeCode.String:
+				return new PrimitiveType ("string");
 			}
-			if (resolver != null && TypeArgumentsTrivial(typeArguments, OuterTypeParameterCount(typeDef))) {
-				TypeResolveResult trr = resolver.ResolveSimpleName(typeDef.Name, typeArguments) as TypeResolveResult;
-				if (trr != null && !trr.IsError && trr.Type.GetDefinition() == typeDef) {
+			if (resolver != null && TypeArgumentsTrivial (typeArguments, OuterTypeParameterCount (typeDef))) {
+				TypeResolveResult trr = resolver.ResolveSimpleName (typeDef.Name, typeArguments) as TypeResolveResult;
+				if (trr != null && !trr.IsError && trr.Type.GetDefinition () == typeDef) {
 					// We can use the short type name
-					SimpleType shortResult = new SimpleType(typeDef.Name);
-					AddTypeArguments(shortResult, typeArguments, OuterTypeParameterCount(typeDef), typeDef.TypeParameterCount);
+					SimpleType shortResult = new SimpleType (typeDef.Name);
+					AddTypeArguments (shortResult, typeArguments, OuterTypeParameterCount (typeDef), typeDef.TypeParameterCount);
 					return shortResult;
 				}
 			}
 			
-			MemberType result = new MemberType();
+			MemberType result = new MemberType ();
 			if (typeDef.DeclaringTypeDefinition != null) {
 				// Handle nested types
-				result.Target = ConvertTypeDefinition(typeDef.DeclaringTypeDefinition, typeArguments);
+				result.Target = ConvertTypeDefinition (typeDef.DeclaringTypeDefinition, typeArguments);
 				result.MemberName = typeDef.Name;
-				AddTypeArguments(result, typeArguments, OuterTypeParameterCount(typeDef), typeDef.TypeParameterCount);
+				AddTypeArguments (result, typeArguments, OuterTypeParameterCount (typeDef), typeDef.TypeParameterCount);
 			} else {
 				// Handle top-level types
-				if (string.IsNullOrEmpty(typeDef.Namespace)) {
-					result.Target = new SimpleType("global");
+				if (string.IsNullOrEmpty (typeDef.Namespace)) {
+					result.Target = new SimpleType ("global");
 					result.IsDoubleColon = true;
 				} else {
-					result.Target = ConvertNamespace(typeDef.Namespace);
+					result.Target = ConvertNamespace (typeDef.Namespace);
 				}
 				result.MemberName = typeDef.Name;
-				AddTypeArguments(result, typeArguments, 0, typeDef.TypeParameterCount);
+				AddTypeArguments (result, typeArguments, 0, typeDef.TypeParameterCount);
 			}
 			return result;
 		}
@@ -135,7 +134,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		/// <summary>
 		/// Gets the number of type parameters belonging to outer classes.
 		/// </summary>
-		int OuterTypeParameterCount(ITypeDefinition typeDef)
+		int OuterTypeParameterCount (ITypeDefinition typeDef)
 		{
 			if (typeDef.DeclaringType != null)
 				return typeDef.DeclaringType.TypeParameterCount;
@@ -147,10 +146,10 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		/// Gets whether the first <paramref name="num"/> type arguments are trivial,
 		/// that is, they point to a type parameter with the same index.
 		/// </summary>
-		bool TypeArgumentsTrivial(IList<IType> typeArguments, int num)
+		bool TypeArgumentsTrivial (IList<IType> typeArguments, int num)
 		{
 			for (int i = 0; i < num; i++) {
-				ITypeParameter tp = typeArguments[i] as ITypeParameter;
+				ITypeParameter tp = typeArguments [i] as ITypeParameter;
 				if (!(tp != null && tp.OwnerType == EntityType.TypeDefinition && tp.Index == i))
 					return false;
 			}
@@ -164,19 +163,19 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		/// <param name="typeArguments">The list of type arguments</param>
 		/// <param name="startIndex">Index of first type argument to add</param>
 		/// <param name="endIndex">Index after last type argument to add</param>
-		void AddTypeArguments(AstType result, IList<IType> typeArguments, int startIndex, int endIndex)
+		void AddTypeArguments (AstType result, IList<IType> typeArguments, int startIndex, int endIndex)
 		{
 			for (int i = startIndex; i < endIndex; i++) {
-				result.AddChild(ConvertType(typeArguments[i]), AstType.Roles.TypeArgument);
+				result.AddChild (ConvertType (typeArguments [i]), AstType.Roles.TypeArgument);
 			}
 		}
 		
-		AstType ConvertNamespace(string ns)
+		AstType ConvertNamespace (string ns)
 		{
-			string[] parts = ns.Split('.');
+			string[] parts = ns.Split ('.');
 			AstType result;
-			if (IsValidNamespace(parts[0])) {
-				result = new SimpleType(parts[0]);
+			if (IsValidNamespace (parts [0])) {
+				result = new SimpleType (parts [0]);
 			} else {
 				result = new MemberType {
 					Target = new SimpleType("global"),
@@ -193,11 +192,11 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			return result;
 		}
 		
-		bool IsValidNamespace(string firstNamespacePart)
+		bool IsValidNamespace (string firstNamespacePart)
 		{
 			if (resolver == null)
 				return true; // just assume namespaces are valid if we don't have a resolver
-			NamespaceResolveResult nrr = resolver.ResolveSimpleName(firstNamespacePart, EmptyList<IType>.Instance) as NamespaceResolveResult;
+			NamespaceResolveResult nrr = resolver.ResolveSimpleName (firstNamespacePart, EmptyList<IType>.Instance) as NamespaceResolveResult;
 			return nrr != null && !nrr.IsError && nrr.NamespaceName == firstNamespacePart;
 		}
 	}