feat: Detect Implicit Object Creation (Mock<T> myMock = new()) (#1090)

Co-authored-by: Alex Barga <99690046+ajbarga@users.noreply.github.com>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: 3 people

Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/NoRegionsInMethodAnalyzer.cs

@@ -1,7 +1,9 @@
 // © 2023 Koninklijke Philips N.V. See License.md in the project root for license information.
 
+using System.Collections.Generic;
 using System.Linq;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Philips.CodeAnalysis.Common;
@@ -25,18 +27,18 @@ public class NoRegionsInMethodSyntaxNodeAction : SyntaxNodeAction<MethodDeclarat
 	{
 		public override void Analyze()
 		{
-			// Specifying Span instead of FullSpan correctly excludes trivia before or after the method
-			System.Collections.Generic.IEnumerable<DirectiveTriviaSyntax> descendants = Node.DescendantNodes(Node.Span, null, descendIntoTrivia: true).OfType<DirectiveTriviaSyntax>();
-			foreach (RegionDirectiveTriviaSyntax regionDirective in descendants.OfType<RegionDirectiveTriviaSyntax>())
-			{
-				Location location = regionDirective.GetLocation();
-				ReportDiagnostic(location);
-			}
+			IEnumerable<DirectiveTriviaSyntax> directives = Node
+				.DescendantTrivia(Node.Span, descendIntoTrivia: true)
+				.Select(trivia => trivia.GetStructure())
+				.OfType<DirectiveTriviaSyntax>();
 
-			foreach (EndRegionDirectiveTriviaSyntax endRegionDirective in descendants.OfType<EndRegionDirectiveTriviaSyntax>())
+			foreach (DirectiveTriviaSyntax directive in directives)
 			{
-				Location location = endRegionDirective.GetLocation();
-				ReportDiagnostic(location);
+				if (directive.IsKind(SyntaxKind.RegionDirectiveTrivia) ||
+					directive.IsKind(SyntaxKind.EndRegionDirectiveTrivia))
+				{
+					ReportDiagnostic(directive.GetLocation());
+				}
 			}
 		}
 	}

Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/ProhibitDynamicKeywordAnalyzer.cs

@@ -13,9 +13,9 @@ namespace Philips.CodeAnalysis.MaintainabilityAnalyzers.Maintainability
 	public class ProhibitDynamicKeywordAnalyzer : SingleDiagnosticAnalyzer
 	{
 		private const string Title = @"Prohibit the ""dynamic"" Keyword";
-		private const string MessageFormat = @"Do not use the ""dynamic"" keyword.  It it not compile time type safe.";
+		private const string MessageFormat = @"Do not use the ""dynamic"" keyword.  It is not compile time type safe.";
 		private const string Description = @"The ""dynamic"" keyword is not checked for type safety at compile time.";
-		private const string DynamicIdentifier = "dynamic";
+		private const string DynamicIdentifier = @"dynamic";
 
 		public ProhibitDynamicKeywordAnalyzer()
 			: base(DiagnosticId.DynamicKeywordProhibited, Title, MessageFormat, Description, Categories.Maintainability)
@@ -70,17 +70,14 @@ private void AnalyzeVariable(SyntaxNodeAnalysisContext context)
 
 		private static bool IsDynamicType(SyntaxNodeAnalysisContext context, TypeSyntax typeSyntax)
 		{
-			if (typeSyntax is SimpleNameSyntax { Identifier.ValueText: DynamicIdentifier })
+			if (typeSyntax is IdentifierNameSyntax { Identifier.ValueText: DynamicIdentifier })
 			{
-				// Double check the semantic model (to distinguish a variable named 'dynamic').
-				SymbolInfo symbol = context.SemanticModel.GetSymbolInfo(typeSyntax);
-				if (symbol.Symbol is IDynamicTypeSymbol)
-				{
-					return true;
-				}
+				TypeInfo typeInfo = context.SemanticModel.GetTypeInfo(typeSyntax);
+				return typeInfo.Type is IDynamicTypeSymbol;
 			}
 
-			if (typeSyntax is GenericNameSyntax generic && generic.TypeArgumentList.Arguments.Any(gen => IsDynamicType(context, gen)))
+			if (typeSyntax is GenericNameSyntax generic &&
+				generic.TypeArgumentList.Arguments.Any(gen => IsDynamicType(context, gen)))
 			{
 				return true;
 			}

Philips.CodeAnalysis.MoqAnalyzers/MockDisposableClassesShouldSetupDisposeAnalyzer.cs

@@ -30,19 +30,12 @@ protected override void InitializeCompilation(CompilationStartAnalysisContext co
 				return;
 			}
 
-			context.RegisterSyntaxNodeAction(AnalyzeObjectCreation, SyntaxKind.ObjectCreationExpression);
+			context.RegisterSyntaxNodeAction(AnalyzeObjectCreation, SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression);
 		}
 
 		private void AnalyzeObjectCreation(SyntaxNodeAnalysisContext context)
 		{
-			var objectCreationExpressionSyntax = (ObjectCreationExpressionSyntax)context.Node;
-
-			if (objectCreationExpressionSyntax.Type is not GenericNameSyntax genericNameSyntax)
-			{
-				return;
-			}
-
-			if (genericNameSyntax.Identifier.ValueText != MockName)
+			if (context.Node is not ExpressionSyntax objectCreationExpressionSyntax)
 			{
 				return;
 			}
@@ -84,9 +77,8 @@ private void AnalyzeObjectCreation(SyntaxNodeAnalysisContext context)
 			ReportDiagnostic(context, objectCreationExpressionSyntax, mockedType);
 		}
 
-		private void ReportDiagnostic(SyntaxNodeAnalysisContext context, ObjectCreationExpressionSyntax objectCreationExpressionSyntax, ITypeSymbol mockedType)
+		private void ReportDiagnostic(SyntaxNodeAnalysisContext context, ExpressionSyntax objectCreationExpressionSyntax, ITypeSymbol mockedType)
 		{
-			// Pass the preferred disposable mock type from editorconfig as additional property, so that code fix can use it to determine which type to suggest in the code fix message and when applying the code fix.
 			var preferredDisposableMockType = Helper.ForAdditionalFiles.GetValueFromEditorConfig(Rule.Id, "preferred_disposable_mock_type");
 
 			ImmutableDictionary<string, string> properties = ImmutableDictionary<string, string>.Empty;
@@ -98,7 +90,7 @@ private void ReportDiagnostic(SyntaxNodeAnalysisContext context, ObjectCreationE
 			context.ReportDiagnostic(Diagnostic.Create(Rule, objectCreationExpressionSyntax.GetLocation(), properties, mockedType.Name));
 		}
 
-		private bool TryGetMockedType(SyntaxNodeAnalysisContext context, ObjectCreationExpressionSyntax objectCreationExpressionSyntax, out ITypeSymbol mockedType)
+		private bool TryGetMockedType(SyntaxNodeAnalysisContext context, ExpressionSyntax objectCreationExpressionSyntax, out ITypeSymbol mockedType)
 		{
 			mockedType = null;
 
@@ -180,7 +172,7 @@ Accessibility.ProtectedOrInternal or
 			};
 		}
 
-		private bool HasDisposeSetupInSameContainingMember(SyntaxNodeAnalysisContext context, ObjectCreationExpressionSyntax objectCreationExpressionSyntax)
+		private bool HasDisposeSetupInSameContainingMember(SyntaxNodeAnalysisContext context, ExpressionSyntax objectCreationExpressionSyntax)
 		{
 			ISymbol mockSymbol = GetAssignedMockSymbol(context, objectCreationExpressionSyntax);
 			if (mockSymbol == null)
@@ -229,16 +221,14 @@ private static SyntaxNode GetContainingMember(SyntaxNode node)
 			return containingMember;
 		}
 
-		private ISymbol GetAssignedMockSymbol(SyntaxNodeAnalysisContext context, ObjectCreationExpressionSyntax objectCreationExpressionSyntax)
+		private ISymbol GetAssignedMockSymbol(SyntaxNodeAnalysisContext context, ExpressionSyntax objectCreationExpressionSyntax)
 		{
-			// Local variable, including "using var mock = ..."
 			var equalsValueClauseSyntax = objectCreationExpressionSyntax.Parent as EqualsValueClauseSyntax;
 			if (equalsValueClauseSyntax?.Parent is VariableDeclaratorSyntax variableDeclaratorSyntax)
 			{
 				return context.SemanticModel.GetDeclaredSymbol(variableDeclaratorSyntax);
 			}
 
-			// Assignment to a field/property/local: mock = new Mock<T>();
 			if (objectCreationExpressionSyntax.Parent is AssignmentExpressionSyntax assignmentExpressionSyntax)
 			{
 				SymbolInfo symbolInfo = context.SemanticModel.GetSymbolInfo(assignmentExpressionSyntax.Left);
@@ -250,10 +240,6 @@ private ISymbol GetAssignedMockSymbol(SyntaxNodeAnalysisContext context, ObjectC
 
 		private bool IsDisposeSetupInvocation(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocationExpressionSyntax, ISymbol expectedMockSymbol)
 		{
-			// Looking for:
-			// mock.Protected().Setup(...Dispose...)
-			// We intentionally do not require CallBase() in v1.
-
 			if (invocationExpressionSyntax.Expression is not MemberAccessExpressionSyntax memberAccessExpressionSyntax)
 			{
 				return false;

Philips.CodeAnalysis.MoqAnalyzers/MockDisposableClassesShouldSetupDisposeCodeFixProvider.cs

@@ -14,13 +14,13 @@
 namespace Philips.CodeAnalysis.MoqAnalyzers
 {
 	[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(MockDisposableClassesShouldSetupDisposeCodeFixProvider)), Shared]
-	public class MockDisposableClassesShouldSetupDisposeCodeFixProvider : SingleDiagnosticCodeFixProvider<ObjectCreationExpressionSyntax>
+	public class MockDisposableClassesShouldSetupDisposeCodeFixProvider : SingleDiagnosticCodeFixProvider<ExpressionSyntax>
 	{
 		protected override string Title => "Use configured disposable mock type";
 
 		protected override DiagnosticId DiagnosticId => DiagnosticId.MockDisposableObjectsShouldSetupDispose;
 
-		protected override async Task<Document> ApplyFix(Document document, ObjectCreationExpressionSyntax node, ImmutableDictionary<string, string> properties, CancellationToken cancellationToken)
+		protected override async Task<Document> ApplyFix(Document document, ExpressionSyntax node, ImmutableDictionary<string, string> properties, CancellationToken cancellationToken)
 		{
 			var configuredTypeName = GetPreferredDisposableMockType(properties);
 			if (string.IsNullOrWhiteSpace(configuredTypeName))
@@ -34,55 +34,98 @@ protected override async Task<Document> ApplyFix(Document document, ObjectCreati
 				return document;
 			}
 
-			if (node.Type is not GenericNameSyntax objectCreationGenericName)
+			ExpressionSyntax currentNode = FindCurrentNode<ExpressionSyntax>(rootNode, node);
+			if (currentNode == null)
 			{
 				return document;
 			}
 
-			TypeSyntax replacementTypeSyntax = CreateReplacementTypeSyntax(configuredTypeName, objectCreationGenericName.TypeArgumentList);
+			TypeSyntax declaredTypeToReplace = GetDeclaredTypeFromContext(currentNode);
 
-			TypeSyntax replacementType = replacementTypeSyntax.WithAdditionalAnnotations(Formatter.Annotation);
+			if (currentNode is ImplicitObjectCreationExpressionSyntax)
+			{
+				if (declaredTypeToReplace is not GenericNameSyntax declaredGenericName)
+				{
+					return document;
+				}
+
+				TypeSyntax replacementType = CreateReplacementTypeSyntax(configuredTypeName, declaredGenericName.TypeArgumentList)
+					.WithAdditionalAnnotations(Formatter.Annotation);
 
-			SyntaxNode newRoot;
-			TypeSyntax declaredTypeToReplace = GetDeclaredTypeToReplace(node, objectCreationGenericName);
+				SyntaxNode newRoot = rootNode.ReplaceNode(
+					declaredTypeToReplace,
+					replacementType.WithTriviaFrom(declaredTypeToReplace));
+
+				return document.WithSyntaxRoot(newRoot);
+			}
 
-			if (declaredTypeToReplace != null)
+			if (currentNode is ObjectCreationExpressionSyntax explicitObjectCreation &&
+				explicitObjectCreation.Type is GenericNameSyntax explicitGenericName)
 			{
-				newRoot = rootNode.ReplaceNodes(
-					new SyntaxNode[] { node.Type, declaredTypeToReplace },
-					(original, _) => replacementType.WithTriviaFrom(original));
+				TypeSyntax replacementType = CreateReplacementTypeSyntax(configuredTypeName, explicitGenericName.TypeArgumentList)
+					.WithAdditionalAnnotations(Formatter.Annotation);
+
+				SyntaxNode newRoot;
+				if (IsMatchingMockDeclaredType(declaredTypeToReplace, explicitGenericName))
+				{
+					newRoot = rootNode.ReplaceNodes(
+						new SyntaxNode[] { explicitObjectCreation.Type, declaredTypeToReplace },
+						(original, _) => replacementType.WithTriviaFrom(original));
+				}
+				else
+				{
+					newRoot = rootNode.ReplaceNode(
+						explicitObjectCreation.Type,
+						replacementType.WithTriviaFrom(explicitObjectCreation.Type));
+				}
+
+				return document.WithSyntaxRoot(newRoot);
 			}
-			else
+
+			return document;
+		}
+
+		private static TNode FindCurrentNode<TNode>(SyntaxNode rootNode, SyntaxNode originalNode)
+			where TNode : SyntaxNode
+		{
+			if (rootNode == null || originalNode == null)
 			{
-				newRoot = rootNode.ReplaceNode(
-					node.Type,
-					replacementType.WithTriviaFrom(node.Type));
+				return null;
 			}
 
-			return document.WithSyntaxRoot(newRoot);
+			SyntaxNode currentNode = rootNode.FindNode(originalNode.Span, getInnermostNodeForTie: true);
+			return currentNode as TNode;
 		}
 
-		private static TypeSyntax GetDeclaredTypeToReplace(ObjectCreationExpressionSyntax objectCreationSyntax, GenericNameSyntax originalObjectCreationType)
+		private static TypeSyntax GetDeclaredTypeFromContext(SyntaxNode node)
 		{
-			VariableDeclarationSyntax variableDeclarationSyntax = objectCreationSyntax.FirstAncestorOrSelf<VariableDeclarationSyntax>();
-			if (variableDeclarationSyntax != null &&
-				variableDeclarationSyntax.Type is GenericNameSyntax declaredGenericName &&
-				declaredGenericName.Identifier.ValueText == originalObjectCreationType.Identifier.ValueText)
+			VariableDeclarationSyntax variableDeclarationSyntax = node.FirstAncestorOrSelf<VariableDeclarationSyntax>();
+			if (variableDeclarationSyntax != null)
 			{
 				return variableDeclarationSyntax.Type;
 			}
 
-			PropertyDeclarationSyntax propertyDeclarationSyntax = objectCreationSyntax.FirstAncestorOrSelf<PropertyDeclarationSyntax>();
-			if (propertyDeclarationSyntax != null &&
-				propertyDeclarationSyntax.Type is GenericNameSyntax propertyGenericName &&
-				propertyGenericName.Identifier.ValueText == originalObjectCreationType.Identifier.ValueText)
+			PropertyDeclarationSyntax propertyDeclarationSyntax = node.FirstAncestorOrSelf<PropertyDeclarationSyntax>();
+			if (propertyDeclarationSyntax != null)
 			{
 				return propertyDeclarationSyntax.Type;
 			}
 
+			FieldDeclarationSyntax fieldDeclarationSyntax = node.FirstAncestorOrSelf<FieldDeclarationSyntax>();
+			if (fieldDeclarationSyntax != null)
+			{
+				return fieldDeclarationSyntax.Declaration?.Type;
+			}
+
 			return null;
 		}
 
+		private static bool IsMatchingMockDeclaredType(TypeSyntax declaredTypeSyntax, GenericNameSyntax originalObjectCreationType)
+		{
+			return declaredTypeSyntax is GenericNameSyntax declaredGenericName &&
+				declaredGenericName.Identifier.ValueText == originalObjectCreationType.Identifier.ValueText;
+		}
+
 		private static string GetPreferredDisposableMockType(ImmutableDictionary<string, string> properties)
 		{
 			if (properties != null &&

Philips.CodeAnalysis.MsTestAnalyzers/TestMethodNameCodeFixProvider.cs

@@ -41,7 +41,7 @@ protected override async Task<Solution> ApplyFix(Document document, MethodDeclar
 
 			// Get the symbol representing the method to be renamed.
 			SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken);
-			IMethodSymbol typeSymbol = semanticModel.GetDeclaredSymbol(node, cancellationToken);
+			IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(node, cancellationToken);
 
 			SymbolRenameOptions renameOptions = new()
 			{
@@ -53,12 +53,11 @@ protected override async Task<Solution> ApplyFix(Document document, MethodDeclar
 
 			Solution newSolution = await Renamer.RenameSymbolAsync(
 				document.Project.Solution,
-				typeSymbol,
+				methodSymbol,
 				renameOptions,
 				name,
 				cancellationToken).ConfigureAwait(false);
 
-			// Return the new solution with the now-uppercase type name.
 			return newSolution;
 		}
 	}

Philips.CodeAnalysis.Test/Maintainability/Documentation/XmlDocumentationShouldAddValueAnalyzerTest.cs

@@ -81,7 +81,6 @@ public DoubleList(int capacity)
 		}}
 }}
 ";
-
 			await VerifyDiagnostic(content, DiagnosticId.EmptyXmlComments).ConfigureAwait(false);
 			await VerifyFix(content, newContent);
 		}

Philips.CodeAnalysis.Test/Maintainability/Maintainability/NoRegionsInMethodAnalyzerTest.cs

@@ -85,7 +85,7 @@ public async Task RegionCoversMultipleMethodsTestAsync()
 		[TestCategory(TestDefinitions.UnitTests)]
 		public async Task RegionBeforeClassTestAsync()
 		{
-			await VerifySuccessfulCompilation(@"	#region testRegion	#endregion Class C{	public void foo(){	return; }	public void bar(){	}	}").ConfigureAwait(false);
+			await VerifySuccessfulCompilation(@"	#region testRegion	#endregion class C{	public void foo(){	return; }	public void bar(){	}	}").ConfigureAwait(false);
 		}
 
 		[TestMethod]