worked on context actions.

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

@@ -54,11 +54,9 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			
 			pdecl.AddChild (accessor, pdecl.Setter.IsNull ? PropertyDeclaration.SetterRole : PropertyDeclaration.GetterRole);
 			
-			var offset = context.GetOffset (pdecl.RBraceToken.StartLocation) - 1;
-			
 			using (var script = context.StartScript ()) {
 				script.Select (accessorStatement);
-				script.Insert (offset, accessor);
+				script.InsertBefore (pdecl.RBraceToken, accessor);
 				script.FormatText (ctx => GetPropertyDeclaration (context));
 			}
 		}

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

@@ -63,10 +63,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				TrueStatement = new ThrowStatement (new ObjectCreateExpression (context.CreateShortType ("System.ArgumentNullException"), new PrimitiveExpression (parameter.Name)))
 			};
 			
-			var offset = context.GetOffset (bodyStatement.StartLocation) + 1;
-			
 			using (var script = context.StartScript ()) {
-				script.Insert (offset, statement);
+				script.AddTo (bodyStatement, statement);
 			}
 		}
 		

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

@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		public bool IsValid (RefactoringContext context)
 		{
 			var pexpr = context.GetNode<PrimitiveExpression> ();
-			if (pexpr == null || pexpr.LiteralValue.ToUpper ().StartsWith ("0X"))
+			if (pexpr == null || pexpr.LiteralValue.StartsWith ("0X", System.StringComparison.InvariantCultureIgnoreCase))
 				return false;
 			return (pexpr.Value is int) || (pexpr.Value is long) || (pexpr.Value is short) || (pexpr.Value is sbyte) ||
 			(pexpr.Value is uint) || (pexpr.Value is ulong) || (pexpr.Value is ushort) || (pexpr.Value is byte);

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

@@ -24,6 +24,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 using System;
+using System.Linq;
 
 namespace ICSharpCode.NRefactory.CSharp.Refactoring
 {
@@ -37,64 +38,46 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			return GetForeachStatement (context) != null;
 		}
 
-		public void Run (RefactoringContext context)
-		{ // TODO: Missing resolver!
+		static string GetCountProperty (AstType type)
+		{
+			if (type is ComposedType && ((ComposedType)type).ArraySpecifiers.Count > 0)
+				return "Length";
+			return "Count";
+		}
 
-//			var foreachStatement = GetForeachStatement (context);
-//			
-//			var resolver = context.Resolver;
-//			
-//			var result = resolver.Resolve (foreachStatement.InExpression.ToString (), new DomLocation (foreachStatement.InExpression.StartLocation.Line, foreachStatement.InExpression.StartLocation.Column));
-//			string itemNumberProperty = "Count";
-//			
-//			if (result != null && result.ResolvedType != null && result.ResolvedType.ArrayDimensions > 0)
-//				itemNumberProperty = "Length";
-//			
-//			ForStatement forStatement = new ForStatement () {
-//				Initializers = {
-//					new VariableDeclarationStatement (new PrimitiveType ("int"), "i", new PrimitiveExpression (0))
-//				},
-//				Condition = new BinaryOperatorExpression (new IdentifierExpression ("i"), BinaryOperatorType.LessThan, new MemberReferenceExpression (foreachStatement.InExpression.Clone (), itemNumberProperty)),
-//				Iterators = {
-//					new ExpressionStatement (new UnaryOperatorExpression (UnaryOperatorType.PostIncrement, new IdentifierExpression ("i")))
-//				},
-//				EmbeddedStatement = new BlockStatement {
-//					new VariableDeclarationStatement (foreachStatement.VariableType.Clone (), foreachStatement.VariableName, new IndexerExpression (foreachStatement.InExpression.Clone (), new IdentifierExpression ("i")))
-//				}
-//			};
-//			
-//			var editor = context.Document.Editor;
-//			var offset = editor.LocationToOffset (foreachStatement.StartLocation.Line, foreachStatement.StartLocation.Column);
-//			var endOffset = editor.LocationToOffset (foreachStatement.EndLocation.Line, foreachStatement.EndLocation.Column);
-//			var offsets = new List<int> ();
-//			string lineIndent = editor.GetLineIndent (foreachStatement.Parent.StartLocation.Line);
-//			string text = context.OutputNode (forStatement, context.Document.CalcIndentLevel (lineIndent) + 1, delegate(int nodeOffset, AstNode astNode) {
-//				if (astNode is VariableInitializer && ((VariableInitializer)astNode).Name == "i")
-//					offsets.Add (nodeOffset);
-//				if (astNode is IdentifierExpression && ((IdentifierExpression)astNode).Identifier == "i") {
-//					offsets.Add (nodeOffset);
-//				}
-//			});
-//			string foreachBlockText;
-//			
-//			if (foreachStatement.EmbeddedStatement is BlockStatement) {
-//				foreachBlockText = editor.GetTextBetween (foreachStatement.EmbeddedStatement.StartLocation.Line, foreachStatement.EmbeddedStatement.StartLocation.Column + 1,
-//						foreachStatement.EmbeddedStatement.EndLocation.Line, foreachStatement.EmbeddedStatement.EndLocation.Column - 1);
-//			} else {
-//				foreachBlockText = editor.GetTextBetween (foreachStatement. EmbeddedStatement.StartLocation.Line, foreachStatement.EmbeddedStatement.StartLocation.Column,
-//					foreachStatement.EmbeddedStatement.EndLocation.Line, foreachStatement.EmbeddedStatement.EndLocation.Column);
-//			}
-//			string singeleIndent = GetSingleIndent (editor);
-//			string indent = lineIndent + singeleIndent;
-//			foreachBlockText = indent + foreachBlockText.TrimEnd () + editor.EolMarker;
-//			int i = text.LastIndexOf ('}');
-//			while (i > 1 && text[i - 1] == ' ' || text[i - 1] == '\t')
-//				i--;
-//			
-//			text = text.Insert (i, foreachBlockText).TrimEnd ();
-//			string trimmedText = text.TrimStart ();
-//			editor.Replace (offset, endOffset - offset + 1, trimmedText);
-//			context.StartTextLinkMode (offset, "i".Length, offsets.Select (o => o - (text.Length - trimmedText.Length)));
+		public void Run (RefactoringContext context)
+		{
+			var foreachStatement = GetForeachStatement (context);
+			
+			var result = context.ResolveType (foreachStatement.InExpression);
+			var countProperty = GetCountProperty (result);
+			
+			var initializer = new VariableDeclarationStatement (new PrimitiveType ("int"), "i", new PrimitiveExpression (0));
+			var id1 = new IdentifierExpression ("i");
+			var id2 = id1.Clone ();
+			var id3 = id1.Clone ();
+			
+			var forStatement = new ForStatement () {
+				Initializers = { initializer },
+				Condition = new BinaryOperatorExpression (id1, BinaryOperatorType.LessThan, new MemberReferenceExpression (foreachStatement.InExpression.Clone (), countProperty)),
+				Iterators = { new ExpressionStatement (new UnaryOperatorExpression (UnaryOperatorType.PostIncrement, id2)) },
+				EmbeddedStatement = new BlockStatement {
+					new VariableDeclarationStatement (foreachStatement.VariableType.Clone (), foreachStatement.VariableName, new IndexerExpression (foreachStatement.InExpression.Clone (), id3))
+				}
+			};
+			
+			if (foreachStatement.EmbeddedStatement is BlockStatement) {
+				foreach (var child in ((BlockStatement)foreachStatement.EmbeddedStatement).Statements) {
+					forStatement.EmbeddedStatement.AddChild (child.Clone (), BlockStatement.StatementRole);
+				}
+			} else {
+				forStatement.EmbeddedStatement.AddChild (foreachStatement.EmbeddedStatement.Clone (), BlockStatement.StatementRole);
+			}
+			
+			using (var script = context.StartScript ()) {
+				script.Replace (foreachStatement, forStatement);
+				script.Link (initializer.Variables.First ().NameToken, id1, id2, id3);
+			}
 		}
 		
 		static ForeachStatement GetForeachStatement (RefactoringContext context)
@@ -102,7 +85,10 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			var astNode = context.GetNode ();
 			if (astNode == null)
 				return null;
-			return (astNode as ForeachStatement) ?? astNode.Parent as ForeachStatement;
+			var result = (astNode as ForeachStatement) ?? astNode.Parent as ForeachStatement;
+			if (result == null || context.ResolveType (result.InExpression) == null)
+				return null;
+			return result;
 		}
 	}
 }

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

