D2LXXXX: don't call default construct of a struct

generic version of the ImmutableArray<> analyzer

has a codefix which can replace with known initializers

Author: omsmith

src/D2L.CodeStyle.Analyzers/Diagnostics.cs

@@ -485,5 +485,15 @@ public static class Diagnostics {
 			description: "[ReadOnly] paramaters must not be assigned to or passed by non-readonly reference."
 		);
 
+		public static readonly DiagnosticDescriptor DontCallDefaultStructConstructor = new DiagnosticDescriptor(
+			id: "D2LXXXX",
+			title: "Don't call default struct constructor",
+			messageFormat: "Don't call default struct constructor",
+			description: "The default parameterless constructor for a struct is overridable, but not removable. It is quite possible it's not doing what you expect. Try another constructor or initializer?",
+			category: "Correctness",
+			defaultSeverity: DiagnosticSeverity.Info,
+			isEnabledByDefault: true
+		);
+
 	}
 }

src/D2L.CodeStyle.Analyzers/Language/DefaultStructCreation/DefaultStructCreationAnalyzer.Codefix.cs

@@ -0,0 +1,88 @@
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using D2L.CodeStyle.Analyzers.Language.DefaultStructCreation.Replacements;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace D2L.CodeStyle.Analyzers.Language.DefaultStructCreation {
+	partial class DefaultStructCreationAnalyzer {
+
+		[ExportCodeFixProvider(
+			LanguageNames.CSharp,
+			Name = nameof( UseSuggestedInitializerCodefix )
+		)]
+		public sealed class UseSuggestedInitializerCodefix : CodeFixProvider {
+
+			public override ImmutableArray<string> FixableDiagnosticIds
+				=> ImmutableArray.Create( Diagnostics.DontCallDefaultStructConstructor.Id );
+
+			public override FixAllProvider GetFixAllProvider()
+				=> WellKnownFixAllProviders.BatchFixer;
+
+			public override async Task RegisterCodeFixesAsync(
+				CodeFixContext ctx
+			) {
+				var root = await ctx.Document
+					.GetSyntaxRootAsync( ctx.CancellationToken )
+					.ConfigureAwait( false );
+
+				var model = await ctx.Document
+					.GetSemanticModelAsync( ctx.CancellationToken )
+					.ConfigureAwait( false );
+
+				var compilation = model.Compilation;
+
+				var replacers = ImmutableArray.Create<IDefaultStructCreationReplacer>(
+					new NewGuidBackedIdTypeReplacer(),
+					new NewGuidReplacer( compilation ),
+					new NewImmutableArrayReplacer( compilation )
+				);
+
+				foreach( var diagnostic in ctx.Diagnostics ) {
+					var span = diagnostic.Location.SourceSpan;
+
+					SyntaxNode syntax = root.FindNode( span, getInnermostNodeForTie: true );
+					if( !( syntax is ObjectCreationExpressionSyntax creationExpression ) ) {
+						continue;
+					}
+
+					INamedTypeSymbol structType = model.GetTypeInfo( creationExpression ).Type as INamedTypeSymbol;
+					if( structType == null || structType.TypeKind == TypeKind.Error ) {
+						continue;
+					}
+
+					foreach( var replacer in replacers ) {
+
+						if( !replacer.CanReplace( structType ) ) {
+							continue;
+						}
+
+						ctx.RegisterCodeFix(
+							CodeAction.Create(
+								title: replacer.Title,
+								createChangedDocument: ct => {
+									SyntaxNode replacement = replacer.GetReplacement(
+										structType,
+										creationExpression.Type
+									);
+
+									replacement = replacement.WithTriviaFrom( creationExpression );
+
+									SyntaxNode newRoot = root.ReplaceNode( creationExpression, replacement );
+									Document newDoc = ctx.Document.WithSyntaxRoot( newRoot );
+
+									return Task.FromResult( newDoc );
+								}
+							),
+							diagnostic
+						);
+
+					}
+				}
+			}
+		}
+	}
+}

src/D2L.CodeStyle.Analyzers/Language/DefaultStructCreation/DefaultStructCreationAnalyzer.cs

