Add analyzer for weighing-machine

src/Exercism.Analyzers.CSharp/Analyzers/Shared/SharedComments.cs

@@ -34,5 +34,8 @@ public static SolutionComment MissingMethod(string method) =>
 
         public static SolutionComment InvalidMethodSignature(string method, string signature) =>
             new SolutionComment("csharp.general.invalid_method_signature", new SolutionCommentParameter(Name, method), new SolutionCommentParameter(Signature, signature));
+
+        public static SolutionComment MissingProperty(string property) =>
+            new("csharp.general.missing_property", new SolutionCommentParameter(Name, property));
     }
 }

src/Exercism.Analyzers.CSharp/Analyzers/WeighingMachine/WeighingMachineAnalyzer.cs

@@ -0,0 +1,66 @@
+
+using Exercism.Analyzers.CSharp.Analyzers.Shared;
+
+using static Exercism.Analyzers.CSharp.Analyzers.Shared.SharedComments;
+using static Exercism.Analyzers.CSharp.Analyzers.WeighingMachine.WeighingMachineSolution;
+
+namespace Exercism.Analyzers.CSharp.Analyzers.WeighingMachine
+{
+    internal class WeighingMachineAnalyzer : SharedAnalyzer<WeighingMachineSolution>
+    {
+        protected override SolutionAnalysis DisapproveWhenInvalid(WeighingMachineSolution solution)
+        {
+            if (solution.MissingWeighingMachineClass)
+                solution.AddComment(MissingClass(WeighingMachineClassName));
+
+            foreach (var missing in solution.MissingRequiredProperties())
+            {
+                solution.AddComment(MissingProperty(missing));
+            }
+
+            if (!solution.PrecisionIsAutoProperty)
+            {
+                solution.AddComment(new SolutionComment("not PrecisionIsAutoProperty"));
+            }
+
+            if (!solution.TareAdjustmentIsAutoProperty)
+            {
+                solution.AddComment(new SolutionComment("not TareAdjustmentIsAutoProperty"));
+            }
+
+            if (solution.PrecisionPropertyHasNonPrivateSetter())
+            {
+                solution.AddComment(new SolutionComment("PrecisionPropertyHasNonPrivateSetter"));
+            }
+
+            if (!solution.WeightFieldNameIsPrivate)
+            {
+                solution.AddComment(new SolutionComment("not WeightFieldNameIsPrivate"));
+            }
+
+            if (!solution.IsRoundMethodCalledInDisplayWeightProperty())
+            {
+                solution.AddComment(new SolutionComment("not IsRoundMethodCalledInDisplayWeightProperty"));
+            }
+
+            return solution.HasComments
+                ? solution.Disapprove()
+                : solution.ContinueAnalysis();
+        }
+
+        protected override SolutionAnalysis ApproveWhenValid(WeighingMachineSolution solution)
+        {
+            if (solution.TareAdjustmentHasInitializer)
+            {
+                solution.AddComment(new SolutionComment("TareAdjustmentHasInitializer"));
+            }
+
+            if (solution.HasComments)
+            {
+                return solution.Approve();
+            }
+
+            return solution.ContinueAnalysis();
+        }
+    }
+}

src/Exercism.Analyzers.CSharp/Analyzers/WeighingMachine/WeighingMachineComments.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Exercism.Analyzers.CSharp.Analyzers.WeighingMachine
+{
+    public class WeighingMachineComments
+    {
+
+    }
+}

