R# remove redundant

Author: GrahamTheCoder

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -144,9 +144,6 @@ private CSharpSyntaxNode InterpolatedString(SyntaxList<InterpolatedStringContent
             .WithArgumentList(ExpressionSyntaxExtensions.CreateArgList(interpolatedString));
     }
 
-    private static InterpolatedStringTextSyntax InterpolatedStringText(string text) =>
-        SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(SyntaxFactory.TriviaList(), SyntaxKind.InterpolatedStringTextToken, text, text, SyntaxFactory.TriviaList()));
-
     public override async Task<CSharpSyntaxNode> VisitXmlString(VBasic.Syntax.XmlStringSyntax node) =>
         CommonConversions.Literal(node.TextTokens.Aggregate("", (a, b) => a + LiteralConversions.EscapeVerbatimQuotes(b.Text)));
 

CodeConverter/CSharp/MethodInfoExtensions.cs

@@ -24,7 +24,7 @@ private static Func<TDesiredTarget, TDesiredReturn> CreateWeaklyTypedDelegateFor
 
     {
         var func = method.CreateOpenDelegate<Func<TTarget, TReturn>>();
-        return (TDesiredTarget target) => target is TTarget tt ? (TDesiredReturn)(object)func(tt) : default;
+        return target => target is TTarget tt ? (TDesiredReturn)func(tt) : default;
     }
 
     /// <summary>
@@ -38,7 +38,7 @@ private static Func<TDesiredTarget, TDesiredParam, TDesiredReturn> CreateWeaklyT
     {
         var paramIsReferenceType = default(TParam) == null;
         var func = method.CreateOpenDelegate<Func<TTarget, TParam, TReturn>>();
-        return (TDesiredTarget target, TDesiredParam param) => {
+        return (target, param) => {
             var desiredParam = paramIsReferenceType ? param is TParam p ? p : default : (TParam)(object)param;
             return target is TTarget desiredTarget ? (TDesiredReturn)(object)func(desiredTarget, desiredParam) : default;
         };

CodeConverter/CSharp/VisualBasicEqualityComparison.cs

@@ -204,7 +204,7 @@ private static ExpressionSyntax NegateIfNeeded(VBSyntax.BinaryExpressionSyntax n
     {
         return node.IsKind(VBasic.SyntaxKind.NotEqualsExpression)
             ? Negate(positiveExpression)
-            : (ExpressionSyntax)positiveExpression;
+            : positiveExpression;
     }
 
     private static PrefixUnaryExpressionSyntax Negate(InvocationExpressionSyntax positiveExpression)
@@ -238,7 +238,7 @@ public ExpressionSyntax GetFullExpressionForVbObjectComparison(ExpressionSyntax
         var compareObject = SyntaxFactory.InvocationExpression(ValidSyntaxFactory.MemberAccess(nameof(Operators), nameof(Operators.ConditionalCompareObjectEqual)),
             SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[]
                 {SyntaxFactory.Argument(lhs), SyntaxFactory.Argument(rhs), optionCompareTextCaseInsensitive})));
-        return negate ? (ExpressionSyntax)Negate(compareObject) : compareObject;
+        return negate ? Negate(compareObject) : compareObject;
     }
 
     private static BinaryExpressionSyntax GetCompareTextCaseInsensitiveCompareOptions()

CodeConverter/Shared/DocumentExtensions.cs

@@ -13,7 +13,7 @@ public static async Task<Document> SimplifyStatementsAsync<TUsingDirectiveSyntax
     {
         Func<SyntaxNode, bool> wouldBeSimplifiedIncorrectly =
             convertedDocument.Project.Language == LanguageNames.VisualBasic
-                ? (Func<SyntaxNode, bool>) VbWouldBeSimplifiedIncorrectly
+                ? VbWouldBeSimplifiedIncorrectly
                 : CsWouldBeSimplifiedIncorrectly;
         var originalRoot = await convertedDocument.GetSyntaxRootAsync();
         var nodesWithUnresolvedTypes = (await convertedDocument.GetSemanticModelAsync()).GetDiagnostics()

CodeConverter/Shared/TextConversionOptions.cs

@@ -2,13 +2,10 @@
 
 public class TextConversionOptions : SingleConversionOptions
 {
-    private readonly ConversionOptions _conversionOptions;
-
     public TextConversionOptions(IReadOnlyCollection<PortableExecutableReference> references, string sourceFilePath = null)
     {
         References = references;
         SourceFilePath = sourceFilePath;
-        _conversionOptions = new ConversionOptions();
     }
 
     public IReadOnlyCollection<PortableExecutableReference> References { get; }

CodeConverter/Util/ExpressionSyntaxExtensions.cs

@@ -12,7 +12,7 @@ public static ArgumentListSyntax CreateArgList(params ExpressionSyntax[] args)
 
     public static VBSyntax.ArgumentListSyntax CreateArgList<T>(params T[] args) where T : VBSyntax.ExpressionSyntax
     {
-        return CreateVbArgList((IEnumerable<T>) args);
+        return CreateVbArgList(args);
     }
 
     public static VBSyntax.ArgumentListSyntax CreateVbArgList<T>(this IEnumerable<T> argExpressions) where T : VBSyntax.ExpressionSyntax

CodeConverter/Util/SyntaxTriviaExtensions.cs

@@ -31,7 +31,7 @@ internal static class SyntaxTriviaExtensions
 
     public static CS.SyntaxKind? GetCSKind(this SyntaxTrivia t)
     {
-        return VBToCSSyntaxKinds.TryGetValue(VBasic.VisualBasicExtensions.Kind(t), out var csKind) ? csKind : (CS.SyntaxKind?)null;
+        return VBToCSSyntaxKinds.TryGetValue(VBasic.VisualBasicExtensions.Kind(t), out var csKind) ? csKind : null;
     }
 
     /// <remarks>Good candidate for unit testing to catch newline issues hidden by the test harness</remarks>