Merge branch 'WithNUnit' of git://github.com/arturek/ILSpy

.gitignore

@@ -2,4 +2,5 @@ bin/
 obj/
 
 /ICSharpCode.Decompiler/Properties/AssemblyInfo.cs
-/ILSpy/Properties/AssemblyInfo.cs
+/ILSpy/Properties/AssemblyInfo.cs
+*.suo

ICSharpCode.Decompiler/Ast/AstBuilder.cs

@@ -6,8 +6,10 @@ using System.Threading;
 using Decompiler.Transforms;
 using ICSharpCode.Decompiler;
 using ICSharpCode.NRefactory.CSharp;
+using ICSharpCode.NRefactory.Utils;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using Ast = ICSharpCode.NRefactory.CSharp;
 using ClassType = ICSharpCode.NRefactory.TypeSystem.ClassType;
 using VarianceModifier = ICSharpCode.NRefactory.TypeSystem.VarianceModifier;
 
@@ -62,21 +64,25 @@ namespace Decompiler
 			astCompileUnit.AcceptVisitor(new OutputVisitor(outputFormatter, formattingPolicy), null);
 		}
 		
-		public void AddAssembly(AssemblyDefinition assemblyDefinition)
+		public void AddAssembly(AssemblyDefinition assemblyDefinition, bool onlyAssemblyLevel = false)
 		{
 			astCompileUnit.AddChild(
 				new UsingDeclaration {
 					Import = new SimpleType("System")
 				}, CompilationUnit.MemberRole);
 			
-			foreach(TypeDefinition typeDef in assemblyDefinition.MainModule.Types) {
+			ConvertCustomAtributes(astCompileUnit, assemblyDefinition, AttributeTarget.Assembly);
-				// Skip nested types - they will be added by the parent type
+
-				if (typeDef.DeclaringType != null) continue;
+			if(!onlyAssemblyLevel)
-				// Skip the <Module> class
+				foreach (TypeDefinition typeDef in assemblyDefinition.MainModule.Types)
-				if (typeDef.Name == "<Module>") continue;
+				{
-				
+					// Skip nested types - they will be added by the parent type
-				AddType(typeDef);
+					if (typeDef.DeclaringType != null) continue;
-			}
+					// Skip the <Module> class
+					if (typeDef.Name == "<Module>") continue;
+
+					AddType(typeDef);
+				}
 		}
 		
 		NamespaceDeclaration GetCodeNamespace(string name)
@@ -159,6 +165,8 @@ namespace Decompiler
 			
 			
 			if (typeDef.IsEnum) {
+				long expectedEnumMemberValue = 0;
+				bool forcePrintingInitializers = IsFlagsEnum(typeDef);
 				foreach (FieldDefinition field in typeDef.Fields) {
 					if (field.IsRuntimeSpecialName) {
 						// the value__ field
@@ -166,6 +174,11 @@ namespace Decompiler
 					} else {
 						EnumMemberDeclaration enumMember = new EnumMemberDeclaration();
 						enumMember.Name = CleanName(field.Name);
+						long memberValue = (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, field.Constant, false);
+						if (forcePrintingInitializers || memberValue != expectedEnumMemberValue) {
+							enumMember.AddChild(new PrimitiveExpression(field.Constant), EnumMemberDeclaration.InitializerRole);
+						}
+						expectedEnumMemberValue = memberValue + 1;
 						astType.AddChild(enumMember, TypeDeclaration.MemberRole);
 					}
 				}
@@ -180,9 +193,15 @@ namespace Decompiler
 				
 				AddTypeMembers(astType, typeDef);
 			}
-			
+
+			ConvertCustomAtributes(astType, typeDef);
 			return astType;
 		}
+
+		public void Transform(IAstTransform transform)
+		{
+			transform.Run(astCompileUnit);
+		}
 		
 		string CleanName(string name)
 		{
@@ -469,6 +488,8 @@ namespace Decompiler
 				astMethod.Modifiers = ConvertModifiers(methodDef);
 				astMethod.Body = AstMethodBodyBuilder.CreateMethodBody(methodDef, context);
 			}
+			ConvertCustomAtributes(astMethod, methodDef);
+			ConvertCustomAtributes(astMethod, methodDef.MethodReturnType, AttributeTarget.Return);
 			return astMethod;
 		}
 		
@@ -513,12 +534,18 @@ namespace Decompiler
 				astProp.Getter = new Accessor {
 					Body = AstMethodBodyBuilder.CreateMethodBody(propDef.GetMethod, context)
 				}.WithAnnotation(propDef.GetMethod);
+				ConvertCustomAtributes(astProp.Getter, propDef.GetMethod);
+				ConvertCustomAtributes(astProp.Getter, propDef.GetMethod.MethodReturnType, AttributeTarget.Return);
 			}
 			if (propDef.SetMethod != null) {
 				astProp.Setter = new Accessor {
 					Body = AstMethodBodyBuilder.CreateMethodBody(propDef.SetMethod, context)
 				}.WithAnnotation(propDef.SetMethod);
+				ConvertCustomAtributes(astProp.Setter, propDef.SetMethod);
+				ConvertCustomAtributes(astProp.Setter, propDef.SetMethod.MethodReturnType, AttributeTarget.Return);
+				ConvertCustomAtributes(astProp.Setter, propDef.SetMethod.Parameters.Last(), AttributeTarget.Param);
 			}
+			ConvertCustomAtributes(astProp, propDef);
 			return astProp;
 		}
 
@@ -556,6 +583,7 @@ namespace Decompiler
 				else
 					initializer.Initializer = new PrimitiveExpression(fieldDef.Constant);
 			}
+			ConvertCustomAtributes(astField, fieldDef);
 			return astField;
 		}
 		
@@ -571,8 +599,137 @@ namespace Decompiler
 				}
 				// TODO: params, this
 				
+				ConvertCustomAtributes(astParam, paramDef);
 				yield return astParam;
 			}
 		}
