Refactoring stuff.

Zotonic - Atom Feed Module 2012-08-21T17:55:14+02:00 http://www.riviti.org/en/feed/article Refactoring stuff. - Article http://www.riviti.org/en/id/327 2012-08-21T17:55:14+02:00 2012-08-21T17:46:00+02:00 Simon Lindgren http://www.riviti.org/en/id/315 GSoC 2012: Rounding up

As it turns out, it was a little hard to keep up the blogging, but I thought I'd at least end with a post, now that the coding period is officially over.

My project was about making Code Action providers and Code Issue inspectors for the NRefactory library. This work will ultimately benefit the <a title="The MonoDevelop project site" href="http://monodevelop.com">MonoDevelop IDE</a> and the <a title="The SharpDevelop project site" href="http://www.icsharpcode.net/opensource/sd/">SharpDevelop IDE</a>.<a title="Converting to and from object and collection initializers" href="/en/article/326/converting-to-and-from-object-and-collection-initializers">Conversion to and from initializers</a> which I talked about previously, is done, as are several other action providers and issue inspectors.Code Action providers:<ul><li>Convert initializer to explicit initializations</li><li>Convert statements to initializer</li><li>Add catch type</li><li>Convert anonymous delegate to lambda</li><li>Convert lambda to anonymous delegate</li><li>Convert extension method invocation to static method invocation</li><li>Convert static method invocation to extension method invocation</li><li>Iterate via foreach</li><li>Move declaration to outer scope</li></ul>Code Issue inspectors:<ul><li>Format string syntax error checker</li><li>Parameter can be demoted to base type</li><li>Call to base.Equals resolves to Object equals which is reference equality</li><li>Call to virtual member from constructor</li><li>Exceptions should be rethrown using empty "throw;"</li><li>Call to base.GetHashCode() resolves to Object.GetHashCode() which is reference based</li><li>Incorrect ordering of parameters to exceptions with inconsistent parameter ordering</li><li>Optional parameter is passed the default value and can be skipped</li><li>Redundant catch clause</li><li>Redundant .ToString()</li><li>Reference to static member via derived type</li><li>Static field in generic type</li><li>[ThreadStatic] on instance field</li><li>'value' parameter unused</li><li>Variable can be moved to nested scope</li></ul>Granted, those are very terse descriptions, but with some imagination I think you'll understand what most of them do. In the end, I'm glad to have completed GSoC, even though I had hoped to complete more Code Actions and Code Issues.I will likely continue improving this code and implement more Code Actions & Code Issues when I have time, so if you have any ideas, feel free to post them in the comments, make a feature request in the <a title="NRefactory bug tracker" href="https://github.com/icsharpcode/NRefactory/issues?state=open">NRefactory issue tracker</a>, or <a title="About" href="http://www.riviti.org/en/page/318/about">contact me</a> directly.Lastly, I'd like to thank the mono project for a great summer of code. :-) http://www.riviti.org/en/id/326 2012-08-19T16:28:58+02:00 2012-06-19T13:57:00+02:00 Simon Lindgren http://www.riviti.org/en/id/315 Converting to and from object and collection initializers

In another "most complicated yet" code action, I feel the need to explain it to myself. So here you go too.

