From 1330b3fd4294464f16ab2ed81556ca332370201e Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 28 Jun 2019 12:57:32 -0700 Subject: [PATCH] Use switch expression --- .../Portable/Diagnostics/AnalyzerHelper.cs | 31 +- .../CodeGeneration/CSharpSyntaxGenerator.cs | 371 +++++++----------- .../Execution/AssetStorages.Storage.cs | 18 +- .../Portable/Utilities/SerializableBytes.cs | 22 +- ...clarationsTests.TestSolutionsAndProject.cs | 36 +- 5 files changed, 174 insertions(+), 304 deletions(-) diff --git a/src/Features/Core/Portable/Diagnostics/AnalyzerHelper.cs b/src/Features/Core/Portable/Diagnostics/AnalyzerHelper.cs index b9f51932f43..11a8f1afbd1 100644 --- a/src/Features/Core/Portable/Diagnostics/AnalyzerHelper.cs +++ b/src/Features/Core/Portable/Diagnostics/AnalyzerHelper.cs @@ -505,15 +505,12 @@ public static bool SupportAnalysisKind(this DiagnosticAnalyzerService service, D return true; } - switch (kind) + return kind switch { - case AnalysisKind.Syntax: - return analyzer.SupportsSyntaxDiagnosticAnalysis(); - case AnalysisKind.Semantic: - return analyzer.SupportsSemanticDiagnosticAnalysis(); - default: - return Contract.FailWithReturn("shouldn't reach here"); - } + AnalysisKind.Syntax => analyzer.SupportsSyntaxDiagnosticAnalysis(), + AnalysisKind.Semantic => analyzer.SupportsSemanticDiagnosticAnalysis(), + _ => Contract.FailWithReturn("shouldn't reach here"), + }; } public static async Task> ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync( @@ -529,21 +526,13 @@ public static bool SupportAnalysisKind(this DiagnosticAnalyzerService service, D try { - Task> analyzeAsync; - switch (kind) + var analyzeAsync = kind switch { - case AnalysisKind.Syntax: - analyzeAsync = analyzer.AnalyzeSyntaxAsync(document, cancellationToken); - break; - - case AnalysisKind.Semantic: - analyzeAsync = analyzer.AnalyzeSemanticsAsync(document, cancellationToken); - break; - - default: - throw ExceptionUtilities.UnexpectedValue(kind); - } + AnalysisKind.Syntax => analyzer.AnalyzeSyntaxAsync(document, cancellationToken), + AnalysisKind.Semantic => analyzer.AnalyzeSemanticsAsync(document, cancellationToken), + _ => throw ExceptionUtilities.UnexpectedValue(kind), + }; var diagnostics = (await analyzeAsync.ConfigureAwait(false)).NullToEmpty(); if (compilationOpt != null) diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs index c74bc00b499..ba36b3573fe 100644 --- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs +++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs @@ -138,21 +138,14 @@ public override SyntaxNode ParameterDeclaration(string name, SyntaxNode type, Sy } internal static SyntaxTokenList GetParameterModifiers(RefKind refKind) - { - switch (refKind) + => refKind switch { - case RefKind.None: - return new SyntaxTokenList(); - case RefKind.Out: - return SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.OutKeyword)); - case RefKind.Ref: - return SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.RefKeyword)); - case RefKind.In: - return SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.InKeyword)); - default: - throw ExceptionUtilities.UnexpectedValue(refKind); - } - } + RefKind.None => new SyntaxTokenList(), + RefKind.Out => SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.OutKeyword)), + RefKind.Ref => SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.RefKeyword)), + RefKind.In => SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.InKeyword)), + _ => throw ExceptionUtilities.UnexpectedValue(refKind), + }; internal static SyntaxToken GetArgumentModifiers(RefKind refKind) { @@ -223,39 +216,36 @@ public override SyntaxNode OperatorDeclaration(OperatorKind kind, IEnumerable kind switch + { + OperatorKind.ImplicitConversion => SyntaxKind.ImplicitKeyword, + OperatorKind.ExplicitConversion => SyntaxKind.ExplicitKeyword, + OperatorKind.Addition => SyntaxKind.PlusToken, + OperatorKind.BitwiseAnd => SyntaxKind.AmpersandToken, + OperatorKind.BitwiseOr => SyntaxKind.BarToken, + OperatorKind.Decrement => SyntaxKind.MinusMinusToken, + OperatorKind.Division => SyntaxKind.SlashToken, + OperatorKind.Equality => SyntaxKind.EqualsEqualsToken, + OperatorKind.ExclusiveOr => SyntaxKind.CaretToken, + OperatorKind.False => SyntaxKind.FalseKeyword, + OperatorKind.GreaterThan => SyntaxKind.GreaterThanToken, + OperatorKind.GreaterThanOrEqual => SyntaxKind.GreaterThanEqualsToken, + OperatorKind.Increment => SyntaxKind.PlusPlusToken, + OperatorKind.Inequality => SyntaxKind.ExclamationEqualsToken, + OperatorKind.LeftShift => SyntaxKind.LessThanLessThanToken, + OperatorKind.LessThan => SyntaxKind.LessThanToken, + OperatorKind.LessThanOrEqual => SyntaxKind.LessThanEqualsToken, + OperatorKind.LogicalNot => SyntaxKind.ExclamationToken, + OperatorKind.Modulus => SyntaxKind.PercentToken, + OperatorKind.Multiply => SyntaxKind.AsteriskToken, + OperatorKind.OnesComplement => SyntaxKind.TildeToken, + OperatorKind.RightShift => SyntaxKind.GreaterThanGreaterThanToken, + OperatorKind.Subtraction => SyntaxKind.MinusToken, + OperatorKind.True => SyntaxKind.TrueKeyword, + OperatorKind.UnaryNegation => SyntaxKind.MinusToken, + OperatorKind.UnaryPlus => SyntaxKind.PlusToken, + _ => throw new ArgumentException("Unknown operator kind."), + }; private static ParameterListSyntax AsParameterList(IEnumerable parameters) { @@ -353,22 +343,18 @@ public override SyntaxNode SetAccessorDeclaration(Accessibility accessibility, I } public override SyntaxNode WithAccessorDeclarations(SyntaxNode declaration, IEnumerable accessorDeclarations) - { - switch (declaration) + => declaration switch { - case PropertyDeclarationSyntax property: - return property.WithAccessorList(CreateAccessorList(property.AccessorList, accessorDeclarations)) - .WithExpressionBody(null) - .WithSemicolonToken(default); + PropertyDeclarationSyntax property => property.WithAccessorList(CreateAccessorList(property.AccessorList, accessorDeclarations)) + .WithExpressionBody(null) + .WithSemicolonToken(default), - case IndexerDeclarationSyntax indexer: - return indexer.WithAccessorList(CreateAccessorList(indexer.AccessorList, accessorDeclarations)) + IndexerDeclarationSyntax indexer => indexer.WithAccessorList(CreateAccessorList(indexer.AccessorList, accessorDeclarations)) .WithExpressionBody(null) - .WithSemicolonToken(default); - } + .WithSemicolonToken(default), - return declaration; - } + _ => declaration, + }; private AccessorListSyntax CreateAccessorList(AccessorListSyntax accessorListOpt, IEnumerable accessorDeclarations) { @@ -553,21 +539,14 @@ private SyntaxNode WithoutConstraints(SyntaxNode declaration) } private static SyntaxNode WithInterfaceSpecifier(SyntaxNode declaration, ExplicitInterfaceSpecifierSyntax specifier) - { - switch (declaration.Kind()) + => declaration.Kind() switch { - case SyntaxKind.MethodDeclaration: - return ((MethodDeclarationSyntax)declaration).WithExplicitInterfaceSpecifier(specifier); - case SyntaxKind.PropertyDeclaration: - return ((PropertyDeclarationSyntax)declaration).WithExplicitInterfaceSpecifier(specifier); - case SyntaxKind.IndexerDeclaration: - return ((IndexerDeclarationSyntax)declaration).WithExplicitInterfaceSpecifier(specifier); - case SyntaxKind.EventDeclaration: - return ((EventDeclarationSyntax)declaration).WithExplicitInterfaceSpecifier(specifier); - default: - return declaration; - } - } + SyntaxKind.MethodDeclaration => ((MethodDeclarationSyntax)declaration).WithExplicitInterfaceSpecifier(specifier), + SyntaxKind.PropertyDeclaration => ((PropertyDeclarationSyntax)declaration).WithExplicitInterfaceSpecifier(specifier), + SyntaxKind.IndexerDeclaration => ((IndexerDeclarationSyntax)declaration).WithExplicitInterfaceSpecifier(specifier), + SyntaxKind.EventDeclaration => ((EventDeclarationSyntax)declaration).WithExplicitInterfaceSpecifier(specifier), + _ => declaration, + }; private SyntaxNode AsImplementation(SyntaxNode declaration, Accessibility requiredAccess) { @@ -1137,30 +1116,24 @@ private static SyntaxNode WithAttributeArgumentList(SyntaxNode declaration, Attr } private static SyntaxList GetAttributeLists(SyntaxNode declaration) - { - switch (declaration) + => declaration switch { - case MemberDeclarationSyntax memberDecl: return memberDecl.AttributeLists; - case AccessorDeclarationSyntax accessor: return accessor.AttributeLists; - case ParameterSyntax parameter: return parameter.AttributeLists; - case CompilationUnitSyntax compilationUnit: return compilationUnit.AttributeLists; - default: - return default; - } - } + MemberDeclarationSyntax memberDecl => memberDecl.AttributeLists, + AccessorDeclarationSyntax accessor => accessor.AttributeLists, + ParameterSyntax parameter => parameter.AttributeLists, + CompilationUnitSyntax compilationUnit => compilationUnit.AttributeLists, + _ => default, + }; private static SyntaxNode WithAttributeLists(SyntaxNode declaration, SyntaxList attributeLists) - { - switch (declaration) + => declaration switch { - case MemberDeclarationSyntax memberDecl: return memberDecl.WithAttributeLists(attributeLists); - case AccessorDeclarationSyntax accessor: return accessor.WithAttributeLists(attributeLists); - case ParameterSyntax parameter: return parameter.WithAttributeLists(attributeLists); - case CompilationUnitSyntax compilationUnit: return compilationUnit.WithAttributeLists(AsAssemblyAttributes(attributeLists)); - default: - return declaration; - } - } + MemberDeclarationSyntax memberDecl => memberDecl.WithAttributeLists(attributeLists), + AccessorDeclarationSyntax accessor => accessor.WithAttributeLists(attributeLists), + ParameterSyntax parameter => parameter.WithAttributeLists(attributeLists), + CompilationUnitSyntax compilationUnit => compilationUnit.WithAttributeLists(AsAssemblyAttributes(attributeLists)), + _ => declaration, + }; internal override ImmutableArray GetTypeInheritance(SyntaxNode declaration) => declaration is BaseTypeDeclarationSyntax baseType && baseType.BaseList != null @@ -1168,17 +1141,12 @@ internal override ImmutableArray GetTypeInheritance(SyntaxNode decla : ImmutableArray.Empty; public override IReadOnlyList GetNamespaceImports(SyntaxNode declaration) - { - switch (declaration.Kind()) + => declaration.Kind() switch { - case SyntaxKind.CompilationUnit: - return ((CompilationUnitSyntax)declaration).Usings; - case SyntaxKind.NamespaceDeclaration: - return ((NamespaceDeclarationSyntax)declaration).Usings; - default: - return SpecializedCollections.EmptyReadOnlyList(); - } - } + SyntaxKind.CompilationUnit => ((CompilationUnitSyntax)declaration).Usings, + SyntaxKind.NamespaceDeclaration => ((NamespaceDeclarationSyntax)declaration).Usings, + _ => SpecializedCollections.EmptyReadOnlyList(), + }; public override SyntaxNode InsertNamespaceImports(SyntaxNode declaration, int index, IEnumerable imports) { @@ -1208,25 +1176,16 @@ public override IReadOnlyList GetMembers(SyntaxNode declaration) } private static IReadOnlyList GetUnflattenedMembers(SyntaxNode declaration) - { - switch (declaration.Kind()) - { - case SyntaxKind.ClassDeclaration: - return ((ClassDeclarationSyntax)declaration).Members; - case SyntaxKind.StructDeclaration: - return ((StructDeclarationSyntax)declaration).Members; - case SyntaxKind.InterfaceDeclaration: - return ((InterfaceDeclarationSyntax)declaration).Members; - case SyntaxKind.EnumDeclaration: - return ((EnumDeclarationSyntax)declaration).Members; - case SyntaxKind.NamespaceDeclaration: - return ((NamespaceDeclarationSyntax)declaration).Members; - case SyntaxKind.CompilationUnit: - return ((CompilationUnitSyntax)declaration).Members; - default: - return SpecializedCollections.EmptyReadOnlyList(); - } - } + => declaration.Kind() switch + { + SyntaxKind.ClassDeclaration => ((ClassDeclarationSyntax)declaration).Members, + SyntaxKind.StructDeclaration => ((StructDeclarationSyntax)declaration).Members, + SyntaxKind.InterfaceDeclaration => ((InterfaceDeclarationSyntax)declaration).Members, + SyntaxKind.EnumDeclaration => ((EnumDeclarationSyntax)declaration).Members, + SyntaxKind.NamespaceDeclaration => ((NamespaceDeclarationSyntax)declaration).Members, + SyntaxKind.CompilationUnit => ((CompilationUnitSyntax)declaration).Members, + _ => SpecializedCollections.EmptyReadOnlyList(), + }; private static IReadOnlyList Flatten(IReadOnlyList members) { @@ -1274,23 +1233,15 @@ private static IReadOnlyList Flatten(IReadOnlyList membe } private static int GetDeclarationCount(SyntaxNode declaration) - { - switch (declaration.Kind()) - { - case SyntaxKind.FieldDeclaration: - return ((FieldDeclarationSyntax)declaration).Declaration.Variables.Count; - case SyntaxKind.EventFieldDeclaration: - return ((EventFieldDeclarationSyntax)declaration).Declaration.Variables.Count; - case SyntaxKind.LocalDeclarationStatement: - return ((LocalDeclarationStatementSyntax)declaration).Declaration.Variables.Count; - case SyntaxKind.VariableDeclaration: - return ((VariableDeclarationSyntax)declaration).Variables.Count; - case SyntaxKind.AttributeList: - return ((AttributeListSyntax)declaration).Attributes.Count; - default: - return 1; - } - } + => declaration.Kind() switch + { + SyntaxKind.FieldDeclaration => ((FieldDeclarationSyntax)declaration).Declaration.Variables.Count, + SyntaxKind.EventFieldDeclaration => ((EventFieldDeclarationSyntax)declaration).Declaration.Variables.Count, + SyntaxKind.LocalDeclarationStatement => ((LocalDeclarationStatementSyntax)declaration).Declaration.Variables.Count, + SyntaxKind.VariableDeclaration => ((VariableDeclarationSyntax)declaration).Variables.Count, + SyntaxKind.AttributeList => ((AttributeListSyntax)declaration).Attributes.Count, + _ => 1, + }; private static void Flatten(SyntaxNode declaration, VariableDeclarationSyntax vd, List flat) { @@ -1571,20 +1522,17 @@ private SyntaxNode WithModifiersInternal(SyntaxNode declaration, DeclarationModi } private static SyntaxTokenList GetModifierTokens(SyntaxNode declaration) - { - switch (declaration) + => declaration switch { - case MemberDeclarationSyntax memberDecl: return memberDecl.Modifiers; - case ParameterSyntax parameter: return parameter.Modifiers; - case LocalDeclarationStatementSyntax localDecl: return localDecl.Modifiers; - case LocalFunctionStatementSyntax localFunc: return localFunc.Modifiers; - case AccessorDeclarationSyntax accessor: return accessor.Modifiers; - case VariableDeclarationSyntax varDecl: return GetModifierTokens(varDecl.Parent); - case VariableDeclaratorSyntax varDecl: return GetModifierTokens(varDecl.Parent); - } - - return default; - } + MemberDeclarationSyntax memberDecl => memberDecl.Modifiers, + ParameterSyntax parameter => parameter.Modifiers, + LocalDeclarationStatementSyntax localDecl => localDecl.Modifiers, + LocalFunctionStatementSyntax localFunc => localFunc.Modifiers, + AccessorDeclarationSyntax accessor => accessor.Modifiers, + VariableDeclarationSyntax varDecl => GetModifierTokens(varDecl.Parent), + VariableDeclaratorSyntax varDecl => GetModifierTokens(varDecl.Parent), + _ => default, + }; private static SyntaxNode SetModifierTokens(SyntaxNode declaration, SyntaxTokenList modifiers) => declaration switch @@ -1817,39 +1765,25 @@ public override SyntaxNode WithTypeParameters(SyntaxNode declaration, IEnumerabl { var typeParameters = AsTypeParameterList(typeParameterNames); - switch (declaration.Kind()) + return declaration.Kind() switch { - case SyntaxKind.MethodDeclaration: - return ((MethodDeclarationSyntax)declaration).WithTypeParameterList(typeParameters); - - case SyntaxKind.ClassDeclaration: - return ((ClassDeclarationSyntax)declaration).WithTypeParameterList(typeParameters); - - case SyntaxKind.StructDeclaration: - return ((StructDeclarationSyntax)declaration).WithTypeParameterList(typeParameters); - - case SyntaxKind.InterfaceDeclaration: - return ((InterfaceDeclarationSyntax)declaration).WithTypeParameterList(typeParameters); - - case SyntaxKind.DelegateDeclaration: - return ((DelegateDeclarationSyntax)declaration).WithTypeParameterList(typeParameters); - default: - return declaration; - } + SyntaxKind.MethodDeclaration => ((MethodDeclarationSyntax)declaration).WithTypeParameterList(typeParameters), + SyntaxKind.ClassDeclaration => ((ClassDeclarationSyntax)declaration).WithTypeParameterList(typeParameters), + SyntaxKind.StructDeclaration => ((StructDeclarationSyntax)declaration).WithTypeParameterList(typeParameters), + SyntaxKind.InterfaceDeclaration => ((InterfaceDeclarationSyntax)declaration).WithTypeParameterList(typeParameters), + SyntaxKind.DelegateDeclaration => ((DelegateDeclarationSyntax)declaration).WithTypeParameterList(typeParameters), + _ => declaration, + }; } internal override SyntaxNode WithExplicitInterfaceImplementations(SyntaxNode declaration, ImmutableArray explicitInterfaceImplementations) - { - switch (declaration) + => declaration switch { - case MethodDeclarationSyntax methodDeclaration: - return WithAccessibility( - methodDeclaration.WithExplicitInterfaceSpecifier(CreateExplicitInterfaceSpecifier(explicitInterfaceImplementations)), - Accessibility.NotApplicable); - } - - return declaration; - } + MethodDeclarationSyntax methodDeclaration => WithAccessibility( + methodDeclaration.WithExplicitInterfaceSpecifier(CreateExplicitInterfaceSpecifier(explicitInterfaceImplementations)), + Accessibility.NotApplicable), + _ => declaration, + }; private ExplicitInterfaceSpecifierSyntax CreateExplicitInterfaceSpecifier(ImmutableArray explicitInterfaceImplementations) => SyntaxFactory.ExplicitInterfaceSpecifier( @@ -2277,33 +2211,20 @@ public override SyntaxNode WithType(SyntaxNode declaration, SyntaxNode type) } private static SyntaxNode WithTypeInternal(SyntaxNode declaration, SyntaxNode type) - { - switch (declaration.Kind()) - { - case SyntaxKind.DelegateDeclaration: - return ((DelegateDeclarationSyntax)declaration).WithReturnType((TypeSyntax)type); - case SyntaxKind.MethodDeclaration: - return ((MethodDeclarationSyntax)declaration).WithReturnType((TypeSyntax)type); - case SyntaxKind.FieldDeclaration: - return ((FieldDeclarationSyntax)declaration).WithDeclaration(((FieldDeclarationSyntax)declaration).Declaration.WithType((TypeSyntax)type)); - case SyntaxKind.PropertyDeclaration: - return ((PropertyDeclarationSyntax)declaration).WithType((TypeSyntax)type); - case SyntaxKind.IndexerDeclaration: - return ((IndexerDeclarationSyntax)declaration).WithType((TypeSyntax)type); - case SyntaxKind.EventFieldDeclaration: - return ((EventFieldDeclarationSyntax)declaration).WithDeclaration(((EventFieldDeclarationSyntax)declaration).Declaration.WithType((TypeSyntax)type)); - case SyntaxKind.EventDeclaration: - return ((EventDeclarationSyntax)declaration).WithType((TypeSyntax)type); - case SyntaxKind.Parameter: - return ((ParameterSyntax)declaration).WithType((TypeSyntax)type); - case SyntaxKind.LocalDeclarationStatement: - return ((LocalDeclarationStatementSyntax)declaration).WithDeclaration(((LocalDeclarationStatementSyntax)declaration).Declaration.WithType((TypeSyntax)type)); - case SyntaxKind.VariableDeclaration: - return ((VariableDeclarationSyntax)declaration).WithType((TypeSyntax)type); - } - - return declaration; - } + => declaration.Kind() switch + { + SyntaxKind.DelegateDeclaration => ((DelegateDeclarationSyntax)declaration).WithReturnType((TypeSyntax)type), + SyntaxKind.MethodDeclaration => ((MethodDeclarationSyntax)declaration).WithReturnType((TypeSyntax)type), + SyntaxKind.FieldDeclaration => ((FieldDeclarationSyntax)declaration).WithDeclaration(((FieldDeclarationSyntax)declaration).Declaration.WithType((TypeSyntax)type)), + SyntaxKind.PropertyDeclaration => ((PropertyDeclarationSyntax)declaration).WithType((TypeSyntax)type), + SyntaxKind.IndexerDeclaration => ((IndexerDeclarationSyntax)declaration).WithType((TypeSyntax)type), + SyntaxKind.EventFieldDeclaration => ((EventFieldDeclarationSyntax)declaration).WithDeclaration(((EventFieldDeclarationSyntax)declaration).Declaration.WithType((TypeSyntax)type)), + SyntaxKind.EventDeclaration => ((EventDeclarationSyntax)declaration).WithType((TypeSyntax)type), + SyntaxKind.Parameter => ((ParameterSyntax)declaration).WithType((TypeSyntax)type), + SyntaxKind.LocalDeclarationStatement => ((LocalDeclarationStatementSyntax)declaration).WithDeclaration(((LocalDeclarationStatementSyntax)declaration).Declaration.WithType((TypeSyntax)type)), + SyntaxKind.VariableDeclaration => ((VariableDeclarationSyntax)declaration).WithType((TypeSyntax)type), + _ => declaration, + }; private SyntaxNode Isolate(SyntaxNode declaration, Func editor) { @@ -2360,34 +2281,22 @@ private static SyntaxNode WithVariable(SyntaxNode declaration, VariableDeclarato } private static VariableDeclarationSyntax GetVariableDeclaration(SyntaxNode declaration) - { - switch (declaration.Kind()) + => declaration.Kind() switch { - case SyntaxKind.FieldDeclaration: - return ((FieldDeclarationSyntax)declaration).Declaration; - case SyntaxKind.EventFieldDeclaration: - return ((EventFieldDeclarationSyntax)declaration).Declaration; - case SyntaxKind.LocalDeclarationStatement: - return ((LocalDeclarationStatementSyntax)declaration).Declaration; - default: - return null; - } - } + SyntaxKind.FieldDeclaration => ((FieldDeclarationSyntax)declaration).Declaration, + SyntaxKind.EventFieldDeclaration => ((EventFieldDeclarationSyntax)declaration).Declaration, + SyntaxKind.LocalDeclarationStatement => ((LocalDeclarationStatementSyntax)declaration).Declaration, + _ => null, + }; private static SyntaxNode WithVariableDeclaration(SyntaxNode declaration, VariableDeclarationSyntax variables) - { - switch (declaration.Kind()) + => declaration.Kind() switch { - case SyntaxKind.FieldDeclaration: - return ((FieldDeclarationSyntax)declaration).WithDeclaration(variables); - case SyntaxKind.EventFieldDeclaration: - return ((EventFieldDeclarationSyntax)declaration).WithDeclaration(variables); - case SyntaxKind.LocalDeclarationStatement: - return ((LocalDeclarationStatementSyntax)declaration).WithDeclaration(variables); - default: - return declaration; - } - } + SyntaxKind.FieldDeclaration => ((FieldDeclarationSyntax)declaration).WithDeclaration(variables), + SyntaxKind.EventFieldDeclaration => ((EventFieldDeclarationSyntax)declaration).WithDeclaration(variables), + SyntaxKind.LocalDeclarationStatement => ((LocalDeclarationStatementSyntax)declaration).WithDeclaration(variables), + _ => declaration, + }; private static SyntaxNode GetFullDeclaration(SyntaxNode declaration) { diff --git a/src/Workspaces/Core/Portable/Execution/AssetStorages.Storage.cs b/src/Workspaces/Core/Portable/Execution/AssetStorages.Storage.cs index 72647dc9e39..2a2b2420038 100644 --- a/src/Workspaces/Core/Portable/Execution/AssetStorages.Storage.cs +++ b/src/Workspaces/Core/Portable/Execution/AssetStorages.Storage.cs @@ -142,19 +142,13 @@ private static string CreateLogMessage(T key, string kind) } private static string GetLogInfo(T key) - { - switch (key) + => key switch { - case SolutionState solutionState: - return solutionState.FilePath; - case ProjectState projectState: - return projectState.FilePath; - case DocumentState documentState: - return documentState.FilePath; - } - - return "no detail"; - } + SolutionState solutionState => solutionState.FilePath, + ProjectState projectState => projectState.FilePath, + DocumentState documentState => documentState.FilePath, + _ => "no detail", + }; } private struct SolutionChecksumFinder diff --git a/src/Workspaces/Core/Portable/Utilities/SerializableBytes.cs b/src/Workspaces/Core/Portable/Utilities/SerializableBytes.cs index 967a8ea994e..51fbabc68ba 100644 --- a/src/Workspaces/Core/Portable/Utilities/SerializableBytes.cs +++ b/src/Workspaces/Core/Portable/Utilities/SerializableBytes.cs @@ -148,23 +148,13 @@ public override long Seek(long offset, SeekOrigin origin) long target; try { - switch (origin) + target = origin switch { - case SeekOrigin.Begin: - target = offset; - break; - - case SeekOrigin.Current: - target = checked(offset + position); - break; - - case SeekOrigin.End: - target = checked(offset + length); - break; - - default: - throw new ArgumentOutOfRangeException(nameof(origin)); - } + SeekOrigin.Begin => offset, + SeekOrigin.Current => checked(offset + position), + SeekOrigin.End => checked(offset + length), + _ => throw new ArgumentOutOfRangeException(nameof(origin)), + }; } catch (OverflowException) { diff --git a/src/Workspaces/CoreTest/FindAllDeclarationsTests.TestSolutionsAndProject.cs b/src/Workspaces/CoreTest/FindAllDeclarationsTests.TestSolutionsAndProject.cs index 56613cb43ec..fc62e051b2b 100644 --- a/src/Workspaces/CoreTest/FindAllDeclarationsTests.TestSolutionsAndProject.cs +++ b/src/Workspaces/CoreTest/FindAllDeclarationsTests.TestSolutionsAndProject.cs @@ -106,31 +106,19 @@ private static Solution GetMultipleProjectSolution(params string[] sourceTexts) } private static Solution GetSolution(WorkspaceKind workspaceKind) - { - switch (workspaceKind) + => workspaceKind switch { - case WorkspaceKind.SingleClass: - return GetSingleProjectSolution(SingleClass); - case WorkspaceKind.SingleClassWithSingleMethod: - return GetSingleProjectSolution(SingleClassWithSingleMethod); - case WorkspaceKind.SingleClassWithSingleProperty: - return GetSingleProjectSolution(SingleClassWithSingleProperty); - case WorkspaceKind.SingleClassWithSingleField: - return GetSingleProjectSolution(SingleClassWithSingleField); - case WorkspaceKind.TwoProjectsEachWithASingleClassWithSingleMethod: - return GetMultipleProjectSolution(SingleClassWithSingleMethod, SingleClassWithSingleMethod); - case WorkspaceKind.TwoProjectsEachWithASingleClassWithSingleProperty: - return GetMultipleProjectSolution(SingleClassWithSingleProperty, SingleClassWithSingleProperty); - case WorkspaceKind.TwoProjectsEachWithASingleClassWithSingleField: - return GetMultipleProjectSolution(SingleClassWithSingleField, SingleClassWithSingleField); - case WorkspaceKind.NestedClass: - return GetSingleProjectSolution(NestedClass); - case WorkspaceKind.TwoNamespacesWithIdenticalClasses: - return GetSingleProjectSolution(Namespace1, Namespace2); - default: - return null; - } - } + WorkspaceKind.SingleClass => GetSingleProjectSolution(SingleClass), + WorkspaceKind.SingleClassWithSingleMethod => GetSingleProjectSolution(SingleClassWithSingleMethod), + WorkspaceKind.SingleClassWithSingleProperty => GetSingleProjectSolution(SingleClassWithSingleProperty), + WorkspaceKind.SingleClassWithSingleField => GetSingleProjectSolution(SingleClassWithSingleField), + WorkspaceKind.TwoProjectsEachWithASingleClassWithSingleMethod => GetMultipleProjectSolution(SingleClassWithSingleMethod, SingleClassWithSingleMethod), + WorkspaceKind.TwoProjectsEachWithASingleClassWithSingleProperty => GetMultipleProjectSolution(SingleClassWithSingleProperty, SingleClassWithSingleProperty), + WorkspaceKind.TwoProjectsEachWithASingleClassWithSingleField => GetMultipleProjectSolution(SingleClassWithSingleField, SingleClassWithSingleField), + WorkspaceKind.NestedClass => GetSingleProjectSolution(NestedClass), + WorkspaceKind.TwoNamespacesWithIdenticalClasses => GetSingleProjectSolution(Namespace1, Namespace2), + _ => null, + }; private static Project GetProject(WorkspaceKind workspaceKind) { -- GitLab