+
+		static void ConvertCustomAtributes(AstNode attributedNode, ICustomAttributeProvider customAttributeProvider, AttributeTarget target = AttributeTarget.None)
+		{
+			if (customAttributeProvider.HasCustomAttributes)
+			{
+				var section = new AttributeSection();
+				section.AttributeTarget = target;
+				foreach (var customAttribute in customAttributeProvider.CustomAttributes)
+				{
+					ICSharpCode.NRefactory.CSharp.Attribute attribute = new ICSharpCode.NRefactory.CSharp.Attribute();
+					attribute.Type = ConvertType(customAttribute.AttributeType);
+					section.Attributes.Add(attribute);
+
+					if(customAttribute.HasConstructorArguments)
+						foreach (var parameter in customAttribute.ConstructorArguments)
+						{
+							Expression parameterValue = ConvertArgumentValue(parameter);
+							attribute.Arguments.Add(parameterValue);
+						}
+
+					if (customAttribute.HasProperties)
+						foreach (var propertyNamedArg in customAttribute.Properties)
+						{
+							var propertyReference = customAttribute.AttributeType.Resolve().Properties.First(pr => pr.Name == propertyNamedArg.Name);
+							var propertyName = new IdentifierExpression(propertyNamedArg.Name).WithAnnotation(propertyReference);
+							var argumentValue = ConvertArgumentValue(propertyNamedArg.Argument);
+							attribute.Arguments.Add(new AssignmentExpression(propertyName, argumentValue));
+						}
+
+					if (customAttribute.HasFields)
+						foreach (var fieldNamedArg in customAttribute.Fields)
+						{
+							var fieldReference = customAttribute.AttributeType.Resolve().Fields.First(f => f.Name == fieldNamedArg.Name);
+							var fieldName = new IdentifierExpression(fieldNamedArg.Name).WithAnnotation(fieldReference);
+							var argumentValue = ConvertArgumentValue(fieldNamedArg.Argument);
+							attribute.Arguments.Add(new AssignmentExpression(fieldName, argumentValue));
+						}
+				}
+
+				attributedNode.AddChild(section, AttributedNode.AttributeRole);
+			}
+		}
+
+		private static Expression ConvertArgumentValue(CustomAttributeArgument parameter)
+		{
+			var type = parameter.Type.Resolve();
+			Expression parameterValue;
+			if (type.IsEnum)
+			{
+				parameterValue = MakePrimitive(Convert.ToInt64(parameter.Value), type);
+			}
+			else if (parameter.Value is TypeReference)
+			{
+				parameterValue = new TypeOfExpression()
+				{
+					Type = ConvertType((TypeReference)parameter.Value),
+				};
+			}
+			else
+			{
+				parameterValue = new PrimitiveExpression(parameter.Value);
+			}
+			return parameterValue;
+		}
+
+
+		internal static Expression MakePrimitive(long val, TypeReference type)
+		{
+			if (TypeAnalysis.IsBoolean(type) && val == 0)
+				return new Ast.PrimitiveExpression(false);
+			else if (TypeAnalysis.IsBoolean(type) && val == 1)
+				return new Ast.PrimitiveExpression(true);
+			if (type != null)
+			{ // cannot rely on type.IsValueType, it's not set for typerefs (but is set for typespecs)
+				TypeDefinition enumDefinition = type.Resolve();
+				if (enumDefinition != null && enumDefinition.IsEnum)
+				{
+					foreach (FieldDefinition field in enumDefinition.Fields)
+					{
+						if (field.IsStatic && object.Equals(CSharpPrimitiveCast.Cast(TypeCode.Int64, field.Constant, false), val))
+							return ConvertType(enumDefinition).Member(field.Name).WithAnnotation(field);
+						else if (!field.IsStatic && field.IsRuntimeSpecialName)
+							type = field.FieldType; // use primitive type of the enum
+					}
+					if (IsFlagsEnum(enumDefinition))
+					{
+						long enumValue = val;
+						Expression expr = null;
+						foreach (FieldDefinition field in enumDefinition.Fields.Where(fld => fld.IsStatic))
+						{
+							long fieldValue = (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, field.Constant, false);
+							if (fieldValue == 0)
+								continue;	// skip None enum value
+
+							if ((fieldValue & enumValue) == fieldValue)
+							{
+								var fieldExpression = ConvertType(enumDefinition).Member(field.Name).WithAnnotation(field);
+								if (expr == null)
+									expr = fieldExpression;
+								else
+									expr = new BinaryOperatorExpression(expr, BinaryOperatorType.BitwiseOr, fieldExpression);
+
+								enumValue &= ~fieldValue;
+								if (enumValue == 0)
+									break;
+							}
+						}
+						if(enumValue == 0 && expr != null)
+							return expr;
+					}
+					TypeCode enumBaseTypeCode = TypeAnalysis.GetTypeCode(type);
+					return new Ast.PrimitiveExpression(CSharpPrimitiveCast.Cast(enumBaseTypeCode, val, false)).CastTo(ConvertType(enumDefinition));
+				}
+			}
+			TypeCode code = TypeAnalysis.GetTypeCode(type);
+			if (code == TypeCode.Object)
+				return new Ast.PrimitiveExpression((int)val);
+			else
+				return new Ast.PrimitiveExpression(CSharpPrimitiveCast.Cast(code, val, false));
+		}
+
+		static bool IsFlagsEnum(TypeDefinition type)
+		{
+			if (!type.HasCustomAttributes)
+				return false;
+
+			return type.CustomAttributes.Any(attr => attr.AttributeType.FullName == "System.FlagsAttribute");
+		}
 	}
 }

ICSharpCode.Decompiler/Ast/AstMethodBodyBuilder.cs

@@ -527,7 +527,7 @@ namespace Decompiler
 						return MakeRef(new Ast.IdentifierExpression(((ParameterDefinition)operand).Name).WithAnnotation(operand));
 					}
 				case Code.Ldc_I4:
-					return MakePrimitive((int)operand, byteCode.InferredType);
+					return AstBuilder.MakePrimitive((int)operand, byteCode.InferredType);
 				case Code.Ldc_I8:
 				case Code.Ldc_R4:
 				case Code.Ldc_R8:
@@ -786,7 +786,7 @@ namespace Decompiler
 					if (TypeAnalysis.IsBoolean(actualType))
 						return expr;
 					if (actualIsIntegerOrEnum) {
-						return new BinaryOperatorExpression(expr, BinaryOperatorType.InEquality, MakePrimitive(0, actualType));
+						return new BinaryOperatorExpression(expr, BinaryOperatorType.InEquality, AstBuilder.MakePrimitive(0, actualType));
 					} else {
 						return new BinaryOperatorExpression(expr, BinaryOperatorType.InEquality, new NullReferenceExpression());
 					}
@@ -794,39 +794,21 @@ namespace Decompiler
 				if (TypeAnalysis.IsBoolean(actualType) && requiredIsIntegerOrEnum) {
 					return new ConditionalExpression {
 						Condition = expr,
-						TrueExpression = MakePrimitive(1, reqType),
+						TrueExpression = AstBuilder.MakePrimitive(1, reqType),
-						FalseExpression = MakePrimitive(0, reqType)
+						FalseExpression = AstBuilder.MakePrimitive(0, reqType)
 					};
 				}
+
+				if (expr is PrimitiveExpression && !requiredIsIntegerOrEnum && TypeAnalysis.IsEnum(actualType))
+				{
+					return expr.CastTo(AstBuilder.ConvertType(actualType));
+				}
+
 				if (actualIsIntegerOrEnum && requiredIsIntegerOrEnum) {
 					return expr.CastTo(AstBuilder.ConvertType(reqType));
 				}
 				return expr;
 			}
 		}
-		
-		Expression MakePrimitive(long val, TypeReference type)
-		{
-			if (TypeAnalysis.IsBoolean(type) && val == 0)
-				return new Ast.PrimitiveExpression(false);
-			else if (TypeAnalysis.IsBoolean(type) && val == 1)
-				return new Ast.PrimitiveExpression(true);
-			if (type != null) { // cannot rely on type.IsValueType, it's not set for typerefs (but is set for typespecs)
-				TypeDefinition enumDefinition = type.Resolve();
-				if (enumDefinition != null && enumDefinition.IsEnum) {
-					foreach (FieldDefinition field in enumDefinition.Fields) {
-						if (field.IsStatic && object.Equals(CSharpPrimitiveCast.Cast(TypeCode.Int64, field.Constant, false), val))
-							return AstBuilder.ConvertType(enumDefinition).Member(field.Name).WithAnnotation(field);
-						else if (!field.IsStatic && field.IsRuntimeSpecialName)
-							type = field.FieldType; // use primitive type of the enum
-					}
-				}
-			}
-			TypeCode code = TypeAnalysis.GetTypeCode(type);
-			if (code == TypeCode.Object)
-				return new Ast.PrimitiveExpression((int)val);
-			else
-				return new Ast.PrimitiveExpression(CSharpPrimitiveCast.Cast(code, val, false));
-		}
 	}
 }

ICSharpCode.Decompiler/Ast/Transforms/ConvertConstructorCallIntoInitializer.cs