Initializers are useful for two reasons: They offer a compact way to initialize an object in a compact way and they do so using a single atomic assignment to the variable holding the object after construction. They also offer a way to initialize fields of an object without giving it a name, since the initializer is usable as an expression.The goal of this weeks GSoC work is to be able to convert between initializers and normal assignments and Add() calls (on Collections).Analyzing this properly is a little difficult, because the initializer construct is fairly flexible. An object initializer can for an object with properties or fields initialize those with a nested initializer, which can either be an instance creation followed by an initializer, or just an initializer. Taken from the <a title="The C# Version 4.0 Specification" href="http://go.microsoft.com/fwlink/?LinkId=199552">C# Specification, Version 4</a>:<blockquote>The following class represents a point with two coordinates:<pre class="Code"> public class Point { int x, y;</pre><pre class="Code"> public int X { get { return x; } set { x = value; } } public int Y { get { return y; } set { y = value; } } }</pre>An instance of Point can be created and initialized as follows:<pre class="Code"> Point a = new Point { X = 0, Y = 1 };</pre>which has the same effect as<pre class="Code"> Point __a = new Point(); __a.X = 0; __a.Y = 1; Point a = __a;</pre>where __a is an otherwise invisible and inaccessible temporary variable. The following class represents a rectangle created from two points:<pre class="Code"> public class Rectangle { Point p1, p2;</pre><pre class="Code"> public Point P1 { get { return p1; } set { p1 = value; } } public Point P2 { get { return p2; } set { p2 = value; } } }</pre>An instance of Rectangle can be created and initialized as follows:<pre class="Code"> Rectangle r = new Rectangle { P1 = new Point { X = 0, Y = 1 }, P2 = new Point { X = 2, Y = 3 } };</pre>which has the same effect as<pre class="Code"> Rectangle __r = new Rectangle(); Point __p1 = new Point(); __p1.X = 0; __p1.Y = 1; __r.P1 = __p1; Point __p2 = new Point(); __p2.X = 2; __p2.Y = 3; __r.P2 = __p2; Rectangle r = __r;</pre>where __r, __p1 and __p2 are temporary variables that are otherwise invisible and inaccessible.If Rectangle’s constructor allocates the two embedded Point instances<pre class="Code"> public class Rectangle { Point p1 = new Point(); Point p2 = new Point();</pre><pre class="Code"> public Point P1 { get { return p1; } } public Point P2 { get { return p2; } } }</pre>the following construct can be used to initialize the embedded Point instances instead of assigning new instances:<pre class="Code"> Rectangle r = new Rectangle { P1 = { X = 0, Y = 1 }, P2 = { X = 2, Y = 3 } };</pre>which has the same effect as<pre class="Code"> Rectangle __r = new Rectangle(); __r.P1.X = 0; __r.P1.Y = 1; __r.P2.X = 2; __r.P2.Y = 3; Rectangle r = __r;</pre></blockquote>Now, that is not how I would expect the code to look, more likely something like:<pre class="Code"> Rectangle r = new Rectangle(); r.P1.X = 0; r.P1.Y = 1; r.P2.X = 2; r.P2.Y = 3;</pre>However, both variants need to be supported, because when converting from an initializer to a set of assignments, we need to generate the strictly equivalent code (or we risk introducing bugs, in this case probably race conditions due to loosing atomicity). We then want to be able to convert that back to the original form.Another interesting case is this:<pre class="Code"> Rectangle r = new Rectangle(); r.P1.X = 0; r.P1 = new Point() { X = 2, Y = 6 } r.P1.Y = 1; r.P2.X = 2; r.P2.Y = 3;</pre>Which admittedly doesn't really make sense, but still needs to be handled in some way (probably by ignoring the entire initialization and not consider it convertible or by stopping after the second line).Add to this the fact that to not generate incorrect code (or show the action where it cannot generate correct code) dependencies between statements need to be taken into account, the fact that initializers can be nested and the fact that individual statements initializing properties can themselves be initializers, you get to a point where there are a lot of cases to keep track of.Alright, on to coding. More details once it's done :) http://www.riviti.org/en/id/323 2012-08-19T16:28:28+02:00 2012-06-11T09:47:00+02:00 Simon Lindgren http://www.riviti.org/en/id/315 Iterate via foreach

One part of my GSoC 2012 projects is to implement the "Iterate via foreach" code action. It will be the most complicated code action I have made so far, because there are some details in how it should work that are not obvious which I need to figure out.

The foreach statement can be used to iterate over any type which implements the IEnumerable interface, which in .NET it pretty much any container type as well as results from language integrated queries and from member functions classes.Any expression to be iterated needs result in an object implementing IEnumerable so the places where the action should work depends on the places where such an expression can be extracted. Below are some examples of these cases (locations where the action should work is marked in bold):<pre>using System.Collections.Generic; class A { public static IEnumerable<int> F () { var list = new List<int> (); return list; } public IList<int> GetInts() { return new List<int>(); } } class B { void F () { var list = A.F (); var zeroes = from item in list where item == 0 select item; } } class C { void F () { A.F (); var a = new A(); } }</pre>At this point I am not sure about the behaviour of the action in some of the cases. For example, when doing the action on a variable, it is reasonable to iterate over the variable. But what about iteration over expressions? Enumeration can be slow, so double enumerations should be avoided. Two examples of how it should look after executing the action (for classes B and C):<pre>class B { void F () { var list = A.F (); foreach (var item in list) { } var zeroes = from item in list where item == 0 select item; } } class C { void F () { foreach (var item in A.F()) { } var a = new A (); } }</pre>How I think it should work may not be obvious just from these examples, but they nevertheless represent my current thinking of how it should behave and are subject to change. This should be implemented by the end of the week, suggestions welcome :) http://www.riviti.org/en/id/316 2012-06-19T15:59:46+02:00 2012-04-30T00:51:00+02:00 Simon Lindgren http://www.riviti.org/en/id/315 GSoC 2012

I got accepted into Google Summer of Code 2012, with a code analysis project for MonoDevelop and NRefactory. Since there is a rumour that a lot of open source people have blogs, I have decided I'm going to try that myself.

The project is conceptually simple: I am going to implement a set of detections for code issues and related (and unrelated) code actions to fix them. To help me I have my mentor <a title="Mike Krüger's blog" href="http://mikemdblog.blogspot.se">Mike Krüger</a> and the <a title="The NRefactory code repository" href="https://github.com/riviti/NRefactory">NRefactory</a> library which was created for this very purpose.The NRefactory library is shared between both <a title="The MonoDevelop project site" href="http://monodevelop.com">MonoDevelop</a> and <a title="The SharpDevelop project site" href="http://www.icsharpcode.net/opensource/sd/">SharpDevelop</a>, so any refactoring operations using the library are usable in both applications. I will only use MonoDevelop during development, since SharpDevelop does not run on Linux.Next up is looking through the APIs for refactoring in NRefactory. It is a large library though the parts that are directly necessary to know are just a part of it. Have some tea or something while I figure it out, and I'll post again when I have. ;)More information about my project can be seen at the <a title="Code issue detection and code actions for MonoDevelop and NRefactory" href="http://www.google-melange.com/gsoc/project/google/gsoc2012/simonlindgren/19002">Google Melange project page</a>.