Fix a bunch of XmlDoc compiler warnings.

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

@@ -7,7 +7,7 @@
 
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
 
-    <NoWarn>1701;1702;1705,67,169,1058,728,1720,649,168,251</NoWarn>
+    <NoWarn>1701;1702;1705,67,169,1058,728,1720,649,168,251,660,661,675</NoWarn>
 
     <GenerateAssemblyInfo>False</GenerateAssemblyInfo>
 

ICSharpCode.Decompiler/CSharp/OutputVisitor/FormattingOptionsFactory.cs

@@ -209,7 +209,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 		}
 
 		/// <summary>
-		/// The K&R style, so named because it was used in Kernighan and Ritchie's book The C Programming Language,
+		/// The K&amp;R style, so named because it was used in Kernighan and Ritchie's book The C Programming Language,
 		/// is commonly used in C. It is less common for C++, C#, and others.
 		/// </summary>
 		public static CSharpFormattingOptions CreateKRStyle()

ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs

@@ -647,7 +647,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		{
 			TypeKind kind = type.Kind;
 			return kind == TypeKind.Class && type.GetDefinition().IsSealed
-				|| kind == TypeKind.Delegate || kind == TypeKind.Anonymous;
+				|| kind == TypeKind.Delegate;
 		}
 		#endregion
 

ICSharpCode.Decompiler/CSharp/Resolver/MethodGroupResolveResult.cs

@@ -174,12 +174,12 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 			return extensionMethods ?? Enumerable.Empty<IEnumerable<IMethod>>();
 		}
-		
+
 		/// <summary>
 		/// Gets the eligible extension methods.
 		/// </summary>
 		/// <param name="substituteInferredTypes">
-		/// Specifies whether to produce a <see cref="SpecializedMethod"/>
+		/// Specifies whether to produce a <c>SpecializedMethod</c>
 		/// when type arguments could be inferred from <see cref="TargetType"/>.
 		/// This setting is only used for inferred types and has no effect if the type parameters are
 		/// specified explicitly.

ICSharpCode.Decompiler/CSharp/Resolver/OverloadResolution.cs

@@ -940,6 +940,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 		/// <param name="initializerStatements">
 		/// Statements for Objects/Collections initializer.
 		/// <see cref="InvocationResolveResult.InitializerStatements"/>
+		/// </param>
 		/// <param name="returnTypeOverride">
 		/// If not null, use this instead of the ReturnType of the member as the type of the created resolve result.
 		/// </param>

ICSharpCode.Decompiler/CSharp/Resolver/RenameCallbackArguments.cs

@@ -1,42 +0,0 @@
-// Copyright (c) 2010-2014 AlphaSierraPapa for the SharpDevelop Team
-// 
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this
-// software and associated documentation files (the "Software"), to deal in the Software
-// without restriction, including without limitation the rights to use, copy, modify, merge,
-// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
-// to whom the Software is furnished to do so, subject to the following conditions:
-// 
-// The above copyright notice and this permission notice shall be included in all copies or
-// substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
-// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
-// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-// DEALINGS IN THE SOFTWARE.
-
-using System;
-using ICSharpCode.Decompiler.CSharp.Syntax;
-
-namespace ICSharpCode.Decompiler.CSharp.Resolver
-{
-	/// <summary>
-	/// Arguments for the callback of <see cref="FindReferences.RenameReferencesInFile"/>.
-	/// </summary>
-	public class RenameCallbackArguments
-	{
-		public AstNode NodeToReplace { get; private set; }
-		public AstNode NewNode { get; private set; }
-		
-		public RenameCallbackArguments(AstNode nodeToReplace, AstNode newNode)
-		{
-			if (nodeToReplace == null)
-				throw new ArgumentNullException("nodeToReplace");
-			if (newNode == null)
-				throw new ArgumentNullException("newNode");
-			this.NodeToReplace = nodeToReplace;
-			this.NewNode = newNode;
-		}
-	}
-}

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

@@ -250,13 +250,13 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		Divide,
 		/// <summary>left %= right</summary>
 		Modulus,
-		
-		/// <summary>left <<= right</summary>
+
+		/// <summary>left &lt;&lt;= right</summary>
 		ShiftLeft,
 		/// <summary>left >>= right</summary>
 		ShiftRight,
 		
-		/// <summary>left &= right</summary>
+		/// <summary>left &amp;= right</summary>
 		BitwiseAnd,
 		/// <summary>left |= right</summary>
 		BitwiseOr,

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

