Add IDE0350 prefer implicitly typed lambda rule

lucaspimentel · lucaspimentel · commit 07b856a67542 · 2026-03-25T14:38:07.000-04:00
Flags lambdas with explicit parameter types when implicit typing
is preferred. Skips lambdas with explicit return types or params.

🤖 Co-Authored-By: Claude Code &lt;noreply@anthropic.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,7 @@
 - Add IDE0320 — prefer static anonymous function rule (`csharp_prefer_static_anonymous_function`), flags non-static lambdas and anonymous methods that don't capture enclosing state
 - Add IDE0150 — prefer null check over type check rule (`csharp_style_prefer_null_check_over_type_check`), flags `is object` → `is not null` and `is not object` → `is null`
 - Add IDE0330 — prefer System.Threading.Lock rule (`csharp_prefer_system_threading_lock`), flags `lock` on `object` fields, `this`, or `typeof`
+- Add IDE0350 — prefer implicitly typed lambda rule (`csharp_style_prefer_implicitly_typed_lambda_expression`), flags lambdas with explicit parameter types when implicit typing is preferred
 
 ## [1.6.0] - 2026-03-23
 
diff --git a/TODO.md b/TODO.md
@@ -36,7 +36,7 @@ Goal: support as many standard .editorconfig rules as possible using standard ke
 - [x] **`csharp_prefer_static_anonymous_function`** (IDE0320)
 - [x] **`csharp_prefer_system_threading_lock`** (IDE0330)
 - [x] **`csharp_style_prefer_unbound_generic_type_in_nameof`** (IDE0340)
-- [ ] **`csharp_style_prefer_implicitly_typed_lambda_expression`** (IDE0350)
+- [x] **`csharp_style_prefer_implicitly_typed_lambda_expression`** (IDE0350)
 - [ ] **`csharp_style_prefer_simple_property_accessors`** (IDE0360)
 - [ ] **`dotnet_style_prefer_foreach_explicit_cast_in_source`** (IDE0220)
 - [x] **`dotnet_style_prefer_inferred_tuple_names`** (IDE0037)
diff --git a/docs/rule-mappings.md b/docs/rule-mappings.md
@@ -141,6 +141,7 @@ Comprehensive reference for all CsLint rules and their corresponding third-party
 | IDE0320 | Prefer static anonymous function | `csharp_prefer_static_anonymous_function` | IDE0320 |
 | IDE0150 | Prefer null check over type check | `csharp_style_prefer_null_check_over_type_check` | IDE0150 |
 | IDE0330 | Prefer System.Threading.Lock | `csharp_prefer_system_threading_lock` | IDE0330 |
+| IDE0350 | Prefer implicitly typed lambda | `csharp_style_prefer_implicitly_typed_lambda_expression` | IDE0350 |
 
 ### Tier 4 -- Semantic Analysis (requires `--semantic`)
 
diff --git a/src/CsLint.Core/Engine/PragmaAliasMap.cs b/src/CsLint.Core/Engine/PragmaAliasMap.cs
@@ -95,6 +95,7 @@ internal static class PragmaAliasMap
             ["IDE0320"] = ["IDE0320"],
             ["IDE0150"] = ["IDE0150"],
             ["IDE0330"] = ["IDE0330"],
+            ["IDE0350"] = ["IDE0350"],
             ["IDE0040"] = ["CSLINT206"],
             ["IDE0041"] = ["CSLINT210"],
             ["IDE0045"] = ["CSLINT274"],
diff --git a/src/CsLint.Core/Engine/RuleRegistry.cs b/src/CsLint.Core/Engine/RuleRegistry.cs
@@ -64,6 +64,7 @@ public static RuleRegistry CreateDefault()
         registry.Register(new StaticAnonymousFunctionRule());
         registry.Register(new NullCheckOverTypeCheckRule());
         registry.Register(new SystemThreadingLockRule());
+        registry.Register(new ImplicitlyTypedLambdaRule());
         registry.Register(new PatternMatchingNotRule());
         registry.Register(new PatternMatchingCombinatorRule());
         registry.Register(new PrimaryConstructorRule());