@@ -48,6 +48,7 @@ namespace Decompiler.Transforms
 			if (ctors.Length == 1 && ctors[0].Body.Children.Count() == 0
 			    && ctors[0].Initializer.ConstructorInitializerType == ConstructorInitializerType.Base
 			    && ctors[0].Initializer.Arguments.Count() == 0
+				&& ctors[0].Parameters.Count == 0
 			    && ctors[0].Modifiers == ((typeDeclaration.Modifiers & Modifiers.Abstract) == Modifiers.Abstract ? Modifiers.Protected : Modifiers.Public))
 			{
 				ctors[0].Remove();

ICSharpCode.Decompiler/ILAst/TypeAnalysis.cs

@@ -647,6 +647,15 @@ namespace Decompiler
 		{
 			return IsSigned(type) != null;
 		}
+
+		public static bool IsEnum(TypeReference type)
+		{
+			if (type == null)
+				return false;
+			// unfortunately we cannot rely on type.IsValueType here - it's not set when the instruction operand is a typeref (as opposed to a typespec)
+			TypeDefinition typeDef = type.Resolve() as TypeDefinition;
+			return typeDef != null && typeDef.IsEnum;
+		}
 		
 		static bool? IsSigned(TypeReference type)
 		{

ICSharpCode.Decompiler/Tests/CodeSampleFileParser.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+
+namespace ICSharpCode.Decompiler.Tests
+{
+	static class CodeSampleFileParser
+	{
+		public static IEnumerable<string> ListSections(string s)
+		{
+			var query = from line in ToLines(s)
+						let sectionName = ReadSectionName(line)
+						where sectionName != null
+						select sectionName;
+			return query;
+		}
+
+		public static string GetSection(string sectionName, string s)
+		{
+			var lines = ToLines(s);
+
+			bool sectionFound = false;
+			var sectionText = new StringBuilder();
+
+			Action<string> parser = null;
+
+			Action<string> commonSectionReader = line =>
+				{
+					if (IsCommonSectionEnd(line))
+						parser = null;
+					else
+						sectionText.AppendLine(line);
+				};
+
+			Action<string> namedSectionReader = line =>
+				{
+					string name = ReadSectionName(line);
+					if (name == null)
+						sectionText.AppendLine(line);
+					else if (name != sectionName)
+						parser = null;
+				};
+
+			Action<string> defaultReader = line =>
+				{
+					if (IsCommonSectionStart(line))
+						parser = commonSectionReader;
+					else if (ReadSectionName(line) == sectionName)
+					{
+						parser = namedSectionReader;
+						sectionFound = true;
+					}
+				};
+
+			foreach(var line in lines)
+			{
+				(parser ?? defaultReader)(line);
+			}
+
+			if (sectionFound)
+				return sectionText.ToString();
+			else
+				return "";
+		}
+
+		public static bool IsCommentOrBlank(string s)
+		{
+			if(String.IsNullOrWhiteSpace(s))
+				return true;
+			return s.Trim().StartsWith("//");
+		}
+
+		public static string ConcatLines(IEnumerable<string> lines)
+		{
+			var buffer = new StringBuilder();
+			foreach (var line in lines)
+			{
+				buffer.AppendLine(line);
+			}
+			return buffer.ToString();
+		}
+
+		static string ReadSectionName(string line)
+		{
+			line = line.TrimStart();
+			if (line.StartsWith("//$$"))
+				return line.Substring(4).Trim();
+			else
+				return null;
+		}
+
+		static bool IsCommonSectionStart(string line)
+		{
+			return line.Trim() == "//$CS";
+		}
+
+		static bool IsCommonSectionEnd(string line)
+		{
+			return line.Trim() == "//$CE";
+		}
+
+		static IEnumerable<string> ToLines(string s)
+		{
+			var reader = new StringReader(s);
+			string line;
+			while ((line = reader.ReadLine()) != null)
+			{
+				yield return line;
+			}
+		}
+	}
+}

ICSharpCode.Decompiler/Tests/CustomAttributes.code.cs

@@ -0,0 +1,41 @@
+using System;
+namespace aa
+{
+	public static class CustomAtributes
+	{
+		[Flags]
+		public enum EnumWithFlag
+		{
+			All = 15,
+			None = 0,
+			Item1 = 1,
+			Item2 = 2,
+			Item3 = 4,
+			Item4 = 8
+		}
+		[AttributeUsage(AttributeTargets.All)]
+		public class MyAttribute : Attribute
+		{
+			public MyAttribute(CustomAtributes.EnumWithFlag en)
+			{
+			}
+		}
+		[CustomAtributes.MyAttribute(CustomAtributes.EnumWithFlag.Item1 | CustomAtributes.EnumWithFlag.Item2)]
+		private static int field;
+		[CustomAtributes.MyAttribute(CustomAtributes.EnumWithFlag.All)]
+		public static string Property
+		{
+			get
+			{
+				return "aa";
+			}
+		}
+		[Obsolete("some message")]
+		public static void ObsoletedMethod()
+		{
+			Console.WriteLine("{0} $$$ {1}", AttributeTargets.Interface, AttributeTargets.Property | AttributeTargets.Field);
+			AttributeTargets attributeTargets = AttributeTargets.Property | AttributeTargets.Field;
+			Console.WriteLine("{0} $$$ {1}", AttributeTargets.Interface, attributeTargets);
+		}
+	}
+}

ICSharpCode.Decompiler/Tests/CustomAttributes/CustomAttributeTests.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace ICSharpCode.Decompiler.Tests.CustomAttributes
+{
+	[TestFixture]
+	public class CustomAttributeTests : DecompilerTestBase
+	{
+		[Test]
+		public void CustomAttributeSamples()
+		{
+			ValidateFileRoundtrip(@"CustomAttributes\S_CustomAttributeSamples.cs");
+		}
+
+		[Test]
+		public void CustomAttributesMultiTest()
+		{
+			ValidateFileRoundtrip(@"CustomAttributes\S_CustomAttributes.cs");
+		}
+
+		[Test]
+		public void AssemblyCustomAttributesMultiTest()
+		{
+			ValidateFileRoundtrip(@"CustomAttributes\S_AssemblyCustomAttribute.cs");
+		}
+	}
+}

ICSharpCode.Decompiler/Tests/CustomAttributes/S_AssemblyCustomAttribute.cs

@@ -0,0 +1,6 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+
+[assembly: CLSCompliant(false)]

ICSharpCode.Decompiler/Tests/CustomAttributes/S_CustomAttributeSamples.cs

@@ -0,0 +1,398 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+//$CS
+using System;
+//$CE
+
+//$$ TargetModule (ignored)
+//[module: CLSCompliantAttribute(false)]
+//$$ ParameterlessAttributeUsage
+namespace ParameterLessAttributeUsage
+{
+	[Flags]
+	public enum EnumWithFlagsAttribute
+	{
+		None = 0
+	}
+}
+//$$ AttributeWithEnumArgument
+namespace AttributeWithEnumArgument
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+}
+//$$ AttributeWithEnumExpressionArgument
+namespace AttributeWithEnumExpressionArgument
+{
+	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Interface)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+}
+//$$ AttributeWithStringExpressionArgument
+namespace AttributeWithStringExpressionArgument
+{
+	[Obsolete("message")]
+	public class ObsoletedClass
+	{
+	}
+}
+//$$ AttributeWithTypeArgument
+namespace AttributeWithTypeArgument
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyTypeAttribute : Attribute
+	{
+		public MyTypeAttribute(Type t) : base()
+		{
+		}
+	}
+
+	[MyType(typeof(Attribute))]
+	public class SomeClass
+	{
+	}
+}
+//$$ AppliedToEvent
+namespace AppliedToEvent
+{
+	[AttributeUsage(AttributeTargets.Event)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class TestClass
+	{
+		[MyAttribute]
+		public event EventHandler MyEvent;
+	}
+}
+//$$ AppliedToField
+namespace AppliedToField
+{
+	[AttributeUsage(AttributeTargets.Field)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class TestClass
+	{
+		[MyAttribute]
+		public int Field;
+	}
+}
+//$$ AppliedToProperty
+namespace AppliedToProperty
+{
+	public class TestClass
+	{
+		[Obsolete("reason")]
+		public int Property
+		{
+			get
+			{
+				return 0;
+			}
+		}
+	}
+}
+//$$ AppliedToPropertyGet
+namespace AppliedToPropertyGet
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class TestClass
+	{
+		public int Property
+		{
+			[MyAttribute]
+			get
+			{
+				return 0;
+			}
+		}
+	}
+}
+//$$ AppliedToPropertySet
+namespace AppliedToPropertySet
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class TestClass
+	{
+		public int Property
+		{
+			get
+			{
+				return 3;
+			}
+			[MyAttribute]
+			set
+			{
+				return;
+			}
+		}
+	}
+}
+//$$ AppliedToDelegate
+[Obsolete("reason")]
+public delegate int AppliedToDelegate();
+//$$ AppliedToMethod
+namespace AppliedToMethod
+{
+	[AttributeUsage(AttributeTargets.Method)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class TestClass
+	{
+		[MyAttribute]
+		public void Method()
+		{
+		}
+	}
+}
+//$$ AppliedToInterface
+[Obsolete("reason")]
+public interface AppliedToInterface
+{
+}
+//$$ AppliedToStruct
+[Obsolete("reason")]
+public struct AppliedToStruct
+{
+	public int Field;
+}
+//$$ AppliedToParameter
+namespace AppliedToParameter
+{
+	[AttributeUsage(AttributeTargets.Parameter)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class MyClass
+	{
+		public void Method([MyAttribute]int val)
+		{
+		}
+	}
+}
+//$$ NamedInitializerProperty
+namespace NamedInitializerProperty
+{
+	[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+}
+//$$ NamedInitializerPropertyString
+namespace NamedInitializerPropertyString
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+		public string Prop
+		{
+			get
+			{
+				return "";
+			}
+			set
+			{
+				return;
+			}
+		}
+	}
+	[MyAttribute(Prop = "value")]
+	public class MyClass
+	{
+	}
+}
+//$$ NamedInitializerPropertyType
+namespace NamedInitializerPropertyType
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+		public Type Prop
+		{
+			get
+			{
+				return null;
+			}
+			set
+			{
+				return;
+			}
+		}
+	}
+	[MyAttribute(Prop = typeof(Enum))]
+	public class MyClass
+	{
+	}
+}
+//$$ NamedInitializerPropertyEnum
+namespace NamedInitializerPropertyEnum
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+		public AttributeTargets Prop
+		{
+			get
+			{
+				return AttributeTargets.All;
+			}
+			set
+			{
+				return;
+			}
+		}
+	}
+	[MyAttribute(Prop = (AttributeTargets.Class | AttributeTargets.Method))]
+	public class MyClass
+	{
+	}
+}
+//$$ NamedInitializerFieldEnum
+namespace NamedInitializerFieldEnum
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+		public AttributeTargets Field;
+	}
+	[MyAttribute(Field = (AttributeTargets.Class | AttributeTargets.Method))]
+	public class MyClass
+	{
+	}
+}
+//$$ TargetReturn
+namespace TargetReturn
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class MyClass
+	{
+		[return: MyAttribute]
+		public int MyMethod()
+		{
+			return 5;
+		}
+	}
+}
+//$$ TargetPropertyGetReturn
+namespace TargetPropertyGetReturn
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class MyClass
+	{
+		public int Prop
+		{
+			[return: MyAttribute]
+			get
+			{
+				return 3;
+			}
+		}
+	}
+}
+//$$ TargetPropertySetParam
+namespace TargetPropertySetParam
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class MyClass
+	{
+		public int Prop
+		{
+			[param: MyAttribute]
+			set
+			{
+				return;
+			}
+		}
+	}
+}
+//$$ TargetPropertySetReturn
+namespace TargetPropertySetReturn
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class MyClass
+	{
+		public int Prop
+		{
+			get
+			{
+				return 3;
+			}
+			[return: MyAttribute]
+			set
+			{
+				return;
+			}
+		}
+	}
+}
+//$$ TargetPropertyIndexSetParam
+namespace TargetPropertyIndexSetParam
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+	}
+	public class MyClass
+	{
+		public string this[int index]
+		{
+			get
+			{
+				return "";
+			}
+			[param: MyAttribute]
+			set
+			{
+				return;
+			}
+		}
+	}
+}
+//$$ TargetPropertyIndexSetMultiParam
+namespace TargetPropertyIndexSetMultiParam
+{
+	[AttributeUsage(AttributeTargets.All)]
+	public class MyAttributeAttribute : Attribute
+	{
+		public int Field;
+	}
+	public class MyClass
+	{
+		public string this[[MyAttribute(Field = 2)]int index1, [MyAttribute(Field = 3)]int index2]
+		{
+			get
+			{
+				return "";
+			}
+			[param: MyAttribute]
+			set
+			{
+				return;
+			}
+		}
+	}
+}