@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		public bool IsValid (RefactoringContext context)
 		{
 			var pexpr = context.GetNode<PrimitiveExpression> ();
-			if (pexpr == null || !pexpr.LiteralValue.ToUpper ().StartsWith ("0X"))
+			if (pexpr == null || !pexpr.LiteralValue.StartsWith ("0X", System.StringComparison.InvariantCultureIgnoreCase))
 				return false;
 			return (pexpr.Value is int) || (pexpr.Value is long) || (pexpr.Value is short) || (pexpr.Value is sbyte) ||
 			(pexpr.Value is uint) || (pexpr.Value is ulong) || (pexpr.Value is ushort) || (pexpr.Value is byte);

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

@@ -63,16 +63,11 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			};
 			
 			using (var script = context.StartScript ()) {
-				
 				script.Replace (property, newProperty);
-				
-				int offset = context.GetOffset (property.StartLocation.Line, 1);
-				script.Insert (offset, backingStore);
-				
+				script.InsertBefore (property, backingStore);
 				script.Link (initializer, id1, id2);
 			}
 		}
-		
 	}
 }
 

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

@@ -53,7 +53,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			
 			using (var script = context.StartScript ()) {
 				script.Replace (varDecl, varDecl.Parent is ForStatement ? (AstNode)assign : new ExpressionStatement (assign));
-				script.Insert (context.GetOffset (varDecl.StartLocation.Line, 1), newVarDecl);
+				script.InsertBefore (varDecl, newVarDecl);
 			}
 		}
 		

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

