Use target typed new

GrahamTheCoder · GrahamTheCoder · commit d5ea247f28e3 · 2022-04-05T02:20:43.000+01:00
diff --git a/CodeConverter/CSharp/AdditionalInitializers.cs b/CodeConverter/CSharp/AdditionalInitializers.cs
@@ -29,8 +29,8 @@ public AdditionalInitializers(VBSyntax.TypeBlockSyntax typeSyntax, INamedTypeSym
     public bool IsBestPartToAddTypeInit { get; }
     public IMethodSymbol DesignerGeneratedInitializeComponentOrNull { get; }
 
-    public List<Assignment> AdditionalStaticInitializers { get; } = new List<Assignment>();
-    public List<Assignment> AdditionalInstanceInitializers { get; } = new List<Assignment>();
+    public List<Assignment> AdditionalStaticInitializers { get; } = new();
+    public List<Assignment> AdditionalInstanceInitializers { get; } = new();
 
     public IReadOnlyCollection<MemberDeclarationSyntax> WithAdditionalInitializers(List<MemberDeclarationSyntax> convertedMembers, SyntaxToken parentTypeName)
     {
diff --git a/CodeConverter/CSharp/CommonConversions.cs b/CodeConverter/CSharp/CommonConversions.cs
@@ -134,7 +134,7 @@ public bool ShouldPreferExplicitType(VBSyntax.ExpressionSyntax exp,
             if (isField && !declaredSymbol.IsStatic && !SemanticModel.IsDefinitelyStatic(vbName, vbInitValue)) {
                 if (!_typeContext.Initializers.HasInstanceConstructorsOutsideThisPart) {
                     var lhs = SyntaxFactory.IdentifierName(ConvertIdentifier(vbName.Identifier, sourceTriviaMapKind: SourceTriviaMapKind.None));
-                    _typeContext.Initializers.AdditionalInstanceInitializers.Add(new(lhs, CSSyntaxKind.SimpleAssignmentExpression, adjustedInitializerExpr));
+                    _typeContext.Initializers.AdditionalInstanceInitializers.Add(new Assignment(lhs, CSSyntaxKind.SimpleAssignmentExpression, adjustedInitializerExpr));
                     equalsValueClauseSyntax = null;
                 } else {
                     var returnBlock = SyntaxFactory.Block(SyntaxFactory.ReturnStatement(adjustedInitializerExpr));
diff --git a/CodeConverter/CSharp/DeclarationNodeVisitor.cs b/CodeConverter/CSharp/DeclarationNodeVisitor.cs
@@ -24,11 +24,11 @@ internal class DeclarationNodeVisitor : VBasic.VisualBasicSyntaxVisitor<Task<CSh
     private readonly ILookup<ITypeSymbol, ITypeSymbol> _typeToInheritors;
     private readonly Compilation _vbCompilation;
     private readonly SemanticModel _semanticModel;
-    private readonly HashSet<string> _generatedNames = new HashSet<string>();
-    private readonly Dictionary<VBSyntax.StatementSyntax, MemberDeclarationSyntax[]> _additionalDeclarations = new Dictionary<VBSyntax.StatementSyntax, MemberDeclarationSyntax[]>();
-    private readonly TypeContext _typeContext = new TypeContext();
+    private readonly HashSet<string> _generatedNames = new();
+    private readonly Dictionary<VBSyntax.StatementSyntax, MemberDeclarationSyntax[]> _additionalDeclarations = new();
+    private readonly TypeContext _typeContext = new();
     private uint _failedMemberConversionMarkerCount;
-    private readonly HashSet<string> _extraUsingDirectives = new HashSet<string>();
+    private readonly HashSet<string> _extraUsingDirectives = new();
     private readonly XmlImportContext _xmlImportContext;
     private readonly VisualBasicEqualityComparison _visualBasicEqualityComparison;
     private HashSet<string> _accessedThroughMyClass;
@@ -274,7 +274,7 @@ private Assignment CreateInitializer((VBSyntax.ModifiedIdentifierSyntax n, VBSyn
         var csId = CommonConversions.ConvertIdentifier(f.n.Identifier);
         string initializerFunctionName = CommonConversions.GetInitialValueFunctionName(f.n);
         var invocation = SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(CommonConversions.CsEscapedIdentifier(initializerFunctionName)), SyntaxFactory.ArgumentList());
-        return new(SyntaxFactory.IdentifierName(csId), CSSyntaxKind.SimpleAssignmentExpression, invocation);
+        return new Assignment(SyntaxFactory.IdentifierName(csId), CSSyntaxKind.SimpleAssignmentExpression, invocation);
     }
 
     private MemberDeclarationSyntax[] GetAdditionalDeclarations(VBSyntax.StatementSyntax member)
@@ -554,7 +554,7 @@ private IEnumerable<MemberDeclarationSyntax> CreateWithEventsMembers(SyntaxToken
             ? initializerState.AdditionalStaticInitializers
             : initializerState.AdditionalInstanceInitializers;
         foreach (var initializer in initializers) {
-            initializerCollection.Add(new(SyntaxFactory.IdentifierName(initializer.Key), CSSyntaxKind.SimpleAssignmentExpression, initializer.Value.Value));
+            initializerCollection.Add(new Assignment(SyntaxFactory.IdentifierName(initializer.Key), CSSyntaxKind.SimpleAssignmentExpression, initializer.Value.Value));
         }
 
         var fieldDecls = _typeContext.HandledEventsAnalysis.GetDeclarationsForFieldBackedProperty(fieldDecl,
@@ -615,7 +615,7 @@ private IReadOnlyCollection<MemberDeclarationSyntax> CreateExtraMethodMembers()
         var newMethodNames = methodsInfos.ToDictionary(l => l.Id, l => l.Prefix);
         for (int i = 0; i < _typeContext.Initializers.AdditionalInstanceInitializers.Count; i++) {
             var (a, b, initializer, _) = _typeContext.Initializers.AdditionalInstanceInitializers[i];
-            _typeContext.Initializers.AdditionalInstanceInitializers[i] = new(a, b, PerScopeState.ReplaceNames(initializer, newMethodNames));
+            _typeContext.Initializers.AdditionalInstanceInitializers[i] = new Assignment(a, b, PerScopeState.ReplaceNames(initializer, newMethodNames));
         }
 
         return methodsInfos
diff --git a/CodeConverter/CSharp/KnownMethod.cs b/CodeConverter/CSharp/KnownMethod.cs
@@ -23,7 +23,7 @@ public override int GetHashCode() =>
         (Import, TypeName, MethodName).GetHashCode();
 
     public static implicit operator KnownMethod((string import, string typeName, string methodName) value) =>
-        new KnownMethod(value.import, value.typeName, value.methodName);
+        new(value.import, value.typeName, value.methodName);
 
     public ExpressionSyntax Invoke(HashSet<string> extraUsingDirectives, params ExpressionSyntax[] args)
     {
diff --git a/CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs b/CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs
@@ -20,7 +20,7 @@ internal class MethodBodyExecutableStatementVisitor : VBasic.VisualBasicSyntaxVi
     private readonly Stack<ExpressionSyntax> _withBlockLhs;
     private readonly HashSet<string> _extraUsingDirectives;
     private readonly HandledEventsAnalysis _handledEventsAnalysis;
-    private readonly HashSet<string> _generatedNames = new HashSet<string>();
+    private readonly HashSet<string> _generatedNames = new();
     private readonly INamedTypeSymbol _vbBooleanTypeSymbol;
     private readonly HashSet<ILocalSymbol> _localsToInlineInLoop;
     private PerScopeState _perScopeState;
diff --git a/CodeConverter/CSharp/PerScopeState.cs b/CodeConverter/CSharp/PerScopeState.cs
@@ -12,7 +12,7 @@ public record ScopeState(List<IHoistedNode> HoistedNodes, VBasic.SyntaxKind Exit
         public IEnumerable<T> OfType<T>() => HoistedNodes.OfType<T>();
     }
 
-    public static SyntaxAnnotation AdditionalLocalAnnotation = new SyntaxAnnotation("CodeConverter.AdditionalLocal");
+    public static SyntaxAnnotation AdditionalLocalAnnotation = new("CodeConverter.AdditionalLocal");
 
     private readonly Stack<ScopeState> _hoistedNodesPerScope;
 
diff --git a/CodeConverter/CSharp/QueryConverter.cs b/CodeConverter/CSharp/QueryConverter.cs
@@ -11,7 +11,7 @@ internal class QueryConverter
 {
     private readonly CommentConvertingVisitorWrapper _triviaConvertingVisitor;
     private readonly SemanticModel _semanticModel;
-    private static readonly SyntaxAnnotation DefaultSelectAnnotation = new SyntaxAnnotation("DefaultSelect");
+    private static readonly SyntaxAnnotation DefaultSelectAnnotation = new("DefaultSelect");
 
     public QueryConverter(CommonConversions commonConversions, SemanticModel semanticModel, CommentConvertingVisitorWrapper triviaConvertingExpressionVisitor)
     {
diff --git a/CodeConverter/CSharp/TypeContext.cs b/CodeConverter/CSharp/TypeContext.cs
@@ -2,12 +2,12 @@
 
 internal class TypeContext : ITypeContext
 {
-    private readonly Stack<(AdditionalInitializers Initializers, HandledEventsAnalysis Methods)> _contextStack = new Stack<(AdditionalInitializers Initializers, HandledEventsAnalysis Methods)>();
+    private readonly Stack<(AdditionalInitializers Initializers, HandledEventsAnalysis Methods)> _contextStack = new();
 
     public AdditionalInitializers Initializers => _contextStack.Peek().Initializers;
     public HandledEventsAnalysis HandledEventsAnalysis => _contextStack.Peek().Methods;
 
-    public PerScopeState PerScopeState { get; internal set; } = new PerScopeState();
+    public PerScopeState PerScopeState { get; internal set; } = new();
 
     public void Push(HandledEventsAnalysis methodWithHandles, AdditionalInitializers additionalInitializers)
     {
diff --git a/CodeConverter/CSharp/XmlImportContext.cs b/CodeConverter/CSharp/XmlImportContext.cs
@@ -7,7 +7,7 @@ namespace ICSharpCode.CodeConverter.CSharp;
 
 internal class XmlImportContext
 {
-    private readonly List<FieldDeclarationSyntax> _xNamespaceFields = new List<FieldDeclarationSyntax>();
+    private readonly List<FieldDeclarationSyntax> _xNamespaceFields = new();
     public IdentifierNameSyntax HelperClassUniqueIdentifierName { get; }
     public IdentifierNameSyntax HelperClassShortIdentifierName => SyntaxFactory.IdentifierName("XmlImports");
 
diff --git a/CodeConverter/CodeWithOptions.cs b/CodeConverter/CodeWithOptions.cs
@@ -2,7 +2,7 @@
 
 public class CodeWithOptions
 {
-    private static readonly HashSet<Type> _typesToFindAssemblyReferencesFrom = new HashSet<Type> {
+    private static readonly HashSet<Type> _typesToFindAssemblyReferencesFrom = new() {
         typeof(System.Text.Encoding),
         typeof(System.ComponentModel.DefaultValueAttribute),
         typeof(System.Dynamic.DynamicObject),
diff --git a/CodeConverter/Shared/CSharpCompiler.cs b/CodeConverter/Shared/CSharpCompiler.cs
@@ -5,7 +5,7 @@ namespace ICSharpCode.CodeConverter.Shared;
 
 internal class CSharpCompiler : ICompiler
 {
-    private static readonly Lazy<CSharpCompilation> LazyCSharpCompilation = new Lazy<CSharpCompilation>(CreateCSharpCompilation);
+    private static readonly Lazy<CSharpCompilation> LazyCSharpCompilation = new(CreateCSharpCompilation);
 
     public SyntaxTree CreateTree(string text)
     {
@@ -33,5 +33,5 @@ public static CSharpCompilationOptions CreateCompilationOptions()
         return new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true);
     }
 
-    public static CSharpParseOptions ParseOptions { get; } = new CSharpParseOptions(LanguageVersion.Latest);
+    public static CSharpParseOptions ParseOptions { get; } = new(LanguageVersion.Latest);
 }
diff --git a/CodeConverter/Shared/DefaultReferences.cs b/CodeConverter/Shared/DefaultReferences.cs
@@ -34,7 +34,7 @@ public static class DefaultReferences
         new[] { Assembly.Load("System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a") }
     ).ToArray();
 
-    private static readonly Dictionary<string, (string Location, string[] ReferenceNames)> _assemblyInfoCache = new Dictionary<string, (string Location, string[] ReferenceNames)>();
+    private static readonly Dictionary<string, (string Location, string[] ReferenceNames)> _assemblyInfoCache = new();
 
     public static IReadOnlyCollection<PortableExecutableReference> NetStandard2 { get; } =
         With(Enumerable.Empty<Assembly>()).ToArray();
diff --git a/CodeConverter/Shared/LineTriviaMapper.cs b/CodeConverter/Shared/LineTriviaMapper.cs
@@ -12,9 +12,9 @@ internal class LineTriviaMapper
     private readonly TextLineCollection _targetLines;
     private readonly IReadOnlyDictionary<int, TextLine> _targetLeadingTextLineFromSourceLine;
     private readonly IReadOnlyDictionary<int, TextLine> _targetTrailingTextLineFromSourceLine;
-    private readonly List<SyntaxTriviaList> _leadingTriviaCarriedOver = new List<SyntaxTriviaList>();
-    private readonly List<SyntaxTriviaList> _trailingTriviaCarriedOver = new List<SyntaxTriviaList>();
-    private readonly Dictionary<SyntaxToken, (List<IReadOnlyCollection<SyntaxTrivia>> Leading, List<IReadOnlyCollection<SyntaxTrivia>> Trailing)> _targetTokenToTrivia = new Dictionary<SyntaxToken, (List<IReadOnlyCollection<SyntaxTrivia>>, List<IReadOnlyCollection<SyntaxTrivia>>)>();
+    private readonly List<SyntaxTriviaList> _leadingTriviaCarriedOver = new();
+    private readonly List<SyntaxTriviaList> _trailingTriviaCarriedOver = new();
+    private readonly Dictionary<SyntaxToken, (List<IReadOnlyCollection<SyntaxTrivia>> Leading, List<IReadOnlyCollection<SyntaxTrivia>> Trailing)> _targetTokenToTrivia = new();
 
     private LineTriviaMapper(SyntaxNode source, TextLineCollection sourceLines, SyntaxNode target, TextLineCollection targetLines, Dictionary<int, TextLine> targetLeadingTextLineFromSourceLine, Dictionary<int, TextLine> targetTrailingTextLineFromSourceLine)
     {
diff --git a/CodeConverter/Shared/RoslynCrashPreventer.cs b/CodeConverter/Shared/RoslynCrashPreventer.cs
@@ -4,8 +4,8 @@ namespace ICSharpCode.CodeConverter.Shared;
 
 internal static class RoslynCrashPreventer
 {
-    private static readonly DelegatingHandler _codeAnalysisHandler= new DelegatingHandler(typeof(Compilation).Assembly, "Microsoft.CodeAnalysis.FatalError");
-    private static readonly DelegatingHandler _errorReportingHandler = new DelegatingHandler(typeof(WorkspaceDiagnostic).Assembly, "Microsoft.CodeAnalysis.ErrorReporting.FatalError");
+    private static readonly DelegatingHandler _codeAnalysisHandler= new(typeof(Compilation).Assembly, "Microsoft.CodeAnalysis.FatalError");
+    private static readonly DelegatingHandler _errorReportingHandler = new(typeof(WorkspaceDiagnostic).Assembly, "Microsoft.CodeAnalysis.ErrorReporting.FatalError");
     private static volatile int _currentUses;
 
     /// <summary>
@@ -31,7 +31,7 @@ private class DelegatingHandler
     {
         private readonly Assembly _assembly;
         private readonly string _containingType;
-        private readonly object _exchangeLock = new object();
+        private readonly object _exchangeLock = new();
         private Action<Exception> _originalHandler;
 
         public DelegatingHandler(Assembly assembly, string containingType)
diff --git a/CodeConverter/Shared/SingleConversionOptions.cs b/CodeConverter/Shared/SingleConversionOptions.cs
@@ -4,6 +4,6 @@ namespace ICSharpCode.CodeConverter.Shared;
 
 public class SingleConversionOptions : ConversionOptions
 {
-    public TextSpan SelectedTextSpan { get; set; } = new TextSpan();
+    public TextSpan SelectedTextSpan { get; set; } = new();
     internal bool ShowCompilationErrors { get; set; }
 }
diff --git a/CodeConverter/Shared/TriviaKinds.cs b/CodeConverter/Shared/TriviaKinds.cs
@@ -2,9 +2,9 @@
 
 internal sealed class TriviaKinds
 {
-    public static TriviaKinds All = new TriviaKinds(_ => true);
-    public static TriviaKinds ImportantOnly = new TriviaKinds(t => !t.IsWhitespaceOrEndOfLine());
-    public static TriviaKinds FormattingOnly = new TriviaKinds(t => t.IsWhitespaceOrEndOfLine());
+    public static TriviaKinds All = new(_ => true);
+    public static TriviaKinds ImportantOnly = new(t => !t.IsWhitespaceOrEndOfLine());
+    public static TriviaKinds FormattingOnly = new(t => t.IsWhitespaceOrEndOfLine());
     public Func<SyntaxTrivia, bool> ShouldAccept { get; }
 
     private TriviaKinds(Func<SyntaxTrivia, bool> shouldAccept)
diff --git a/CodeConverter/Util/FromRoslyn/INamespaceOrTypeSymbolExtensions.cs b/CodeConverter/Util/FromRoslyn/INamespaceOrTypeSymbolExtensions.cs
@@ -10,8 +10,7 @@ namespace ICSharpCode.CodeConverter.Util.FromRoslyn;
 
 internal static partial class INamespaceOrTypeSymbolExtensions
 {
-    private static readonly ConditionalWeakTable<INamespaceOrTypeSymbol, List<string>> s_namespaceOrTypeToNameMap =
-        new ConditionalWeakTable<INamespaceOrTypeSymbol, List<string>>();
+    private static readonly ConditionalWeakTable<INamespaceOrTypeSymbol, List<string>> s_namespaceOrTypeToNameMap = new();
     public static readonly ConditionalWeakTable<INamespaceOrTypeSymbol, List<string>>.CreateValueCallback s_getNamePartsCallBack =
         namespaceSymbol =>
         {
@@ -20,7 +19,7 @@ internal static partial class INamespaceOrTypeSymbolExtensions
             return result;
         };
 
-    private static readonly SymbolDisplayFormat s_shortNameFormat = new SymbolDisplayFormat(
+    private static readonly SymbolDisplayFormat s_shortNameFormat = new(
         miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes | SymbolDisplayMiscellaneousOptions.ExpandNullable);
 
     public static string GetShortName(this INamespaceOrTypeSymbol symbol)
diff --git a/CodeConverter/Util/FromRoslyn/SpecializedCollections.cs b/CodeConverter/Util/FromRoslyn/SpecializedCollections.cs
@@ -265,7 +265,7 @@ public void Dispose()
 
         internal class List<T> : Collection<T>, IList<T>, IReadOnlyList<T>
         {
-            public static readonly new List<T> Instance = new List<T>();
+            public static readonly new List<T> Instance = new();
 
             protected List()
             {
diff --git a/CodeConverter/Util/FromRoslyn/SymbolEquivalenceComparer.cs b/CodeConverter/Util/FromRoslyn/SymbolEquivalenceComparer.cs
@@ -41,8 +41,8 @@ internal partial class SymbolEquivalenceComparer :
     private readonly ImmutableArray<EquivalenceVisitor> _equivalenceVisitors;
     private readonly ImmutableArray<GetHashCodeVisitor> _getHashCodeVisitors;
 
-    public static readonly SymbolEquivalenceComparer Instance = new SymbolEquivalenceComparer(SimpleNameAssemblyComparer.Instance, distinguishRefFromOut: false);
-    public static readonly SymbolEquivalenceComparer IgnoreAssembliesInstance = new SymbolEquivalenceComparer(assemblyComparerOpt: null, distinguishRefFromOut: false);
+    public static readonly SymbolEquivalenceComparer Instance = new(SimpleNameAssemblyComparer.Instance, distinguishRefFromOut: false);
+    public static readonly SymbolEquivalenceComparer IgnoreAssembliesInstance = new(assemblyComparerOpt: null, distinguishRefFromOut: false);
 
     private readonly IEqualityComparer<IAssemblySymbol> _assemblyComparerOpt;
 
diff --git a/CodeConverter/Util/SyntaxTriviaExtensions.cs b/CodeConverter/Util/SyntaxTriviaExtensions.cs
@@ -5,7 +5,7 @@ namespace ICSharpCode.CodeConverter.Util;
 
 internal static class SyntaxTriviaExtensions
 {
-    private static readonly Dictionary<VBasic.SyntaxKind, CS.SyntaxKind> VBToCSSyntaxKinds = new Dictionary<VBasic.SyntaxKind, CS.SyntaxKind> {
+    private static readonly Dictionary<VBasic.SyntaxKind, CS.SyntaxKind> VBToCSSyntaxKinds = new() {
         {VBasic.SyntaxKind.SkippedTokensTrivia, CS.SyntaxKind.SkippedTokensTrivia},
         {VBasic.SyntaxKind.DisabledTextTrivia, CS.SyntaxKind.DisabledTextTrivia},
         {VBasic.SyntaxKind.ConstDirectiveTrivia, CS.SyntaxKind.DefineDirectiveTrivia}, // Just a guess
diff --git a/CodeConverter/VB/CSharpHelperMethodDefinition.CSharpHelperMethodDefinition.cs b/CodeConverter/VB/CSharpHelperMethodDefinition.CSharpHelperMethodDefinition.cs
@@ -25,8 +25,8 @@ Throw e
 End Function";
 
     private static readonly ICompiler Compiler = new VisualBasicCompiler();
-    private List<INamedTypeSymbol> AssignMethodTypeSymbols { get; } = new List<INamedTypeSymbol>();
-    private List<INamedTypeSymbol> ThrowMethodTypeSymbols { get; } = new List<INamedTypeSymbol>();
+    private List<INamedTypeSymbol> AssignMethodTypeSymbols { get; } = new();
+    private List<INamedTypeSymbol> ThrowMethodTypeSymbols { get; } = new();
 
     public void AddAssignMethod(INamedTypeSymbol symbol) {
         if(AssignMethodTypeSymbols.Contains(symbol))
diff --git a/CodeConverter/VB/MethodBodyExecutableStatementVisitor.cs b/CodeConverter/VB/MethodBodyExecutableStatementVisitor.cs
@@ -18,13 +18,13 @@ internal class MethodBodyExecutableStatementVisitor : CS.CSharpSyntaxVisitor<Syn
     private SemanticModel _semanticModel;
     private readonly CommentConvertingVisitorWrapper<VisualBasicSyntaxNode> _nodesVisitor;
     private readonly CommonConversions _commonConversions;
-    private readonly Stack<BlockInfo> _blockInfo = new Stack<BlockInfo>(); // currently only works with switch blocks
+    private readonly Stack<BlockInfo> _blockInfo = new(); // currently only works with switch blocks
     private int _switchCount = 0;
     public bool IsIterator { get; private set; }
 
     private class BlockInfo
     {
-        public readonly List<VisualBasicSyntaxNode> GotoCaseExpressions = new List<VisualBasicSyntaxNode>();
+        public readonly List<VisualBasicSyntaxNode> GotoCaseExpressions = new();
     }
     public CommentConvertingMethodBodyVisitor CommentConvertingVisitor { get; }
 
diff --git a/CodeConverter/VB/NodesVisitor.cs b/CodeConverter/VB/NodesVisitor.cs
@@ -40,11 +40,11 @@ internal class NodesVisitor : CS.CSharpSyntaxVisitor<VisualBasicSyntaxNode>
     private readonly SemanticModel _semanticModel;
     private readonly VisualBasicCompilation _vbViewOfCsSymbols;
     private readonly SyntaxGenerator _vbSyntaxGenerator;
-    private readonly List<CSSyntax.UsingDirectiveSyntax> _importsToConvert = new List<CSSyntax.UsingDirectiveSyntax>();
-    private readonly HashSet<string> _extraImports = new HashSet<string>();
+    private readonly List<CSSyntax.UsingDirectiveSyntax> _importsToConvert = new();
+    private readonly HashSet<string> _extraImports = new();
     private readonly CSharpHelperMethodDefinition _cSharpHelperMethodDefinition;
     private readonly CommonConversions _commonConversions;
-    private readonly HashSet<string> _addedNames = new HashSet<string>();
+    private readonly HashSet<string> _addedNames = new();
 
     private int _placeholder = 1;
     public CommentConvertingVisitorWrapper<VisualBasicSyntaxNode> TriviaConvertingVisitor { get; }
diff --git a/Tests/TestRunners/MultiFileTestFixture.cs b/Tests/TestRunners/MultiFileTestFixture.cs
diff --git a/Tests/TestRunners/TestFileRewriter.cs b/Tests/TestRunners/TestFileRewriter.cs
diff --git a/Vsix/Cancellation.cs b/Vsix/Cancellation.cs
diff --git a/Vsix/CodeConverterPackage.cs b/Vsix/CodeConverterPackage.cs
diff --git a/Vsix/ConvertCSToVBCommand.cs b/Vsix/ConvertCSToVBCommand.cs
diff --git a/Vsix/ConvertVBToCSCommand.cs b/Vsix/ConvertVBToCSCommand.cs
diff --git a/Vsix/OutputWindow.cs b/Vsix/OutputWindow.cs
diff --git a/Vsix/PasteAsCS.cs b/Vsix/PasteAsCS.cs
diff --git a/Vsix/PasteAsVB.cs b/Vsix/PasteAsVB.cs
diff --git a/Vsix/VisualStudioInteraction.cs b/Vsix/VisualStudioInteraction.cs

Original file line number	Diff line number	Diff line change
`@@ -29,8 +29,8 @@ public AdditionalInitializers(VBSyntax.TypeBlockSyntax typeSyntax, INamedTypeSym`
`29`	`29`	`public bool IsBestPartToAddTypeInit { get; }`
`30`	`30`	`public IMethodSymbol DesignerGeneratedInitializeComponentOrNull { get; }`
`31`	`31`
`32`		`- public List<Assignment> AdditionalStaticInitializers { get; } = new List<Assignment>();`
`33`		`- public List<Assignment> AdditionalInstanceInitializers { get; } = new List<Assignment>();`
	`32`	`+ public List<Assignment> AdditionalStaticInitializers { get; } = new();`
	`33`	`+ public List<Assignment> AdditionalInstanceInitializers { get; } = new();`
`34`	`34`
`35`	`35`	`public IReadOnlyCollection<MemberDeclarationSyntax> WithAdditionalInitializers(List<MemberDeclarationSyntax> convertedMembers, SyntaxToken parentTypeName)`
`36`	`36`	`{`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public override int GetHashCode() =>`
`23`	`23`	`(Import, TypeName, MethodName).GetHashCode();`
`24`	`24`
`25`	`25`	`public static implicit operator KnownMethod((string import, string typeName, string methodName) value) =>`
`26`		`- new KnownMethod(value.import, value.typeName, value.methodName);`
	`26`	`+ new(value.import, value.typeName, value.methodName);`
`27`	`27`
`28`	`28`	`public ExpressionSyntax Invoke(HashSet<string> extraUsingDirectives, params ExpressionSyntax[] args)`
`29`	`29`	`{`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public record ScopeState(List<IHoistedNode> HoistedNodes, VBasic.SyntaxKind Exit`
`12`	`12`	`public IEnumerable<T> OfType<T>() => HoistedNodes.OfType<T>();`
`13`	`13`	`}`
`14`	`14`
`15`		`- public static SyntaxAnnotation AdditionalLocalAnnotation = new SyntaxAnnotation("CodeConverter.AdditionalLocal");`
	`15`	`+ public static SyntaxAnnotation AdditionalLocalAnnotation = new("CodeConverter.AdditionalLocal");`
`16`	`16`
`17`	`17`	`private readonly Stack<ScopeState> _hoistedNodesPerScope;`
`18`	`18`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ internal class QueryConverter`
`11`	`11`	`{`
`12`	`12`	`private readonly CommentConvertingVisitorWrapper _triviaConvertingVisitor;`
`13`	`13`	`private readonly SemanticModel _semanticModel;`
`14`		`- private static readonly SyntaxAnnotation DefaultSelectAnnotation = new SyntaxAnnotation("DefaultSelect");`
	`14`	`+ private static readonly SyntaxAnnotation DefaultSelectAnnotation = new("DefaultSelect");`
`15`	`15`
`16`	`16`	`public QueryConverter(CommonConversions commonConversions, SemanticModel semanticModel, CommentConvertingVisitorWrapper triviaConvertingExpressionVisitor)`
`17`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2,12 +2,12 @@`
`2`	`2`
`3`	`3`	`internal class TypeContext : ITypeContext`
`4`	`4`	`{`
`5`		`- private readonly Stack<(AdditionalInitializers Initializers, HandledEventsAnalysis Methods)> _contextStack = new Stack<(AdditionalInitializers Initializers, HandledEventsAnalysis Methods)>();`
	`5`	`+ private readonly Stack<(AdditionalInitializers Initializers, HandledEventsAnalysis Methods)> _contextStack = new();`
`6`	`6`
`7`	`7`	`public AdditionalInitializers Initializers => _contextStack.Peek().Initializers;`
`8`	`8`	`public HandledEventsAnalysis HandledEventsAnalysis => _contextStack.Peek().Methods;`
`9`	`9`
`10`		`- public PerScopeState PerScopeState { get; internal set; } = new PerScopeState();`
	`10`	`+ public PerScopeState PerScopeState { get; internal set; } = new();`
`11`	`11`
`12`	`12`	`public void Push(HandledEventsAnalysis methodWithHandles, AdditionalInitializers additionalInitializers)`
`13`	`13`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ namespace ICSharpCode.CodeConverter.CSharp;`
`7`	`7`
`8`	`8`	`internal class XmlImportContext`
`9`	`9`	`{`
`10`		`- private readonly List<FieldDeclarationSyntax> _xNamespaceFields = new List<FieldDeclarationSyntax>();`
	`10`	`+ private readonly List<FieldDeclarationSyntax> _xNamespaceFields = new();`
`11`	`11`	`public IdentifierNameSyntax HelperClassUniqueIdentifierName { get; }`
`12`	`12`	`public IdentifierNameSyntax HelperClassShortIdentifierName => SyntaxFactory.IdentifierName("XmlImports");`
`13`	`13`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`public class CodeWithOptions`
`4`	`4`	`{`
`5`		`- private static readonly HashSet<Type> _typesToFindAssemblyReferencesFrom = new HashSet<Type> {`
	`5`	`+ private static readonly HashSet<Type> _typesToFindAssemblyReferencesFrom = new() {`
`6`	`6`	`typeof(System.Text.Encoding),`
`7`	`7`	`typeof(System.ComponentModel.DefaultValueAttribute),`
`8`	`8`	`typeof(System.Dynamic.DynamicObject),`