ICSharpCode.Decompiler/Tests/CustomAttributes/S_CustomAttributes.cs

@@ -0,0 +1,46 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+
+namespace aa
+{
+	public static class CustomAtributes
+	{
+		[Flags]
+		public enum EnumWithFlag
+		{
+			All = 15,
+			None = 0,
+			Item1 = 1,
+			Item2 = 2,
+			Item3 = 4,
+			Item4 = 8
+		}
+		[AttributeUsage(AttributeTargets.All)]
+		public class MyAttribute : Attribute
+		{
+			public MyAttribute(CustomAtributes.EnumWithFlag en) : base()
+			{
+			}
+		}
+		[CustomAtributes.MyAttribute(CustomAtributes.EnumWithFlag.Item1 | CustomAtributes.EnumWithFlag.Item2)]
+		private static int field;
+		[CustomAtributes.MyAttribute(CustomAtributes.EnumWithFlag.All)]
+		public static string Property
+		{
+			get
+			{
+				return "aa";
+			}
+		}
+		[Obsolete("some message")]
+		public static void ObsoletedMethod()
+		{
+			//Console.WriteLine("{0} $$$ {1}", AttributeTargets.Interface, (AttributeTargets)(AttributeTargets.Property | AttributeTargets.Field));
+			Console.WriteLine("{0} $$$ {1}", AttributeTargets.Interface, AttributeTargets.Property | AttributeTargets.Field);
+			AttributeTargets attributeTargets = AttributeTargets.Property | AttributeTargets.Field;
+			Console.WriteLine("{0} $$$ {1}", AttributeTargets.Interface, attributeTargets);
+		}
+	}
+}