src/Exercism.Analyzers.CSharp/Analyzers/WeighingMachine/WeighingMachineSolution.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Exercism.Analyzers.CSharp.Syntax;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Exercism.Analyzers.CSharp.Analyzers.WeighingMachine
+{
+    internal class WeighingMachineSolution : Solution
+    {
+        public const string WeighingMachineClassName = "WeighingMachine";
+        public const string PrecisionPropertyName = "Precision";
+        public const string WeightPropertyName = "Weight";
+        public const string TareAdjustmentPropertyName = "TareAdjustment";
+        public const string DisplayWeightPropertyName = "DisplayWeight";
+        public const string WeightFieldName = "weight";
+
+        public WeighingMachineSolution(Solution solution) : base(solution)
+        {
+        }
+
+        private ClassDeclarationSyntax WeighingMachineClass => SyntaxRoot.GetClass(WeighingMachineClassName);
+
+        public bool MissingWeighingMachineClass => WeighingMachineClass is null;
+
+        private PropertyDeclarationSyntax PrecisionProperty => WeighingMachineClass?.GetProperty(PrecisionPropertyName);
+
+        private PropertyDeclarationSyntax WeightProperty => WeighingMachineClass?.GetProperty(WeightPropertyName);
+
+        private PropertyDeclarationSyntax TareAdjustmentProperty => WeighingMachineClass?.GetProperty(TareAdjustmentPropertyName);
+
+        private PropertyDeclarationSyntax DisplayWeightProperty => WeighingMachineClass?.GetProperty(DisplayWeightPropertyName);
+
+        public IEnumerable<string> MissingRequiredProperties()
+        {
+            if (PrecisionProperty is null) yield return PrecisionPropertyName;
+            if (WeightProperty is null) yield return WeightPropertyName;
+            if (TareAdjustmentProperty is null) yield return TareAdjustmentPropertyName;
+            if (DisplayWeightProperty is null) yield return DisplayWeightPropertyName;
+        }
+
+        public bool PrecisionIsAutoProperty => PrecisionProperty?.IsAutoProperty() == true;
+
+        public bool TareAdjustmentIsAutoProperty => TareAdjustmentProperty?.IsAutoProperty() == true;
+
+        public bool TareAdjustmentHasInitializer => TareAdjustmentProperty?.HasInitializer() == true;
+
+        public bool PrecisionPropertyHasNonPrivateSetter()
+        {
+            var setAccessor = PrecisionProperty.GetSetAccessor();
+            return setAccessor is not null && 
+                (setAccessor.Modifiers.Count == 0 || 
+                !setAccessor.Modifiers.Any(m => m.IsKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind.PrivateKeyword)));
+        }
+
+        public bool WeightFieldNameIsPrivate => WeighingMachineClass?.GetField(WeightFieldName)?.IsPrivate() ?? false;
+
+        public bool IsRoundMethodCalledInDisplayWeightProperty() => 
+            DisplayWeightProperty?.GetMethodCalled("Round") is not null;
+
+
+    }
+}

src/Exercism.Analyzers.CSharp/Analyzers/WeighingMachine/WeighingMachineSyntaxFactory.cs

@@ -0,0 +1,19 @@
+using System.Linq;
+
+using Exercism.Analyzers.CSharp.Syntax;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Exercism.Analyzers.CSharp.Analyzers.WeighingMachine
+{
+    public static class WeighingMachineSyntaxFactory
+    {
+        public static MemberAccessExpressionSyntax GetMethodCalled(this SyntaxNode syntaxNode, string methodName) =>
+            syntaxNode
+                .DescendantNodes<InvocationExpressionSyntax>()
+                .Select(s => s.Expression)
+                .OfType<MemberAccessExpressionSyntax>()
+                .FirstOrDefault(s => s.Name.Identifier.Text == methodName);
+    }
+}

src/Exercism.Analyzers.CSharp/Exercises.cs

@@ -5,5 +5,6 @@ internal static class Exercises
         public const string TwoFer = "two-fer";
         public const string Gigasecond = "gigasecond";
         public const string Leap = "leap";
+        public const string WeighingMachine = "weighing-machine";
     }
 }

src/Exercism.Analyzers.CSharp/Exercism.Analyzers.CSharp.csproj

@@ -9,9 +9,9 @@
     <ItemGroup>
         <PackageReference Include="CommandLineParser" Version="2.8.0" />
         <PackageReference Include="Humanizer.Core" Version="2.11.10" />
-        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" />
         <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3" />
-        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.11.0" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.0.1" />
         <PackageReference Include="Serilog" Version="2.10.0" />
         <PackageReference Include="Serilog.Sinks.Console" Version="4.0.0" />
     </ItemGroup>

src/Exercism.Analyzers.CSharp/SolutionAnalyzer.cs

@@ -2,6 +2,7 @@
 using Exercism.Analyzers.CSharp.Analyzers.Gigasecond;
 using Exercism.Analyzers.CSharp.Analyzers.Leap;
 using Exercism.Analyzers.CSharp.Analyzers.TwoFer;