@@ -182,7 +182,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		PostDecrement,
 		/// <summary>Dereferencing (*a)</summary>
 		Dereference,
-		/// <summary>Get address (&a)</summary>
+		/// <summary>Get address (&amp;a)</summary>
 		AddressOf,
 		/// <summary>C# 5.0 await</summary>
 		Await,

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

@@ -28,7 +28,7 @@
 namespace ICSharpCode.Decompiler.CSharp.Syntax
 {
 	/// <summary>
-	/// extern alias <Identifier>;
+	/// extern alias IDENTIFIER;
 	/// </summary>
 	public class ExternAliasDeclaration : AstNode
 	{

ICSharpCode.Decompiler/CSharp/Syntax/TextLocation.cs

@@ -26,10 +26,6 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 	/// A line/column position.
 	/// Text editor lines/columns are counted started from one.
 	/// </summary>
-	/// <remarks>
-	/// The document provides the methods <see cref="IDocument.GetLocation"/> and
-	/// <see cref="IDocument.GetOffset(ICSharpCode.Decompiler.CSharp.Syntax.TextLocation)"/> to convert between offsets and TextLocations.
-	/// </remarks>
 	[Serializable]
 	[TypeConverter(typeof(TextLocationConverter))]
 	public struct TextLocation : IComparable<TextLocation>, IEquatable<TextLocation>

ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj

@@ -48,6 +48,10 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <NoWarn>1701;1702;1591;1573</NoWarn>
+  </PropertyGroup>
+
   <ItemGroup>
     <PackageReference Include="Humanizer.Core" Version="2.2.0" />
     <PackageReference Include="System.Collections.Immutable" Version="1.5.0" />
@@ -223,7 +227,6 @@
     <Compile Include="CSharp\Resolver\OverloadResolution.cs" />
     <Compile Include="CSharp\Resolver\OverloadResolutionErrors.cs" />
     <Compile Include="CSharp\Resolver\ReducedExtensionMethod.cs" />
-    <Compile Include="CSharp\Resolver\RenameCallbackArguments.cs" />
     <Compile Include="CSharp\Resolver\TypeInference.cs" />
     <Compile Include="CSharp\Transforms\CombineQueryExpressions.cs" />
     <Compile Include="CSharp\Transforms\FlattenSwitchBlocks.cs" />

ICSharpCode.Decompiler/IL/ControlFlow/ConditionDetection.cs

@@ -403,7 +403,7 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 		/// <summary>
 		///   if (cond) { if (nestedCond) { nestedThen... } }
 		/// ->
-		///   if (cond && nestedCond) { nestedThen... }
+		///   if (cond &amp;&amp; nestedCond) { nestedThen... }
 		/// </summary>
 		private void IntroduceShortCircuit(IfInstruction ifInst)
 		{

ICSharpCode.Decompiler/IL/ControlFlow/LoopDetection.cs

@@ -458,7 +458,6 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 		/// or that leave the block Container.
 		/// </summary>
 		/// <param name="loopHead">Entry point of the loop.</param>
-		/// <param name="isSwitch">Whether to ignore branches that map to C# 'continue' statements.</param>
 		/// <param name="exitNodeArity">out: The number of different CFG nodes.
 		/// Possible values:
 		///  0 = no CFG nodes used as exit nodes (although edges leaving the block container might still be exits);

ICSharpCode.Decompiler/IL/ControlFlow/SwitchDetection.cs

@@ -441,7 +441,7 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 		///   s   c
 		/// 
 		///  where:
-		///   p|n: if (a && b) goto c; goto s;
+		///   p|n: if (a && b) goto c; goto s;
 		/// 
 		///  Note that if n has only 1 successor, but is still a flow node, then a short circuit expression 
 		///  has a target (c) with no corresponding block (leave)

ICSharpCode.Decompiler/IL/ControlFlow/YieldReturnDecompiler.cs

@@ -70,7 +70,7 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 		/// <remarks>Set in AnalyzeCurrentProperty()</remarks>
 		IField currentField;
 
-		/// <summary>The disposing field of the compiler-generated enumerator class./summary>
+		/// <summary>The disposing field of the compiler-generated enumerator class.</summary>
 		/// <remarks>Set in ConstructExceptionTable() for assembly compiled with Mono</remarks>
 		IField disposingField;
 

ICSharpCode.Decompiler/IL/Instructions.cs

@@ -115,7 +115,7 @@ namespace ICSharpCode.Decompiler.IL
 		/// In case 3 (managed reference), the dereferenced value is the input being tested, and the nullable.unwrap instruction returns the managed reference unmodified (if the value is non-null).</summary>
 		NullableUnwrap,
 		/// <summary>Serves as jump target for the nullable.unwrap instruction.
-		/// If the input evaluates normally, evaluates to the input value (wrapped in Nullable<T> if the input is a non-nullable value type).If a nullable.unwrap instruction encounters a null input and jumps to the (endpoint of the) nullable.rewrap instruction,the nullable.rewrap instruction evaluates to null.</summary>
+		/// If the input evaluates normally, evaluates to the input value (wrapped in Nullable&lt;T&gt; if the input is a non-nullable value type).If a nullable.unwrap instruction encounters a null input and jumps to the (endpoint of the) nullable.rewrap instruction,the nullable.rewrap instruction evaluates to null.</summary>
 		NullableRewrap,
 		/// <summary>Loads a constant string.</summary>
 		LdStr,
@@ -189,7 +189,7 @@ namespace ICSharpCode.Decompiler.IL
 		StringToInt,
 		/// <summary>ILAst representation of Expression.Convert.</summary>
 		ExpressionTreeCast,
-		/// <summary>Use of user-defined && or || operator.</summary>
+		/// <summary>Use of user-defined &amp;&amp; or || operator.</summary>
 		UserDefinedLogicOperator,
 		/// <summary>ILAst representation of a short-circuiting binary operator inside a dynamic expression.</summary>
 		DynamicLogicOperatorInstruction,
@@ -1058,7 +1058,7 @@ namespace ICSharpCode.Decompiler.IL
 		protected internal override bool PerformMatch(ILInstruction other, ref Patterns.Match match)
 		{
 			var o = other as NumericCompoundAssign;
-			return o != null && type.Equals(o.type) && CheckForOverflow == o.CheckForOverflow && Sign == o.Sign && Operator == o.Operator && Target.PerformMatch(o.Target, ref match) && Value.PerformMatch(o.Value, ref match);
+			return o != null && type.Equals(o.type) && CheckForOverflow == o.CheckForOverflow && Sign == o.Sign && Operator == o.Operator && this.EvalMode == o.EvalMode && this.TargetKind == o.TargetKind && Target.PerformMatch(o.Target, ref match) && Value.PerformMatch(o.Value, ref match);
 		}
 	}
 }
@@ -1092,7 +1092,7 @@ namespace ICSharpCode.Decompiler.IL
 		protected internal override bool PerformMatch(ILInstruction other, ref Patterns.Match match)
 		{
 			var o = other as UserDefinedCompoundAssign;
-			return o != null && this.Method.Equals(o.Method) && this.EvalMode == o.EvalMode && Target.PerformMatch(o.Target, ref match) && Value.PerformMatch(o.Value, ref match);
+			return o != null && this.Method.Equals(o.Method) && this.EvalMode == o.EvalMode && this.TargetKind == o.TargetKind && Target.PerformMatch(o.Target, ref match) && Value.PerformMatch(o.Value, ref match);
 		}
 	}
 }
