Fix CA1507:UseNameofInPlaceOfString, adjust formatting of some older source files copied from NRefactory.

ICSharpCode.Decompiler/CSharp/Annotations.cs

@@ -41,8 +41,8 @@ namespace ICSharpCode.Decompiler.CSharp
 	/// <summary>
 	/// Currently unused; we'll probably use the LdToken ILInstruction as annotation instead when LdToken support gets reimplemented.
 	/// </summary>
-	public class LdTokenAnnotation {}
+	public class LdTokenAnnotation { }
-	
+
 	public static class AnnotationExtensions
 	{
 		internal static ExpressionWithILInstruction WithILInstruction(this Expression expression, ILInstruction instruction)
@@ -98,7 +98,7 @@ namespace ICSharpCode.Decompiler.CSharp
 			expression.Expression.AddAnnotation(resolveResult);
 			return new TranslatedExpression(expression, resolveResult);
 		}
-		
+
 		/// <summary>
 		/// Retrieves the <see cref="ISymbol"/> associated with this AstNode, or null if no symbol is associated with the node.
 		/// </summary>
@@ -208,7 +208,7 @@ namespace ICSharpCode.Decompiler.CSharp
 			return node;
 		}
 	}
-	
+
 	/// <summary>
 	/// Represents a reference to a local variable.
 	/// </summary>
@@ -223,7 +223,7 @@ namespace ICSharpCode.Decompiler.CSharp
 
 		public ILVariableResolveResult(ILVariable v, IType type) : base(type)
 		{
-			this.Variable = v ?? throw new ArgumentNullException("v");
+			this.Variable = v ?? throw new ArgumentNullException(nameof(v));
 		}
 	}
 

ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpAmbience.cs

@@ -33,34 +33,34 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 	public class CSharpAmbience : IAmbience
 	{
 		public ConversionFlags ConversionFlags { get; set; }
-		
+
 		#region ConvertSymbol
 		public string ConvertSymbol(ISymbol symbol)
 		{
 			if (symbol == null)
-				throw new ArgumentNullException("symbol");
+				throw new ArgumentNullException(nameof(symbol));
-			
+
 			StringWriter writer = new StringWriter();
 			ConvertSymbol(symbol, new TextWriterTokenWriter(writer), FormattingOptionsFactory.CreateEmpty());
 			return writer.ToString();
 		}
-		
+
 		public void ConvertSymbol(ISymbol symbol, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
 		{
 			if (symbol == null)
-				throw new ArgumentNullException("symbol");
+				throw new ArgumentNullException(nameof(symbol));
 			if (writer == null)
-				throw new ArgumentNullException("writer");
+				throw new ArgumentNullException(nameof(writer));
 			if (formattingPolicy == null)
-				throw new ArgumentNullException("formattingPolicy");
+				throw new ArgumentNullException(nameof(formattingPolicy));
-			
+
 			TypeSystemAstBuilder astBuilder = CreateAstBuilder();
 			AstNode node = astBuilder.ConvertSymbol(symbol);
 			writer.StartNode(node);
 			EntityDeclaration entityDecl = node as EntityDeclaration;
 			if (entityDecl != null)
 				PrintModifiers(entityDecl.Modifiers, writer);
-			
+
 			if ((ConversionFlags & ConversionFlags.ShowDefinitionKeyword) == ConversionFlags.ShowDefinitionKeyword) {
 				if (node is TypeDeclaration) {
 					switch (((TypeDeclaration)node).ClassType) {
@@ -91,24 +91,23 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 					writer.Space();
 				}
 			}
-			
+
 			if ((ConversionFlags & ConversionFlags.PlaceReturnTypeAfterParameterList) != ConversionFlags.PlaceReturnTypeAfterParameterList
-				&& (ConversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType)
+				&& (ConversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType) {
-			{
 				var rt = node.GetChildByRole(Roles.Type);
 				if (!rt.IsNull) {
 					rt.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy));
 					writer.Space();
 				}
 			}
-			
+
 			if (symbol is ITypeDefinition)
 				WriteTypeDeclarationName((ITypeDefinition)symbol, writer, formattingPolicy);
 			else if (symbol is IMember)
 				WriteMemberDeclarationName((IMember)symbol, writer, formattingPolicy);
 			else
 				writer.WriteIdentifier(Identifier.Create(symbol.Name));
-			
+
 			if ((ConversionFlags & ConversionFlags.ShowParameterList) == ConversionFlags.ShowParameterList && HasParameters(symbol)) {
 				writer.WriteToken(symbol.SymbolKind == SymbolKind.Indexer ? Roles.LBracket : Roles.LPar, symbol.SymbolKind == SymbolKind.Indexer ? "[" : "(");
 				bool first = true;
@@ -131,8 +130,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 			}
 
 			if ((ConversionFlags & ConversionFlags.PlaceReturnTypeAfterParameterList) == ConversionFlags.PlaceReturnTypeAfterParameterList
-				&& (ConversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType)
+				&& (ConversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType) {
-			{
 				var rt = node.GetChildByRole(Roles.Type);
 				if (!rt.IsNull) {
 					writer.Space();
@@ -171,7 +169,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 				writer.EndNode(node);
 			}
 		}
-		
+
 		static bool HasParameters(ISymbol e)
 		{
 			switch (e.SymbolKind) {
@@ -187,7 +185,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 					return false;
 			}
 		}
-		
+
 		TypeSystemAstBuilder CreateAstBuilder()
 		{
 			TypeSystemAstBuilder astBuilder = new TypeSystemAstBuilder();
@@ -199,7 +197,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 			astBuilder.ShowParameterNames = (ConversionFlags & ConversionFlags.ShowParameterNames) == ConversionFlags.ShowParameterNames;
 			return astBuilder;
 		}
-		
+
 		void WriteTypeDeclarationName(ITypeDefinition typeDef, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
 		{
 			TypeSystemAstBuilder astBuilder = CreateAstBuilder();
@@ -299,7 +297,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 				}
 			}
 		}
-		
+
 		void WriteQualifiedName(string name, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
 		{
 			var node = AstType.Create(name);
@@ -307,25 +305,25 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 			node.AcceptVisitor(outputVisitor);
 		}
 		#endregion
-		
+
 		public string ConvertVariable(IVariable v)
 		{
 			TypeSystemAstBuilder astBuilder = CreateAstBuilder();
 			AstNode astNode = astBuilder.ConvertVariable(v);
 			return astNode.ToString().TrimEnd(';', '\r', '\n', (char)8232);
 		}
-		
+
 		public string ConvertType(IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
-			
+
 			TypeSystemAstBuilder astBuilder = CreateAstBuilder();
 			astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedEntityNames) != ConversionFlags.UseFullyQualifiedEntityNames;
 			AstType astType = astBuilder.ConvertType(type);
 			return astType.ToString();
 		}
-		
+
 		public void ConvertType(IType type, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
 		{
 			TypeSystemAstBuilder astBuilder = CreateAstBuilder();
@@ -333,12 +331,12 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 			AstType astType = astBuilder.ConvertType(type);
 			astType.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy));
 		}
-		
+
 		public string ConvertConstantValue(object constantValue)
 		{
 			return TextWriterTokenWriter.PrintPrimitiveValue(constantValue);
 		}
-		
+
 		public string WrapComment(string comment)
 		{
 			return "// " + comment;

ICSharpCode.Decompiler/CSharp/OutputVisitor/ITokenWriter.cs

@@ -26,42 +26,42 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 	{
 		public abstract void StartNode(AstNode node);
 		public abstract void EndNode(AstNode node);
-		
+
 		/// <summary>
 		/// Writes an identifier.
 		/// </summary>
 		public abstract void WriteIdentifier(Identifier identifier);
-		
+
 		/// <summary>
 		/// Writes a keyword to the output.
 		/// </summary>
 		public abstract void WriteKeyword(Role role, string keyword);
-		
+
 		/// <summary>
 		/// Writes a token to the output.
 		/// </summary>
 		public abstract void WriteToken(Role role, string token);
-		
+
 		/// <summary>
 		/// Writes a primitive/literal value
 		/// </summary>
 		public abstract void WritePrimitiveValue(object value, string literalValue = null);
-		
+
 		public abstract void WritePrimitiveType(string type);
-		
+
 		public abstract void Space();
 		public abstract void Indent();
 		public abstract void Unindent();
 		public abstract void NewLine();
-		
+
 		public abstract void WriteComment(CommentType commentType, string content);
 		public abstract void WritePreProcessorDirective(PreProcessorDirectiveType type, string argument);
-		
+
 		public static TokenWriter Create(TextWriter writer, string indentation = "\t")
 		{
 			return new InsertSpecialsDecorator(new InsertRequiredSpacesDecorator(new TextWriterTokenWriter(writer) { IndentationString = indentation }));
 		}
-		
+
 		public static TokenWriter CreateWriterThatSetsLocationsInAST(TextWriter writer, string indentation = "\t")
 		{
 			var target = new TextWriterTokenWriter(writer) { IndentationString = indentation };
@@ -72,7 +72,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 		{
 			return new InsertRequiredSpacesDecorator(writer);
 		}
-		
+
 		public static TokenWriter WrapInWriterThatSetsLocationsInAST(TokenWriter writer)
 		{
 			if (!(writer is ILocatable))
@@ -80,84 +80,84 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 			return new InsertMissingTokensDecorator(writer, (ILocatable)writer);
 		}
 	}
-	
+
 	public interface ILocatable
 	{
 		TextLocation Location { get; }
 		int Length { get; }
 	}
-	
+
 	public abstract class DecoratingTokenWriter : TokenWriter
 	{
 		TokenWriter decoratedWriter;
-		
+
 		protected DecoratingTokenWriter(TokenWriter decoratedWriter)
 		{
 			if (decoratedWriter == null)
-				throw new ArgumentNullException("decoratedWriter");
+				throw new ArgumentNullException(nameof(decoratedWriter));
 			this.decoratedWriter = decoratedWriter;
 		}
-		
+
 		public override void StartNode(AstNode node)
 		{
 			decoratedWriter.StartNode(node);
 		}
-		
+
 		public override void EndNode(AstNode node)
 		{
 			decoratedWriter.EndNode(node);
 		}
-		
+
 		public override void WriteIdentifier(Identifier identifier)
 		{
 			decoratedWriter.WriteIdentifier(identifier);
 		}
-		
+
 		public override void WriteKeyword(Role role, string keyword)
 		{
 			decoratedWriter.WriteKeyword(role, keyword);
 		}
-		
+
 		public override void WriteToken(Role role, string token)
 		{
 			decoratedWriter.WriteToken(role, token);
 		}
-		
+
 		public override void WritePrimitiveValue(object value, string literalValue = null)
 		{
 			decoratedWriter.WritePrimitiveValue(value, literalValue);
 		}
-		
+
 		public override void WritePrimitiveType(string type)
 		{
 			decoratedWriter.WritePrimitiveType(type);
 		}
-		
+
 		public override void Space()
 		{
 			decoratedWriter.Space();
 		}
-		
+
 		public override void Indent()
 		{
 			decoratedWriter.Indent();
 		}
-		
+
 		public override void Unindent()
 		{
 			decoratedWriter.Unindent();
 		}
-		
+
 		public override void NewLine()
 		{
 			decoratedWriter.NewLine();
 		}
-		
+
 		public override void WriteComment(CommentType commentType, string content)
 		{
 			decoratedWriter.WriteComment(commentType, content);
 		}
-		
+
 		public override void WritePreProcessorDirective(PreProcessorDirectiveType type, string argument)
 		{
 			decoratedWriter.WritePreProcessorDirective(type, argument);

ICSharpCode.Decompiler/CSharp/OutputVisitor/TextWriterTokenWriter.cs

@@ -47,7 +47,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 		public TextWriterTokenWriter(TextWriter textWriter)
 		{
 			if (textWriter == null)
-				throw new ArgumentNullException("textWriter");
+				throw new ArgumentNullException(nameof(textWriter));
 			this.textWriter = textWriter;
 			this.IndentationString = "\t";
 			this.line = 1;

ICSharpCode.Decompiler/CSharp/Resolver/AwaitResolveResult.cs

@@ -48,7 +48,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		/// This can also refer to an UnsafeOnCompleted method, if the awaiter type implements <c>System.Runtime.CompilerServices.ICriticalNotifyCompletion</c>.
 		/// </summary>
 		public readonly IMethod OnCompletedMethod;
-		
+
 		/// <summary>
 		/// Method representing the GetResult method on the awaiter type. Can be null if the awaiter type or the method was not found, or when awaiting a dynamic expression.
 		/// </summary>
@@ -58,21 +58,22 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			: base(resultType)
 		{
 			if (awaiterType == null)
-				throw new ArgumentNullException("awaiterType");
+				throw new ArgumentNullException(nameof(awaiterType));
 			if (getAwaiterInvocation == null)
-				throw new ArgumentNullException("getAwaiterInvocation");
+				throw new ArgumentNullException(nameof(getAwaiterInvocation));
 			this.GetAwaiterInvocation = getAwaiterInvocation;
 			this.AwaiterType = awaiterType;
 			this.IsCompletedProperty = isCompletedProperty;
 			this.OnCompletedMethod = onCompletedMethod;
 			this.GetResultMethod = getResultMethod;
 		}
-		
+
 		public override bool IsError {
 			get { return this.GetAwaiterInvocation.IsError || (AwaiterType.Kind != TypeKind.Dynamic && (this.IsCompletedProperty == null || this.OnCompletedMethod == null || this.GetResultMethod == null)); }
 		}
 
-		public override IEnumerable<ResolveResult> GetChildResults() {
+		public override IEnumerable<ResolveResult> GetChildResults()
+		{
 			return new[] { GetAwaiterInvocation };
 		}
 	}

ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs

@@ -38,14 +38,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 	{
 		readonly ConcurrentDictionary<TypePair, Conversion> implicitConversionCache = new ConcurrentDictionary<TypePair, Conversion>();
 		readonly ICompilation compilation;
-		
+
 		public CSharpConversions(ICompilation compilation)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			this.compilation = compilation;
 		}
-		
+
 		/// <summary>
 		/// Gets the Conversions instance for the specified <see cref="ICompilation"/>.
 		/// This will make use of the context's cache manager to reuse the Conversions instance.
@@ -53,7 +53,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public static CSharpConversions Get(ICompilation compilation)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			CacheManager cache = compilation.CacheManager;
 			CSharpConversions operators = (CSharpConversions)cache.GetShared(typeof(CSharpConversions));
 			if (operators == null) {
@@ -61,30 +61,30 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 			return operators;
 		}
-		
+
 		#region TypePair (for caching)
 		struct TypePair : IEquatable<TypePair>
 		{
 			public readonly IType FromType;
 			public readonly IType ToType;
-			
+
 			public TypePair(IType fromType, IType toType)
 			{
 				Debug.Assert(fromType != null && toType != null);
 				this.FromType = fromType;
 				this.ToType = toType;
 			}
-			
+
 			public override bool Equals(object obj)
 			{
 				return (obj is TypePair) && Equals((TypePair)obj);
 			}
-			
+
 			public bool Equals(TypePair other)
 			{
 				return object.Equals(this.FromType, other.FromType) && object.Equals(this.ToType, other.ToType);
 			}
-			
+
 			public override int GetHashCode()
 			{
 				unchecked {
@@ -93,7 +93,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 		}
 		#endregion
-		
+
 		#region ImplicitConversion
 		private Conversion ImplicitConversion(ResolveResult resolveResult, IType toType, bool allowUserDefined, bool allowTuple)
 		{
@@ -137,7 +137,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			c = MethodGroupConversion(resolveResult, toType);
 			return c;
 		}
-		
+
 		private Conversion ImplicitConversion(IType fromType, IType toType, bool allowUserDefined, bool allowTuple)
 		{
 			// C# 4.0 spec: §6.1
@@ -151,17 +151,17 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public Conversion ImplicitConversion(ResolveResult resolveResult, IType toType)
 		{
 			if (resolveResult == null)
-				throw new ArgumentNullException("resolveResult");
+				throw new ArgumentNullException(nameof(resolveResult));
 			return ImplicitConversion(resolveResult, toType, allowUserDefined: true, allowTuple: true);
 		}
 
 		public Conversion ImplicitConversion(IType fromType, IType toType)
 		{
 			if (fromType == null)
-				throw new ArgumentNullException("fromType");
+				throw new ArgumentNullException(nameof(fromType));
 			if (toType == null)
-				throw new ArgumentNullException("toType");
+				throw new ArgumentNullException(nameof(toType));
-			
+
 			TypePair pair = new TypePair(fromType, toType);
 			Conversion c;
 			if (implicitConversionCache.TryGetValue(pair, out c))
@@ -176,9 +176,9 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public Conversion StandardImplicitConversion(IType fromType, IType toType)
 		{
 			if (fromType == null)
-				throw new ArgumentNullException("fromType");
+				throw new ArgumentNullException(nameof(fromType));
 			if (toType == null)
-				throw new ArgumentNullException("toType");
+				throw new ArgumentNullException(nameof(toType));
 			return StandardImplicitConversion(fromType, toType, allowTupleConversion: true);
 		}
 
@@ -220,10 +220,10 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public bool IsConstraintConvertible(IType fromType, IType toType)
 		{
 			if (fromType == null)
-				throw new ArgumentNullException("fromType");
+				throw new ArgumentNullException(nameof(fromType));
 			if (toType == null)
-				throw new ArgumentNullException("toType");
+				throw new ArgumentNullException(nameof(toType));
-			
+
 			if (IdentityConversion(fromType, toType))
 				return true;
 			if (ImplicitReferenceConversion(fromType, toType, 0))
@@ -242,15 +242,15 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			return false;
 		}
 		#endregion
-		
+
 		#region ExplicitConversion
 		public Conversion ExplicitConversion(ResolveResult resolveResult, IType toType)
 		{
 			if (resolveResult == null)
-				throw new ArgumentNullException("resolveResult");
+				throw new ArgumentNullException(nameof(resolveResult));
 			if (toType == null)
-				throw new ArgumentNullException("toType");
+				throw new ArgumentNullException(nameof(toType));
-			
+
 			if (resolveResult.Type.Kind == TypeKind.Dynamic)
 				return Conversion.ExplicitDynamicConversion;
 			Conversion c = ImplicitConversion(resolveResult, toType, allowUserDefined: false, allowTuple: false);
@@ -266,14 +266,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return c;
 			return UserDefinedExplicitConversion(resolveResult, resolveResult.Type, toType);
 		}
-		
+
 		public Conversion ExplicitConversion(IType fromType, IType toType)
 		{
 			if (fromType == null)
-				throw new ArgumentNullException("fromType");
+				throw new ArgumentNullException(nameof(fromType));
 			if (toType == null)
-				throw new ArgumentNullException("toType");
+				throw new ArgumentNullException(nameof(toType));
-			
+
 			Conversion c = ImplicitConversion(fromType, toType, allowUserDefined: false, allowTuple: false);
 			if (c != Conversion.None)
 				return c;
@@ -282,7 +282,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return c;
 			return UserDefinedExplicitConversion(null, fromType, toType);
 		}
-		
+
 		Conversion ExplicitConversionImpl(IType fromType, IType toType)
 		{
 			// This method is called after we already checked for implicit conversions,
@@ -319,7 +319,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			return fromType.Equals(toType);
 		}
 		#endregion
-		
+
 		#region Numeric Conversions
 		static readonly bool[,] implicitNumericConversionLookup = {
 			//       to:   short  ushort  int   uint   long   ulong
@@ -332,11 +332,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			/* int    */ { false, false, false, false, true , false },
 			/* uint   */ { false, false, false, false, true , true  },
 		};
-		
+
 		bool ImplicitNumericConversion(IType fromType, IType toType)
 		{
 			// C# 4.0 spec: §6.1.2
-			
+
 			TypeCode from = ReflectionHelper.GetTypeCode(fromType);
 			TypeCode to = ReflectionHelper.GetTypeCode(toType);
 			if (to >= TypeCode.Single && to <= TypeCode.Decimal) {
@@ -351,20 +351,20 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 					&& implicitNumericConversionLookup[from - TypeCode.Char, to - TypeCode.Int16];
 			}
 		}
-		
+
 		bool IsNumericType(IType type)
 		{
 			TypeCode c = ReflectionHelper.GetTypeCode(type);
 			return c >= TypeCode.Char && c <= TypeCode.Decimal;
 		}
-		
+
 		bool AnyNumericConversion(IType fromType, IType toType)
 		{
 			// C# 4.0 spec: §6.1.2 + §6.2.1
 			return IsNumericType(fromType) && IsNumericType(toType);
 		}
 		#endregion
-		
+
 		#region Enumeration Conversions
 		Conversion ImplicitEnumerationConversion(ResolveResult rr, IType toType)
 		{
@@ -378,7 +378,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 			return Conversion.None;
 		}
-		
+
 		bool ExplicitEnumerationConversion(IType fromType, IType toType)
 		{
 			// C# 4.0 spec: §6.2.2
@@ -390,7 +390,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			return false;
 		}
 		#endregion
-		
+
 		#region Nullable Conversions
 		Conversion ImplicitNullableConversion(IType fromType, IType toType)
 		{
@@ -405,7 +405,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 			return Conversion.None;
 		}
-		
+
 		Conversion ExplicitNullableConversion(IType fromType, IType toType)
 		{
 			// C# 4.0 spec: §6.1.4
@@ -422,7 +422,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			return Conversion.None;
 		}
 		#endregion
-		
+
 		#region Null Literal Conversion
 		bool NullLiteralConversion(IType fromType, IType toType)
 		{
@@ -434,24 +434,24 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 		}
 		#endregion
-		
+
 		#region Implicit Reference Conversion
 		public bool IsImplicitReferenceConversion(IType fromType, IType toType)
 		{
 			return ImplicitReferenceConversion(fromType, toType, 0);
 		}
-		
+
 		bool ImplicitReferenceConversion(IType fromType, IType toType, int subtypeCheckNestingDepth)
 		{
 			// C# 4.0 spec: §6.1.6
-			
+
 			// reference conversions are possible:
 			// - if both types are known to be reference types
 			// - if both types are type parameters and fromType has a class constraint
 			//     (ImplicitTypeParameterConversionWithClassConstraintOnlyOnT)
 			if (!(fromType.IsReferenceType == true && toType.IsReferenceType != false))
 				return false;
-			
+
 			ArrayType fromArray = fromType as ArrayType;
 			if (fromArray != null) {
 				ArrayType toArray = toType as ArrayType;
@@ -471,11 +471,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				IType systemArray = compilation.FindType(KnownTypeCode.Array);
 				return ImplicitReferenceConversion(systemArray, toType, subtypeCheckNestingDepth);
 			}
-			
+
 			// now comes the hard part: traverse the inheritance chain and figure out generics+variance
 			return IsSubtypeOf(fromType, toType, subtypeCheckNestingDepth);
 		}
-		
+
 		/// <summary>
 		/// For IList{T}, ICollection{T}, IEnumerable{T} and IReadOnlyList{T}, returns T.
 		/// Otherwise, returns null.
@@ -494,10 +494,10 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 			return null;
 		}
-		
+
 		// Determines whether s is a subtype of t.
 		// Helper method used for ImplicitReferenceConversion, BoxingConversion and ImplicitTypeParameterConversion
-		
+
 		bool IsSubtypeOf(IType s, IType t, int subtypeCheckNestingDepth)
 		{
 			// conversion to dynamic + object are always possible
@@ -507,7 +507,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				// Subtyping in C# is undecidable
 				// (see "On Decidability of Nominal Subtyping with Variance" by Andrew J. Kennedy and Benjamin C. Pierce),
 				// so we'll prevent infinite recursions by putting a limit on the nesting depth of variance conversions.
-				
+
 				// No real C# code should use generics nested more than 10 levels deep, and even if they do, most of
 				// those nestings should not involve variance.
 				return false;
@@ -519,7 +519,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 			return false;
 		}
-		
+
 		bool IdentityOrVarianceConversion(IType s, IType t, int subtypeCheckNestingDepth)
 		{
 			ITypeDefinition def = s.GetDefinition();
@@ -559,12 +559,12 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 		}
 		#endregion
-		
+
 		#region Explicit Reference Conversion
 		bool ExplicitReferenceConversion(IType fromType, IType toType)
 		{
 			// C# 4.0 spec: §6.2.4
-			
+
 			// test that the types are reference types:
 			if (toType.IsReferenceType != true)
 				return false;
@@ -576,7 +576,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 					return IsSubtypeOf(toType, fromType, 0);
 				return false;
 			}
-			
+
 			if (toType.Kind == TypeKind.Array) {
 				ArrayType toArray = (ArrayType)toType;
 				if (fromType.Kind == TypeKind.Array) {
@@ -645,7 +645,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 						|| IsImplicitReferenceConversion(fromType, toType);
 			}
 		}
-		
+
 		bool IsSealedReferenceType(IType type)
 		{
 			TypeKind kind = type.Kind;
@@ -686,7 +686,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return false;
 		}
 		#endregion
-		
+
 		#region Implicit Constant-Expression Conversion
 		bool ImplicitConstantExpressionConversion(ResolveResult rr, IType toType)
 		{
@@ -721,7 +721,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			return false;
 		}
 		#endregion
-		
+
 		#region Conversions involving type parameters
 		/// <summary>
 		/// Implicit conversions involving type parameters.
@@ -734,7 +734,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return false; // already handled by ImplicitReferenceConversion
 			return IsSubtypeOf(fromType, toType, 0);
 		}
-		
+
 		Conversion ExplicitTypeParameterConversion(IType fromType, IType toType)
 		{
 			if (toType.Kind == TypeKind.TypeParameter) {
@@ -749,7 +749,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			return Conversion.None;
 		}
 		#endregion
-		
+
 		#region Pointer Conversions
 		bool ImplicitPointerConversion(IType fromType, IType toType)
 		{
@@ -760,7 +760,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return true;
 			return false;
 		}
-		
+
 		bool ExplicitPointerConversion(IType fromType, IType toType)
 		{
 			// C# 4.0 spec: §18.4 Pointer conversions
@@ -770,14 +770,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return toType.Kind == TypeKind.Pointer && IsIntegerType(fromType);
 			}
 		}
-		
+
 		bool IsIntegerType(IType type)
 		{
 			TypeCode c = ReflectionHelper.GetTypeCode(type);
 			return c >= TypeCode.SByte && c <= TypeCode.UInt64;
 		}
 		#endregion
-		
+
 		#region User-Defined Conversions
 		/// <summary>
 		/// Gets whether type A is encompassed by type B.
@@ -786,7 +786,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		{
 			return a.Kind != TypeKind.Interface && b.Kind != TypeKind.Interface && StandardImplicitConversion(a, b).IsValid;
 		}
-		
+
 		bool IsEncompassingOrEncompassedBy(IType a, IType b)
 		{
 			return a.Kind != TypeKind.Interface && b.Kind != TypeKind.Interface
@@ -800,7 +800,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				if (best == null || IsEncompassedBy(current, best))
 					best = current;
 				else if (!IsEncompassedBy(best, current))
-					return null;	// Ambiguous
+					return null;    // Ambiguous
 			}
 			return best;
 		}
@@ -812,7 +812,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				if (best == null || IsEncompassedBy(best, current))
 					best = current;
 				else if (!IsEncompassedBy(current, best))
-					return null;	// Ambiguous
+					return null;    // Ambiguous
 			}
 			return best;
 		}
@@ -831,7 +831,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				var op = selected.First(s => !s.IsLifted);
 				return Conversion.UserDefinedConversion(op.Method, isLifted: op.IsLifted, isImplicit: isImplicit, conversionBeforeUserDefinedOperator: ExplicitConversion(source, mostSpecificSource), conversionAfterUserDefinedOperator: ExplicitConversion(mostSpecificTarget, target));
 			}
-			
+
 			return Conversion.UserDefinedConversion(selected[0].Method, isLifted: selected[0].IsLifted, isImplicit: isImplicit, isAmbiguous: true, conversionBeforeUserDefinedOperator: ExplicitConversion(source, mostSpecificSource), conversionAfterUserDefinedOperator: ExplicitConversion(mostSpecificTarget, target));
 		}
 
@@ -861,17 +861,15 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 							return other;
 					}
 					return selected;
-				}
+				} else if (NullableType.IsNullable(toType))
-				else if (NullableType.IsNullable(toType))
 					return UserDefinedImplicitConversion(fromResult, fromType, NullableType.GetUnderlyingType(toType));
 				else
 					return Conversion.None;
-			}
+			} else {
-			else {
 				return Conversion.None;
 			}
 		}
-		
+
 		Conversion UserDefinedExplicitConversion(ResolveResult fromResult, IType fromType, IType toType)
 		{
 			// C# 4.0 spec §6.4.5 User-defined explicit conversions
@@ -913,26 +911,24 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 							return other;
 					}
 					return selected;
-				}
+				} else if (NullableType.IsNullable(toType))
-				else if (NullableType.IsNullable(toType))
 					return UserDefinedExplicitConversion(fromResult, fromType, NullableType.GetUnderlyingType(toType));
 				else if (NullableType.IsNullable(fromType))
