Implement control flow graph for Lock object feature

src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs

@@ -2052,7 +2052,22 @@ private ILockOperation CreateBoundLockStatementOperation(BoundLockStatement boun
             SyntaxNode syntax = boundLockStatement.Syntax;
             bool isImplicit = boundLockStatement.WasCompilerGenerated;
 
-            return new LockOperation(lockedValue, body, lockTakenSymbol, _semanticModel, syntax, isImplicit);
+            (IOperation, IMethodSymbol)? lockTypeInfo =
+                boundLockStatement.Argument is { Type: { } argType, Syntax: var argSyntax } argExpression &&
+                argType.IsWellKnownTypeLock() &&
+                LockBinder.TryFindLockTypeInfo(argType, CSharp.BindingDiagnosticBag.Discarded, argSyntax) is { } binderInfo
+                    ? (CreateBoundCallOperation(BoundCall.Synthesized(
+                            argSyntax,
+                            argExpression,
+                            initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown,
+                            binderInfo.EnterLockScopeMethod)),
+                        binderInfo.ScopeDisposeMethod.GetPublicSymbol())
+                    : null;
+
+            return new LockOperation(lockedValue, body, lockTakenSymbol, _semanticModel, syntax, isImplicit)
+            {
+                LockTypeInfo = lockTypeInfo,
+            };
         }
 
         private IInvalidOperation CreateBoundBadStatementOperation(BoundBadStatement boundBadStatement)

src/Compilers/CSharp/Test/Emit2/Semantics/LockTests.cs

@@ -1441,6 +1441,118 @@ public void LangVersion()
             verify: Verification.FailsILVerify).VerifyDiagnostics();
     }
 