@@ -1126,7 +1126,7 @@ namespace ICSharpCode.Decompiler.IL
 		protected internal override bool PerformMatch(ILInstruction other, ref Patterns.Match match)
 		{
 			var o = other as DynamicCompoundAssign;
-			return o != null && this.EvalMode == o.EvalMode && Target.PerformMatch(o.Target, ref match) && Value.PerformMatch(o.Value, ref match);
+			return o != null && this.EvalMode == o.EvalMode && this.TargetKind == o.TargetKind && Target.PerformMatch(o.Target, ref match) && Value.PerformMatch(o.Value, ref match);
 		}
 	}
 }
@@ -2709,7 +2709,7 @@ namespace ICSharpCode.Decompiler.IL
 namespace ICSharpCode.Decompiler.IL
 {
 	/// <summary>Serves as jump target for the nullable.unwrap instruction.
-	/// If the input evaluates normally, evaluates to the input value (wrapped in Nullable<T> if the input is a non-nullable value type).If a nullable.unwrap instruction encounters a null input and jumps to the (endpoint of the) nullable.rewrap instruction,the nullable.rewrap instruction evaluates to null.</summary>
+	/// If the input evaluates normally, evaluates to the input value (wrapped in Nullable&lt;T&gt; if the input is a non-nullable value type).If a nullable.unwrap instruction encounters a null input and jumps to the (endpoint of the) nullable.rewrap instruction,the nullable.rewrap instruction evaluates to null.</summary>
 	public sealed partial class NullableRewrap : UnaryInstruction
 	{
 		public NullableRewrap(ILInstruction argument) : base(OpCode.NullableRewrap, argument)
@@ -4905,7 +4905,7 @@ namespace ICSharpCode.Decompiler.IL
 }
 namespace ICSharpCode.Decompiler.IL
 {
-	/// <summary>Use of user-defined && or || operator.</summary>
+	/// <summary>Use of user-defined &amp;&amp; or || operator.</summary>
 	public sealed partial class UserDefinedLogicOperator : ILInstruction, IInstructionWithMethodOperand
 	{
 		public UserDefinedLogicOperator(IMethod method, ILInstruction left, ILInstruction right) : base(OpCode.UserDefinedLogicOperator)

ICSharpCode.Decompiler/IL/Instructions.tt

@@ -74,19 +74,23 @@
 			CustomClassName("NumericCompoundAssign"), BaseClass("CompoundAssignmentInstruction"), CustomConstructor, CustomComputeFlags,
 			MayThrow, HasTypeOperand, ResultType("type.GetStackType()"), CustomWriteTo,
 			MatchCondition("CheckForOverflow == o.CheckForOverflow && Sign == o.Sign && Operator == o.Operator"),
+			MatchCondition("this.EvalMode == o.EvalMode"),
+			MatchCondition("this.TargetKind == o.TargetKind"),
 			MatchCondition("Target.PerformMatch(o.Target, ref match)"),
 			MatchCondition("Value.PerformMatch(o.Value, ref match)")),
 		new OpCode("user.compound", "Common instruction for user-defined compound assignments.",
 			CustomClassName("UserDefinedCompoundAssign"), BaseClass("CompoundAssignmentInstruction"), CustomConstructor,
 			MayThrow, SideEffect, CustomWriteTo,
 			MatchCondition("this.Method.Equals(o.Method)"),
-			MatchCondition("this.CompoundAssignmentType == o.CompoundAssignmentType"),
+			MatchCondition("this.EvalMode == o.EvalMode"),
+			MatchCondition("this.TargetKind == o.TargetKind"),
 			MatchCondition("Target.PerformMatch(o.Target, ref match)"),
 			MatchCondition("Value.PerformMatch(o.Value, ref match)")),
 		new OpCode("dynamic.compound", "Common instruction for dynamic compound assignments.",
 			CustomClassName("DynamicCompoundAssign"), BaseClass("CompoundAssignmentInstruction"),
 			MayThrow, SideEffect, CustomWriteTo, CustomConstructor, ResultType("O"),
-			MatchCondition("this.CompoundAssignmentType == o.CompoundAssignmentType"),
+			MatchCondition("this.EvalMode == o.EvalMode"),
+			MatchCondition("this.TargetKind == o.TargetKind"),
 			MatchCondition("Target.PerformMatch(o.Target, ref match)"),
 			MatchCondition("Value.PerformMatch(o.Value, ref match)")),
 		new OpCode("bit.not", "Bitwise NOT", Unary, CustomConstructor, MatchCondition("IsLifted == o.IsLifted && UnderlyingResultType == o.UnderlyingResultType")),
@@ -189,7 +193,7 @@
 				+ "returns the managed reference unmodified (if the value is non-null).",
 			Unary, CustomConstructor, CustomWriteTo, HasFlag("InstructionFlags.MayUnwrapNull")),
 		new OpCode("nullable.rewrap", "Serves as jump target for the nullable.unwrap instruction." + Environment.NewLine
-				+ "If the input evaluates normally, evaluates to the input value (wrapped in Nullable<T> if the input is a non-nullable value type)."
+				+ "If the input evaluates normally, evaluates to the input value (wrapped in Nullable&lt;T&gt; if the input is a non-nullable value type)."
 				+ "If a nullable.unwrap instruction encounters a null input and jumps to the (endpoint of the) nullable.rewrap instruction,"
 				+ "the nullable.rewrap instruction evaluates to null.",
 			Unary, CustomComputeFlags),
@@ -281,7 +285,7 @@
 			CustomClassName("ExpressionTreeCast"), Unary, HasTypeOperand, MayThrow, CustomConstructor, CustomWriteTo, ResultType("type.GetStackType()"),
 			MatchCondition("this.IsChecked == o.IsChecked")),
 