ICSharpCode.Decompiler/Tests/DecompilerTestBase.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Mono.Cecil;
+using System.IO;
+using Decompiler;
+using Microsoft.CSharp;
+using System.CodeDom.Compiler;
+using NUnit.Framework;
+
+namespace ICSharpCode.Decompiler.Tests
+{
+	public abstract class DecompilerTestBase
+	{
+		protected static void ValidateFileRoundtrip(string samplesFileName)
+		{
+			var lines = File.ReadAllLines(Path.Combine(@"..\..\Tests", samplesFileName));
+			var testCode = RemoveIgnorableLines(lines);
+			var decompiledTestCode = RoundtripCode(testCode);
+			Assert.AreEqual(testCode, decompiledTestCode);
+		}
+
+		static string RemoveIgnorableLines(IEnumerable<string> lines)
+		{
+			return CodeSampleFileParser.ConcatLines(lines.Where(l => !CodeSampleFileParser.IsCommentOrBlank(l)));
+		}
+
+		/// <summary>
+		/// Compiles and decompiles a source code.
+		/// </summary>
+		/// <param name="code">The source code to copile.</param>
+		/// <returns>The decompilation result of compiled source code.</returns>
+		static string RoundtripCode(string code)
+		{
+			AssemblyDefinition assembly = Compile(code);
+			AstBuilder decompiler = new AstBuilder(new DecompilerContext());
+			decompiler.AddAssembly(assembly);
+			decompiler.Transform(new Helpers.RemoveCompilerAttribute());
+			StringWriter output = new StringWriter();
+			decompiler.GenerateCode(new PlainTextOutput(output));
+			return output.ToString();
+		}
+
+		static AssemblyDefinition Compile(string code)
+		{
+			CSharpCodeProvider provider = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } });
+			CompilerParameters options = new CompilerParameters();
+			options.ReferencedAssemblies.Add("System.Core.dll");
+			CompilerResults results = provider.CompileAssemblyFromSource(options, code);
+			try
+			{
+				if (results.Errors.Count > 0)
+				{
+					StringBuilder b = new StringBuilder("Compiler error:");
+					foreach (var error in results.Errors)
+					{
+						b.AppendLine(error.ToString());
+					}
+					throw new Exception(b.ToString());
+				}
+				return AssemblyDefinition.ReadAssembly(results.PathToAssembly);
+			}
+			finally
+			{
+				File.Delete(results.PathToAssembly);
+				results.TempFiles.Delete();
+			}
+		}
+	}
+}

ICSharpCode.Decompiler/Tests/Helpers/RemoveCompilerAttribute.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using ICSharpCode.NRefactory.CSharp;
+using Decompiler.Transforms;
+
+namespace ICSharpCode.Decompiler.Tests.Helpers
+{
+	class RemoveCompilerAttribute : DepthFirstAstVisitor<object, object>, IAstTransform
+	{
+		public override object VisitAttribute(NRefactory.CSharp.Attribute attribute, object data)
+		{
+			var section = (AttributeSection)attribute.Parent;
+			SimpleType type = attribute.Type as SimpleType;
+			if (section.AttributeTarget == AttributeTarget.Assembly &&
+				(type.Identifier == "CompilationRelaxationsAttribute" || type.Identifier == "RuntimeCompatibilityAttribute"))
+			{
+				attribute.Remove();
+				if (section.Attributes.Count == 0)
+					section.Remove();
+			}
+			return null;
+		}
+
+		public void Run(AstNode node)
+		{
+			node.AcceptVisitor(this, null);
+		}
+	}
+}

ICSharpCode.Decompiler/Tests/ICSharpCode.Decompiler.Tests.csproj

@@ -38,6 +38,10 @@
     <DefineConstants>TRACE</DefineConstants>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="nunit.framework">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>.\nunit.framework.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
@@ -48,13 +52,23 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ArrayInitializers.cs" />
+    <None Include="Types\S_EnumSamples.cs" />
+    <None Include="CustomAttributes\S_AssemblyCustomAttribute.cs" />
+    <Compile Include="Helpers\RemoveCompilerAttribute.cs" />
+    <Compile Include="Types\EnumTests.cs" />
+    <Compile Include="Types\TypeTests.cs" />
     <Compile Include="DelegateConstruction.cs" />
+    <None Include="CustomAttributes\S_CustomAttributes.cs" />
+    <Compile Include="Loops.cs" />
+    <Compile Include="PropertiesAndEvents.cs" />
+    <None Include="CustomAttributes\S_CustomAttributeSamples.cs" />
+    <Compile Include="CodeSampleFileParser.cs" />
+    <Compile Include="CustomAttributes\CustomAttributeTests.cs" />
+    <Compile Include="DecompilerTestBase.cs" />
+    <Compile Include="ArrayInitializers.cs" />
     <Compile Include="ExceptionHandling.cs" />
     <Compile Include="Generics.cs" />
     <Compile Include="MultidimensionalArray.cs" />
-    <Compile Include="Loops.cs" />
-    <Compile Include="PropertiesAndEvents.cs" />
     <Compile Include="TestRunner.cs" />
     <Compile Include="ValueTypes.cs" />
   </ItemGroup>
@@ -63,14 +77,16 @@
       <Project>{D68133BD-1E63-496E-9EDE-4FBDBF77B486}</Project>
       <Name>Mono.Cecil</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\NRefactory\ICSharpCode.NRefactory\ICSharpCode.NRefactory.csproj">
+      <Project>{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}</Project>
+      <Name>ICSharpCode.NRefactory</Name>
+    </ProjectReference>
     <ProjectReference Include="..\ICSharpCode.Decompiler.csproj">
       <Project>{984CC812-9470-4A13-AFF9-CC44068D666C}</Project>
       <Name>ICSharpCode.Decompiler</Name>
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
+  <ItemGroup />
-    <Folder Include="StackTests" />
-  </ItemGroup>
   <ItemGroup>
     <None Include="BooleanConsumedAsInteger.il" />
     <None Include="StackTests\StackTests.il" />

ICSharpCode.Decompiler/Tests/TestRunner.cs

