Add IDE0330 prefer System.Threading.Lock rule

Flags lock statements on object-typed fields, 'this', and typeof()
expressions, suggesting System.Threading.Lock instead.

🤖 Co-Authored-By: Claude Code <noreply@anthropic.com>

Author: lucaspimentel

CHANGELOG.md

@@ -9,6 +9,7 @@
 - Add IDE0062 — prefer static local function rule (`csharp_prefer_static_local_function`), flags non-static local functions that don't capture enclosing state
 - 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`
 
 ## [1.6.0] - 2026-03-23
 

TODO.md

@@ -34,7 +34,7 @@ Goal: support as many standard .editorconfig rules as possible using standard ke
 - [ ] **`dotnet_style_parentheses_in_other_operators`** (IDE0047/IDE0048)
 - [x] **`csharp_style_prefer_null_check_over_type_check`** (IDE0150)
 - [x] **`csharp_prefer_static_anonymous_function`** (IDE0320)
-- [ ] **`csharp_prefer_system_threading_lock`** (IDE0330)
+- [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)
 - [ ] **`csharp_style_prefer_simple_property_accessors`** (IDE0360)

docs/rule-mappings.md

@@ -140,6 +140,7 @@ Comprehensive reference for all CsLint rules and their corresponding third-party
 | IDE0062 | Prefer static local function | `csharp_prefer_static_local_function` | IDE0062 |
 | 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 |
 
 ### Tier 4 -- Semantic Analysis (requires `--semantic`)
 

src/CsLint.Core/Engine/PragmaAliasMap.cs

@@ -94,6 +94,7 @@ internal static class PragmaAliasMap
             ["IDE0062"] = ["IDE0062"],
             ["IDE0320"] = ["IDE0320"],
             ["IDE0150"] = ["IDE0150"],
+            ["IDE0330"] = ["IDE0330"],
             ["IDE0040"] = ["CSLINT206"],
             ["IDE0041"] = ["CSLINT210"],
             ["IDE0045"] = ["CSLINT274"],

src/CsLint.Core/Engine/RuleRegistry.cs

@@ -63,6 +63,7 @@ public static RuleRegistry CreateDefault()
         registry.Register(new StaticLocalFunctionRule());
         registry.Register(new StaticAnonymousFunctionRule());
         registry.Register(new NullCheckOverTypeCheckRule());
+        registry.Register(new SystemThreadingLockRule());
         registry.Register(new PatternMatchingNotRule());
         registry.Register(new PatternMatchingCombinatorRule());
         registry.Register(new PrimaryConstructorRule());

src/CsLint.Core/Rules/Tier3/SystemThreadingLockRule.cs

@@ -0,0 +1,163 @@
+using Cslint.Core.Config;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Cslint.Core.Rules.Tier3;
+
+public sealed class SystemThreadingLockRule : IRuleDefinition, IDescendantNodeHandler
+{
+    public string RuleId => "IDE0330";
+
+    public string Name => "SystemThreadingLock";
+
+    public IReadOnlyList<string> ConfigKeys { get; } = ["csharp_prefer_system_threading_lock"];
+
+    public LintSeverity DefaultSeverity => LintSeverity.Info;
+
+    private static bool IsObjectType(TypeSyntax type) =>
+        type is PredefinedTypeSyntax predefined && predefined.Keyword.IsKind(SyntaxKind.ObjectKeyword);
+
+    private static TypeDeclarationSyntax? FindEnclosingType(SyntaxNode node)
+    {
+        SyntaxNode? current = node.Parent;
+
+        while (current is not null)
+        {
+            if (current is TypeDeclarationSyntax typeDecl)
+            {
+                return typeDecl;
+            }
+
+            current = current.Parent;
+        }
+
+        return null;
+    }
+
+    private static bool IsObjectField(string fieldName, TypeDeclarationSyntax enclosingType)
+    {
+        foreach (MemberDeclarationSyntax member in enclosingType.Members)
+        {
+            if (member is not FieldDeclarationSyntax field)
+            {
+                continue;
+            }
+
+            foreach (VariableDeclaratorSyntax variable in field.Declaration.Variables)
+            {
+                if (variable.Identifier.Text == fieldName && IsObjectType(field.Declaration.Type))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public bool IsEnabled(LintConfiguration configuration) =>
+        configuration.GetValue("csharp_prefer_system_threading_lock") is not null;
+
+    public IReadOnlyList<LintDiagnostic> Analyze(RuleContext context)
+    {
+        (string? pref, string? _) = context.Configuration
+            .GetValueWithSeverity("csharp_prefer_system_threading_lock");
+
+        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 LockStatementSyntax lockStatement)
+        {
+            return;
+        }
+
+        (string? pref, string? _) = config.GetValueWithSeverity("csharp_prefer_system_threading_lock");
+
+        if (!string.Equals(pref, "true", StringComparison.OrdinalIgnoreCase))
+        {
+            return;
+        }
+
+        ExpressionSyntax expression = lockStatement.Expression;
+        string? message = GetDiagnosticMessage(expression);
+
+        if (message is null)
+        {
+            return;
+        }
+
+        FileLinePositionSpan span = lockStatement.LockKeyword.GetLocation().GetLineSpan();
+
+        diagnostics.Add(
+            new LintDiagnostic
+            {
+                RuleId = RuleId,
+                Message = message,
+                Severity = LintSeverity.Info,
+                FilePath = filePath,
+                Line = span.StartLinePosition.Line + 1,
+                Column = span.StartLinePosition.Character + 1,
+            });
+    }
+
+    private string? GetDiagnosticMessage(ExpressionSyntax expression)
+    {
+        // lock (this)
+        if (expression is ThisExpressionSyntax)
+        {
+            return "Use a dedicated System.Threading.Lock field instead of locking on 'this'";
+        }
+
+        // lock (typeof(...))
+        if (expression is TypeOfExpressionSyntax)
+        {
+            return "Use a dedicated System.Threading.Lock field instead of locking on a Type object";
+        }
+
+        // Extract field name from identifier or this.identifier
+        string? fieldName = expression switch
+        {
+            IdentifierNameSyntax id => id.Identifier.Text,
+            MemberAccessExpressionSyntax { Expression: ThisExpressionSyntax, Name: IdentifierNameSyntax name } => name.Identifier.Text,
+            _ => null,
+        };
+
+        if (fieldName is null)
+        {
+            return null;
+        }
+
+        TypeDeclarationSyntax? enclosingType = FindEnclosingType(expression);
+
+        if (enclosingType is null)
+        {
+            return null;
+        }
+
+        if (IsObjectField(fieldName, enclosingType))
+        {
+            return $"Use System.Threading.Lock instead of object for lock field '{fieldName}'";
+        }
+
+        return null;
+    }
+}