diff --git a/src/CsLint.Core/Rules/Tier3/ImplicitlyTypedLambdaRule.cs b/src/CsLint.Core/Rules/Tier3/ImplicitlyTypedLambdaRule.cs
@@ -0,0 +1,110 @@
+using Cslint.Core.Config;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Cslint.Core.Rules.Tier3;
+
+public sealed class ImplicitlyTypedLambdaRule : IRuleDefinition, IDescendantNodeHandler
+{
+    public string RuleId => "IDE0350";
+
+    public string Name => "ImplicitlyTypedLambda";
+
+    public IReadOnlyList<string> ConfigKeys { get; } = ["csharp_style_prefer_implicitly_typed_lambda_expression"];
+
+    public LintSeverity DefaultSeverity => LintSeverity.Info;
+
+    public bool IsEnabled(LintConfiguration configuration) =>
+        configuration.GetValue("csharp_style_prefer_implicitly_typed_lambda_expression") is not null;
+
+    public IReadOnlyList<LintDiagnostic> Analyze(RuleContext context)
+    {
+        (string? pref, string? _) = context.Configuration
+            .GetValueWithSeverity("csharp_style_prefer_implicitly_typed_lambda_expression");
+
+        if (!string.Equals(pref, "true", StringComparison.OrdinalIgnoreCase))
+        {
+            return [];
+        }
+
+        var diagnostics = new List<LintDiagnostic>();
+
+        foreach (SyntaxNode node in context.Root.DescendantNodes())
+        {
+            VisitNode(node, context.Configuration, context.FilePath, diagnostics);
+        }
+
+        return diagnostics;
+    }
+
+    public void VisitNode(
+        SyntaxNode node,
+        LintConfiguration config,
+        string filePath,
+        List<LintDiagnostic> diagnostics)
+    {
+        if (node is not ParenthesizedLambdaExpressionSyntax lambda)
+        {
+            return;
+        }
+
+        // No parameters — nothing to flag
+        if (lambda.ParameterList.Parameters.Count == 0)
+        {
+            return;
+        }
+
+        // Explicit return type requires explicit parameter types
+        if (lambda.ReturnType is not null)
+        {
+            return;
+        }
+
+        // Check if all parameters have explicit types
+        bool allExplicit = true;
+
+        foreach (ParameterSyntax param in lambda.ParameterList.Parameters)
+        {
+            if (param.Type is null)
+            {
+                allExplicit = false;
+                break;
+            }
+        }
+
+        if (!allExplicit)
+        {
+            return;
+        }
+
+        // Skip if any parameter has params modifier
+        foreach (ParameterSyntax param in lambda.ParameterList.Parameters)
+        {
+            if (param.Modifiers.Any(SyntaxKind.ParamsKeyword))
+            {
+                return;
+            }
+        }
+
+        (string? pref, string? _) = config.GetValueWithSeverity("csharp_style_prefer_implicitly_typed_lambda_expression");
+
+        if (!string.Equals(pref, "true", StringComparison.OrdinalIgnoreCase))
+        {
+            return;
+        }
+
+        FileLinePositionSpan span = lambda.ParameterList.OpenParenToken.GetLocation().GetLineSpan();
+
+        diagnostics.Add(
+            new LintDiagnostic
+            {
+                RuleId = RuleId,
+                Message = "Lambda parameter types can be inferred",
+                Severity = LintSeverity.Info,
+                FilePath = filePath,
+                Line = span.StartLinePosition.Line + 1,
+                Column = span.StartLinePosition.Character + 1,
+            });
+    }
+}
diff --git a/test/CsLint.Core.Tests/Rules/Tier3/ImplicitlyTypedLambdaRuleTests.cs b/test/CsLint.Core.Tests/Rules/Tier3/ImplicitlyTypedLambdaRuleTests.cs
@@ -0,0 +1,201 @@
+using Cslint.Core.Config;
+using Cslint.Core.Rules;
+using Cslint.Core.Rules.Tier3;
+
+namespace Cslint.Core.Tests.Rules.Tier3;
+
+public class ImplicitlyTypedLambdaRuleTests
+{
+    private readonly ImplicitlyTypedLambdaRule _rule = new();
+
+    [Fact]
+    public void Analyze_ExplicitTypes_ReturnsDiagnostic()
+    {
+        string source = """
+            using System;
+            class C
+            {
+                void M()
+                {
+                    Func<int, int> f = (int x) => x + 1;
+                }
+            }
+            """;
+        var config = new LintConfiguration(new Dictionary<string, string>
+        {
+            ["csharp_style_prefer_implicitly_typed_lambda_expression"] = "true",
+        });
+        RuleContext context = TestHelper.CreateContext(source, config);
+
+        IReadOnlyList<LintDiagnostic> diagnostics = _rule.Analyze(context);
+
+        Assert.Single(diagnostics);
+        Assert.Equal("IDE0350", diagnostics[0].RuleId);
+    }
+
+    [Fact]
+    public void Analyze_MultipleExplicitTypes_ReturnsDiagnostic()
+    {
+        string source = """
+            using System;
+            class C
+            {
+                void M()
+                {
+                    Func<int, string, bool> f = (int x, string y) => true;
+                }
+            }
+            """;
+        var config = new LintConfiguration(new Dictionary<string, string>
+        {
+            ["csharp_style_prefer_implicitly_typed_lambda_expression"] = "true",
+        });
+        RuleContext context = TestHelper.CreateContext(source, config);
+
+        IReadOnlyList<LintDiagnostic> diagnostics = _rule.Analyze(context);
+
+        Assert.Single(diagnostics);
+    }
+
+    [Fact]
+    public void Analyze_ImplicitTypes_ReturnsNoDiagnostics()
+    {
+        string source = """
+            using System;
+            class C
+            {
+                void M()
+                {
+                    Func<int, int> f = (x) => x + 1;
+                }
+            }
+            """;
+        var config = new LintConfiguration(new Dictionary<string, string>
+        {
+            ["csharp_style_prefer_implicitly_typed_lambda_expression"] = "true",
+        });
+        RuleContext context = TestHelper.CreateContext(source, config);
+
+        IReadOnlyList<LintDiagnostic> diagnostics = _rule.Analyze(context);
+
+        Assert.Empty(diagnostics);
+    }
+
+    [Fact]
+    public void Analyze_SimpleLambda_ReturnsNoDiagnostics()
+    {
+        string source = """
+            using System;
+            class C
+            {
+                void M()
+                {
+                    Func<int, int> f = x => x + 1;
+                }
+            }
+            """;
+        var config = new LintConfiguration(new Dictionary<string, string>
+        {
+            ["csharp_style_prefer_implicitly_typed_lambda_expression"] = "true",
+        });
+        RuleContext context = TestHelper.CreateContext(source, config);
+
+        IReadOnlyList<LintDiagnostic> diagnostics = _rule.Analyze(context);
+
+        Assert.Empty(diagnostics);
+    }
+
+    [Fact]
+    public void Analyze_ExplicitReturnType_ReturnsNoDiagnostics()
+    {
+        string source = """
+            using System;
+            class C
+            {
+                void M()
+                {
+                    var f = int (int x) => x + 1;
+                }
+            }
+            """;
+        var config = new LintConfiguration(new Dictionary<string, string>
+        {
+            ["csharp_style_prefer_implicitly_typed_lambda_expression"] = "true",
+        });
+        RuleContext context = TestHelper.CreateContext(source, config);
+
+        IReadOnlyList<LintDiagnostic> diagnostics = _rule.Analyze(context);
+
+        Assert.Empty(diagnostics);
+    }
+
+    [Fact]
+    public void Analyze_NoParameters_ReturnsNoDiagnostics()
+    {
+        string source = """
+            using System;
+            class C
+            {
+                void M()
+                {
+                    Action a = () => Console.WriteLine();
+                }
+            }
+            """;
+        var config = new LintConfiguration(new Dictionary<string, string>
+        {
+            ["csharp_style_prefer_implicitly_typed_lambda_expression"] = "true",
+        });
+        RuleContext context = TestHelper.CreateContext(source, config);
+
+        IReadOnlyList<LintDiagnostic> diagnostics = _rule.Analyze(context);
+
+        Assert.Empty(diagnostics);
+    }
+
+    [Theory]
+    [InlineData("false")]
+    [InlineData("FALSE")]
+    public void Analyze_ConfigFalse_ReturnsNoDiagnostics(string value)
+    {
+        string source = """
+            using System;
+            class C
+            {
+                void M()
+                {
+                    Func<int, int> f = (int x) => x + 1;
+                }
+            }
+            """;
+        var config = new LintConfiguration(new Dictionary<string, string>
+        {
+            ["csharp_style_prefer_implicitly_typed_lambda_expression"] = value,
+        });
+        RuleContext context = TestHelper.CreateContext(source, config);
+
+        IReadOnlyList<LintDiagnostic> diagnostics = _rule.Analyze(context);
+
+        Assert.Empty(diagnostics);
+    }
+
+    [Fact]
+    public void Analyze_ConfigMissing_ReturnsNoDiagnostics()
+    {
+        string source = """
+            using System;
+            class C
+            {
+                void M()
+                {
+                    Func<int, int> f = (int x) => x + 1;
+                }
+            }
+            """;
+        RuleContext context = TestHelper.CreateContext(source);
+
+        IReadOnlyList<LintDiagnostic> diagnostics = _rule.Analyze(context);
+
+        Assert.Empty(diagnostics);
+    }
+}