@@ -14,21 +14,23 @@ namespace ICSharpCode.Decompiler.Tests
 {
 	public class TestRunner
 	{
-		public static void Main()
+		public static void Main(string[] args)
 		{
-			Test(@"..\..\Tests\DelegateConstruction.cs");
+			if (args.Length == 1)
-			
+				TestFile(args[0]);
+			else
+				TestFile(@"..\..\Tests\DelegateConstruction.cs");
+
 			Console.ReadKey();
 		}
-		
+
-		
+		static void TestFile(string fileName)
-		
-		static void Test(string fileName)
 		{
 			string code = File.ReadAllText(fileName);
 			AssemblyDefinition assembly = Compile(code);
 			AstBuilder decompiler = new AstBuilder(new DecompilerContext());
 			decompiler.AddAssembly(assembly);
+			decompiler.Transform(new Helpers.RemoveCompilerAttribute());
 			StringWriter output = new StringWriter();
 			decompiler.GenerateCode(new PlainTextOutput(output));
 			StringWriter diff = new StringWriter();
@@ -79,7 +81,7 @@ namespace ICSharpCode.Decompiler.Tests
 		
 		static AssemblyDefinition Compile(string code)
 		{
-			CSharpCodeProvider provider = new CSharpCodeProvider(new Dictionary<string, string> {{ "CompilerVersion", "v4.0" }});
+			CSharpCodeProvider provider = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } });
 			CompilerParameters options = new CompilerParameters();
 			options.ReferencedAssemblies.Add("System.Core.dll");
 			CompilerResults results = provider.CompileAssemblyFromSource(options, code);

ICSharpCode.Decompiler/Tests/Types/EnumTests.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace ICSharpCode.Decompiler.Tests.Types
+{
+	[TestFixture]
+	public class EnumTests : DecompilerTestBase
+	{
+		[Test]
+		public void EnumSamples()
+		{
+			ValidateFileRoundtrip(@"Types\S_EnumSamples.cs");
+		}
+	}
+}

ICSharpCode.Decompiler/Tests/Types/S_EnumSamples.cs

@@ -0,0 +1,114 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+//$CS
+using System;
+//$CE
+
+//$$ SingleValue
+public class TS_SingleValue
+{
+	public AttributeTargets Method()
+	{
+		return AttributeTargets.Class;
+	}
+}
+//$$ TwoValuesOr
+public class TS_TwoValuesOr
+{
+	public AttributeTargets Method()
+	{
+		return AttributeTargets.Class | AttributeTargets.Method;
+	}
+}
+//$$ ThreeValuesOr
+public class TS_ThreeValuesOr
+{
+	public AttributeTargets Method()
+	{
+		return AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Parameter;
+	}
+}
+//$$ UnknownNumericValue
+public class TS_UnknownNumericValue
+{
+	public AttributeTargets Method()
+	{
+		return (AttributeTargets)1000000;
+	}
+}
+//$$ AllValue
+public class TS_AllValue
+{
+	public AttributeTargets Method()
+	{
+		return AttributeTargets.All;
+	}
+}
+//$$ ZeroValue
+public class TS_ZeroValue
+{
+	public AttributeTargets Method()
+	{
+		return (AttributeTargets)0;
+	}
+}
+//$$ PreservingTypeWhenBoxed
+public class TS_PreservingTypeWhenBoxed
+{
+	public object Method()
+	{
+		return AttributeTargets.Delegate;
+	}
+}
+//$$ PreservingTypeWhenBoxedTwoEnum
+public class TS_PreservingTypeWhenBoxedTwoEnum
+{
+	public object Method()
+	{
+		return AttributeTargets.Class | AttributeTargets.Delegate;
+	}
+}
+//$$ DeclarationSimpleEnum
+public enum TS_DeclarationSimpleEnum
+{
+	Item1,
+	Item2
+}
+//$$ DeclarationLongBasedEnum
+public enum TS_DeclarationLongBasedEnum : long
+{
+	Item1,
+	Item2
+}
+//$$ DeclarationLongWithInitializers
+public enum TS_DeclarationLongWithInitializers : long
+{
+	Item1,
+	Item2 = 20L,
+	Item3
+}
+//$$ DeclarationShortWithInitializers
+public enum TS_DeclarationShortWithInitializers : short
+{
+	Item1,
+	Item2 = 20,
+	Item3
+}
+//$$ DeclarationByteWithInitializers
+public enum TS_DeclarationByteWithInitializers : byte
+{
+	Item1,
+	Item2 = 20,
+	Item3
+}
+//$$ DeclarationFlags
+[Flags]
+public enum TS_DeclarationFlags
+{
+	None = 0,
+	Item1 = 1,
+	Item2 = 2,
+	Item3 = 4,
+	All = 7
+}

ICSharpCode.Decompiler/Tests/Types/TypeTests.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace ICSharpCode.Decompiler.Tests.Types
+{
+	public class TypeTests : DecompilerTestBase
+	{
+	}
+}

ILSpy.sln

@@ -1,7 +1,6 @@
 
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
-# SharpDevelop 4.0.1.7096
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ILSpy", "ILSpy\ILSpy.csproj", "{1E85EFF9-E370-4683-83E4-8A3D063FF791}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.TreeView", "SharpTreeView\ICSharpCode.TreeView.csproj", "{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}"
@@ -18,67 +17,70 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Decompiler.Test
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x86 = Debug|x86
-		Release|x86 = Release|x86
 		Debug|Any CPU = Debug|Any CPU
+		Debug|x86 = Debug|x86
 		Release|Any CPU = Release|Any CPU
+		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Debug|x86.Build.0 = Debug|x86
-		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Debug|x86.ActiveCfg = Debug|x86
-		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Release|x86.Build.0 = Release|x86
-		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Release|x86.ActiveCfg = Release|x86
-		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Debug|x86.ActiveCfg = Debug|x86
+		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Debug|x86.Build.0 = Debug|x86
 		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Debug|x86.Build.0 = Debug|Any CPU
+		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Release|Any CPU.Build.0 = Release|Any CPU
-		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Release|x86.ActiveCfg = Release|x86
-		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Release|x86.Build.0 = Release|Any CPU
+		{1E85EFF9-E370-4683-83E4-8A3D063FF791}.Release|x86.Build.0 = Release|x86
-		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Release|x86.ActiveCfg = Release|Any CPU
-		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Debug|x86.Build.0 = Debug|Any CPU
 		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|x86.Build.0 = net_2_0_Debug|Any CPU
+		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|x86.ActiveCfg = net_4_0_Debug|Any CPU
+		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Release|x86.ActiveCfg = Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|Any CPU.Build.0 = net_2_0_Debug|Any CPU
+		{DDE2A481-8271-4EAC-A330-8FA6A38D13D1}.Release|x86.Build.0 = Release|Any CPU
 		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|Any CPU.ActiveCfg = net_4_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|x86.Build.0 = net_2_0_Debug|Any CPU
+		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|Any CPU.Build.0 = net_4_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|x86.ActiveCfg = net_4_0_Release|Any CPU
+		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|x86.ActiveCfg = net_4_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|Any CPU.Build.0 = net_2_0_Debug|Any CPU
+		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|x86.Build.0 = net_2_0_Debug|Any CPU
 		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|Any CPU.ActiveCfg = net_4_0_Release|Any CPU
-		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Debug|x86.Build.0 = Debug|Any CPU
+		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|Any CPU.Build.0 = net_4_0_Release|Any CPU
-		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|x86.ActiveCfg = net_4_0_Release|Any CPU
-		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|x86.Build.0 = net_2_0_Debug|Any CPU
 		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Release|x86.Build.0 = Release|Any CPU
+		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Release|x86.ActiveCfg = Release|Any CPU
+		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Debug|x86.Build.0 = Debug|Any CPU
 		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{984CC812-9470-4A13-AFF9-CC44068D666C}.Debug|x86.Build.0 = Debug|Any CPU
+		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Release|Any CPU.Build.0 = Release|Any CPU
-		{984CC812-9470-4A13-AFF9-CC44068D666C}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Release|x86.ActiveCfg = Release|Any CPU
-		{984CC812-9470-4A13-AFF9-CC44068D666C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}.Release|x86.Build.0 = Release|Any CPU
 		{984CC812-9470-4A13-AFF9-CC44068D666C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{984CC812-9470-4A13-AFF9-CC44068D666C}.Release|x86.Build.0 = Release|Any CPU
+		{984CC812-9470-4A13-AFF9-CC44068D666C}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{984CC812-9470-4A13-AFF9-CC44068D666C}.Release|x86.ActiveCfg = Release|Any CPU
+		{984CC812-9470-4A13-AFF9-CC44068D666C}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{984CC812-9470-4A13-AFF9-CC44068D666C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{984CC812-9470-4A13-AFF9-CC44068D666C}.Debug|x86.Build.0 = Debug|Any CPU
 		{984CC812-9470-4A13-AFF9-CC44068D666C}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Debug|x86.Build.0 = Debug|Any CPU
+		{984CC812-9470-4A13-AFF9-CC44068D666C}.Release|Any CPU.Build.0 = Release|Any CPU
-		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{984CC812-9470-4A13-AFF9-CC44068D666C}.Release|x86.ActiveCfg = Release|Any CPU
-		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{984CC812-9470-4A13-AFF9-CC44068D666C}.Release|x86.Build.0 = Release|Any CPU
 		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Release|x86.Build.0 = Release|Any CPU
+		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Release|x86.ActiveCfg = Release|Any CPU
+		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Debug|x86.Build.0 = Debug|Any CPU
 		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Debug|x86.Build.0 = Debug|x86
+		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Release|Any CPU.Build.0 = Release|Any CPU
-		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Debug|x86.ActiveCfg = Debug|x86
+		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Release|x86.ActiveCfg = Release|Any CPU
-		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Debug|Any CPU.Build.0 = Debug|x86
+		{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}.Release|x86.Build.0 = Release|Any CPU
 		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Release|x86.Build.0 = Release|x86
+		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Debug|Any CPU.Build.0 = Debug|x86
-		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Release|x86.ActiveCfg = Release|x86
+		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Debug|x86.ActiveCfg = Debug|x86
-		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Release|Any CPU.Build.0 = Release|x86
+		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Debug|x86.Build.0 = Debug|x86
 		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Release|Any CPU.ActiveCfg = Release|x86
+		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Release|Any CPU.Build.0 = Release|x86
+		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Release|x86.ActiveCfg = Release|x86
+		{FEC0DA52-C4A6-4710-BE36-B484A20C5E22}.Release|x86.Build.0 = Release|x86
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
 	EndGlobalSection
 EndGlobal

ILSpy/CSharpLanguage.cs

@@ -132,6 +132,9 @@ namespace ICSharpCode.ILSpy
 				}
 			} else {
 				base.DecompileAssembly(assembly, fileName, output, options);
+				AstBuilder codeDomBuilder = CreateAstBuilder(options, currentType: null);
+				codeDomBuilder.AddAssembly(assembly, onlyAssemblyLevel: true);
+				codeDomBuilder.GenerateCode(output, transformAbortCondition);
 			}
 		}
 		