-					return UserDefinedExplicitConversion(null, NullableType.GetUnderlyingType(fromType), toType);	// A? -> A -> B
+					return UserDefinedExplicitConversion(null, NullableType.GetUnderlyingType(fromType), toType);   // A? -> A -> B
 				else
 					return Conversion.None;
-			}
+			} else {
-			else {
 				return Conversion.None;
 			}
 		}
-		
+
 		class OperatorInfo
 		{
 			public readonly IMethod Method;
 			public readonly IType SourceType;
 			public readonly IType TargetType;
 			public readonly bool IsLifted;
-			
+
 			public OperatorInfo(IMethod method, IType sourceType, IType targetType, bool isLifted)
 			{
 				this.Method = method;
@@ -941,7 +937,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				this.IsLifted = isLifted;
 			}
 		}
-		
+
 		List<OperatorInfo> GetApplicableConversionOperators(ResolveResult fromResult, IType fromType, IType toType, bool isExplicit)
 		{
 			// Find the candidate operators:
@@ -950,7 +946,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				opFilter = m => m.IsStatic && m.IsOperator && (m.Name == "op_Explicit" || m.Name == "op_Implicit") && m.Parameters.Count == 1;
 			else
 				opFilter = m => m.IsStatic && m.IsOperator && m.Name == "op_Implicit" && m.Parameters.Count == 1;
-			
+
 			var operators = NullableType.GetUnderlyingType(fromType).GetMethods(opFilter)
 				.Concat(NullableType.GetUnderlyingType(toType).GetMethods(opFilter)).Distinct();
 			// Determine whether one of them is applicable:
@@ -990,7 +986,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			return result;
 		}
 		#endregion
-		
+
 		#region AnonymousFunctionConversion
 		Conversion AnonymousFunctionConversion(ResolveResult resolveResult, IType toType)
 		{
@@ -1006,18 +1002,18 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			IMethod d = toType.GetDelegateInvokeMethod();
 			if (d == null)
 				return Conversion.None;
-			
+
 			IType[] dParamTypes = new IType[d.Parameters.Count];
 			for (int i = 0; i < dParamTypes.Length; i++) {
 				dParamTypes[i] = d.Parameters[i].Type;
 			}
 			IType dReturnType = d.ReturnType;
-			
+
 			if (f.HasParameterList) {
 				// If F contains an anonymous-function-signature, then D and F have the same number of parameters.
 				if (d.Parameters.Count != f.Parameters.Count)
 					return Conversion.None;
-				
+
 				if (f.IsImplicitlyTyped) {
 					// If F has an implicitly typed parameter list, D has no ref or out parameters.
 					foreach (IParameter p in d.Parameters) {
@@ -1044,7 +1040,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 						return Conversion.None;
 				}
 			}
-			
+
 			return f.IsValid(dParamTypes, dReturnType, this);
 		}
 
@@ -1058,7 +1054,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 		}
 		#endregion