+using Exercism.Analyzers.CSharp.Analyzers.WeighingMachine;
 
 namespace Exercism.Analyzers.CSharp
 {
@@ -17,6 +18,8 @@ public static SolutionAnalysis Analyze(Solution solution)
                     return new GigasecondAnalyzer().Analyze(new GigasecondSolution(solution));
                 case Exercises.Leap:
                     return new LeapAnalyzer().Analyze(new LeapSolution(solution));
+                case Exercises.WeighingMachine:
+                    return new WeighingMachineAnalyzer().Analyze(new WeighingMachineSolution(solution));
                 default:
                     return new DefaultExerciseAnalyzer().Analyze(new DefaultSolution(solution));
             }

src/Exercism.Analyzers.CSharp/Syntax/PropertyDeclarationSyntaxExtensions.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Exercism.Analyzers.CSharp.Syntax
+{
+    public static class PropertyDeclarationSyntaxExtensions
+    {
+        public const string GetAccessorName = "get";
+        public const string SetAccessorName = "set";
+
+        public static bool IsAutoProperty(this PropertyDeclarationSyntax property)
+        {
+            if (property.AccessorList != null)
+            {
+                return property.AccessorList.Accessors.All(a => a.Body is null || a.ExpressionBody is null);
+            }
+
+            return property.ExpressionBody is null;
+        }
+
+        public static bool HasInitializer(this PropertyDeclarationSyntax property) => property?.Initializer is not null;
+
+        public static AccessorDeclarationSyntax GetAccessor(this PropertyDeclarationSyntax property, string accessor)
+        {
+            return property?.AccessorList?.Accessors.Where(ac => ac.Keyword.Text == accessor).FirstOrDefault();
+        }
+
+        public static AccessorDeclarationSyntax GetGetAccessor(this PropertyDeclarationSyntax property) => 
+            property?.GetAccessor(GetAccessorName);
+
+        public static AccessorDeclarationSyntax GetSetAccessor(this PropertyDeclarationSyntax property) => 
+            property?.GetAccessor(SetAccessorName);
+    }
+}

src/Exercism.Analyzers.CSharp/Syntax/SyntaxNodeExtensions.cs

@@ -34,6 +34,34 @@ public static IEnumerable<MethodDeclarationSyntax> GetMethods(this SyntaxNode sy
                 .DescendantNodes<MethodDeclarationSyntax>()
                 .Where(syntax => syntax.Identifier.Text == methodName) ?? Enumerable.Empty<MethodDeclarationSyntax>();
 
+        public static PropertyDeclarationSyntax GetProperty(this SyntaxNode syntaxNode, string propertyName) =>
+            syntaxNode?
+                .DescendantNodes<PropertyDeclarationSyntax>()
+                .FirstOrDefault(syntax => syntax.Identifier.Text == propertyName);
+
+        public static IEnumerable<PropertyDeclarationSyntax> GetProperties(this SyntaxNode syntaxNode, string propertyName) =>
+            syntaxNode?
+                .DescendantNodes<PropertyDeclarationSyntax>()
+                .Where(syntax => syntax.Identifier.Text == propertyName) ?? Enumerable.Empty<PropertyDeclarationSyntax>();
+
+        public static FieldDeclarationSyntax GetField(this SyntaxNode syntaxNode, string variable) =>
+            syntaxNode?
+                .DescendantNodes<VariableDeclaratorSyntax>()
+                .FirstOrDefault(syntax => IsEqualFieldName(syntax.Identifier.Text, variable))
+                ?.FieldDeclaration();
+
+        public static IEnumerable<FieldDeclarationSyntax> GetFields(this SyntaxNode syntaxNode, string variable) =>
+            syntaxNode?
+                .DescendantNodes<VariableDeclaratorSyntax>()
+                .Where(syntax => IsEqualFieldName(syntax.Identifier.Text, variable))
+                .Select(v => v?.FieldDeclaration()) ?? Enumerable.Empty<FieldDeclarationSyntax>();
+
+        public static bool IsEqualFieldName(string name, string expectedName)
+        {
+            var expected = new[] { expectedName, expectedName.StartsWith("_") ? expectedName.Substring(1) : "_" + expectedName };
+            return expected.Contains(name);
+        }
+
         public static bool AssignsToIdentifier(this SyntaxNode syntaxNode, IdentifierNameSyntax identifierName) =>
             syntaxNode?
                 .DescendantNodes<AssignmentExpressionSyntax>()