@@ -375,7 +378,7 @@ namespace ICSharpCode.ILSpy
 					CurrentType = currentType
 				});
 		}
-		
+
 		public override string TypeToString(TypeReference type, bool includeNamespace, ICustomAttributeProvider typeAttributes)
 		{
 			AstType astType = AstBuilder.ConvertType(type, typeAttributes);

NRefactory/ICSharpCode.NRefactory.Demo/ICSharpCode.NRefactory.Demo.csproj

@@ -40,21 +40,29 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="VBEditDialog.cs" />
+    <Compile Include="VBEditDialog.cs">
+      <SubType>Form</SubType>
+    </Compile>
     <Compile Include="VBEditDialog.Designer.cs">
       <DependentUpon>VBEditDialog.cs</DependentUpon>
     </Compile>
-    <Compile Include="VBDomView.cs" />
+    <Compile Include="VBDomView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
     <Compile Include="VBDomView.Designer.cs">
       <DependentUpon>VBDomView.cs</DependentUpon>
     </Compile>
-    <Compile Include="MainForm.cs" />
+    <Compile Include="MainForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
     <Compile Include="MainForm.Designer.cs">
       <DependentUpon>MainForm.cs</DependentUpon>
     </Compile>
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="VBDemo.cs" />
+    <Compile Include="VBDemo.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
     <Compile Include="VBDemo.Designer.cs">
       <DependentUpon>VBDemo.cs</DependentUpon>
     </Compile>