+    [Fact]
+    public void OperationTree()
+    {
+        var source = """
+            using System;
+            using System.Threading;
+
+            Lock l = new Lock();
+            /*<bind>*/lock (l)
+            {
+            }/*</bind>*/
+            """;
+
+        var expectedOperationTree = """
+            ILockOperation (OperationKind.Lock, Type: null) (Syntax: 'lock (l) ... }')
+              Expression:
+                ILocalReferenceOperation: l (OperationKind.LocalReference, Type: System.Threading.Lock) (Syntax: 'l')
+              Body:
+                IBlockOperation (0 statements) (OperationKind.Block, Type: null) (Syntax: '{ ... }')
+            """;
+
+        var expectedDiagnostics = DiagnosticDescription.None;
+
+        VerifyOperationTreeAndDiagnosticsForTest<LockStatementSyntax>([source, LockTypeDefinition], expectedOperationTree, expectedDiagnostics);
+    }
+
+    [Fact]
+    public void FlowGraph()
+    {
+        var source = """
+            using System;
+            using System.Threading;
+
+            class C
+            {
+                void M()
+                /*<bind>*/{
+                    Lock l = new Lock();
+                    lock (l)
+                    {
+                    }
+                }/*</bind>*/
+            }
+            """;
+
+        var expectedFlowGraph = """
+            Block[B0] - Entry
+                Statements (0)
+                Next (Regular) Block[B1]
+                    Entering: {R1}
+            .locals {R1}
+            {
+                Locals: [System.Threading.Lock l]
+                Block[B1] - Block
+                    Predecessors: [B0]
+                    Statements (1)
+                        ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Threading.Lock, IsImplicit) (Syntax: 'l = new Lock()')
+                          Left:
+                            ILocalReferenceOperation: l (IsDeclaration: True) (OperationKind.LocalReference, Type: System.Threading.Lock, IsImplicit) (Syntax: 'l = new Lock()')
+                          Right:
+                            IObjectCreationOperation (Constructor: System.Threading.Lock..ctor()) (OperationKind.ObjectCreation, Type: System.Threading.Lock) (Syntax: 'new Lock()')
+                              Arguments(0)
+                              Initializer:
+                                null
+                    Next (Regular) Block[B2]
+                        Entering: {R2}
+                .locals {R2}
+                {
+                    CaptureIds: [0]
+                    Block[B2] - Block
+                        Predecessors: [B1]
+                        Statements (1)
+                            IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'l')
+                              Value:
+                                IInvocationOperation ( System.Threading.Lock.Scope System.Threading.Lock.EnterLockScope()) (OperationKind.Invocation, Type: System.Threading.Lock.Scope, IsImplicit) (Syntax: 'l')
+                                  Instance Receiver:
+                                    ILocalReferenceOperation: l (OperationKind.LocalReference, Type: System.Threading.Lock) (Syntax: 'l')
+                                  Arguments(0)
+                        Next (Regular) Block[B3]
+                            Entering: {R3} {R4}
+                    .try {R3, R4}
+                    {
+                        Block[B3] - Block
+                            Predecessors: [B2]
+                            Statements (0)
+                            Next (Regular) Block[B5]
+                                Finalizing: {R5}
+                                Leaving: {R4} {R3} {R2} {R1}
+                    }
+                    .finally {R5}
+                    {
+                        Block[B4] - Block
+                            Predecessors (0)
+                            Statements (1)
+                                IInvocationOperation ( void System.Threading.Lock.Scope.Dispose()) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'l')
+                                  Instance Receiver:
+                                    IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: System.Threading.Lock.Scope, IsImplicit) (Syntax: 'l')
+                                  Arguments(0)
+                            Next (StructuredExceptionHandling) Block[null]
+                    }
+                }
+            }
+            Block[B5] - Exit
+                Predecessors: [B3]
+                Statements (0)
+            """;
+
+        var expectedDiagnostics = DiagnosticDescription.None;
+
+        VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>([source, LockTypeDefinition], expectedFlowGraph, expectedDiagnostics);
+    }
+
     [Fact]
     public void InPlace()
     {

src/Compilers/Core/Portable/Operations/ControlFlowGraphBuilder.cs

@@ -4200,6 +4200,22 @@ private IOperation ConvertToIDisposable(IOperation operand, ITypeSymbol iDisposa
         {
             StartVisitingStatement(operation);
 
+            var lockStatement = (LockOperation)operation;
+
+            // `lock (l) { }` on value of type `System.Threading.Lock` is lowered to `using (l.EnterLockScope()) { }`.
+            if (lockStatement.LockTypeInfo is (var enterLockScope, var disposeMethod))
+            {
+                HandleUsingOperationParts(
+                    resources: enterLockScope,
+                    body: lockStatement.Body,
+                    disposeMethod: disposeMethod,
+                    disposeArguments: ImmutableArray<IArgumentOperation>.Empty,
+                    locals: ImmutableArray<ILocalSymbol>.Empty,
+                    isAsynchronous: false);
+
+                return FinishVisitingStatement(operation);
+            }
+
             ITypeSymbol objectType = _compilation.GetSpecialType(SpecialType.System_Object);
 
             // If Monitor.Enter(object, ref bool) is available:
@@ -4233,7 +4249,6 @@ private IOperation ConvertToIDisposable(IOperation operand, ITypeSymbol iDisposa
             // Microsoft.VisualBasic.CompilerServices.ObjectFlowControl.CheckForSyncLockOnValueType to ensure no value type is
             // used.
             // For simplicity, we will not synthesize this call because its presence is unlikely to affect graph analysis.
-            var lockStatement = (LockOperation)operation;
 
             var lockRegion = new RegionBuilder(ControlFlowRegionKind.LocalLifetime,
                                                locals: lockStatement.LockTakenSymbol != null ?

src/Compilers/Core/Portable/Operations/OperationNodes.cs

@@ -701,4 +701,9 @@ private BlockOperation(ImmutableArray<IOperation> statements, SemanticModel sema
             Locals = ImmutableArray<ILocalSymbol>.Empty;
         }
     }
+
+    internal sealed partial class LockOperation
+    {
+        public (IOperation EnterLockScope, IMethodSymbol DisposeMethod)? LockTypeInfo { get; init; }
+    }
 }