-		new OpCode("user.logic.operator", "Use of user-defined && or || operator.",
+		new OpCode("user.logic.operator", "Use of user-defined &amp;&amp; or || operator.",
 			CustomClassName("UserDefinedLogicOperator"),
 			HasMethodOperand, ResultType("O"),
 			CustomChildren(new []{

ICSharpCode.Decompiler/IL/Instructions/IfInstruction.cs

@@ -30,7 +30,7 @@ namespace ICSharpCode.Decompiler.IL
 	/// 
 	/// IfInstruction is also used to represent logical operators:
 	///   "a || b" ==> if (a) (ldc.i4 1) else (b)
-	///   "a && b" ==> if (a) (b) else (ldc.i4 0)
+	///   "a && b" ==> if (a) (b) else (ldc.i4 0)
 	///   "a ? b : c" ==> if (a) (b) else (c)
 	/// </remarks>
 	partial class IfInstruction : ILInstruction

ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs

@@ -373,7 +373,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 		/// Determines whether a variable should be inlined in non-aggressive mode, even though it is not a generated variable.
 		/// </summary>
 		/// <param name="next">The next top-level expression</param>
-		/// <param name="loadInst">The load within 'next'</param>
+		/// <param name="v">The variable being eliminated by inlining.</param>
 		/// <param name="inlinedExpression">The expression being inlined</param>
 		static bool NonAggressiveInlineInto(ILInstruction next, FindResult findResult, ILInstruction inlinedExpression, ILVariable v)
 		{

ICSharpCode.Decompiler/IL/Transforms/LocalFunctionDecompiler.cs

@@ -57,8 +57,8 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 		}
 
 		/// <summary>
-		/// Newer Roslyn versions use the format "&ltcallerName&gtg__functionName|x_y"
-		/// Older versions use "&ltcallerName&gtg__functionNamex_y"
+		/// Newer Roslyn versions use the format "&lt;callerName&gt;g__functionName|x_y"
+		/// Older versions use "&lt;callerName&gt;g__functionNamex_y"
 		/// </summary>
 		static readonly Regex functionNameRegex = new Regex(@"^<(.*)>g__(.*)\|{0,1}\d+(_\d+)?$", RegexOptions.Compiled);
 

ICSharpCode.Decompiler/IL/Transforms/NullableLiftingTransform.cs

@@ -66,10 +66,10 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 
 		/// <summary>
 		/// VS2017.8 / Roslyn 2.9 started optimizing some cases of
-		///   "a.GetValueOrDefault() == b.GetValueOrDefault() && (a.HasValue & b.HasValue)"
+		///   "a.GetValueOrDefault() == b.GetValueOrDefault() &amp;&amp; (a.HasValue &amp; b.HasValue)"
 		/// to
-		///   "(a.GetValueOrDefault() == b.GetValueOrDefault()) & (a.HasValue & b.HasValue)"
-		/// so this secondary entry point analyses logic.and as-if it was a short-circuting &&.
+		///   "(a.GetValueOrDefault() == b.GetValueOrDefault()) &amp; (a.HasValue &amp; b.HasValue)"
+		/// so this secondary entry point analyses logic.and as-if it was a short-circuting &amp;&amp;.
 		/// </summary>
 		public bool Run(BinaryNumericInstruction bni)
 		{
@@ -85,7 +85,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 
 		public bool RunStatements(Block block, int pos)
 		{
-			/// e.g.:
+			// e.g.:
 			//  if (!condition) Block {
 			//    leave IL_0000 (default.value System.Nullable`1[[System.Int64]])
 			//  }
@@ -541,7 +541,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 		/// Performs nullable lifting.
 		/// 
 		/// Produces a lifted instruction with semantics equivalent to:
-		///   (v1 != null && ... && vn != null) ? trueInst : falseInst,
+		///   (v1 != null &amp;&amp; ... &amp;&amp; vn != null) ? trueInst : falseInst,
 		/// where the v1,...,vn are the <c>this.nullableVars</c>.
 		/// If lifting fails, returns <c>null</c>.
 		/// </summary>

ICSharpCode.Decompiler/IL/Transforms/Stepper.cs

@@ -25,7 +25,7 @@ using ICSharpCode.Decompiler.Util;
 namespace ICSharpCode.Decompiler.IL.Transforms
 {
 	/// <summary>
-	/// Exception thrown when an IL transform runs into the <see cref="Stepper.MaxStepCount"/> limit.
+	/// Exception thrown when an IL transform runs into the <see cref="Stepper.StepLimit"/>.
 	/// </summary>
 	public class StepLimitReachedException : Exception
 	{

ICSharpCode.Decompiler/TypeSystem/IParameter.cs

@@ -47,10 +47,10 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// Gets whether this parameter is a C# 'params' parameter.
 		/// </summary>
 		bool IsParams { get; }
-		
+
 		/// <summary>
 		/// Gets whether this parameter is optional.
-		/// The default value is given by the <see cref="IVariable.ConstantValue"/> property.
+		/// The default value is given by the <see cref="IVariable.GetConstantValue"/> function.
 		/// </summary>
 		bool IsOptional { get; }
 		

ICSharpCode.Decompiler/TypeSystem/ITypeParameter.cs

@@ -30,10 +30,10 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// </summary>
 		/// <returns>SymbolKind.TypeDefinition or SymbolKind.Method</returns>
 		SymbolKind OwnerType { get; }
-		
+
 		/// <summary>
 		/// Gets the owning method/class.
-		/// This property may return null (for example for the dummy type parameters used by <see cref="ParameterListComparer.NormalizeMethodTypeParameters"/>).
+		/// This property may return null (for example for the dummy type parameters used by <see cref="NormalizeTypeVisitor.ReplaceMethodTypeParametersWithDummy"/>).
 		/// </summary>
 		/// <remarks>
 		/// For "class Outer&lt;T&gt; { class Inner {} }",

ICSharpCode.Decompiler/TypeSystem/Implementation/ThreeState.cs

@@ -19,7 +19,7 @@
 namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 {
 	/// <summary>
-	/// Constants used instead of <see cref="bool?"/> 
+	/// Constants used instead of <c>bool?</c>
 	/// in multithreaded code, as <c>bool?</c> might produce torn reads.
 	/// </summary>
 	static class ThreeState

ICSharpCode.Decompiler/TypeSystem/TypeKind.cs

@@ -41,7 +41,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		Enum,
 		
 		/// <summary>The <c>System.Void</c> type.</summary>
-		/// <see cref="KnownTypeReference.Void"/>
+		/// <see cref="KnownTypeCode.Void"/>
 		Void,
 
 		/// <summary>Type used for invalid expressions and for types whose definition could not be found.</summary>
@@ -58,7 +58,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		Dynamic,
 		/// <summary>Represents missing type arguments in partially parameterized types.</summary>
 		/// <see cref="SpecialType.UnboundTypeArgument"/>
-		/// <see cref="IType.GetNestedTypes(Predicate{ITypeDefinition}, GetMemberOptions)"/>
+		/// <see cref="IType">IType.GetNestedTypes(Predicate{ITypeDefinition}, GetMemberOptions)</see>
 		UnboundTypeArgument,
 		
 		/// <summary>The type is a type parameter.</summary>
@@ -74,9 +74,6 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// <summary>A managed reference type</summary>
 		/// <see cref="ByReferenceType"/>
 		ByReference,
-		/// <summary>An anonymous type</summary>
-		/// <see cref="AnonymousType"/>
-		Anonymous,
 		
 		/// <summary>Intersection of several types</summary>
 		/// <see cref="IntersectionType"/>

ICSharpCode.Decompiler/TypeSystem/TypeSystemExtensions.cs

@@ -384,9 +384,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// (if the given <paramref name="entity"/> in an <c>override</c>)
 		/// should be returned.
 		/// </param>
-		public static bool HasAttribute(this IEntity entity, KnownAttribute attrType, bool inherit=false)
+		public static bool HasAttribute(this IEntity entity, KnownAttribute attributeType, bool inherit=false)
 		{
-			return GetAttribute(entity, attrType, inherit) != null;
+			return GetAttribute(entity, attributeType, inherit) != null;
 		}
 
 		/// <summary>
@@ -445,9 +445,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// </summary>
 		/// <param name="parameter">The parameter on which the attributes are declared.</param>
 		/// <param name="attributeType">The attribute type to look for.</param>
-		public static bool HasAttribute(this IParameter parameter, KnownAttribute attrType)
+		public static bool HasAttribute(this IParameter parameter, KnownAttribute attributeType)
 		{
-			return GetAttribute(parameter, attrType) != null;
+			return GetAttribute(parameter, attributeType) != null;
 		}
 
 		/// <summary>