Distinguish between unknown type and no type.

ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs

@@ -1996,7 +1996,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				} else {
 					// argument might be a lambda or delegate type, so we have to try to guess the delegate type
 					IType type = arguments[i].Type;
-					if (type.Kind == TypeKind.Null || type.Kind == TypeKind.Unknown) {
+					if (type.Kind == TypeKind.Null || type.Kind == TypeKind.None) {
 						list.Add(new DefaultParameter(compilation.FindType(KnownTypeCode.Object), argumentNames[i]));
 					} else {
 						list.Add(new DefaultParameter(type, argumentNames[i]));
@@ -2353,7 +2353,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		
 		bool HasType(ResolveResult r)
 		{
-			return r.Type.Kind != TypeKind.Unknown && r.Type.Kind != TypeKind.Null;
+			return r.Type.Kind != TypeKind.None && r.Type.Kind != TypeKind.Null;
 		}
 		#endregion
 		

ICSharpCode.Decompiler/CSharp/Resolver/LambdaResolveResult.cs

@@ -30,7 +30,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 	/// </summary>
 	public abstract class LambdaResolveResult : ResolveResult
 	{
-		protected LambdaResolveResult() : base(SpecialType.UnknownType)
+		protected LambdaResolveResult() : base(SpecialType.NoType)
 		{
 		}
 		

ICSharpCode.Decompiler/CSharp/Resolver/MethodGroupResolveResult.cs

@@ -83,7 +83,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		
 		public MethodGroupResolveResult(ResolveResult targetResult, string methodName, 
 			IReadOnlyList<MethodListWithDeclaringType> methods, IReadOnlyList<IType> typeArguments)
-			: base(SpecialType.UnknownType)
+			: base(SpecialType.NoType)
 		{
 			if (methods == null)
 				throw new ArgumentNullException("methods");

ICSharpCode.Decompiler/CSharp/Resolver/TypeInference.cs

@@ -295,7 +295,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		
 		static bool IsValidType(IType type)
 		{
-			return type.Kind != TypeKind.Unknown && type.Kind != TypeKind.Null;
+			return type.Kind != TypeKind.Unknown && type.Kind != TypeKind.Null && type.Kind != TypeKind.None;
 		}
 		
 		bool PhaseTwo()
@@ -818,7 +818,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			if (expressions == null)
 				throw new ArgumentNullException("expressions");
 			if (expressions.Count == 1) {
-				success = (expressions[0].Type.Kind != TypeKind.Unknown);
+				success = IsValidType(expressions[0].Type);
 				return expressions[0].Type;
 			}
 			Log.WriteCollection("GetBestCommonType() for ", expressions);

ICSharpCode.Decompiler/CSharp/TypeSystem/AliasNamespaceReference.cs

@@ -54,7 +54,7 @@ namespace ICSharpCode.Decompiler.CSharp.TypeSystem
 		public override IType ResolveType(CSharpResolver resolver)
 		{
 			// alias cannot refer to types
-			return SpecialType.UnknownType;
+			return SpecialType.NoType;
 		}
 		
 		public override string ToString()

ICSharpCode.Decompiler/Semantics/NamespaceResolveResult.cs

@@ -28,7 +28,7 @@ namespace ICSharpCode.Decompiler.Semantics
 	{
 		readonly INamespace ns;
 		
-		public NamespaceResolveResult(INamespace ns) : base(SpecialType.UnknownType)
+		public NamespaceResolveResult(INamespace ns) : base(SpecialType.NoType)
 		{
 			this.ns = ns;
 		}

ICSharpCode.Decompiler/TypeSystem/SpecialType.cs

@@ -36,7 +36,12 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// The null type is used as type of the null literal. It is a reference type without any members; and it is a subtype of all reference types.
 		/// </summary>
 		public readonly static SpecialType NullType = new SpecialType(TypeKind.Null, "null", isReferenceType: true);
-		
+
+		/// <summary>
+		/// Used for expressions without type, e.g. method groups or lambdas.
+		/// </summary>
+		public readonly static SpecialType NoType = new SpecialType(TypeKind.None, "?", isReferenceType: null);
+
 		/// <summary>
 		/// Type representing the C# 'dynamic' type.
 		/// </summary>

ICSharpCode.Decompiler/TypeSystem/TypeKind.cs

@@ -45,12 +45,16 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// <summary>The <c>System.Void</c> type.</summary>
 		/// <see cref="KnownTypeReference.Void"/>
 		Void,
-		
+
+		/// <summary>Type used for invalid expressions and for types whose definition could not be found.</summary>
 		/// <see cref="SpecialType.UnknownType"/>
 		Unknown,
 		/// <summary>The type of the null literal.</summary>
 		/// <see cref="SpecialType.NullType"/>
 		Null,
+		/// <summary>The type of expressions without type (except for null literals, which have <c>TypeKind.Null</c>).</summary>
+		/// <see cref="SpecialType.NoType"/>
+		None,
 		/// <summary>Type representing the C# 'dynamic' type.</summary>
 		/// <see cref="SpecialType.Dynamic"/>
 		Dynamic,