@@ -49,7 +49,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			var pexpr = context.GetNode<PrimitiveExpression> ();
 			int offset = context.GetOffset (context.Location);
 			using (var script = context.StartScript ()) {
-				script.Insert (offset, pexpr.LiteralValue.StartsWith ("@") ? "\" + @\"" : "\" + \"");
+				script.InsertText (offset, pexpr.LiteralValue.StartsWith ("@") ? "\" + @\"" : "\" + \"");
 			}
 		}	
 	}

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

@@ -34,36 +34,26 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			return GetVariableDeclarationStatement (context) != null;
 		}
 		
-		// TODO: Resolving
 		public void Run (RefactoringContext context)
 		{
-//			var varDecl = GetVariableDeclarationStatement (context);
-//			var resolver = context.Resolver;
-//			var resolveResult = resolver.Resolve (varDecl.Variables.First ().Initializer.ToString (), context.Location);
-//			
-//			int offset = context.Document.Editor.LocationToOffset (varDecl.Type.StartLocation.Line, varDecl.Type.StartLocation.Column);
-//			int endOffset = context.Document.Editor.LocationToOffset (varDecl.Type.EndLocation.Line, varDecl.Type.EndLocation.Column);
-//			string text = context.OutputNode (ShortenTypeName (context.Document, resolveResult.ResolvedType), 0).Trim ();
-//			context.DoReplace (offset, endOffset - offset, text);
-//			context.CommitChanges ();
-//			context.Document.Editor.Caret.Offset = offset + text.Length;
+			var varDecl = GetVariableDeclarationStatement (context);
+			var resolver = context.Resolver;
+			
+			using (var script = context.StartScript ()) {
+				script.Replace (varDecl.Type, context.ResolveType (varDecl.Variables.First ().Initializer));
+			}
 		}
 		
 		static VariableDeclarationStatement GetVariableDeclarationStatement (RefactoringContext context)
 		{
-//			var result = context.GetNode<VariableDeclarationStatement> ();
-//			if (result != null && result.Variables.Count == 1 && !result.Variables.First ().Initializer.IsNull && result.Type.Contains (context.Location.Line, context.Location.Column) && result.Type.IsMatch (new SimpleType ("var"))) {
-//				var resolver = context.Resolver;
-//				var resolveResult = resolver.Resolve (result.Variables.First ().Initializer.ToString (), context.Location);
-//				if (resolveResult == null || resolveResult.ResolvedType == null || string.IsNullOrEmpty (resolveResult.ResolvedType.FullName))
-//					return null;
-//				return result;
-//				
-//			}
+			var result = context.GetNode<VariableDeclarationStatement> ();
+			if (result.Variables.Count == 1 && !result.Variables.First ().Initializer.IsNull && result.Type.Contains (context.Location.Line, context.Location.Column) && result.Type.IsMatch (new SimpleType ("var"))) {
+				if (context.ResolveType (result.Variables.First ().Initializer) == null)
+					return null;
+				return result;
+			}
 			return null;
 		}
