merge NRTypeExtensions and DecompilerTypeSystemUtils into TypeUtils

ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs

@@ -309,7 +309,7 @@ namespace ICSharpCode.Decompiler.CSharp
 			if (rr == null || rr.IsError || rr.UserDefinedOperatorMethod != null
 			    || rr.Operands[0].Type.GetStackType() != inst.OpType)
 			{
-				var targetType = DecompilerTypeSystemUtils.GetLargerType(left.Type, right.Type);
+				var targetType = TypeUtils.GetLargerType(left.Type, right.Type);
 				if (targetType.Equals(left.Type)) {
 					right = right.ConvertTo(targetType, this);
 				} else {
@@ -673,7 +673,7 @@ namespace ICSharpCode.Decompiler.CSharp
 		protected internal override TranslatedExpression VisitLdObj(LdObj inst)
 		{
 			var target = Translate(inst.Target);
-			if (target.Expression is DirectionExpression && DecompilerTypeSystemUtils.IsCompatibleTypeForMemoryAccess(target.Type, inst.Type)) {
+			if (target.Expression is DirectionExpression && TypeUtils.IsCompatibleTypeForMemoryAccess(target.Type, inst.Type)) {
 				// we can dereference the managed reference by stripping away the 'ref'
 				var result = target.UnwrapChild(((DirectionExpression)target.Expression).Expression);
 				// we don't convert result to inst.Type, because the LdObj type
@@ -698,7 +698,7 @@ namespace ICSharpCode.Decompiler.CSharp
 			var target = Translate(inst.Target);
 			var value = Translate(inst.Value);
 			TranslatedExpression result;
-			if (target.Expression is DirectionExpression && DecompilerTypeSystemUtils.IsCompatibleTypeForMemoryAccess(target.Type, inst.Type)) {
+			if (target.Expression is DirectionExpression && TypeUtils.IsCompatibleTypeForMemoryAccess(target.Type, inst.Type)) {
 				// we can deference the managed reference by stripping away the 'ref'
 				result = target.UnwrapChild(((DirectionExpression)target.Expression).Expression);
 			} else {

ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj

@@ -116,7 +116,6 @@
     <Compile Include="IL\Instructions\UnaryInstruction.cs" />
     <Compile Include="IL\IInlineContext.cs" />
     <Compile Include="IL\Instructions\VariableScope.cs" />
-    <Compile Include="IL\NRTypeExtensions.cs" />
     <Compile Include="IL\SlotInfo.cs" />
     <Compile Include="IL\Transforms\CopyPropagation.cs" />
     <Compile Include="IL\Transforms\IILTransform.cs" />
@@ -150,7 +149,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Output\TextOutputWriter.cs" />
     <Compile Include="TypeSystem\DecompilerTypeSystem.cs" />
-    <Compile Include="TypeSystem\DecompilerTypeSystemUtils.cs" />
+    <Compile Include="TypeSystem\TypeUtils.cs" />
     <Compile Include="TypeSystem\SpecializingDecompilerTypeSystem.cs" />
     <Compile Include="TypeSystem\IDecompilerTypeSystem.cs" />
     <Compile Include="TypeSystem\ReferenceResolvingException.cs" />

ICSharpCode.Decompiler/IL/NRTypeExtensions.cs

@@ -1,159 +0,0 @@
-// Copyright (c) 2014 Daniel Grunwald
-// 
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this
-// software and associated documentation files (the "Software"), to deal in the Software
-// without restriction, including without limitation the rights to use, copy, modify, merge,
-// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
-// to whom the Software is furnished to do so, subject to the following conditions:
-// 
-// The above copyright notice and this permission notice shall be included in all copies or
-// substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
-// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
-// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-// DEALINGS IN THE SOFTWARE.
-
-using System;
-using ICSharpCode.NRefactory.TypeSystem;
-
-namespace ICSharpCode.Decompiler.IL
-{
-	public static class NRTypeExtensions
-	{
-		public static StackType GetStackType(this IType type)
-		{
-			switch (type.Kind)
-			{
-				case TypeKind.Unknown:
-					return StackType.Unknown;
-				case TypeKind.ByReference:
-					return StackType.Ref;
-				case TypeKind.Pointer:
-					return StackType.I;
-			}
-			ITypeDefinition typeDef = type.GetDefinition();
-			if (typeDef == null)
-				return StackType.O;
-			if (typeDef.Kind == TypeKind.Enum) {
-				typeDef = typeDef.EnumUnderlyingType.GetDefinition();
-				if (typeDef == null)
-					return StackType.O;
-			}
-			switch (typeDef.KnownTypeCode) {
-				case KnownTypeCode.Boolean:
-				case KnownTypeCode.Char:
-				case KnownTypeCode.SByte:
-				case KnownTypeCode.Byte:
-				case KnownTypeCode.Int16:
-				case KnownTypeCode.UInt16:
-				case KnownTypeCode.Int32:
-				case KnownTypeCode.UInt32:
-					return StackType.I4;
-				case KnownTypeCode.Int64:
-				case KnownTypeCode.UInt64:
-					return StackType.I8;
-				case KnownTypeCode.Single:
-				case KnownTypeCode.Double:
-					return StackType.F;
-				case KnownTypeCode.Void:
-					return StackType.Void;
-				case KnownTypeCode.IntPtr:
-				case KnownTypeCode.UIntPtr:
-					return StackType.I;
-				default:
-					return StackType.O;
-			}
-		}
-		
-		public static Sign GetSign(this IType type)
-		{
-			var typeForConstant = (type.Kind == TypeKind.Enum) ? type.GetDefinition().EnumUnderlyingType : type;
-			var typeDef = typeForConstant.GetDefinition();
-			if (typeDef == null)
-				return Sign.None;
-			switch (typeDef.KnownTypeCode) {
-				case KnownTypeCode.SByte:
-				case KnownTypeCode.Int16:
-				case KnownTypeCode.Int32:
-				case KnownTypeCode.Int64:
-				case KnownTypeCode.IntPtr:
-				case KnownTypeCode.Single:
-				case KnownTypeCode.Double:
-				case KnownTypeCode.Decimal:
-					return Sign.Signed;
-				case KnownTypeCode.UIntPtr:
-				case KnownTypeCode.Char:
-				case KnownTypeCode.Boolean:
-				case KnownTypeCode.Byte:
-				case KnownTypeCode.UInt16:
-				case KnownTypeCode.UInt32:
-				case KnownTypeCode.UInt64:
-					return Sign.Unsigned;
-				default:
-					return Sign.None;
-			}
-		}
-		
-		public static KnownTypeCode ToKnownTypeCode(this PrimitiveType primitiveType)
-		{
-			switch (primitiveType) {
-				case PrimitiveType.I1:
-					return KnownTypeCode.SByte;
-				case PrimitiveType.I2:
-					return KnownTypeCode.Int16;
-				case PrimitiveType.I4:
-					return KnownTypeCode.Int32;
-				case PrimitiveType.I8:
-					return KnownTypeCode.Int64;
-				case PrimitiveType.R4:
-					return KnownTypeCode.Single;
-				case PrimitiveType.R8:
-					return KnownTypeCode.Double;
-				case PrimitiveType.U1:
-					return KnownTypeCode.Byte;
-				case PrimitiveType.U2:
-					return KnownTypeCode.UInt16;
-				case PrimitiveType.U4:
-					return KnownTypeCode.UInt32;
-				case PrimitiveType.U8:
-					return KnownTypeCode.UInt64;
-				case PrimitiveType.I:
-					return KnownTypeCode.IntPtr;
-				case PrimitiveType.U:
-					return KnownTypeCode.UIntPtr;
-				default:
-					return KnownTypeCode.None;
-			}
-		}
-		
-		public static KnownTypeCode ToKnownTypeCode(this StackType stackType, Sign sign = Sign.None)
-		{
-			switch (stackType) {
-				case StackType.I4:
-					return sign == Sign.Unsigned ? KnownTypeCode.UInt32 : KnownTypeCode.Int32;
-				case StackType.I8:
-					return sign == Sign.Unsigned ? KnownTypeCode.UInt64 : KnownTypeCode.Int64;
-				case StackType.I:
-					return sign == Sign.Unsigned ? KnownTypeCode.UIntPtr : KnownTypeCode.IntPtr;
-				case StackType.F:
-					return KnownTypeCode.Double;
-				case StackType.O:
-					return KnownTypeCode.Object;
-				case StackType.Void:
-					return KnownTypeCode.Void;
-				default:
-					return KnownTypeCode.None;
-			}
-		}
-	}
-	
-	public enum Sign : byte
-	{
-		None,
-		Signed,
-		Unsigned
-	}
-}

ICSharpCode.Decompiler/IL/Transforms/ExpressionTransforms.cs

@@ -123,7 +123,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 		protected internal override void VisitStObj(StObj inst)
 		{
 			ILVariable v;
-			if (inst.Target.MatchLdLoca(out v) && DecompilerTypeSystemUtils.IsCompatibleTypeForMemoryAccess(v.Type, inst.Type) && inst.UnalignedPrefix == 0 && !inst.IsVolatile) {
+			if (inst.Target.MatchLdLoca(out v) && TypeUtils.IsCompatibleTypeForMemoryAccess(v.Type, inst.Type) && inst.UnalignedPrefix == 0 && !inst.IsVolatile) {
 				inst.ReplaceWith(new StLoc(v, inst.Value.Clone()));
 			}
 			base.VisitStObj(inst);

ICSharpCode.Decompiler/TypeSystem/TypeUtils.cs

@@ -16,11 +16,12 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 using System;
+using ICSharpCode.Decompiler.IL;
 using ICSharpCode.NRefactory.TypeSystem;
 
 namespace ICSharpCode.Decompiler
 {
-	public static class DecompilerTypeSystemUtils
+	public static class TypeUtils
 	{
 		static int GetNativeSize(IType type)
 		{
@@ -121,5 +122,138 @@ namespace ICSharpCode.Decompiler
 			}
 			return false;
 		}
+
+		public static StackType GetStackType(this IType type)
+		{
+			switch (type.Kind)
+			{
+				case TypeKind.Unknown:
+					return StackType.Unknown;
+				case TypeKind.ByReference:
+					return StackType.Ref;
+				case TypeKind.Pointer:
+					return StackType.I;
+			}
+			ITypeDefinition typeDef = type.GetDefinition();
+			if (typeDef == null)
+				return StackType.O;
+			if (typeDef.Kind == TypeKind.Enum) {
+				typeDef = typeDef.EnumUnderlyingType.GetDefinition();
+				if (typeDef == null)
+					return StackType.O;
+			}
+			switch (typeDef.KnownTypeCode) {
+				case KnownTypeCode.Boolean:
+				case KnownTypeCode.Char:
+				case KnownTypeCode.SByte:
+				case KnownTypeCode.Byte:
+				case KnownTypeCode.Int16:
+				case KnownTypeCode.UInt16:
+				case KnownTypeCode.Int32:
+				case KnownTypeCode.UInt32:
+					return StackType.I4;
+				case KnownTypeCode.Int64:
+				case KnownTypeCode.UInt64:
+					return StackType.I8;
+				case KnownTypeCode.Single:
+				case KnownTypeCode.Double:
+					return StackType.F;
+				case KnownTypeCode.Void:
+					return StackType.Void;
+				case KnownTypeCode.IntPtr:
+				case KnownTypeCode.UIntPtr:
+					return StackType.I;
+				default:
+					return StackType.O;
+			}
+		}
+		
+		public static Sign GetSign(this IType type)
+		{
+			var typeForConstant = (type.Kind == TypeKind.Enum) ? type.GetDefinition().EnumUnderlyingType : type;
+			var typeDef = typeForConstant.GetDefinition();
+			if (typeDef == null)
+				return Sign.None;
+			switch (typeDef.KnownTypeCode) {
+				case KnownTypeCode.SByte:
+				case KnownTypeCode.Int16:
+				case KnownTypeCode.Int32:
+				case KnownTypeCode.Int64:
+				case KnownTypeCode.IntPtr:
+				case KnownTypeCode.Single:
+				case KnownTypeCode.Double:
+				case KnownTypeCode.Decimal:
+					return Sign.Signed;
+				case KnownTypeCode.UIntPtr:
+				case KnownTypeCode.Char:
+				case KnownTypeCode.Boolean:
+				case KnownTypeCode.Byte:
+				case KnownTypeCode.UInt16:
+				case KnownTypeCode.UInt32:
+				case KnownTypeCode.UInt64:
+					return Sign.Unsigned;
+				default:
+					return Sign.None;
+			}
+		}
+		
+		public static KnownTypeCode ToKnownTypeCode(this PrimitiveType primitiveType)
+		{
+			switch (primitiveType) {
+				case PrimitiveType.I1:
+					return KnownTypeCode.SByte;
+				case PrimitiveType.I2:
+					return KnownTypeCode.Int16;
+				case PrimitiveType.I4:
+					return KnownTypeCode.Int32;
+				case PrimitiveType.I8:
+					return KnownTypeCode.Int64;
+				case PrimitiveType.R4:
+					return KnownTypeCode.Single;
+				case PrimitiveType.R8:
+					return KnownTypeCode.Double;
+				case PrimitiveType.U1:
+					return KnownTypeCode.Byte;
+				case PrimitiveType.U2:
+					return KnownTypeCode.UInt16;
+				case PrimitiveType.U4:
+					return KnownTypeCode.UInt32;
+				case PrimitiveType.U8:
+					return KnownTypeCode.UInt64;
+				case PrimitiveType.I:
+					return KnownTypeCode.IntPtr;
+				case PrimitiveType.U:
+					return KnownTypeCode.UIntPtr;
+				default:
+					return KnownTypeCode.None;
+			}
+		}
+		
+		public static KnownTypeCode ToKnownTypeCode(this StackType stackType, Sign sign = Sign.None)
+		{
+			switch (stackType) {
+				case StackType.I4:
+					return sign == Sign.Unsigned ? KnownTypeCode.UInt32 : KnownTypeCode.Int32;
+				case StackType.I8:
+					return sign == Sign.Unsigned ? KnownTypeCode.UInt64 : KnownTypeCode.Int64;
+				case StackType.I:
+					return sign == Sign.Unsigned ? KnownTypeCode.UIntPtr : KnownTypeCode.IntPtr;
+				case StackType.F:
+					return KnownTypeCode.Double;
+				case StackType.O:
+					return KnownTypeCode.Object;
+				case StackType.Void:
+					return KnownTypeCode.Void;
+				default:
+					return KnownTypeCode.None;
+			}
+		}
+	}
+	
+	public enum Sign : byte
+	{
+		None,
+		Signed,
+		Unsigned
 	}
 }