#6 using existing field IFileSystem for FileServiceInterfaceInjectionCodeAction

Author: inyutin-maxim

System.IO.Abstractions.Analyzers.Tests/TestData/CodeFix/FileServiceInterfaceInjectionCodeFix/AfterFixConstructorParameterUniqName.txt

@@ -5,11 +5,11 @@ namespace SomeNameSpace
 {
 	public class WithOutFileSystem
 	{
-		private readonly IFileSystem _fileSystem;
+		private readonly IFileSystem _fSystem;
 
 		public WithOutFileSystem(IFileSystem fSystem)
 		{
-			_fileSystem = fSystem;
+			_fSystem = fSystem;
 		}
 
 		public void SomeMethod()

System.IO.Abstractions.Analyzers.Tests/TestData/CodeFix/FileServiceInterfaceInjectionCodeFix/BeforeFixExistingConstructorParameterUniqName.txt

@@ -4,6 +4,8 @@ namespace SomeNameSpace
 {
 	public class WithOutFileSystem
 	{
+		private readonly IFileSystem _fSystem;
+
 		public WithOutFileSystem(IFileSystem fSystem)
 		{
 		}

System.IO.Abstractions.Analyzers/Analyzers/FileServiceInterfaceInjectionAnalyzer.cs

@@ -1,4 +1,5 @@
 using System.Collections.Immutable;
+using System.IO.Abstractions.Analyzers.RoslynToken;
 using System.Linq;
 using JetBrains.Annotations;
 using Microsoft.CodeAnalysis;
@@ -64,11 +65,18 @@ protected override void AnalyzeCompilation(CompilationStartAnalysisContext compi
 						return;
 					}
 
-					var fileSystem = classDeclarationSyntax.Members.OfType<FieldDeclarationSyntax>()
-						.FirstOrDefault(x =>
-							x.Declaration.Type.NormalizeWhitespace().ToFullString() == fileSystemContext.FileSystemType.Name);
-
-					if (fileSystem == null)
+					if (RoslynClassFileSystem.HasFileSystemField(classDeclarationSyntax)
+						&& RoslynClassFileSystem.HasConstructor(classDeclarationSyntax))
+					{
+						var ctor = RoslynClassFileSystem.GetConstructor(classDeclarationSyntax);
+						var field = RoslynClassFileSystem.GetFileSystemFieldFromClass(classDeclarationSyntax);
+
+						if (!RoslynClassFileSystem.ConstructorHasAssignmentExpression(ctor, field.Declaration.Variables.ToFullString()))
+						{
+							syntaxContext.ReportDiagnostic(Diagnostic.Create(Rule,
+								classDeclarationSyntax.Identifier.GetLocation()));
+						}
+					} else
 					{
 						syntaxContext.ReportDiagnostic(Diagnostic.Create(Rule,
 							classDeclarationSyntax.Identifier.GetLocation()));

System.IO.Abstractions.Analyzers/CodeActions/FileServiceInterfaceInjectionCodeAction.cs

@@ -74,10 +74,10 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
 			return editor.GetChangedDocument();
 		}
 
-		private static ExpressionStatementSyntax CreateAssignmentExpression(string parameter)
+		private static ExpressionStatementSyntax CreateAssignmentExpression(string field, string parameter)
 		{
 			return SF.ExpressionStatement(SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
-				SF.IdentifierName(Constants.FieldFileSystemName),
+				SF.IdentifierName(field),
 				SF.IdentifierName(parameter)));
 		}
 
@@ -101,8 +101,18 @@ private static void ConstructorAddParameter(ClassDeclarationSyntax classDeclarat
 			{
 				var parameterSyntax = RoslynClassFileSystem.GetFileSystemParameterFromConstructor(newConstructor);
 
-				newConstructor =
-					newConstructor.AddBodyStatements(CreateAssignmentExpression(parameterSyntax.Identifier.Text));
+				if (RoslynClassFileSystem.HasFileSystemField(classDeclaration))
+				{
+					var fileSystem = RoslynClassFileSystem.GetFileSystemFieldFromClass(classDeclaration);
+
+					newConstructor = newConstructor.AddBodyStatements(CreateAssignmentExpression(fileSystem.Declaration.Variables.ToFullString(),
+						parameterSyntax.Identifier.Text));
+				} else
+				{
+					newConstructor =
+						newConstructor.AddBodyStatements(CreateAssignmentExpression(Constants.FieldFileSystemName,
+							parameterSyntax.Identifier.Text));
+				}
 			}
 
 			if (RoslynClassFileSystem.HasConstructor(classDeclaration))

System.IO.Abstractions.Analyzers/RoslynToken/RoslynClassFileSystem.cs

@@ -66,13 +66,20 @@ public static bool ConstructorHasFileSystemParameter(BaseMethodDeclarationSyntax
 				.Any(x => x.Type.NormalizeWhitespace().ToFullString() == GetFileSystemType().NormalizeWhitespace().ToFullString());
 		}
 
-		public static ParameterSyntax GetFileSystemParameterFromConstructor(BaseMethodDeclarationSyntax constructor)
+		public static ParameterSyntax GetFileSystemParameterFromConstructor(ConstructorDeclarationSyntax constructor)
 		{
 			return constructor.ParameterList.Parameters
 				.FirstOrDefault(x =>
 					x.Type.NormalizeWhitespace().ToFullString() == GetFileSystemType().NormalizeWhitespace().ToFullString());
 		}
 
+		public static FieldDeclarationSyntax GetFileSystemFieldFromClass(ClassDeclarationSyntax @class)
+		{
+			return @class.Members.OfType<FieldDeclarationSyntax>()
+				.FirstOrDefault(x =>
+					x.Declaration.Type.NormalizeWhitespace().ToFullString() == GetFileSystemType().ToFullString());
+		}
+
 		public static ParameterSyntax CreateFileSystemParameterDeclaration()
 		{
 			return SF.Parameter(SF.Identifier(Constants.ParameterFileSystemName))
@@ -97,16 +104,17 @@ public static CompilationUnitSyntax GetCompilationUnit(SyntaxNode node)
 			}
 		}
 
-		public static bool ConstructorHasAssignmentExpression(BaseMethodDeclarationSyntax constructor)
+		public static bool ConstructorHasAssignmentExpression(BaseMethodDeclarationSyntax constructor,
+															string field = Constants.FieldFileSystemName)
 		{
 			if (constructor.Body == null)
 			{
 				return false;
 			}
 
 			return constructor.Body.Statements.OfType<ExpressionStatementSyntax>()
-				.Any(x => x.IsKind(SyntaxKind.SimpleAssignmentExpression)
-						&& x.Expression.Contains(SF.IdentifierName(Constants.FieldFileSystemName)));
+				.Any(x => x.Expression.IsKind(SyntaxKind.SimpleAssignmentExpression)
+						&& x.Expression.ChildNodes().OfType<IdentifierNameSyntax>().Any(a => a.Identifier.Text == field));
 		}
 	}
 }