-		
-
 	}
 }
 

ICSharpCode.NRefactory/CSharp/Refactoring/Script.cs

@@ -55,17 +55,25 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			changes.Add (change);
 		}
 		
-		public void Insert (int offset, string text)
+		public void InsertText (int offset, string text)
 		{
 			Queue (Context.CreateTextReplaceAction (offset, 0, text));
 		}
 		
-		public void Insert (int offset, AstNode node)
+		public void InsertBefore (AstNode node, AstNode insertNode)
 		{
-			var output = OutputNode (GetIndentLevelAt (offset), node);
-			Queue (Context.CreateNodeOutputAction (offset, 0, output));
+			var startOffset = Context.GetOffset (node.StartLocation);
+			var output = OutputNode (GetIndentLevelAt (startOffset), insertNode);
+			Queue (Context.CreateNodeOutputAction (startOffset, 0, output));
 		}
 
+		public void AddTo (BlockStatement bodyStatement, AstNode insertNode)
+		{
+			var startOffset = Context.GetOffset (bodyStatement.LBraceToken.StartLocation) + 1;
+			var output = OutputNode (GetIndentLevelAt (startOffset), insertNode);
+			Queue (Context.CreateNodeOutputAction (startOffset, 0, output));
+		}
+		
 		public void Link (params AstNode[] nodes)
 		{
 			Queue (Context.CreateLinkAction (nodes));
@@ -83,12 +91,12 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			Remove (startOffset, endOffset - startOffset);
 		}
 		
-		public void Remove (int offset, int length)
+		void Remove (int offset, int length)
 		{
 			Queue (Context.CreateTextReplaceAction (offset, length, null));
 		}
 		
-		public void Replace (int offset, int length, string text)
+		void Replace (int offset, int length, string text)
 		{
 			Queue (Context.CreateTextReplaceAction (offset, length, text));
 		}
@@ -98,8 +106,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			var startOffset = Context.GetOffset (node.StartLocation);
 			var endOffset = Context.GetOffset (node.EndLocation);
 			int level = 0;
-//			if (!(replaceWith is Expression))
-//				level = GetIndentLevelAt (startOffset);
+			if (!(replaceWith is Expression))
+				level = GetIndentLevelAt (startOffset);
 			Queue (Context.CreateNodeOutputAction (startOffset, endOffset - startOffset, OutputNode (level, replaceWith)));
 		}