-		
+
 		#region MethodGroupConversion
 		Conversion MethodGroupConversion(ResolveResult resolveResult, IType toType)
 		{
@@ -1069,7 +1065,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			IMethod invoke = toType.GetDelegateInvokeMethod();
 			if (invoke == null)
 				return Conversion.None;
-			
+
 			ResolveResult[] args = new ResolveResult[invoke.Parameters.Count];
 			for (int i = 0; i < args.Length; i++) {
 				IParameter param = invoke.Parameters[i];
@@ -1096,7 +1092,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return Conversion.None;
 			}
 		}
-		
+
 		/// <summary>
 		/// Gets whether a <paramref name="method"/> is compatible with a delegate type.
 		/// §15.2 Delegate compatibility
@@ -1106,15 +1102,15 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public bool IsDelegateCompatible(IMethod method, IType delegateType)
 		{
 			if (method == null)
-				throw new ArgumentNullException("method");
+				throw new ArgumentNullException(nameof(method));
 			if (delegateType == null)
-				throw new ArgumentNullException("delegateType");
+				throw new ArgumentNullException(nameof(delegateType));
 			IMethod invoke = delegateType.GetDelegateInvokeMethod();
 			if (invoke == null)
 				return false;
 			return IsDelegateCompatible(method, invoke, false);
 		}
-		
+
 		/// <summary>
 		/// Gets whether a method <paramref name="m"/> is compatible with a delegate type.
 		/// §15.2 Delegate compatibility
@@ -1126,9 +1122,9 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		bool IsDelegateCompatible(IMethod m, IMethod invoke, bool isExtensionMethodInvocation)
 		{
 			if (m == null)
-				throw new ArgumentNullException("m");
+				throw new ArgumentNullException(nameof(m));
 			if (invoke == null)
-				throw new ArgumentNullException("invoke");
+				throw new ArgumentNullException(nameof(invoke));
 			int firstParameterInM = isExtensionMethodInvocation ? 1 : 0;
 			if (m.Parameters.Count - firstParameterInM != invoke.Parameters.Count)
 				return false;
@@ -1227,14 +1223,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				}
 				if (lambda.HasParameterList && parameterTypes.Length != lambda.Parameters.Count)
 					return 0;
-				
+
 				IType ret1 = m1.ReturnType;
 				IType ret2 = m2.ReturnType;
 				if (ret1.Kind == TypeKind.Void && ret2.Kind != TypeKind.Void)
 					return 2;
 				if (ret1.Kind != TypeKind.Void && ret2.Kind == TypeKind.Void)
 					return 1;
-				
+
 				IType inferredRet = lambda.GetInferredReturnType(parameterTypes);
 				int r = BetterConversion(inferredRet, ret1, ret2);
 				if (r == 0 && lambda.IsAsync) {
@@ -1249,7 +1245,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return BetterConversion(resolveResult.Type, t1, t2);
 			}
 		}
-		
+
 		/// <summary>
 		/// Unpacks the generic Task[T]. Returns null if the input is not Task[T].
 		/// </summary>
@@ -1261,7 +1257,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 			return null;
 		}
-		
+
 		/// <summary>
 		/// Gets the better conversion (C# 4.0 spec, §7.5.3.4)
 		/// </summary>
@@ -1276,7 +1272,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return 2;
 			return BetterConversionTarget(t1, t2);
 		}
-		
+
 		/// <summary>
 		/// Gets the better conversion target (C# 4.0 spec, §7.5.3.5)
 		/// </summary>
@@ -1297,7 +1293,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return 2;
 			return 0;
 		}