@@ -0,0 +1,49 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace D2L.CodeStyle.Analyzers.Language.DefaultStructCreation {
+
+	[DiagnosticAnalyzer( LanguageNames.CSharp )]
+	internal sealed partial class DefaultStructCreationAnalyzer : DiagnosticAnalyzer {
+		public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+			=> ImmutableArray.Create( Diagnostics.DontCallDefaultStructConstructor );
+
+		public override void Initialize( AnalysisContext context ) {
+			context.EnableConcurrentExecution();
+
+			context.ConfigureGeneratedCodeAnalysis(
+				GeneratedCodeAnalysisFlags.None
+			);
+
+			context.RegisterOperationAction(
+				ctx => AnalyzeObjectCreation(
+					context: ctx,
+					operation: ctx.Operation as IObjectCreationOperation
+				),
+				OperationKind.ObjectCreation
+			);
+		}
+
+		private static void AnalyzeObjectCreation(
+			OperationAnalysisContext context,
+			IObjectCreationOperation operation
+		) {
+			ITypeSymbol type = operation.Type;
+			if( type.TypeKind != TypeKind.Struct ) {
+				return;
+			}
+
+			IMethodSymbol constructor = operation.Constructor;
+			if( constructor.Parameters.Length > 0 ) {
+				return;
+			}
+
+			context.ReportDiagnostic( Diagnostic.Create(
+				Diagnostics.DontCallDefaultStructConstructor,
+				operation.Syntax.GetLocation()
+			) );
+		}
+	}
+}

src/D2L.CodeStyle.Analyzers/Language/DefaultStructCreation/Replacements/IDefaultStructCreationReplacer.cs

@@ -0,0 +1,20 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace D2L.CodeStyle.Analyzers.Language.DefaultStructCreation.Replacements {
+
+	internal interface IDefaultStructCreationReplacer {
+
+		string Title { get; }
+
+		bool CanReplace(
+			INamedTypeSymbol structType
+		);
+
+		SyntaxNode GetReplacement(
+			INamedTypeSymbol structType,
+			TypeSyntax structName
+		);
+
+	}
+}

src/D2L.CodeStyle.Analyzers/Language/DefaultStructCreation/Replacements/NewGuidBackedIdTypeReplacer.cs

@@ -0,0 +1,47 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace D2L.CodeStyle.Analyzers.Language.DefaultStructCreation.Replacements {
+
+	internal sealed class NewGuidBackedIdTypeReplacer : IDefaultStructCreationReplacer {
+
+		string IDefaultStructCreationReplacer.Title { get; } = "Use GenerateNew()";
+
+		bool IDefaultStructCreationReplacer.CanReplace(
+			INamedTypeSymbol structType
+		) {
+			ImmutableArray<ISymbol> maybeGenerateNew = structType.GetMembers( "GenerateNew" );
+			if( maybeGenerateNew.Length != 1 ) {
+				return false;
+			}
+
+			if( !( maybeGenerateNew[0] is IMethodSymbol generateNew ) ) {
+				return false;
+			}
+
+			if( generateNew.Parameters.Length != 0 ) {
+				return false;
+			}
+
+			// Sure seems like one of our Guid-backed IdTypes
+			return true;
+		}
+
+		SyntaxNode IDefaultStructCreationReplacer.GetReplacement(
+			INamedTypeSymbol structType,
+			TypeSyntax structName
+		) {
+			return SyntaxFactory
+				.InvocationExpression(
+					SyntaxFactory.MemberAccessExpression(
+						SyntaxKind.SimpleMemberAccessExpression,
+						structName,
+						SyntaxFactory.IdentifierName( "GenerateNew" )
+					)
+				);
+		}
+
+	}
+}

src/D2L.CodeStyle.Analyzers/Language/DefaultStructCreation/Replacements/NewGuidReplacer.cs

