Add binary operation handler for DateTime to DateTimeOffset conversion detection (WIP)

Co-authored-by: BenjaminMichaelis <22186029+BenjaminMichaelis@users.noreply.github.com>

Author: Copilot

IntelliTect.Analyzer/IntelliTect.Analyzer.Test/DateTimeConversionTests.cs

@@ -262,6 +262,51 @@ static void Main(string[] args)
 
         }
 
+        [TestMethod]
+        public void UsageInLambdaWithDateProperty_ProducesWarningMessage()
+        {
+            // This test matches the original issue scenario
+            string source = @"
+using System;
+using System.Linq;
+
+namespace Test
+{
+    public class TimeEntry
+    {
+        public DateTimeOffset EndDate { get; set; }
+        public DateTimeOffset StartDate { get; set; }
+    }
+
+    public class DataSource
+    {
+        public IQueryable<TimeEntry> GetQuery(DateTime startDate, DateTime endDate)
+        {
+            return Enumerable.Empty<TimeEntry>().AsQueryable()
+                .Where(te =>
+                    te.EndDate <= endDate.Date.AddDays(1).AddTicks(-1) &&
+                    te.StartDate >= startDate.Date);
+        }
+    }
+}";
+
+            VerifyCSharpDiagnostic(source,
+                new DiagnosticResult
+                {
+                    Id = "INTL0202",
+                    Severity = DiagnosticSeverity.Warning,
+                    Message = "Using the symbol 'DateTimeOffset.implicit operator DateTimeOffset(DateTime)' can result in unpredictable behavior",
+                    Locations = [new DiagnosticResultLocation("Test0.cs", 18, 35)]
+                },
+                new DiagnosticResult
+                {
+                    Id = "INTL0202",
+                    Severity = DiagnosticSeverity.Warning,
+                    Message = "Using the symbol 'DateTimeOffset.implicit operator DateTimeOffset(DateTime)' can result in unpredictable behavior",
+                    Locations = [new DiagnosticResultLocation("Test0.cs", 19, 38)]
+                });
+        }
+
         protected override DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer()
         {
             return new Analyzers.BanImplicitDateTimeToDateTimeOffsetConversion();

IntelliTect.Analyzer/IntelliTect.Analyzer/Analyzers/BanImplicitDateTimeToDateTimeOffsetConversion.cs

@@ -2,6 +2,7 @@
 using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
 
@@ -30,6 +31,7 @@ public override void Initialize(AnalysisContext context)
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
             context.EnableConcurrentExecution();
             context.RegisterOperationAction(AnalyzeConversion, OperationKind.Conversion);
+            context.RegisterOperationAction(AnalyzeBinaryOperation, OperationKind.Binary);
         }
 
         private void AnalyzeConversion(OperationAnalysisContext context)
@@ -39,30 +41,74 @@ private void AnalyzeConversion(OperationAnalysisContext context)
                 return;
             }
 
-            if (conversionOperation.Conversion.MethodSymbol is object && conversionOperation.Conversion.MethodSymbol.ContainingType is object)
+            ITypeSymbol sourceType = conversionOperation.Operand.Type;
+            ITypeSymbol targetType = conversionOperation.Type;
+
+            if (sourceType is null || targetType is null)
+            {
+                return;
+            }
+
+            INamedTypeSymbol dateTimeType = context.Compilation.GetTypeByMetadataName("System.DateTime");
+            INamedTypeSymbol dateTimeOffsetType = context.Compilation.GetTypeByMetadataName("System.DateTimeOffset");
+
+            if (dateTimeType is null || dateTimeOffsetType is null)
             {
-                INamedTypeSymbol containingType = conversionOperation.Conversion.MethodSymbol.ContainingType;
-                if (IsDateTimeOffsetSymbol(context, containingType))
-                {
-                    context.ReportDiagnostic(Diagnostic.Create(_Rule202, conversionOperation.Syntax.GetLocation()));
-                }
+                return;
             }
-            else
+
+            // Check if source is DateTime and target is DateTimeOffset
+            if (SymbolEqualityComparer.Default.Equals(sourceType, dateTimeType) && 
+                SymbolEqualityComparer.Default.Equals(targetType, dateTimeOffsetType))
             {
-                IOperation implicitDateTimeOffsetOp = conversionOperation.Operand.ChildOperations
-                    .Where(op => op.Kind == OperationKind.Argument && IsDateTimeOffsetSymbol(context, ((IArgumentOperation)op).Value.Type))
-                    .FirstOrDefault();
-                if (implicitDateTimeOffsetOp != default)
-                {
-                    context.ReportDiagnostic(Diagnostic.Create(_Rule202, implicitDateTimeOffsetOp.Syntax.GetLocation()));
-                }
+                // Report the diagnostic at the operand's location (the DateTime expression being converted)
+                context.ReportDiagnostic(Diagnostic.Create(_Rule202, conversionOperation.Operand.Syntax.GetLocation()));
             }
         }
 
-        private static bool IsDateTimeOffsetSymbol(OperationAnalysisContext context, ITypeSymbol symbol)
+        private void AnalyzeBinaryOperation(OperationAnalysisContext context)
         {
+            if (context.Operation is not IBinaryOperation binaryOperation)
+            {
+                return;
+            }
+
+            INamedTypeSymbol dateTimeType = context.Compilation.GetTypeByMetadataName("System.DateTime");
             INamedTypeSymbol dateTimeOffsetType = context.Compilation.GetTypeByMetadataName("System.DateTimeOffset");
-            return SymbolEqualityComparer.Default.Equals(symbol, dateTimeOffsetType);
+
+            if (dateTimeType is null || dateTimeOffsetType is null)
+            {
+                return;
+            }
+
+            // For binary operations, check if either operand is DateTime and the other is DateTimeOffset
+            // This catches cases where IConversionOperation nodes are not created (e.g., property access)
+            CheckBinaryOperandPair(context, binaryOperation.LeftOperand, binaryOperation.RightOperand, dateTimeType, dateTimeOffsetType);
+            CheckBinaryOperandPair(context, binaryOperation.RightOperand, binaryOperation.LeftOperand, dateTimeType, dateTimeOffsetType);
+        }
+
+        private void CheckBinaryOperandPair(OperationAnalysisContext context, IOperation operand, IOperation otherOperand, INamedTypeSymbol dateTimeType, INamedTypeSymbol dateTimeOffsetType)
+        {
+            if (operand is null || operand.Type is null || otherOperand is null || otherOperand.Type is null)
+            {
+                return;
+            }
+
+            // Skip if we don't have a syntax location to report
+            if (operand.Syntax is null)
+            {
+                return;
+            }
+
+            // Check if operand is DateTime and other operand is DateTimeOffset
+            bool isDateTimeOperand = SymbolEqualityComparer.Default.Equals(operand.Type, dateTimeType);
+            bool isDateTimeOffsetOtherOperand = SymbolEqualityComparer.Default.Equals(otherOperand.Type, dateTimeOffsetType);
+
+            if (isDateTimeOperand && isDateTimeOffsetOtherOperand)
+            {
+                // DateTime will be implicitly converted to DateTimeOffset in the comparison
+                context.ReportDiagnostic(Diagnostic.Create(_Rule202, operand.Syntax.GetLocation()));
+            }
         }
 
         private static class Rule202