-		
+
 		bool IsBetterIntegralType(TypeCode t1, TypeCode t2)
 		{
 			// signed types are better than unsigned types

ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs

@@ -49,7 +49,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public CSharpResolver(ICompilation compilation)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			this.compilation = compilation;
 			this.conversions = CSharpConversions.Get(compilation);
 			this.context = new CSharpTypeResolveContext(compilation.MainModule);
@@ -58,7 +58,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public CSharpResolver(CSharpTypeResolveContext context)
 		{
 			if (context == null)
-				throw new ArgumentNullException("context");
+				throw new ArgumentNullException(nameof(context));
 			this.compilation = context.Compilation;
 			this.conversions = CSharpConversions.Get(compilation);
 			this.context = context;
@@ -262,7 +262,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public CSharpResolver AddVariable(IVariable variable)
 		{
 			if (variable == null)
-				throw new ArgumentNullException("variable");
+				throw new ArgumentNullException(nameof(variable));
 			return WithLocalVariableStack(localVariableStack.Push(variable));
 		}
 		
@@ -313,7 +313,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public CSharpResolver PushObjectInitializer(ResolveResult initializedObject)
 		{
 			if (initializedObject == null)
-				throw new ArgumentNullException("initializedObject");
+				throw new ArgumentNullException(nameof(initializedObject));
 			return WithObjectInitializerStack(new ObjectInitializerContext(initializedObject, objectInitializerStack));
 		}
 		
@@ -1313,9 +1313,9 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			// C# 4.0 spec: §3.8 Namespace and type names; §7.6.2 Simple Names
 			
 			if (identifier == null)
-				throw new ArgumentNullException("identifier");
+				throw new ArgumentNullException(nameof(identifier));
 			if (typeArguments == null)
-				throw new ArgumentNullException("typeArguments");
+				throw new ArgumentNullException(nameof(typeArguments));
 			
 			int k = typeArguments.Count;
 			
@@ -1866,9 +1866,9 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public static bool IsEligibleExtensionMethod(IType targetType, IMethod method, bool useTypeInference, out IType[] outInferredTypes)
 		{
 			if (targetType == null)
-				throw new ArgumentNullException("targetType");
+				throw new ArgumentNullException(nameof(targetType));
 			if (method == null)
-				throw new ArgumentNullException("method");
+				throw new ArgumentNullException(nameof(method));
 			var compilation = method.Compilation;
 			return IsEligibleExtensionMethod(compilation, CSharpConversions.Get(compilation), targetType, method, useTypeInference, out outInferredTypes);
 		}
@@ -2348,7 +2348,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public ResolveResult ResolveCondition(ResolveResult input)
 		{
 			if (input == null)
-				throw new ArgumentNullException("input");
+				throw new ArgumentNullException(nameof(input));
 			IType boolean = compilation.FindType(KnownTypeCode.Boolean);
 			Conversion c = conversions.ImplicitConversion(input, boolean);
 			if (!c.IsValid) {
@@ -2368,7 +2368,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public ResolveResult ResolveConditionFalse(ResolveResult input)
 		{
 			if (input == null)
-				throw new ArgumentNullException("input");
+				throw new ArgumentNullException(nameof(input));
 			IType boolean = compilation.FindType(KnownTypeCode.Boolean);
 			Conversion c = conversions.ImplicitConversion(input, boolean);
 			if (!c.IsValid) {

ICSharpCode.Decompiler/CSharp/Resolver/MemberLookup.cs

@@ -37,7 +37,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public static bool IsInvocable(IMember member)
 		{
 			if (member == null)
-				throw new ArgumentNullException("member");
+				throw new ArgumentNullException(nameof(member));
 			// C# 4.0 spec, §7.4 member lookup
 			if (member is IEvent || member is IMethod)
 				return true;
@@ -99,7 +99,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public bool IsAccessible(IEntity entity, bool allowProtectedAccess)
 		{
 			if (entity == null)
-				throw new ArgumentNullException("entity");
+				throw new ArgumentNullException(nameof(entity));
 			// C# 4.0 spec, §3.5.2 Accessiblity domains
 			switch (entity.Accessibility) {
 				case Accessibility.None:
@@ -159,7 +159,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public IEnumerable<IEntity> GetAccessibleMembers(ResolveResult targetResolveResult)
 		{
 			if (targetResolveResult == null)
-				throw new ArgumentNullException("targetResolveResult");
+				throw new ArgumentNullException(nameof(targetResolveResult));
 			
 			bool targetIsTypeParameter = targetResolveResult.Type.Kind == TypeKind.TypeParameter;
 			bool allowProtectedAccess = IsProtectedAccessAllowed(targetResolveResult);
@@ -276,11 +276,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public ResolveResult LookupType(IType declaringType, string name, IReadOnlyList<IType> typeArguments, bool parameterizeResultType = true)
 		{
 			if (declaringType == null)
-				throw new ArgumentNullException("declaringType");
+				throw new ArgumentNullException(nameof(declaringType));
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			if (typeArguments == null)
-				throw new ArgumentNullException("typeArguments");
+				throw new ArgumentNullException(nameof(typeArguments));
 			
 			int typeArgumentCount = typeArguments.Count;
 			Predicate<ITypeDefinition> filter = delegate (ITypeDefinition d) {
@@ -335,11 +335,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public ResolveResult Lookup(ResolveResult targetResolveResult, string name, IReadOnlyList<IType> typeArguments, bool isInvocation)
 		{
 			if (targetResolveResult == null)
-				throw new ArgumentNullException("targetResolveResult");
+				throw new ArgumentNullException(nameof(targetResolveResult));
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			if (typeArguments == null)
-				throw new ArgumentNullException("typeArguments");
+				throw new ArgumentNullException(nameof(typeArguments));
 			
 			bool targetIsTypeParameter = targetResolveResult.Type.Kind == TypeKind.TypeParameter;
 			
@@ -413,7 +413,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public IReadOnlyList<MethodListWithDeclaringType> LookupIndexers(ResolveResult targetResolveResult)
 		{
 			if (targetResolveResult == null)
-				throw new ArgumentNullException("targetResolveResult");
+				throw new ArgumentNullException(nameof(targetResolveResult));
 			
 			IType targetType = targetResolveResult.Type;
 			bool allowProtectedAccess = IsProtectedAccessAllowed(targetResolveResult);

ICSharpCode.Decompiler/CSharp/Resolver/MethodGroupResolveResult.cs

@@ -86,7 +86,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			: base(SpecialType.NoType)
 		{
 			if (methods == null)
-				throw new ArgumentNullException("methods");
+				throw new ArgumentNullException(nameof(methods));
 			this.targetResult = targetResult;
 			this.methodName = methodName;
 			this.methodLists = methods;

ICSharpCode.Decompiler/CSharp/Resolver/OverloadResolution.cs

@@ -35,53 +35,53 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		sealed class Candidate
 		{
 			public readonly IParameterizedMember Member;
-			
+
 			/// <summary>
 			/// Returns the normal form candidate, if this is an expanded candidate.
 			/// </summary>
 			public readonly bool IsExpandedForm;
-			
+
 			/// <summary>
 			/// Gets the parameter types. In the first step, these are the types without any substition.
 			/// After type inference, substitutions will be performed.
 			/// </summary>
 			public readonly IType[] ParameterTypes;
-			
+
 			/// <summary>
 			/// argument index -> parameter index; -1 for arguments that could not be mapped
 			/// </summary>
 			public int[] ArgumentToParameterMap;
-			
+
 			public OverloadResolutionErrors Errors;
 			public int ErrorCount;
-			
+
 			public bool HasUnmappedOptionalParameters;
-			
+
 			public IType[] InferredTypes;
-			
+
 			/// <summary>
 			/// Gets the original member parameters (before any substitution!)
 			/// </summary>
 			public readonly IReadOnlyList<IParameter> Parameters;
-			
+
 			/// <summary>
 			/// Gets the original method type parameters (before any substitution!)
 			/// </summary>
 			public readonly IReadOnlyList<ITypeParameter> TypeParameters;
-			
+
 			/// <summary>
 			/// Conversions applied to the arguments.
 			/// This field is set by the CheckApplicability step.
 			/// </summary>
 			public Conversion[] ArgumentConversions;
-			
+
 			public bool IsGenericMethod {
 				get {
 					IMethod method = Member as IMethod;
 					return method != null && method.TypeParameters.Count > 0;
 				}
 			}
-			
+
 			public int ArgumentsPassedToParamsArray {
 				get {
 					int count = 0;
@@ -95,7 +95,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 					return count;
 				}
 			}
-			
+
 			public Candidate(IParameterizedMember member, bool isExpanded)
 			{
 				this.Member = member;
@@ -111,7 +111,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				}
 				this.ParameterTypes = new IType[this.Parameters.Count];
 			}
-			
+
 			public void AddError(OverloadResolutionErrors newError)
 			{
 				this.Errors |= newError;
@@ -119,7 +119,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 					this.ErrorCount++;
 			}
 		}
-		
+
 		readonly ICompilation compilation;
 		readonly ResolveResult[] arguments;
 		readonly string[] argumentNames;
@@ -130,14 +130,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		IType[] explicitlyGivenTypeArguments;
 		bool bestCandidateWasValidated;
 		OverloadResolutionErrors bestCandidateValidationResult;
-		
+
 		#region Constructor
 		public OverloadResolution(ICompilation compilation, ResolveResult[] arguments, string[] argumentNames = null, IType[] typeArguments = null, CSharpConversions conversions = null)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			if (arguments == null)
-				throw new ArgumentNullException("arguments");
+				throw new ArgumentNullException(nameof(arguments));
 			if (argumentNames == null)
 				argumentNames = new string[arguments.Length];
 			else if (argumentNames.Length != arguments.Length)
@@ -145,17 +145,17 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			this.compilation = compilation;
 			this.arguments = arguments;
 			this.argumentNames = argumentNames;
-			
+
 			// keep explicitlyGivenTypeArguments==null when no type arguments were specified
 			if (typeArguments != null && typeArguments.Length > 0)
 				this.explicitlyGivenTypeArguments = typeArguments;
-			
+
 			this.conversions = conversions ?? CSharpConversions.Get(compilation);
 			this.AllowExpandingParams = true;
 			this.AllowOptionalParameters = true;
 		}
 		#endregion
-		
+
 		#region Input Properties
 		/// <summary>
 		/// Gets/Sets whether the methods are extension methods that are being called using extension method syntax.
@@ -165,27 +165,27 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		/// implicit identity, reference, or boxing conversions.
 		/// </remarks>
 		public bool IsExtensionMethodInvocation { get; set; }
-		
+
 		/// <summary>
 		/// Gets/Sets whether expanding 'params' into individual elements is allowed.
 		/// The default value is true.
 		/// </summary>
 		public bool AllowExpandingParams { get; set; }
-		
+
 		/// <summary>
 		/// Gets/Sets whether optional parameters may be left at their default value.
 		/// The default value is true.
 		/// If this property is set to false, optional parameters will be treated like regular parameters.
 		/// </summary>
 		public bool AllowOptionalParameters { get; set; }
-		
+
 		/// <summary>
 		/// Gets/Sets whether ConversionResolveResults created by this OverloadResolution
 		/// instance apply overflow checking.
 		/// The default value is false.
 		/// </summary>
 		public bool CheckForOverflow { get; set; }
-		
+
 		/// <summary>
 		/// Gets the arguments for which this OverloadResolution instance was created.
 		/// </summary>
@@ -193,7 +193,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			get { return arguments; }
 		}
 		#endregion
-		
+
 		#region AddCandidate
 		/// <summary>
 		/// Adds a candidate to overload resolution.
@@ -205,7 +205,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		{
 			return AddCandidate(member, OverloadResolutionErrors.None);
 		}
-		
+
 		/// <summary>
 		/// Adds a candidate to overload resolution.
 		/// </summary>
@@ -218,30 +218,30 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public OverloadResolutionErrors AddCandidate(IParameterizedMember member, OverloadResolutionErrors additionalErrors)
 		{
 			if (member == null)
-				throw new ArgumentNullException("member");
+				throw new ArgumentNullException(nameof(member));
-			
+
 			Candidate c = new Candidate(member, false);
 			c.AddError(additionalErrors);
 			if (CalculateCandidate(c)) {
 				//candidates.Add(c);
 			}
-			
+
 			if (this.AllowExpandingParams && member.Parameters.Count > 0
-			    && member.Parameters[member.Parameters.Count - 1].IsParams)
+				&& member.Parameters[member.Parameters.Count - 1].IsParams)
 			{
 				Candidate expandedCandidate = new Candidate(member, true);
 				expandedCandidate.AddError(additionalErrors);
 				// consider expanded form only if it isn't obviously wrong
 				if (CalculateCandidate(expandedCandidate)) {
 					//candidates.Add(expandedCandidate);
-					
+
 					if (expandedCandidate.ErrorCount < c.ErrorCount)
 						return expandedCandidate.Errors;
 				}
 			}
 			return c.Errors;
 		}
-		
+
 		/// <summary>
 		/// Calculates applicability etc. for the candidate.
 		/// </summary>
@@ -256,7 +256,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			ConsiderIfNewCandidateIsBest(candidate);
 			return true;
 		}
-		
+
 		bool ResolveParameterTypes(Candidate candidate, bool useSpecializedParameters)
 		{
 			for (int i = 0; i < candidate.Parameters.Count; i++) {
@@ -281,7 +281,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			return true;
 		}
 		#endregion
-		
+
 		#region AddMethodLists
 		/// <summary>
 		/// Adds all candidates from the method lists.
@@ -293,7 +293,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public void AddMethodLists(IReadOnlyList<MethodListWithDeclaringType> methodLists)
 		{
 			if (methodLists == null)
-				throw new ArgumentNullException("methodLists");
+				throw new ArgumentNullException(nameof(methodLists));
 			// Base types come first, so go through the list backwards (derived types first)
 			bool[] isHiddenByDerivedType;
 			if (methodLists.Count > 1)
@@ -305,20 +305,20 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 					Log.WriteLine("  Skipping methods in {0} because they are hidden by an applicable method in a derived type", methodLists[i].DeclaringType);
 					continue;
 				}
-				
+
 				MethodListWithDeclaringType methodList = methodLists[i];
 				bool foundApplicableCandidateInCurrentList = false;
-				
+
 				for (int j = 0; j < methodList.Count; j++) {
 					IParameterizedMember method = methodList[j];
 					Log.Indent();
 					OverloadResolutionErrors errors = AddCandidate(method);
 					Log.Unindent();
 					LogCandidateAddingResult("  Candidate", method, errors);
-					
+
 					foundApplicableCandidateInCurrentList |= IsApplicable(errors);
 				}
-				
+
 				if (foundApplicableCandidateInCurrentList && i > 0) {
 					foreach (IType baseType in methodList.DeclaringType.GetAllBaseTypes()) {
 						for (int j = 0; j < i; j++) {
@@ -329,21 +329,21 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				}
 			}
 		}
-		
+
 		[Conditional("DEBUG")]
 		internal void LogCandidateAddingResult(string text, IParameterizedMember method, OverloadResolutionErrors errors)
 		{
 			#if DEBUG
 			Log.WriteLine(string.Format("{0} {1} = {2}{3}",
-			                            text, method,
+										text, method,
-			                            errors == OverloadResolutionErrors.None ? "Success" : errors.ToString(),
+										errors == OverloadResolutionErrors.None ? "Success" : errors.ToString(),
-			                            this.BestCandidate == method ? " (best candidate so far)" :
+										this.BestCandidate == method ? " (best candidate so far)" :
-			                            this.BestCandidateAmbiguousWith == method ? " (ambiguous)" : ""
+										this.BestCandidateAmbiguousWith == method ? " (ambiguous)" : ""
-			                           ));
+									   ));
 			#endif
 		}
 		#endregion
-		
+
 		#region MapCorrespondingParameters
 		void MapCorrespondingParameters(Candidate candidate)
 		{
@@ -386,7 +386,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 		}
 		#endregion
-		
+
 		#region RunTypeInference
 		void RunTypeInference(Candidate candidate)
 		{
@@ -436,18 +436,18 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			if (!substitution.ConstraintsValid)
 				candidate.AddError(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint);
 		}
-		
+
 		sealed class ConstraintValidatingSubstitution : TypeParameterSubstitution
 		{
 			readonly CSharpConversions conversions;
 			public bool ConstraintsValid = true;
-			
+
 			public ConstraintValidatingSubstitution(IReadOnlyList<IType> classTypeArguments, IReadOnlyList<IType> methodTypeArguments, OverloadResolution overloadResolution)
 				: base(classTypeArguments, methodTypeArguments)
 			{
 				this.conversions = overloadResolution.conversions;
 			}
-			
+
 			public override IType VisitParameterizedType(ParameterizedType type)
 			{
 				IType newType = base.VisitParameterizedType(type);
@@ -470,14 +470,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 		}
 		#endregion
-		
+
 		#region Validate Constraints
 		OverloadResolutionErrors ValidateMethodConstraints(Candidate candidate)
 		{
 			// If type inference already failed, we won't check the constraints:
 			if ((candidate.Errors & OverloadResolutionErrors.TypeInferenceFailed) != 0)
 				return OverloadResolutionErrors.None;
-			
+
 			if (candidate.TypeParameters == null || candidate.TypeParameters.Count == 0)
 				return OverloadResolutionErrors.None; // the method isn't generic
 			var substitution = GetSubstitution(candidate);
@@ -487,7 +487,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 			return OverloadResolutionErrors.None;
 		}
-		
+
 		/// <summary>
 		/// Validates whether the given type argument satisfies the constraints for the given type parameter.
 		/// </summary>
@@ -500,12 +500,12 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public static bool ValidateConstraints(ITypeParameter typeParameter, IType typeArgument, TypeVisitor substitution = null)
 		{
 			if (typeParameter == null)
-				throw new ArgumentNullException("typeParameter");
+				throw new ArgumentNullException(nameof(typeParameter));
 			if (typeArgument == null)
-				throw new ArgumentNullException("typeArgument");
+				throw new ArgumentNullException(nameof(typeArgument));
 			return ValidateConstraints(typeParameter, typeArgument, substitution, CSharpConversions.Get(typeParameter.Owner.Compilation));
 		}
-		
+
 		internal static bool ValidateConstraints(ITypeParameter typeParameter, IType typeArgument, TypeVisitor substitution, CSharpConversions conversions)
 		{
 			switch (typeArgument.Kind) { // void, null, and pointers cannot be used as type arguments
@@ -543,7 +543,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			return true;
 		}
 		#endregion
-		
+
 		#region CheckApplicability
 		/// <summary>
 		/// Returns whether a candidate with the given errors is still considered to be applicable.
@@ -554,11 +554,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				OverloadResolutionErrors.AmbiguousMatch | OverloadResolutionErrors.MethodConstraintsNotSatisfied;
 			return (errors & ~errorsThatDoNotMatterForApplicability) == OverloadResolutionErrors.None;
 		}
-		
+
 		void CheckApplicability(Candidate candidate)
 		{
 			// C# 4.0 spec: §7.5.3.1 Applicable function member
-			
+
 			// Test whether parameters were mapped the correct number of arguments:
 			int[] argumentCountPerParameter = new int[candidate.ParameterTypes.Length];
 			foreach (int parameterIndex in candidate.ArgumentToParameterMap) {
@@ -577,7 +577,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 					candidate.AddError(OverloadResolutionErrors.MultipleArgumentsForSingleParameter);
 				}
 			}
-			
+
 			candidate.ArgumentConversions = new Conversion[arguments.Length];
 			// Test whether argument passing mode matches the parameter passing mode
 			for (int i = 0; i < arguments.Length; i++) {
@@ -586,7 +586,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 					candidate.ArgumentConversions[i] = Conversion.None;
 					continue;
 				}
-				
+
 				ByReferenceResolveResult brrr = arguments[i] as ByReferenceResolveResult;
 				if (brrr != null) {
 					if (brrr.ReferenceKind != candidate.Parameters[parameterIndex].ReferenceKind)
@@ -609,7 +609,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 		}
 		#endregion
-		
+
 		#region BetterFunctionMember
 		/// <summary>
 		/// Returns 1 if c1 is better than c2; 2 if c2 is better than c1; or 0 if neither is better.
@@ -621,7 +621,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return 1;
 			if (c1.ErrorCount > 0 && c2.ErrorCount == 0)
 				return 2;
-			
+
 			// C# 4.0 spec: §7.5.3.2 Better function member
 			bool c1IsBetter = false;
 			bool c2IsBetter = false;
@@ -650,42 +650,42 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return 1;
 			if (!c1IsBetter && c2IsBetter)
 				return 2;
-			
+
 			// prefer members with less errors (part of heuristic that produces a best candidate even if none is applicable)
 			if (c1.ErrorCount < c2.ErrorCount) return 1;
 			if (c1.ErrorCount > c2.ErrorCount) return 2;
-			
+
 			if (!c1IsBetter && !c2IsBetter && parameterTypesEqual) {
 				// we need the tie-breaking rules
-				
+
 				// non-generic methods are better
 				if (!c1.IsGenericMethod && c2.IsGenericMethod)
 					return 1;
 				else if (c1.IsGenericMethod && !c2.IsGenericMethod)
 					return 2;
-				
+
 				// non-expanded members are better
 				if (!c1.IsExpandedForm && c2.IsExpandedForm)
 					return 1;
 				else if (c1.IsExpandedForm && !c2.IsExpandedForm)
 					return 2;
-				
+
 				// prefer the member with less arguments mapped to the params-array
 				int r = c1.ArgumentsPassedToParamsArray.CompareTo(c2.ArgumentsPassedToParamsArray);
 				if (r < 0) return 1;
 				else if (r > 0) return 2;
-				
+
 				// prefer the member where no default values need to be substituted
 				if (!c1.HasUnmappedOptionalParameters && c2.HasUnmappedOptionalParameters)
 					return 1;
 				else if (c1.HasUnmappedOptionalParameters && !c2.HasUnmappedOptionalParameters)
 					return 2;
-				
+
 				// compare the formal parameters
 				r = MoreSpecificFormalParameters(c1, c2);
 				if (r != 0)
 					return r;
-				
+
 				// prefer non-lifted operators
 				ILiftedOperator lift1 = c1.Member as ILiftedOperator;
 				ILiftedOperator lift2 = c2.Member as ILiftedOperator;
@@ -696,22 +696,22 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 			return 0;
 		}
-		
+
 		int MoreSpecificFormalParameters(Candidate c1, Candidate c2)
 		{
 			// prefer the member with more formal parmeters (in case both have different number of optional parameters)
 			int r = c1.Parameters.Count.CompareTo(c2.Parameters.Count);
 			if (r > 0) return 1;
 			else if (r < 0) return 2;
-			
+
 			return MoreSpecificFormalParameters(c1.Parameters.Select(p => p.Type), c2.Parameters.Select(p => p.Type));
 		}
-		
+
 		static int MoreSpecificFormalParameters(IEnumerable<IType> t1, IEnumerable<IType> t2)
 		{
 			bool c1IsBetter = false;
 			bool c2IsBetter = false;
-			foreach (var pair in t1.Zip(t2, (a,b) => new { Item1 = a, Item2 = b })) {
+			foreach (var pair in t1.Zip(t2, (a, b) => new { Item1 = a, Item2 = b })) {
 				switch (MoreSpecificFormalParameter(pair.Item1, pair.Item2)) {
 					case 1:
 						c1IsBetter = true;
@@ -727,14 +727,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return 2;
 			return 0;
 		}
-		
+
 		static int MoreSpecificFormalParameter(IType t1, IType t2)
 		{
 			if ((t1 is ITypeParameter) && !(t2 is ITypeParameter))
 				return 2;
 			if ((t2 is ITypeParameter) && !(t1 is ITypeParameter))
 				return 1;
-			
+
 			ParameterizedType p1 = t1 as ParameterizedType;
 			ParameterizedType p2 = t2 as ParameterizedType;
 			if (p1 != null && p2 != null && p1.TypeParameterCount == p2.TypeParameterCount) {
@@ -750,7 +750,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			return 0;
 		}
 		#endregion
-		
+
 		#region ConsiderIfNewCandidateIsBest
 		void ConsiderIfNewCandidateIsBest(Candidate candidate)
 		{
@@ -775,12 +775,12 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 		}
 		#endregion
-		
+
 		#region Output Properties
 		public IParameterizedMember BestCandidate {
 			get { return bestCandidate != null ? bestCandidate.Member : null; }
 		}
-		
+
 		/// <summary>
 		/// Returns the errors that apply to the best candidate.
 		/// This includes additional errors that do not affect applicability (e.g. AmbiguousMatch, MethodConstraintsNotSatisfied)
@@ -799,23 +799,23 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return err;
 			}
 		}
-		
+
 		public bool FoundApplicableCandidate {
 			get { return bestCandidate != null && IsApplicable(bestCandidate.Errors); }
 		}
-		
+
 		public IParameterizedMember BestCandidateAmbiguousWith {
 			get { return bestCandidateAmbiguousWith != null ? bestCandidateAmbiguousWith.Member : null; }
 		}
-		
+
 		public bool BestCandidateIsExpandedForm {
 			get { return bestCandidate != null ? bestCandidate.IsExpandedForm : false; }
 		}
-		
+
 		public bool IsAmbiguous {
 			get { return bestCandidateAmbiguousWith != null; }
 		}
-		
+
 		public IReadOnlyList<IType> InferredTypeArguments {
 			get {
 				if (bestCandidate != null && bestCandidate.InferredTypes != null)
@@ -824,7 +824,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 					return EmptyList<IType>.Instance;
 			}
 		}
-		
+
 		/// <summary>
 		/// Gets the implicit conversions that are being applied to the arguments.
 		/// </summary>
@@ -836,7 +836,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 					return Enumerable.Repeat(Conversion.None, arguments.Length).ToList();
 			}
 		}
-		
+
 		/// <summary>
 		/// Gets an array that maps argument indices to parameter indices.
 		/// For arguments that could not be mapped to any parameter, the value will be -1.
@@ -850,7 +850,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			else
 				return null;
 		}
-		
+
 		/// <summary>
 		/// Returns the arguments for the method call in the order they were provided (not in the order of the parameters).
 		/// Arguments are wrapped in a <see cref="ConversionResolveResult"/> if an implicit conversion is being applied
@@ -863,7 +863,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			else
 				return GetArgumentsWithConversions(null, null);
 		}
-		
+
 		/// <summary>
 		/// Returns the arguments for the method call in the order they were provided (not in the order of the parameters).
 		/// Arguments are wrapped in a <see cref="ConversionResolveResult"/> if an implicit conversion is being applied
@@ -878,7 +878,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			else
 				return GetArgumentsWithConversions(null, GetBestCandidateWithSubstitutedTypeArguments());
 		}
-		
+
 		IList<ResolveResult> GetArgumentsWithConversions(ResolveResult targetResolveResult, IParameterizedMember bestCandidateForNamedArguments)
 		{
 			var conversions = this.ArgumentConversions;
@@ -911,7 +911,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 			return args;
 		}
-		
+
 		public IParameterizedMember GetBestCandidateWithSubstitutedTypeArguments()
 		{
 			if (bestCandidate == null)
@@ -923,14 +923,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				return bestCandidate.Member;
 			}
 		}
-		
+
 		TypeParameterSubstitution GetSubstitution(Candidate candidate)
 		{
 			// Do not compose the substitutions, but merge them.
 			// This is required for InvocationTests.SubstituteClassAndMethodTypeParametersAtOnce
 			return new TypeParameterSubstitution(candidate.Member.Substitution.ClassTypeArguments, candidate.InferredTypes);
 		}
-		
+
 		/// <summary>
 		/// Creates a ResolveResult representing the result of overload resolution.
 		/// </summary>

ICSharpCode.Decompiler/CSharp/Resolver/TypeInference.cs

@@ -61,7 +61,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public TypeInference(ICompilation compilation)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			this.compilation = compilation;
 			this.conversions = CSharpConversions.Get(compilation);
 		}
@@ -115,11 +115,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public IType[] InferTypeArguments(IReadOnlyList<ITypeParameter> typeParameters, IReadOnlyList<ResolveResult> arguments, IReadOnlyList<IType> parameterTypes, out bool success, IReadOnlyList<IType> classTypeArguments = null)
 		{
 			if (typeParameters == null)
-				throw new ArgumentNullException("typeParameters");
+				throw new ArgumentNullException(nameof(typeParameters));
 			if (arguments == null)
-				throw new ArgumentNullException("arguments");
+				throw new ArgumentNullException(nameof(arguments));
 			if (parameterTypes == null)
-				throw new ArgumentNullException("parameterTypes");
+				throw new ArgumentNullException(nameof(parameterTypes));
 			try {
 				this.typeParameters = new TP[typeParameters.Count];
 				for (int i = 0; i < this.typeParameters.Length; i++) {
@@ -173,13 +173,13 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public IType[] InferTypeArgumentsFromBounds(IReadOnlyList<ITypeParameter> typeParameters, IType targetType, IEnumerable<IType> lowerBounds, IEnumerable<IType> upperBounds, out bool success)
 		{
 			if (typeParameters == null)
-				throw new ArgumentNullException("typeParameters");
+				throw new ArgumentNullException(nameof(typeParameters));
 			if (targetType == null)
-				throw new ArgumentNullException("targetType");
+				throw new ArgumentNullException(nameof(targetType));
 			if (lowerBounds == null)
-				throw new ArgumentNullException("lowerBounds");
+				throw new ArgumentNullException(nameof(lowerBounds));
 			if (upperBounds == null)
-				throw new ArgumentNullException("upperBounds");
+				throw new ArgumentNullException(nameof(upperBounds));
 			this.typeParameters = new TP[typeParameters.Count];
 			for (int i = 0; i < this.typeParameters.Length; i++) {
 				if (i != typeParameters[i].Index)
@@ -223,7 +223,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			public TP(ITypeParameter typeParameter)
 			{
 				if (typeParameter == null)
-					throw new ArgumentNullException("typeParameter");
+					throw new ArgumentNullException(nameof(typeParameter));
 				this.TypeParameter = typeParameter;
 			}
 			
@@ -834,7 +834,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public IType GetBestCommonType(IList<ResolveResult> expressions, out bool success)
 		{
 			if (expressions == null)
-				throw new ArgumentNullException("expressions");
+				throw new ArgumentNullException(nameof(expressions));
 			if (expressions.Count == 1) {
 				success = IsValidType(expressions[0].Type);
 				return expressions[0].Type;
@@ -861,9 +861,9 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		public IType FindTypeInBounds(IReadOnlyList<IType> lowerBounds, IReadOnlyList<IType> upperBounds)
 		{
 			if (lowerBounds == null)
-				throw new ArgumentNullException("lowerBounds");
+				throw new ArgumentNullException(nameof(lowerBounds));
 			if (upperBounds == null)
-				throw new ArgumentNullException("upperBounds");
+				throw new ArgumentNullException(nameof(upperBounds));
 			
 			var result = FindTypesInBounds(lowerBounds, upperBounds);
 			

ICSharpCode.Decompiler/CSharp/Syntax/AstNodeCollection.cs

@@ -37,9 +37,9 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public AstNodeCollection(AstNode node, Role<T> role)
 		{
 			if (node == null)
-				throw new ArgumentNullException("node");
+				throw new ArgumentNullException(nameof(node));
 			if (role == null)
-				throw new ArgumentNullException("role");
+				throw new ArgumentNullException(nameof(role));
 			this.node = node;
 			this.role = role;
 		}
@@ -96,7 +96,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public void MoveTo(ICollection<T> targetCollection)
 		{
 			if (targetCollection == null)
-				throw new ArgumentNullException("targetCollection");
+				throw new ArgumentNullException(nameof(targetCollection));
 			foreach (T node in this) {
 				node.Remove();
 				targetCollection.Add(node);

ICSharpCode.Decompiler/CSharp/Syntax/Expressions/Expression.cs

@@ -123,7 +123,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public Expression ReplaceWith(Func<Expression, Expression> replaceFunction)
 		{
 			if (replaceFunction == null)
-				throw new ArgumentNullException("replaceFunction");
+				throw new ArgumentNullException(nameof(replaceFunction));
 			return (Expression)base.ReplaceWith(node => replaceFunction((Expression)node));
 		}
 	}

ICSharpCode.Decompiler/CSharp/Syntax/GeneralScope/NamespaceDeclaration.cs

@@ -64,7 +64,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		static AstType ConstructType(string[] arr, int i)
 		{
 			if (i < 0 || i >= arr.Length)
-				throw new ArgumentOutOfRangeException("i");
+				throw new ArgumentOutOfRangeException(nameof(i));
 			if (i == 0)
 				return new SimpleType(arr[i]);
 			return new MemberType(ConstructType(arr, i - 1), arr[i]);

ICSharpCode.Decompiler/CSharp/Syntax/IAnnotatable.cs

@@ -34,7 +34,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		IEnumerable<object> Annotations {
 			get;
 		}
-		
+
 		/// <summary>
 		/// Gets the first annotation of the specified type.
 		/// Returns null if no matching annotation exists.
@@ -42,8 +42,8 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		/// <typeparam name='T'>
 		/// The type of the annotation.
 		/// </typeparam>
-		T Annotation<T> () where T: class;
+		T Annotation<T>() where T : class;
-		
+
 		/// <summary>
 		/// Gets the first annotation of the specified type.
 		/// Returns null if no matching annotation exists.
@@ -51,24 +51,24 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		/// <param name='type'>
 		/// The type of the annotation.
 		/// </param>
-		object Annotation (Type type);
+		object Annotation(Type type);
-		
+
 		/// <summary>
 		/// Adds an annotation to this instance.
 		/// </summary>
 		/// <param name='annotation'>
 		/// The annotation to add.
 		/// </param>
-		void AddAnnotation (object annotation);
+		void AddAnnotation(object annotation);
-		
+
 		/// <summary>
 		/// Removes all annotations of the specified type.
 		/// </summary>
 		/// <typeparam name='T'>
 		/// The type of the annotations to remove.
 		/// </typeparam>
-		void RemoveAnnotations<T> () where T : class;
+		void RemoveAnnotations<T>() where T : class;
-		
+
 		/// <summary>
 		/// Removes all annotations of the specified type.
 		/// </summary>
@@ -77,7 +77,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		/// </param>
 		void RemoveAnnotations(Type type);
 	}
-	
+
 	/// <summary>
 	/// Base class used to implement the IAnnotatable interface.
 	/// This implementation is thread-safe.
@@ -88,9 +88,9 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		// Annotations: points either null (no annotations), to the single annotation,
 		// or to an AnnotationList.
 		// Once it is pointed at an AnnotationList, it will never change (this allows thread-safety support by locking the list)
-		
+
 		object annotations;
-		
+
 		/// <summary>
 		/// Clones all annotations.
 		/// This method is intended to be called by Clone() implementations in derived classes.
@@ -111,86 +111,86 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 			// There are two uses for this custom list type:
 			// 1) it's private, and thus (unlike List<object>) cannot be confused with real annotations
 			// 2) It allows us to simplify the cloning logic by making the list behave the same as a clonable annotation.
-			public AnnotationList (int initialCapacity) : base(initialCapacity)
+			public AnnotationList(int initialCapacity) : base(initialCapacity)
 			{
 			}
-			
+
-			public object Clone ()
+			public object Clone()
 			{
 				lock (this) {
-					AnnotationList copy = new AnnotationList (this.Count);
+					AnnotationList copy = new AnnotationList(this.Count);
 					for (int i = 0; i < this.Count; i++) {
-						object obj = this [i];
+						object obj = this[i];
 						ICloneable c = obj as ICloneable;
-						copy.Add (c != null ? c.Clone () : obj);
+						copy.Add(c != null ? c.Clone() : obj);
 					}
 					return copy;
 				}
 			}
 		}
-		
+
-		public virtual void AddAnnotation (object annotation)
+		public virtual void AddAnnotation(object annotation)
 		{
 			if (annotation == null)
-				throw new ArgumentNullException ("annotation");
+				throw new ArgumentNullException(nameof(annotation));
 		retry: // Retry until successful
-			object oldAnnotation = Interlocked.CompareExchange (ref this.annotations, annotation, null);
+			object oldAnnotation = Interlocked.CompareExchange(ref this.annotations, annotation, null);
 			if (oldAnnotation == null) {
 				return; // we successfully added a single annotation
 			}
 			AnnotationList list = oldAnnotation as AnnotationList;
 			if (list == null) {
 				// we need to transform the old annotation into a list
-				list = new AnnotationList (4);
+				list = new AnnotationList(4);
-				list.Add (oldAnnotation);
+				list.Add(oldAnnotation);
-				list.Add (annotation);
+				list.Add(annotation);
-				if (Interlocked.CompareExchange (ref this.annotations, list, oldAnnotation) != oldAnnotation) {
+				if (Interlocked.CompareExchange(ref this.annotations, list, oldAnnotation) != oldAnnotation) {
 					// the transformation failed (some other thread wrote to this.annotations first)
 					goto retry;
 				}
 			} else {
 				// once there's a list, use simple locking
 				lock (list) {
-					list.Add (annotation);
+					list.Add(annotation);
 				}
 			}
 		}
-		
+
-		public virtual void RemoveAnnotations<T> () where T : class
+		public virtual void RemoveAnnotations<T>() where T : class
 		{
-		retry: // Retry until successful
+			retry: // Retry until successful
 			object oldAnnotations = this.annotations;
 			AnnotationList list = oldAnnotations as AnnotationList;
 			if (list != null) {
 				lock (list)
-					list.RemoveAll (obj => obj is T);
+					list.RemoveAll(obj => obj is T);
 			} else if (oldAnnotations is T) {
-				if (Interlocked.CompareExchange (ref this.annotations, null, oldAnnotations) != oldAnnotations) {
+				if (Interlocked.CompareExchange(ref this.annotations, null, oldAnnotations) != oldAnnotations) {
 					// Operation failed (some other thread wrote to this.annotations first)
 					goto retry;
 				}
 			}
 		}
-		
+
-		public virtual void RemoveAnnotations (Type type)
+		public virtual void RemoveAnnotations(Type type)
 		{
 			if (type == null)
-				throw new ArgumentNullException ("type");
+				throw new ArgumentNullException(nameof(type));
-		retry: // Retry until successful
+			retry: // Retry until successful
 			object oldAnnotations = this.annotations;
 			AnnotationList list = oldAnnotations as AnnotationList;
 			if (list != null) {
 				lock (list)
 					list.RemoveAll(type.IsInstanceOfType);
-			} else if (type.IsInstanceOfType (oldAnnotations)) {
+			} else if (type.IsInstanceOfType(oldAnnotations)) {
-				if (Interlocked.CompareExchange (ref this.annotations, null, oldAnnotations) != oldAnnotations) {
+				if (Interlocked.CompareExchange(ref this.annotations, null, oldAnnotations) != oldAnnotations) {
 					// Operation failed (some other thread wrote to this.annotations first)
 					goto retry;
 				}
 			}
 		}
-		
+
-		public T Annotation<T> () where T: class
+		public T Annotation<T>() where T : class
 		{
 			object annotations = this.annotations;
 			AnnotationList list = annotations as AnnotationList;
@@ -207,27 +207,27 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 				return annotations as T;
 			}
 		}
-		
+
-		public object Annotation (Type type)
+		public object Annotation(Type type)
 		{
 			if (type == null)
-				throw new ArgumentNullException ("type");
+				throw new ArgumentNullException(nameof(type));
 			object annotations = this.annotations;
 			AnnotationList list = annotations as AnnotationList;
 			if (list != null) {
 				lock (list) {
 					foreach (object obj in list) {
-						if (type.IsInstanceOfType (obj))
+						if (type.IsInstanceOfType(obj))
 							return obj;
 					}
 				}
 			} else {
-				if (type.IsInstanceOfType (annotations))
+				if (type.IsInstanceOfType(annotations))
 					return annotations;
 			}
 			return null;
 		}
-		
+
 		/// <summary>
 		/// Gets all annotations stored on this AstNode.
 		/// </summary>
@@ -237,13 +237,13 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 				AnnotationList list = annotations as AnnotationList;
 				if (list != null) {
 					lock (list) {
-						return list.ToArray ();
+						return list.ToArray();
 					}
 				} else {
 					if (annotations != null)
 						return new object[] { annotations };
 					else
-						return Enumerable.Empty<object> ();
+						return Enumerable.Empty<object>();
 				}
 			}
 		}

ICSharpCode.Decompiler/CSharp/Syntax/Identifier.cs

@@ -71,7 +71,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 			get { return this.name; }
 			set {
 				if (value == null)
-					throw new ArgumentNullException("value");
+					throw new ArgumentNullException(nameof(value));
 				ThrowIfFrozen();
 				this.name = value;
 			}
@@ -119,7 +119,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		protected Identifier (string name, TextLocation location)
 		{
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			this.Name = name;
 			this.startLocation = location;
 		}

ICSharpCode.Decompiler/CSharp/Syntax/IdentifierExpressionBackreference.cs

@@ -35,7 +35,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public IdentifierExpressionBackreference(string referencedGroupName)
 		{
 			if (referencedGroupName == null)
-				throw new ArgumentNullException("referencedGroupName");
+				throw new ArgumentNullException(nameof(referencedGroupName));
 			this.referencedGroupName = referencedGroupName;
 		}
 		

ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/Backreference.cs

@@ -35,7 +35,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching
 		public Backreference(string referencedGroupName)
 		{
 			if (referencedGroupName == null)
-				throw new ArgumentNullException("referencedGroupName");
+				throw new ArgumentNullException(nameof(referencedGroupName));
 			this.referencedGroupName = referencedGroupName;
 		}
 		

ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/Choice.cs

@@ -32,14 +32,14 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching
 		public void Add(string name, INode alternative)
 		{
 			if (alternative == null)
-				throw new ArgumentNullException("alternative");
+				throw new ArgumentNullException(nameof(alternative));
 			alternatives.Add(new NamedNode(name, alternative));
 		}
 		
 		public void Add(INode alternative)
 		{
 			if (alternative == null)
-				throw new ArgumentNullException("alternative");
+				throw new ArgumentNullException(nameof(alternative));
 			alternatives.Add(alternative);
 		}
 		

ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/INode.cs

@@ -51,7 +51,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching
 		public static Match Match(this INode pattern, INode other)
 		{
 			if (pattern == null)
-				throw new ArgumentNullException("pattern");
+				throw new ArgumentNullException(nameof(pattern));
 			Match match = PatternMatching.Match.CreateNew();
 			if (pattern.DoMatch(other, match))
 				return match;
@@ -62,7 +62,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching
 		public static bool IsMatch(this INode pattern, INode other)
 		{
 			if (pattern == null)
-				throw new ArgumentNullException("pattern");
+				throw new ArgumentNullException(nameof(pattern));
 			return pattern.DoMatch(other, PatternMatching.Match.CreateNew());
 		}
 

ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/NamedNode.cs

@@ -39,7 +39,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching
 		public NamedNode(string groupName, INode childNode)
 		{
 			if (childNode == null)
-				throw new ArgumentNullException("childNode");
+				throw new ArgumentNullException(nameof(childNode));
 			this.groupName = groupName;
 			this.childNode = childNode;
 		}

ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/OptionalNode.cs

@@ -31,7 +31,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching
 		public OptionalNode(INode childNode)
 		{
 			if (childNode == null)
-				throw new ArgumentNullException("childNode");
+				throw new ArgumentNullException(nameof(childNode));
 			this.childNode = childNode;
 		}
 		

ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/Repeat.cs

@@ -38,7 +38,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching
 		public Repeat(INode childNode)
 		{
 			if (childNode == null)
-				throw new ArgumentNullException("childNode");
+				throw new ArgumentNullException(nameof(childNode));
 			this.childNode = childNode;
 			this.MinCount = 0;
 			this.MaxCount = int.MaxValue;

ICSharpCode.Decompiler/CSharp/Syntax/Role.cs

@@ -89,16 +89,16 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public Role(string name)
 		{
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			this.name = name;
 		}
 		
 		public Role(string name, T nullObject)
 		{
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			if (nullObject == null)
-				throw new ArgumentNullException ("nullObject");
+				throw new ArgumentNullException (nameof(nullObject));
 			this.nullObject = nullObject;
 			this.name = name;
 		}

ICSharpCode.Decompiler/CSharp/Syntax/Statements/Statement.cs

@@ -116,7 +116,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public Statement ReplaceWith(Func<Statement, Statement> replaceFunction)
 		{
 			if (replaceFunction == null)
-				throw new ArgumentNullException("replaceFunction");
+				throw new ArgumentNullException(nameof(replaceFunction));
 			return (Statement)base.ReplaceWith(node => replaceFunction((Statement)node));
 		}
 		

ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs

@@ -47,7 +47,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public TypeSystemAstBuilder(CSharpResolver resolver)
 		{
 			if (resolver == null)
-				throw new ArgumentNullException("resolver");
+				throw new ArgumentNullException(nameof(resolver));
 			this.resolver = resolver;
 			InitProperties();
 		}
@@ -204,7 +204,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public AstType ConvertType(IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			AstType astType = ConvertTypeHelper(type);
 			AddTypeAnnotation(astType, type);
 			return astType;
@@ -579,7 +579,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public AstType ConvertAttributeType(IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			AstType astType = ConvertTypeHelper(type);
 
 			string shortName = null;
@@ -663,7 +663,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public Expression ConvertConstantValue(ResolveResult rr)
 		{
 			if (rr == null)
-				throw new ArgumentNullException("rr");
+				throw new ArgumentNullException(nameof(rr));
 			bool isBoxing = false;
 			if (rr is ConversionResolveResult crr) {
 				// unpack ConversionResolveResult if necessary
@@ -734,7 +734,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public Expression ConvertConstantValue(IType expectedType, IType type, object constantValue)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			if (constantValue == null) {
 				if (type.IsReferenceType == true || type.IsKnownType(KnownTypeCode.NullableOfT)) {
 					var expr = new NullReferenceExpression();
@@ -1248,7 +1248,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public ParameterDeclaration ConvertParameter(IParameter parameter)
 		{
 			if (parameter == null)
-				throw new ArgumentNullException("parameter");
+				throw new ArgumentNullException(nameof(parameter));
 			ParameterDeclaration decl = new ParameterDeclaration();
 			if (parameter.IsRef) {
 				decl.ParameterModifier = ParameterModifier.Ref;
@@ -1286,7 +1286,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public AstNode ConvertSymbol(ISymbol symbol)
 		{
 			if (symbol == null)
-				throw new ArgumentNullException("symbol");
+				throw new ArgumentNullException(nameof(symbol));
 			switch (symbol.SymbolKind) {
 				case SymbolKind.Namespace:
 					return ConvertNamespaceDeclaration((INamespace)symbol);
@@ -1307,7 +1307,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public EntityDeclaration ConvertEntity(IEntity entity)
 		{
 			if (entity == null)
-				throw new ArgumentNullException("entity");
+				throw new ArgumentNullException(nameof(entity));
 			switch (entity.SymbolKind) {
 				case SymbolKind.TypeDefinition:
 					return ConvertTypeDefinition((ITypeDefinition)entity);

ICSharpCode.Decompiler/CSharp/TypeSystem/AliasNamespaceReference.cs

@@ -38,7 +38,7 @@ namespace ICSharpCode.Decompiler.CSharp.TypeSystem
 		public AliasNamespaceReference(string identifier)
 		{
 			if (identifier == null)
-				throw new ArgumentNullException("identifier");
+				throw new ArgumentNullException(nameof(identifier));
 			this.identifier = identifier;
 		}
 		

ICSharpCode.Decompiler/CSharp/TypeSystem/MemberTypeOrNamespaceReference.cs

@@ -40,9 +40,9 @@ namespace ICSharpCode.Decompiler.CSharp.TypeSystem
 		public MemberTypeOrNamespaceReference(TypeOrNamespaceReference target, string identifier, IList<ITypeReference> typeArguments, NameLookupMode lookupMode = NameLookupMode.Type)
 		{
 			if (target == null)
-				throw new ArgumentNullException("target");
+				throw new ArgumentNullException(nameof(target));
 			if (identifier == null)
-				throw new ArgumentNullException("identifier");
+				throw new ArgumentNullException(nameof(identifier));
 			this.target = target;
 			this.identifier = identifier;
 			this.typeArguments = typeArguments ?? EmptyList<ITypeReference>.Instance;

ICSharpCode.Decompiler/CSharp/TypeSystem/ResolvedUsingScope.cs

@@ -44,9 +44,9 @@ namespace ICSharpCode.Decompiler.CSharp.TypeSystem
 		public ResolvedUsingScope(CSharpTypeResolveContext context, UsingScope usingScope)
 		{
 			if (context == null)
-				throw new ArgumentNullException("context");
+				throw new ArgumentNullException(nameof(context));
 			if (usingScope == null)
-				throw new ArgumentNullException("usingScope");
+				throw new ArgumentNullException(nameof(usingScope));
 			this.parentContext = context;
 			this.usingScope = usingScope;
 			if (usingScope.Parent != null) {

ICSharpCode.Decompiler/CSharp/TypeSystem/SimpleTypeOrNamespaceReference.cs

@@ -39,7 +39,7 @@ namespace ICSharpCode.Decompiler.CSharp.TypeSystem
 		public SimpleTypeOrNamespaceReference(string identifier, IList<ITypeReference> typeArguments, NameLookupMode lookupMode = NameLookupMode.Type)
 		{
 			if (identifier == null)
-				throw new ArgumentNullException("identifier");
+				throw new ArgumentNullException(nameof(identifier));
 			this.identifier = identifier;
 			this.typeArguments = typeArguments ?? EmptyList<ITypeReference>.Instance;
 			this.lookupMode = lookupMode;

ICSharpCode.Decompiler/CSharp/TypeSystem/UsingScope.cs

@@ -67,9 +67,9 @@ namespace ICSharpCode.Decompiler.CSharp.TypeSystem
 		public UsingScope(UsingScope parent, string shortName)
 		{
 			if (parent == null)
-				throw new ArgumentNullException("parent");
+				throw new ArgumentNullException(nameof(parent));
 			if (shortName == null)
-				throw new ArgumentNullException("shortName");
+				throw new ArgumentNullException(nameof(shortName));
 			this.parent = parent;
 			this.shortName = shortName;
 		}

ICSharpCode.Decompiler/DebugInfo/DebugInfoGenerator.cs

@@ -60,7 +60,7 @@ namespace ICSharpCode.Decompiler.DebugInfo
 
 		public DebugInfoGenerator(IDecompilerTypeSystem typeSystem)
 		{
-			this.typeSystem = typeSystem ?? throw new ArgumentNullException("typeSystem");
+			this.typeSystem = typeSystem ?? throw new ArgumentNullException(nameof(typeSystem));
 			this.currentImportScope = globalImportScope;
 		}
 

ICSharpCode.Decompiler/DecompilerException.cs

@@ -77,7 +77,7 @@ namespace ICSharpCode.Decompiler
 		string ToString(Exception exception)
 		{
 			if (exception == null)
-				throw new ArgumentNullException("exception");
+				throw new ArgumentNullException(nameof(exception));
 			string exceptionType = GetTypeName(exception);
 			string stacktrace = GetStackTrace(exception);
 			while (exception.InnerException != null) {

ICSharpCode.Decompiler/Documentation/IdStringProvider.cs

@@ -94,7 +94,7 @@ namespace ICSharpCode.Decompiler.Documentation
 		public static string GetTypeName(IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			StringBuilder b = new StringBuilder();
 			AppendTypeName(b, type, false);
 			return b.ToString();
@@ -194,7 +194,7 @@ namespace ICSharpCode.Decompiler.Documentation
 		public static IMemberReference ParseMemberIdString(string memberIdString)
 		{
 			if (memberIdString == null)
-				throw new ArgumentNullException("memberIdString");
+				throw new ArgumentNullException(nameof(memberIdString));
 			if (memberIdString.Length < 2 || memberIdString[1] != ':')
 				throw new ReflectionNameParseException(0, "Missing type tag");
 			char typeChar = memberIdString[0];
@@ -242,7 +242,7 @@ namespace ICSharpCode.Decompiler.Documentation
 		public static ITypeReference ParseTypeName(string typeName)
 		{
 			if (typeName == null)
-				throw new ArgumentNullException("typeName");
+				throw new ArgumentNullException(nameof(typeName));
 			int pos = 0;
 			if (typeName.StartsWith("T:", StringComparison.Ordinal))
 				pos = 2;
@@ -378,9 +378,9 @@ namespace ICSharpCode.Decompiler.Documentation
 		public static IEntity FindEntity(string idString, ITypeResolveContext context)
 		{
 			if (idString == null)
-				throw new ArgumentNullException("idString");
+				throw new ArgumentNullException(nameof(idString));
 			if (context == null)
-				throw new ArgumentNullException("context");
+				throw new ArgumentNullException(nameof(context));
 			if (idString.StartsWith("T:", StringComparison.Ordinal)) {
 				return ParseTypeName(idString.Substring(2)).Resolve(context).GetDefinition();
 			} else {

ICSharpCode.Decompiler/Documentation/XmlDocumentationElement.cs

@@ -55,7 +55,7 @@ namespace ICSharpCode.Decompiler.Documentation
 		public XmlDocumentationElement(XElement element, IEntity declaringEntity, Func<string, IEntity> crefResolver)
 		{
 			if (element == null)
-				throw new ArgumentNullException("element");
+				throw new ArgumentNullException(nameof(element));
 			this.element = element;
 			this.declaringEntity = declaringEntity;
 			this.crefResolver = crefResolver;
@@ -67,7 +67,7 @@ namespace ICSharpCode.Decompiler.Documentation
 		public XmlDocumentationElement(string text, IEntity declaringEntity)
 		{
 			if (text == null)
-				throw new ArgumentNullException("text");
+				throw new ArgumentNullException(nameof(text));
 			this.declaringEntity = declaringEntity;
 			this.textContent = text;
 		}

ICSharpCode.Decompiler/Documentation/XmlDocumentationProvider.cs

@@ -62,7 +62,7 @@ namespace ICSharpCode.Decompiler.Documentation
 			public XmlDocumentationCache(int size = 50)
 			{
 				if (size <= 0)
-					throw new ArgumentOutOfRangeException("size", size, "Value must be positive");
+					throw new ArgumentOutOfRangeException(nameof(size), size, "Value must be positive");
 				this.entries = new KeyValuePair<string, string>[size];
 			}
 			
@@ -129,7 +129,7 @@ namespace ICSharpCode.Decompiler.Documentation
 		public XmlDocumentationProvider(string fileName)
 		{
 			if (fileName == null)
-				throw new ArgumentNullException("fileName");
+				throw new ArgumentNullException(nameof(fileName));
 			
 			using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete)) {
 				using (XmlTextReader xmlReader = new XmlTextReader(fs)) {
@@ -328,7 +328,7 @@ namespace ICSharpCode.Decompiler.Documentation
 		public string GetDocumentation(string key)
 		{
 			if (key == null)
-				throw new ArgumentNullException("key");
+				throw new ArgumentNullException(nameof(key));
 			return GetDocumentation(key, true);
 		}
 

ICSharpCode.Decompiler/IL/Instructions/CallIndirect.cs

@@ -68,7 +68,7 @@ namespace ICSharpCode.Decompiler.IL
 			this.IsInstance = isInstance;
 			this.HasExplicitThis = hasExplicitThis;
 			this.CallingConvention = callingConvention;
-			this.ReturnType = returnType ?? throw new ArgumentNullException("returnType");
+			this.ReturnType = returnType ?? throw new ArgumentNullException(nameof(returnType));
 			this.ParameterTypes = parameterTypes.ToImmutableArray();
 			this.Arguments = new InstructionCollection<ILInstruction>(this, 0);
 			this.Arguments.AddRange(arguments);

ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs

@@ -313,7 +313,7 @@ namespace ICSharpCode.Decompiler.IL
 			: base(OpCode.DynamicCompoundAssign, CompoundEvalModeFromOperation(op), target, targetKind, value)
 		{
 			if (!IsExpressionTypeSupported(op))
-				throw new ArgumentOutOfRangeException("op");
+				throw new ArgumentOutOfRangeException(nameof(op));
 			this.BinderFlags = binderFlags;
 			this.Operation = op;
 			this.TargetArgumentInfo = targetArgumentInfo;

ICSharpCode.Decompiler/IL/Transforms/NullPropagationTransform.cs

@@ -262,7 +262,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 						return NullableLiftingTransform.MatchGetValueOrDefault(inst, out ILInstruction arg)
 							&& arg.MatchLdLoc(testedVar);
 					default:
-						throw new ArgumentOutOfRangeException("mode");
+						throw new ArgumentOutOfRangeException(nameof(mode));
 				}
 			}
 
@@ -306,7 +306,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 					).WithILRange(varLoad);
 					break;
 				default:
-					throw new ArgumentOutOfRangeException("mode");
+					throw new ArgumentOutOfRangeException(nameof(mode));
 			}
 			oldParentChildren[oldChildIndex] = replacement;
 		}

ICSharpCode.Decompiler/Metadata/AssemblyReferences.cs

@@ -116,7 +116,7 @@ namespace ICSharpCode.Decompiler.Metadata
 		public static AssemblyNameReference Parse(string fullName)
 		{
 			if (fullName == null)
-				throw new ArgumentNullException("fullName");
+				throw new ArgumentNullException(nameof(fullName));
 			if (fullName.Length == 0)
 				throw new ArgumentException("Name can not be empty");
 

ICSharpCode.Decompiler/Semantics/ArrayAccessResolveResult.cs

@@ -34,9 +34,9 @@ namespace ICSharpCode.Decompiler.Semantics
 		public ArrayAccessResolveResult(IType elementType, ResolveResult array, IList<ResolveResult> indexes) : base(elementType)
 		{
 			if (array == null)
-				throw new ArgumentNullException("array");
+				throw new ArgumentNullException(nameof(array));
 			if (indexes == null)
-				throw new ArgumentNullException("indexes");
+				throw new ArgumentNullException(nameof(indexes));
 			this.Array = array;
 			this.Indexes = indexes;
 		}

ICSharpCode.Decompiler/Semantics/ArrayCreateResolveResult.cs

@@ -43,7 +43,7 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(arrayType)
 		{
 			if (sizeArguments == null)
-				throw new ArgumentNullException("sizeArguments");
+				throw new ArgumentNullException(nameof(sizeArguments));
 			this.SizeArguments = sizeArguments;
 			this.InitializerElements = initializerElements;
 		}

ICSharpCode.Decompiler/Semantics/Conversion.cs

@@ -89,21 +89,21 @@ namespace ICSharpCode.Decompiler.Semantics
 		public static Conversion UserDefinedConversion(IMethod operatorMethod, bool isImplicit, Conversion conversionBeforeUserDefinedOperator, Conversion conversionAfterUserDefinedOperator, bool isLifted = false, bool isAmbiguous = false)
 		{
 			if (operatorMethod == null)
-				throw new ArgumentNullException("operatorMethod");
+				throw new ArgumentNullException(nameof(operatorMethod));
 			return new UserDefinedConv(isImplicit, operatorMethod, conversionBeforeUserDefinedOperator, conversionAfterUserDefinedOperator, isLifted, isAmbiguous);
 		}
 		
 		public static Conversion MethodGroupConversion(IMethod chosenMethod, bool isVirtualMethodLookup, bool delegateCapturesFirstArgument)
 		{
 			if (chosenMethod == null)
-				throw new ArgumentNullException("chosenMethod");
+				throw new ArgumentNullException(nameof(chosenMethod));
 			return new MethodGroupConv(chosenMethod, isVirtualMethodLookup, delegateCapturesFirstArgument, isValid: true);
 		}
 		
 		public static Conversion InvalidMethodGroupConversion(IMethod chosenMethod, bool isVirtualMethodLookup, bool delegateCapturesFirstArgument)
 		{
 			if (chosenMethod == null)
-				throw new ArgumentNullException("chosenMethod");
+				throw new ArgumentNullException(nameof(chosenMethod));
 			return new MethodGroupConv(chosenMethod, isVirtualMethodLookup, delegateCapturesFirstArgument, isValid: false);
 		}
 

ICSharpCode.Decompiler/Semantics/ConversionResolveResult.cs

@@ -42,9 +42,9 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(targetType)
 		{
 			if (input == null)
-				throw new ArgumentNullException("input");
+				throw new ArgumentNullException(nameof(input));
 			if (conversion == null)
-				throw new ArgumentNullException("conversion");
+				throw new ArgumentNullException(nameof(conversion));
 			this.Input = input;
 			this.Conversion = conversion;
 		}

ICSharpCode.Decompiler/Semantics/ForEachResolveResult.cs

@@ -64,13 +64,13 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(voidType)
 		{
 			if (getEnumeratorCall == null)
-				throw new ArgumentNullException("getEnumeratorCall");
+				throw new ArgumentNullException(nameof(getEnumeratorCall));
 			if (collectionType == null)
-				throw new ArgumentNullException("collectionType");
+				throw new ArgumentNullException(nameof(collectionType));
 			if (enumeratorType == null)
-				throw new ArgumentNullException("enumeratorType");
+				throw new ArgumentNullException(nameof(enumeratorType));
 			if (elementType == null)
-				throw new ArgumentNullException("elementType");
+				throw new ArgumentNullException(nameof(elementType));
 			this.GetEnumeratorCall = getEnumeratorCall;
 			this.CollectionType = collectionType;
 			this.EnumeratorType = enumeratorType;

ICSharpCode.Decompiler/Semantics/LocalResolveResult.cs

@@ -38,7 +38,7 @@ namespace ICSharpCode.Decompiler.Semantics
 		static IType UnpackTypeIfByRefParameter(IVariable variable)
 		{
 			if (variable == null)
-				throw new ArgumentNullException("variable");
+				throw new ArgumentNullException(nameof(variable));
 			IType type = variable.Type;
 			if (type.Kind == TypeKind.ByReference) {
 				IParameter p = variable as IParameter;

ICSharpCode.Decompiler/Semantics/NamedArgumentResolveResult.cs

@@ -53,9 +53,9 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(argument.Type)
 		{
 			if (parameter == null)
-				throw new ArgumentNullException("parameter");
+				throw new ArgumentNullException(nameof(parameter));
 			if (argument == null)
-				throw new ArgumentNullException("argument");
+				throw new ArgumentNullException(nameof(argument));
 			this.Member = member;
 			this.Parameter = parameter;
 			this.ParameterName = parameter.Name;
@@ -66,9 +66,9 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(argument.Type)
 		{
 			if (parameterName == null)
-				throw new ArgumentNullException("parameterName");
+				throw new ArgumentNullException(nameof(parameterName));
 			if (argument == null)
-				throw new ArgumentNullException("argument");
+				throw new ArgumentNullException(nameof(argument));
 			this.ParameterName = parameterName;
 			this.Argument = argument;
 		}

ICSharpCode.Decompiler/Semantics/OperatorResolveResult.cs

@@ -37,7 +37,7 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(resultType)
 		{
 			if (operands == null)
-				throw new ArgumentNullException("operands");
+				throw new ArgumentNullException(nameof(operands));
 			this.operatorType = operatorType;
 			this.operands = operands;
 		}
@@ -46,7 +46,7 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(resultType)
 		{
 			if (operands == null)
-				throw new ArgumentNullException("operands");
+				throw new ArgumentNullException(nameof(operands));
 			this.operatorType = operatorType;
 			this.userDefinedOperatorMethod = userDefinedOperatorMethod;
 			this.isLiftedOperator = isLiftedOperator;

ICSharpCode.Decompiler/Semantics/ResolveResult.cs

@@ -33,7 +33,7 @@ namespace ICSharpCode.Decompiler.Semantics
 		public ResolveResult(IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			this.type = type;
 		}
 		

ICSharpCode.Decompiler/Semantics/SizeOfResolveResult.cs

@@ -33,7 +33,7 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(int32)
 		{
 			if (referencedType == null)
-				throw new ArgumentNullException("referencedType");
+				throw new ArgumentNullException(nameof(referencedType));
 			this.referencedType = referencedType;
 			this.constantValue = constantValue;
 		}

ICSharpCode.Decompiler/Semantics/TypeIsResolveResult.cs

@@ -37,9 +37,9 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(booleanType)
 		{
 			if (input == null)
-				throw new ArgumentNullException("input");
+				throw new ArgumentNullException(nameof(input));
 			if (targetType == null)
-				throw new ArgumentNullException("targetType");
+				throw new ArgumentNullException(nameof(targetType));
 			this.Input = input;
 			this.TargetType = targetType;
 		}

ICSharpCode.Decompiler/Semantics/TypeOfResolveResult.cs

@@ -32,7 +32,7 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(systemType)
 		{
 			if (referencedType == null)
-				throw new ArgumentNullException("referencedType");
+				throw new ArgumentNullException(nameof(referencedType));
 			this.referencedType = referencedType;
 		}
 		

ICSharpCode.Decompiler/Semantics/UnknownMemberResolveResult.cs

@@ -38,7 +38,7 @@ namespace ICSharpCode.Decompiler.Semantics
 			: base(SpecialType.UnknownType)
 		{
 			if (targetType == null)
-				throw new ArgumentNullException("targetType");
+				throw new ArgumentNullException(nameof(targetType));
 			this.targetType = targetType;
 			this.memberName = memberName;
 			this.typeArguments = new ReadOnlyCollection<IType>(typeArguments.ToArray());

ICSharpCode.Decompiler/TypeSystem/ArrayType.cs

@@ -35,9 +35,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public ArrayType(ICompilation compilation, IType elementType, int dimensions = 1, Nullability nullability = Nullability.Oblivious) : base(elementType)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			if (dimensions <= 0)
-				throw new ArgumentOutOfRangeException("dimensions", dimensions, "dimensions must be positive");
+				throw new ArgumentOutOfRangeException(nameof(dimensions), dimensions, "dimensions must be positive");
 			this.compilation = compilation;
 			this.dimensions = dimensions;
 			this.nullability = nullability;
@@ -181,9 +181,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public ArrayTypeReference(ITypeReference elementType, int dimensions = 1)
 		{
 			if (elementType == null)
-				throw new ArgumentNullException("elementType");
+				throw new ArgumentNullException(nameof(elementType));
 			if (dimensions <= 0)
-				throw new ArgumentOutOfRangeException("dimensions", dimensions, "dimensions must be positive");
+				throw new ArgumentOutOfRangeException(nameof(dimensions), dimensions, "dimensions must be positive");
 			this.elementType = elementType;
 			this.dimensions = dimensions;
 		}

ICSharpCode.Decompiler/TypeSystem/ByReferenceType.cs

@@ -77,7 +77,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public ByReferenceTypeReference(ITypeReference elementType)
 		{
 			if (elementType == null)
-				throw new ArgumentNullException("elementType");
+				throw new ArgumentNullException(nameof(elementType));
 			this.elementType = elementType;
 		}
 		

ICSharpCode.Decompiler/TypeSystem/FullTypeName.cs

@@ -45,7 +45,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 			public NestedTypeName(string name, int additionalTypeParameterCount)
 			{
 				if (name == null)
-					throw new ArgumentNullException("name");
+					throw new ArgumentNullException(nameof(name));
 				this.Name = name;
 				this.AdditionalTypeParameterCount = additionalTypeParameterCount;
 			}
@@ -217,7 +217,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public FullTypeName NestedType(string name, int additionalTypeParameterCount)
 		{
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			var newNestedType = new NestedTypeName(name, additionalTypeParameterCount);
 			if (nestedTypes == null)
 				return new FullTypeName(topLevelType, new[] { newNestedType });

ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractTypeParameter.cs

@@ -36,7 +36,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		protected AbstractTypeParameter(IEntity owner, int index, string name, VarianceModifier variance)
 		{
 			if (owner == null)
-				throw new ArgumentNullException("owner");
+				throw new ArgumentNullException(nameof(owner));
 			this.owner = owner;
 			this.compilation = owner.Compilation;
 			this.ownerType = owner.SymbolKind;
@@ -48,7 +48,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		protected AbstractTypeParameter(ICompilation compilation, SymbolKind ownerType, int index, string name, VarianceModifier variance)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			this.compilation = compilation;
 			this.ownerType = ownerType;
 			this.index = index;

ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultAttribute.cs

@@ -42,7 +42,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 			ImmutableArray<CustomAttributeNamedArgument<IType>> namedArguments)
 		{
 			if (attributeType == null)
-				throw new ArgumentNullException("attributeType");
+				throw new ArgumentNullException(nameof(attributeType));
 			this.attributeType = attributeType;
 			this.FixedArguments = fixedArguments;
 			this.NamedArguments = namedArguments;
@@ -53,7 +53,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 			ImmutableArray<CustomAttributeNamedArgument<IType>> namedArguments)
 		{
 			if (constructor == null)
-				throw new ArgumentNullException("constructor");
+				throw new ArgumentNullException(nameof(constructor));
 			this.constructor = constructor;
 			this.attributeType = constructor.DeclaringType ?? SpecialType.UnknownType;
 			this.FixedArguments = fixedArguments;

ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultParameter.cs

@@ -39,9 +39,9 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		public DefaultParameter(IType type, string name)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			this.type = type;
 			this.name = name;
 			this.attributes = EmptyList<IAttribute>.Instance;
@@ -51,9 +51,9 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		                        ReferenceKind referenceKind = ReferenceKind.None, bool isParams = false, bool isOptional = false, object defaultValue = null)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			this.type = type;
 			this.name = name;
 			this.owner = owner;

ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultVariable.cs

@@ -33,9 +33,9 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		public DefaultVariable(IType type, string name)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			this.type = type;
 			this.name = name;
 		}

ICSharpCode.Decompiler/TypeSystem/Implementation/GetClassTypeReference.cs

@@ -98,7 +98,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		public IType Resolve(ITypeResolveContext context)
 		{
 			if (context == null)
-				throw new ArgumentNullException("context");
+				throw new ArgumentNullException(nameof(context));
 			
 			IType type = null;
 			if (module == null) {

ICSharpCode.Decompiler/TypeSystem/Implementation/MergedNamespace.cs

@@ -44,9 +44,9 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		public MergedNamespace(ICompilation compilation, INamespace[] namespaces, string externAlias = null)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			if (namespaces == null)
-				throw new ArgumentNullException("namespaces");
+				throw new ArgumentNullException(nameof(namespaces));
 			this.compilation = compilation;
 			this.namespaces = namespaces;
 			this.externAlias = externAlias;
@@ -60,9 +60,9 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		public MergedNamespace(INamespace parentNamespace, INamespace[] namespaces)
 		{
 			if (parentNamespace == null)
-				throw new ArgumentNullException("parentNamespace");
+				throw new ArgumentNullException(nameof(parentNamespace));
 			if (namespaces == null)
-				throw new ArgumentNullException("namespaces");
+				throw new ArgumentNullException(nameof(namespaces));
 			this.parentNamespace = parentNamespace;
 			this.namespaces = namespaces;
 			this.compilation = parentNamespace.Compilation;

ICSharpCode.Decompiler/TypeSystem/Implementation/NestedTypeReference.cs

@@ -44,9 +44,9 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		public NestedTypeReference(ITypeReference declaringTypeRef, string name, int additionalTypeParameterCount, bool? isReferenceType = null)
 		{
 			if (declaringTypeRef == null)
-				throw new ArgumentNullException("declaringTypeRef");
+				throw new ArgumentNullException(nameof(declaringTypeRef));
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			this.declaringTypeRef = declaringTypeRef;
 			this.name = name;
 			this.additionalTypeParameterCount = additionalTypeParameterCount;

ICSharpCode.Decompiler/TypeSystem/Implementation/SimpleCompilation.cs

@@ -52,9 +52,9 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		protected void Init(IModuleReference mainAssembly, IEnumerable<IModuleReference> assemblyReferences)
 		{
 			if (mainAssembly == null)
-				throw new ArgumentNullException("mainAssembly");
+				throw new ArgumentNullException(nameof(mainAssembly));
 			if (assemblyReferences == null)
-				throw new ArgumentNullException("assemblyReferences");
+				throw new ArgumentNullException(nameof(assemblyReferences));
 			var context = new SimpleTypeResolveContext(this);
 			this.mainModule = mainAssembly.Resolve(context);
 			List<IModule> assemblies = new List<IModule>();

ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMember.cs

@@ -40,7 +40,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		protected SpecializedMember(IMember memberDefinition)
 		{
 			if (memberDefinition == null)
-				throw new ArgumentNullException("memberDefinition");
+				throw new ArgumentNullException(nameof(memberDefinition));
 			if (memberDefinition is SpecializedMember)
 				throw new ArgumentException("Member definition cannot be specialized. Please use IMember.Specialize() instead of directly constructing SpecializedMember instances.");
 			

ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMethod.cs

@@ -54,7 +54,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 			: base(methodDefinition)
 		{
 			if (substitution == null)
-				throw new ArgumentNullException("substitution");
+				throw new ArgumentNullException(nameof(substitution));
 			this.methodDefinition = methodDefinition;
 			this.isParameterized = substitution.MethodTypeArguments != null;
 			if (methodDefinition.TypeParameters.Count > 0) {

ICSharpCode.Decompiler/TypeSystem/Implementation/TypeWithElementType.cs

@@ -27,7 +27,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		protected TypeWithElementType(IType elementType)
 		{
 			if (elementType == null)
-				throw new ArgumentNullException("elementType");
+				throw new ArgumentNullException(nameof(elementType));
 			this.elementType = elementType;
 		}
 		

ICSharpCode.Decompiler/TypeSystem/Implementation/UnknownType.cs

@@ -41,7 +41,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		public UnknownType(string namespaceName, string name, int typeParameterCount = 0, bool? isReferenceType = null)
 		{
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			this.namespaceKnown = namespaceName != null;
 			this.fullTypeName = new TopLevelTypeName(namespaceName ?? string.Empty, name, typeParameterCount);
 			this.isReferenceType = isReferenceType;
@@ -71,7 +71,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		IType ITypeReference.Resolve(ITypeResolveContext context)
 		{
 			if (context == null)
-				throw new ArgumentNullException("context");
+				throw new ArgumentNullException(nameof(context));
 			return this;
 		}
 		

ICSharpCode.Decompiler/TypeSystem/InheritanceHelper.cs

@@ -48,7 +48,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IEnumerable<IMember> GetBaseMembers(IMember member, bool includeImplementedInterfaces)
 		{
 			if (member == null)
-				throw new ArgumentNullException("member");
+				throw new ArgumentNullException(nameof(member));
 
 			if (includeImplementedInterfaces) {
 				if (member.IsExplicitInterfaceImplementation && member.ExplicitlyImplementedInterfaceMembers.Count() == 1) {
@@ -100,9 +100,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IMember GetDerivedMember(IMember baseMember, ITypeDefinition derivedType)
 		{
 			if (baseMember == null)
-				throw new ArgumentNullException("baseMember");
+				throw new ArgumentNullException(nameof(baseMember));
 			if (derivedType == null)
-				throw new ArgumentNullException("derivedType");
+				throw new ArgumentNullException(nameof(derivedType));
 
 			if (baseMember.Compilation != derivedType.Compilation)
 				throw new ArgumentException("baseMember and derivedType must be from the same compilation");

ICSharpCode.Decompiler/TypeSystem/NullableType.cs

@@ -31,7 +31,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static bool IsNullable(IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			ParameterizedType pt = type.SkipModifiers() as ParameterizedType;
 			return pt != null && pt.TypeParameterCount == 1 && pt.GenericType.IsKnownType(KnownTypeCode.NullableOfT);
 		}
@@ -48,7 +48,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IType GetUnderlyingType(IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			ParameterizedType pt = type.SkipModifiers() as ParameterizedType;
 			if (pt != null && pt.TypeParameterCount == 1 && pt.GenericType.IsKnownType(KnownTypeCode.NullableOfT))
 				return pt.GetTypeArgument(0);
@@ -62,9 +62,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IType Create(ICompilation compilation, IType elementType)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			if (elementType == null)
-				throw new ArgumentNullException("elementType");
+				throw new ArgumentNullException(nameof(elementType));
 			
 			IType nullableType = compilation.FindType(KnownTypeCode.NullableOfT);
 			ITypeDefinition nullableTypeDef = nullableType.GetDefinition();
@@ -80,7 +80,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static ParameterizedTypeReference Create(ITypeReference elementType)
 		{
 			if (elementType == null)
-				throw new ArgumentNullException("elementType");
+				throw new ArgumentNullException(nameof(elementType));
 			return new ParameterizedTypeReference(KnownTypeReference.Get(KnownTypeCode.NullableOfT), new [] { elementType });
 		}
 	}

ICSharpCode.Decompiler/TypeSystem/ParameterListComparer.cs

@@ -111,7 +111,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public SignatureComparer(StringComparer nameComparer)
 		{
 			if (nameComparer == null)
-				throw new ArgumentNullException("nameComparer");
+				throw new ArgumentNullException(nameof(nameComparer));
 			this.nameComparer = nameComparer;
 		}
 		

ICSharpCode.Decompiler/TypeSystem/ParameterizedType.cs

@@ -44,9 +44,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public ParameterizedType(IType genericType, IEnumerable<IType> typeArguments)
 		{
 			if (genericType == null)
-				throw new ArgumentNullException("genericType");
+				throw new ArgumentNullException(nameof(genericType));
 			if (typeArguments == null)
-				throw new ArgumentNullException("typeArguments");
+				throw new ArgumentNullException(nameof(typeArguments));
 			this.genericType = genericType;
 			this.typeArguments = typeArguments.ToArray(); // copy input array to ensure it isn't modified
 			if (this.typeArguments.Length == 0)
@@ -358,9 +358,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public ParameterizedTypeReference(ITypeReference genericType, IEnumerable<ITypeReference> typeArguments)
 		{
 			if (genericType == null)
-				throw new ArgumentNullException("genericType");
+				throw new ArgumentNullException(nameof(genericType));
 			if (typeArguments == null)
-				throw new ArgumentNullException("typeArguments");
+				throw new ArgumentNullException(nameof(typeArguments));
 			this.genericType = genericType;
 			this.typeArguments = typeArguments.ToArray();
 			for (int i = 0; i < this.typeArguments.Length; i++) {

ICSharpCode.Decompiler/TypeSystem/PointerType.cs

@@ -75,7 +75,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public PointerTypeReference(ITypeReference elementType)
 		{
 			if (elementType == null)
-				throw new ArgumentNullException("elementType");
+				throw new ArgumentNullException(nameof(elementType));
 			this.elementType = elementType;
 		}
 		

ICSharpCode.Decompiler/TypeSystem/ReflectionHelper.cs

@@ -210,7 +210,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static ITypeReference ParseReflectionName(string reflectionTypeName)
 		{
 			if (reflectionTypeName == null)
-				throw new ArgumentNullException("reflectionTypeName");
+				throw new ArgumentNullException(nameof(reflectionTypeName));
 			int pos = 0;
 			ITypeReference r = ParseReflectionName(reflectionTypeName, ref pos);
 			if (pos < reflectionTypeName.Length)

ICSharpCode.Decompiler/TypeSystem/SimpleTypeResolveContext.cs

@@ -33,7 +33,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public SimpleTypeResolveContext(ICompilation compilation)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			this.compilation = compilation;
 		}
 		
@@ -48,7 +48,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public SimpleTypeResolveContext(IEntity entity)
 		{
 			if (entity == null)
-				throw new ArgumentNullException("entity");
+				throw new ArgumentNullException(nameof(entity));
 			this.compilation = entity.Compilation;
 			this.currentModule = entity.ParentModule;
 			this.currentTypeDefinition = (entity as ITypeDefinition) ?? entity.DeclaringTypeDefinition;

ICSharpCode.Decompiler/TypeSystem/SpecialType.cs

@@ -84,7 +84,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		IType ITypeReference.Resolve(ITypeResolveContext context)
 		{
 			if (context == null)
-				throw new ArgumentNullException("context");
+				throw new ArgumentNullException(nameof(context));
 			return this;
 		}
 		

ICSharpCode.Decompiler/TypeSystem/TaskType.cs

@@ -121,9 +121,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IType Create(ICompilation compilation, IType elementType)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			if (elementType == null)
-				throw new ArgumentNullException("elementType");
+				throw new ArgumentNullException(nameof(elementType));
 			
 			if (elementType.Kind == TypeKind.Void)
 				return compilation.FindType(KnownTypeCode.Task);

ICSharpCode.Decompiler/TypeSystem/TopLevelTypeName.cs

@@ -36,9 +36,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public TopLevelTypeName(string namespaceName, string name, int typeParameterCount = 0)
 		{
 			if (namespaceName == null)
-				throw new ArgumentNullException("namespaceName");
+				throw new ArgumentNullException(nameof(namespaceName));
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 			this.namespaceName = namespaceName;
 			this.name = name;
 			this.typeParameterCount = typeParameterCount;

ICSharpCode.Decompiler/TypeSystem/TypeSystemExtensions.cs

@@ -44,7 +44,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IEnumerable<IType> GetAllBaseTypes(this IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			BaseTypeCollector collector = new BaseTypeCollector();
 			collector.CollectBaseTypes(type);
 			return collector;
@@ -61,7 +61,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IEnumerable<IType> GetNonInterfaceBaseTypes(this IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			BaseTypeCollector collector = new BaseTypeCollector();
 			collector.SkipImplementedInterfaces = true;
 			collector.CollectBaseTypes(type);
@@ -80,7 +80,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IEnumerable<ITypeDefinition> GetAllBaseTypeDefinitions(this IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			
 			return type.GetAllBaseTypes().Select(t => t.GetDefinition()).Where(d => d != null).Distinct();
 		}
@@ -91,7 +91,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static bool IsDerivedFrom(this ITypeDefinition type, ITypeDefinition baseType)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			if (baseType == null)
 				return false;
 			if (type.Compilation != baseType.Compilation) {
@@ -106,7 +106,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static bool IsDerivedFrom(this ITypeDefinition type, KnownTypeCode baseType)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			if (baseType == KnownTypeCode.None)
 				return false;
 			return IsDerivedFrom(type, type.Compilation.FindType(baseType).GetDefinition());
@@ -178,7 +178,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static bool IsOpen(this IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			TypeClassificationVisitor v = new TypeClassificationVisitor();
 			type.AcceptVisitor(v);
 			return v.isOpen;
@@ -193,7 +193,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		static IEntity GetTypeParameterOwner(IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			TypeClassificationVisitor v = new TypeClassificationVisitor();
 			type.AcceptVisitor(v);
 			return v.typeParameterOwner;
@@ -210,7 +210,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static bool IsUnbound(this IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			return type is ITypeDefinition && type.TypeParameterCount > 0;
 		}
 		
@@ -265,7 +265,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IMethod GetDelegateInvokeMethod(this IType type)
 		{
 			if (type == null)
-				throw new ArgumentNullException("type");
+				throw new ArgumentNullException(nameof(type));
 			if (type.Kind == TypeKind.Delegate)
 				return type.GetMethods(m => m.Name == "Invoke", GetMemberOptions.IgnoreInheritedMembers).FirstOrDefault();
 			else
@@ -310,7 +310,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IReadOnlyList<IType> Resolve(this IList<ITypeReference> typeReferences, ITypeResolveContext context)
 		{
 			if (typeReferences == null)
-				throw new ArgumentNullException("typeReferences");
+				throw new ArgumentNullException(nameof(typeReferences));
 			if (typeReferences.Count == 0)
 				return EmptyList<IType>.Instance;
 			else
@@ -336,7 +336,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		public static IType FindType(this ICompilation compilation, FullTypeName fullTypeName)
 		{
 			if (compilation == null)
-				throw new ArgumentNullException("compilation");
+				throw new ArgumentNullException(nameof(compilation));
 			foreach (IModule asm in compilation.Modules) {
 				ITypeDefinition def = asm.GetTypeDefinition(fullTypeName);
 				if (def != null)

ICSharpCode.Decompiler/Util/CallbackOnDispose.cs

@@ -35,7 +35,7 @@ namespace ICSharpCode.Decompiler.Util
 		public CallbackOnDispose(Action action)
 		{
 			if (action == null)
-				throw new ArgumentNullException("action");
+				throw new ArgumentNullException(nameof(action));
 			this.action = action;
 		}
 		

ICSharpCode.Decompiler/Util/EmptyList.cs

@@ -30,8 +30,8 @@ namespace ICSharpCode.Decompiler.Util
 		private EmptyList() {}
 		
 		public T this[int index] {
-			get { throw new ArgumentOutOfRangeException("index"); }
+			get { throw new ArgumentOutOfRangeException(nameof(index)); }
-			set { throw new ArgumentOutOfRangeException("index"); }
+			set { throw new ArgumentOutOfRangeException(nameof(index)); }
 		}
 		
 		public int Count {

ICSharpCode.Decompiler/Util/GraphVizGraph.cs

@@ -114,7 +114,7 @@ namespace ICSharpCode.Decompiler.Util
 		public void Save(TextWriter writer)
 		{
 			if (writer == null)
-				throw new ArgumentNullException("writer");
+				throw new ArgumentNullException(nameof(writer));
 			writer.WriteLine("digraph G {");
 			writer.WriteLine("node [fontsize = 16];");
 			WriteGraphAttribute(writer, "rankdir", rankdir);
@@ -147,9 +147,9 @@ namespace ICSharpCode.Decompiler.Util
 		public GraphVizEdge(string source, string target)
 		{
 			if (source == null)
-				throw new ArgumentNullException("source");
+				throw new ArgumentNullException(nameof(source));
 			if (target == null)
-				throw new ArgumentNullException("target");
+				throw new ArgumentNullException(nameof(target));
 			this.Source = source;
 			this.Target = target;
 		}
@@ -195,7 +195,7 @@ namespace ICSharpCode.Decompiler.Util
 		public GraphVizNode(string id)
 		{
 			if (id == null)
-				throw new ArgumentNullException("id");
+				throw new ArgumentNullException(nameof(id));
 			this.ID = id;
 		}
 

ICSharpCode.Decompiler/Util/KeyComparer.cs

@@ -58,11 +58,11 @@ namespace ICSharpCode.Decompiler.Util
 		public KeyComparer(Func<TElement, TKey> keySelector, IComparer<TKey> keyComparer, IEqualityComparer<TKey> keyEqualityComparer)
 		{
 			if (keySelector == null)
-				throw new ArgumentNullException("keySelector");
+				throw new ArgumentNullException(nameof(keySelector));
 			if (keyComparer == null)
-				throw new ArgumentNullException("keyComparer");
+				throw new ArgumentNullException(nameof(keyComparer));
 			if (keyEqualityComparer == null)
-				throw new ArgumentNullException("keyEqualityComparer");
+				throw new ArgumentNullException(nameof(keyEqualityComparer));
 			this.keySelector = keySelector;
 			this.keyComparer = keyComparer;
 			this.keyEqualityComparer = keyEqualityComparer;

ICSharpCode.Decompiler/Util/ProjectedList.cs

@@ -30,9 +30,9 @@ namespace ICSharpCode.Decompiler.Util
 		public ProjectedList(IList<TInput> input, Func<TInput, TOutput> projection)
 		{
 			if (input == null)
-				throw new ArgumentNullException("input");
+				throw new ArgumentNullException(nameof(input));
 			if (projection == null)
-				throw new ArgumentNullException("projection");
+				throw new ArgumentNullException(nameof(projection));
 			this.input = input;
 			this.projection = projection;
 			this.items = new TOutput[input.Count];
@@ -75,9 +75,9 @@ namespace ICSharpCode.Decompiler.Util
 		public ProjectedList(TContext context, IList<TInput> input, Func<TContext, TInput, TOutput> projection)
 		{
 			if (input == null)
-				throw new ArgumentNullException("input");
+				throw new ArgumentNullException(nameof(input));
 			if (projection == null)
-				throw new ArgumentNullException("projection");
+				throw new ArgumentNullException(nameof(projection));
 			this.input = input;
 			this.context = context;
 			this.projection = projection;

ICSharpCode.Decompiler/Util/ResXResourceWriter.cs

@@ -69,10 +69,10 @@ namespace ICSharpCode.Decompiler.Util
 		public ResXResourceWriter(Stream stream)
 		{
 			if (stream == null)
-				throw new ArgumentNullException("stream");
+				throw new ArgumentNullException(nameof(stream));
 
 			if (!stream.CanWrite)
-				throw new ArgumentException("stream is not writable.", "stream");
+				throw new ArgumentException("stream is not writable.", nameof(stream));
 
 			this.stream = stream;
 		}
@@ -80,7 +80,7 @@ namespace ICSharpCode.Decompiler.Util
 		public ResXResourceWriter(TextWriter textWriter)
 		{
 			if (textWriter == null)
-				throw new ArgumentNullException("textWriter");
+				throw new ArgumentNullException(nameof(textWriter));
 
 			this.textwriter = textWriter;
 		}
@@ -88,7 +88,7 @@ namespace ICSharpCode.Decompiler.Util
 		public ResXResourceWriter(string fileName)
 		{
 			if (fileName == null)
-				throw new ArgumentNullException("fileName");
+				throw new ArgumentNullException(nameof(fileName));
 
 			this.filename = fileName;
 		}
@@ -217,10 +217,10 @@ namespace ICSharpCode.Decompiler.Util
 		public void AddResource(string name, byte[] value)
 		{
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 
 			if (value == null)
-				throw new ArgumentNullException("value");
+				throw new ArgumentNullException(nameof(value));
 
 			if (written)
 				throw new InvalidOperationException("The resource is already generated.");
@@ -244,7 +244,7 @@ namespace ICSharpCode.Decompiler.Util
 			}
 
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 
 			if (written)
 				throw new InvalidOperationException("The resource is already generated.");
@@ -307,10 +307,10 @@ namespace ICSharpCode.Decompiler.Util
 		private void AddResource(string name, string value, string comment)
 		{
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 
 			if (value == null)
-				throw new ArgumentNullException("value");
+				throw new ArgumentNullException(nameof(value));
 
 			if (written)
 				throw new InvalidOperationException("The resource is already generated.");
@@ -324,10 +324,10 @@ namespace ICSharpCode.Decompiler.Util
 		public void AddMetadata(string name, string value)
 		{
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 
 			if (value == null)
-				throw new ArgumentNullException("value");
+				throw new ArgumentNullException(nameof(value));
 
 			if (written)
 				throw new InvalidOperationException("The resource is already generated.");
@@ -347,10 +347,10 @@ namespace ICSharpCode.Decompiler.Util
 		public void AddMetadata(string name, byte[] value)
 		{
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 
 			if (value == null)
-				throw new ArgumentNullException("value");
+				throw new ArgumentNullException(nameof(value));
 
 			if (written)
 				throw new InvalidOperationException("The resource is already generated.");
@@ -383,10 +383,10 @@ namespace ICSharpCode.Decompiler.Util
 			}
 
 			if (name == null)
-				throw new ArgumentNullException("name");
+				throw new ArgumentNullException(nameof(name));
 
 			if (value == null)
-				throw new ArgumentNullException("value");
+				throw new ArgumentNullException(nameof(value));
 
 			if (!value.GetType().IsSerializable)
 				throw new InvalidOperationException(String.Format("The element '{0}' of type '{1}' is not serializable.", name, value.GetType().Name));