@@ -0,0 +1,51 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace D2L.CodeStyle.Analyzers.Language.DefaultStructCreation.Replacements {
+
+	internal sealed class NewGuidReplacer : IDefaultStructCreationReplacer {
+		string IDefaultStructCreationReplacer.Title { get; } = "Use Guid.NewGuid()";
+
+		private readonly INamedTypeSymbol m_guidType;
+
+		public NewGuidReplacer(
+			Compilation compilation
+		) {
+			m_guidType = compilation.GetTypeByMetadataName( "System.Guid" );
+		}
+
+		bool IDefaultStructCreationReplacer.CanReplace(
+			INamedTypeSymbol structType
+		) {
+			if( m_guidType == null ) {
+				return false;
+			}
+
+			if( m_guidType.TypeKind == TypeKind.Error ) {
+				return false;
+			}
+
+			if( m_guidType != structType ) {
+				return false;
+			}
+
+			return true;
+		}
+
+		SyntaxNode IDefaultStructCreationReplacer.GetReplacement(
+			INamedTypeSymbol structType,
+			TypeSyntax structName
+		) {
+			return SyntaxFactory
+				.InvocationExpression(
+					SyntaxFactory.MemberAccessExpression(
+						SyntaxKind.SimpleMemberAccessExpression,
+						structName,
+						SyntaxFactory.IdentifierName( "NewGuid" )
+					)
+				);
+		}
+
+	}
+}

src/D2L.CodeStyle.Analyzers/Language/DefaultStructCreation/Replacements/NewImmutableArrayReplacer.cs

@@ -0,0 +1,48 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace D2L.CodeStyle.Analyzers.Language.DefaultStructCreation.Replacements {
+
+	internal sealed class NewImmutableArrayReplacer : IDefaultStructCreationReplacer {
+		string IDefaultStructCreationReplacer.Title { get; } = "Use ImmutableArray<>.Empty";
+
+		private readonly INamedTypeSymbol m_immutableArrayType;
+
+		public NewImmutableArrayReplacer(
+			Compilation compilation
+		) {
+			m_immutableArrayType = compilation
+				.GetTypeByMetadataName( "System.Collections.Immutable.ImmutableArray`1" );
+		}
+
+		bool IDefaultStructCreationReplacer.CanReplace(
+			INamedTypeSymbol structType
+		) {
+			if( m_immutableArrayType == null ) {
+				return false;
+			}
+
+			if( m_immutableArrayType.TypeKind == TypeKind.Error ) {
+				return false;
+			}
+
+			if( m_immutableArrayType != structType.OriginalDefinition ) {
+				return false;
+			}
+
+			return true;
+		}
+
+		SyntaxNode IDefaultStructCreationReplacer.GetReplacement(
+			INamedTypeSymbol structType,
+			TypeSyntax structName
+		) {
+			return SyntaxFactory.MemberAccessExpression(
+				SyntaxKind.SimpleMemberAccessExpression,
+				structName,
+				SyntaxFactory.IdentifierName( "Empty" )
+			);
+		}
+	}
+}

tests/D2L.CodeStyle.Analyzers.Test/Specs/DefaultStructCreationAnalyzer.cs

@@ -0,0 +1,32 @@
+// analyzer: D2L.CodeStyle.Analyzers.Language.DefaultStructCreation.DefaultStructCreationAnalyzer
+
+using System;
+
+namespace SpecTests {
+
+	public struct StructWithOnlyDefault { }
+	public struct StructWithAdditional {
+		public StructWithAdditional( int x ) { }
+	}
+	public struct StructWithOverridenDefault {
+		public StructWithOverridenDefault() { }
+	}
+
+	public class SpecTests {
+		public void SpecTests() {
+
+			{ var x = /* DontCallDefaultStructConstructor() */ new StructWithOnlyDefault() /**/; }
+			{ var x = /* DontCallDefaultStructConstructor() */ new StructWithAdditional() /**/; }
+			{ var x = new StructWithAdditional( 1 ); }
+			{ var x = /* DontCallDefaultStructConstructor() */ new StructWithOverridenDefault() /**/; }
+			{ var x = /* DontCallDefaultStructConstructor() */ new Guid() /**/; }
+			{ var x = /* DontCallDefaultStructConstructor() */ new System.Guid() /**/; }
+			{
+				// this constructor doesn't actually exist
+				var x = new StructWithOnlyDefault( 1 );
+			}
+
+		}
+	}
+
+}