IOperation API extensions to expose low-level operations (v2)

src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs

@@ -1753,6 +1753,69 @@ internal PointerTypeSymbol CreatePointerTypeSymbol(TypeSymbol elementType)
 
         #endregion
 
+        #region Operations
+
+        /// <summary>
+        /// Gets the low-level operation corresponding to the method's body.
+        /// </summary>
+        /// <param name="method">The method symbol.</param>
+        /// <param name="cancellationToken">An optional cancellation token.</param>
+        /// <returns>The low-level operation corresponding to the method's body.</returns>
+        protected override IOperation GetOperationCore(IMethodSymbol method, CancellationToken cancellationToken = default)
+        {
+            IOperation result = null;
+            var csmethod = method.EnsureCSharpSymbolOrNull<IMethodSymbol, MethodSymbol>(nameof(method));
+
+            if (csmethod != null)
+            {
+                var body = LowerMethodBody(csmethod);
+
+                if (body != null)
+                {
+                    var operationFactory = new Semantics.CSharpOperationFactory(null);
+                    result = operationFactory.Create(body);
+                }
+            }
+
+            return result;
+        }
+
+        private BoundStatement LowerMethodBody(MethodSymbol method)
+        {
+            BoundStatement result = null;
+            var compilationState = new TypeCompilationState(method.ContainingType, this, null);
+            var diagnostics = DiagnosticBag.GetInstance();
+            var body = MethodCompiler.BindMethodBody(method, compilationState, diagnostics);
+
+            if (body != null && !body.HasErrors)
+            {
+                const int methodOrdinal = -1;
+                var dynamicAnalysisSpans = ImmutableArray<SourceSpan>.Empty;
+
+                result = LocalRewriter.Rewrite(
+                    this,
+                    method,
+                    methodOrdinal,
+                    method.ContainingType,
+                    body,
+                    compilationState,
+                    previousSubmissionFields: null,
+                    allowOmissionOfConditionalCalls: true,
+                    instrumentForDynamicAnalysis: false,
+                    debugDocumentProvider: null,
+                    dynamicAnalysisSpans: ref dynamicAnalysisSpans,
+                    diagnostics: diagnostics,
+                    sawLambdas: out bool sawLambdas,
+                    sawLocalFunctions: out bool sawLocalFunctions,
+                    sawAwaitInExceptionHandler: out bool sawAwaitInExceptionHandler);
+            }
+
+            diagnostics.Free();
+            return result;
+        }
+
+        #endregion
+
         #region Binding
 
         /// <summary>

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

@@ -254,6 +254,21 @@ private IOperation CreateInternal(BoundNode boundNode)
                     return CreateBoundPatternSwitchLabelOperation((BoundPatternSwitchLabel)boundNode);
                 case BoundKind.IsPatternExpression:
                     return CreateBoundIsPatternExpressionOperation((BoundIsPatternExpression)boundNode);
+
+                // To support BoundNodes after lowering phase.
+                case BoundKind.SequencePoint:
+                    return CreateBoundSequencePointOperation((BoundSequencePoint)boundNode);
+                case BoundKind.SequencePointWithSpan:
+                    return CreateBoundSequencePointWithSpanOperation((BoundSequencePointWithSpan)boundNode);
+                case BoundKind.SequencePointExpression:
+                    return CreateBoundSequencePointExpressionOperation((BoundSequencePointExpression)boundNode);
+                case BoundKind.StatementList:
+                    return CreateBoundStatementListOperation((BoundStatementList)boundNode);
+                case BoundKind.ConditionalGoto:
+                    return CreateBoundConditionalGotoOperation((BoundConditionalGoto)boundNode);
+                case BoundKind.Sequence:
+                    return CreateBoundSequenceOperation((BoundSequence)boundNode);
+
                 default:
                     var constantValue = ConvertToOptional((boundNode as BoundExpression)?.ConstantValue);
                     bool isImplicit = boundNode.WasCompilerGenerated;
@@ -426,7 +441,7 @@ private IEventAssignmentExpression CreateBoundEventAssignmentOperatorOperation(B
             return new LazyEventAssignmentExpression(eventReference, handlerValue, adds, _semanticModel, syntax, type, constantValue, isImplicit);
         }
 
-            private IParameterReferenceExpression CreateBoundParameterOperation(BoundParameter boundParameter)
+        private IParameterReferenceExpression CreateBoundParameterOperation(BoundParameter boundParameter)
         {
             IParameterSymbol parameter = boundParameter.ParameterSymbol;
             SyntaxNode syntax = boundParameter.Syntax;
@@ -1064,7 +1079,7 @@ private IParameterInitializer CreateBoundParameterEqualsValueOperation(BoundPara
         private IBlockStatement CreateBoundBlockOperation(BoundBlock boundBlock)
         {
             Lazy<ImmutableArray<IOperation>> statements =
-                new Lazy<ImmutableArray<IOperation>>(() => boundBlock.Statements.Select(s => Create(s)).Where(s => s.Kind != OperationKind.None).ToImmutableArray());
+                new Lazy<ImmutableArray<IOperation>>(() => boundBlock.Statements.Select(s => Create(s)).Where(s => s != null && s.Kind != OperationKind.None).ToImmutableArray());
 
             ImmutableArray<ILocalSymbol> locals = boundBlock.Locals.As<ILocalSymbol>();
             SyntaxNode syntax = boundBlock.Syntax;
@@ -1506,5 +1521,59 @@ private IIsPatternExpression CreateBoundIsPatternExpressionOperation(BoundIsPatt
             bool isImplicit = boundIsPatternExpression.WasCompilerGenerated;
             return new LazyIsPatternExpression(expression, pattern, _semanticModel, syntax, type, constantValue, isImplicit);
         }
+
+        private IOperation CreateBoundSequencePointOperation(BoundSequencePoint boundSequencePoint)
+        {
+            return Create(boundSequencePoint.StatementOpt);
+        }
+
+        private IOperation CreateBoundSequencePointWithSpanOperation(BoundSequencePointWithSpan boundSequencePointWithSpan)
+        {
+            return Create(boundSequencePointWithSpan.StatementOpt);
+        }
+
+        private IOperation CreateBoundSequencePointExpressionOperation(BoundSequencePointExpression boundSequencePointExpression)
+        {
+            return Create(boundSequencePointExpression.Expression);
+        }
+
+        private IBlockStatement CreateBoundStatementListOperation(BoundStatementList boundStatementList)
+        {
+            Lazy<ImmutableArray<IOperation>> statements =
+                new Lazy<ImmutableArray<IOperation>>(() => boundStatementList.Statements.Select(s => Create(s)).Where(s => s != null && s.Kind != OperationKind.None).ToImmutableArray());
+
+            ImmutableArray<ILocalSymbol> locals = ImmutableArray<ILocalSymbol>.Empty;
+            SyntaxNode syntax = boundStatementList.Syntax;
+            ITypeSymbol type = null;
+            Optional<object> constantValue = default(Optional<object>);
+            bool isImplicit = boundStatementList.WasCompilerGenerated;
+            return new LazyBlockStatement(statements, locals, _semanticModel, syntax, type, constantValue, isImplicit);
+        }
+
+        private IConditionalGotoStatement CreateBoundConditionalGotoOperation(BoundConditionalGoto boundConditionalGoto)
+        {
+            Lazy<IOperation> condition = new Lazy<IOperation>(() => Create(boundConditionalGoto.Condition));
+            ILabelSymbol target = boundConditionalGoto.Label;
+            bool jumpIfTrue = boundConditionalGoto.JumpIfTrue;
+            SyntaxNode syntax = boundConditionalGoto.Syntax;
+            ITypeSymbol type = null;
+            Optional<object> constantValue = default(Optional<object>);
+            bool isImplicit = boundConditionalGoto.WasCompilerGenerated;
+            return new LazyConditionalGotoStatement(condition, target, jumpIfTrue, _semanticModel, syntax, type, constantValue, isImplicit);
+        }
+
+        private ISequenceExpression CreateBoundSequenceOperation(BoundSequence boundSequence)
+        {
+            Lazy<ImmutableArray<IOperation>> expressions =
+new Lazy<ImmutableArray<IOperation>>(() => boundSequence.SideEffects.Select(s => Create(s)).Where(s => s != null && s.Kind != OperationKind.None).ToImmutableArray());
+
+            Lazy<IOperation> value = new Lazy<IOperation>(() => Create(boundSequence.Value));
+            ImmutableArray<ILocalSymbol> locals = boundSequence.Locals.As<ILocalSymbol>();
+            SyntaxNode syntax = boundSequence.Syntax;
+            ITypeSymbol type = null;
+            Optional<object> constantValue = default(Optional<object>);
+            bool isImplicit = boundSequence.WasCompilerGenerated;
+            return new LazySequenceExpression(expressions, value, locals, _semanticModel, syntax, type, constantValue, isImplicit);
+        }
     }
 }

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IConditionalGotoStatement.cs

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Diagnostics;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Semantics;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public partial class IOperationTests : SemanticModelTestBase
+    {
+        [Fact]
+        public void IConditionalGotoStatement_FromIf()
+        {
+            string source = @"
+class C
+{
+    /*<bind>*/
+    static void Method(int p)
+    {
+        if (p < 0) p = 0;
+    }
+    /*</bind>*/
+}
+";
+            string expectedOperationTree = @"
+IBlockStatement (1 statements) (OperationKind.BlockStatement) (Syntax: '{ ... }')
+  IBlockStatement (3 statements) (OperationKind.BlockStatement) (Syntax: 'if (p < 0) p = 0;')
+    IConditionalGotoStatement (JumpIfTrue: False) (OperationKind.ConditionalGotoStatement) (Syntax: 'p < 0')
+      Condition: IBinaryOperatorExpression (BinaryOperatorKind.LessThan) (OperationKind.BinaryOperatorExpression, Type: System.Boolean) (Syntax: 'p < 0')
+          Left: IParameterReferenceExpression: p (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'p')
+          Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: '0')
+    IExpressionStatement (OperationKind.ExpressionStatement) (Syntax: 'p = 0;')
+      Expression: ISimpleAssignmentExpression (OperationKind.SimpleAssignmentExpression, Type: System.Int32) (Syntax: 'p = 0')
+          Left: IParameterReferenceExpression: p (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'p')
+          Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: '0')
+    ILabeledStatement (OperationKind.LabeledStatement) (Syntax: 'if (p < 0) p = 0;')
+      Statement: null
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+            VerifyOperationTreeAndDiagnosticsForTest<BaseMethodDeclarationSyntax>(source, expectedOperationTree, expectedDiagnostics, highLevelOperation: false);
+        }
+
+        [Fact]
+        public void IConditionalGotoStatement_FromIfElse()
+        {
+            string source = @"
+class C
+{
+    /*<bind>*/
+    static void Method(int p)
+    {
+        if (p < 0) p = 0;
+        else p = 1;
+    }
+    /*</bind>*/
+}
+";
+            string expectedOperationTree = @"
+IBlockStatement (1 statements) (OperationKind.BlockStatement) (Syntax: '{ ... }')
+  IBlockStatement (6 statements) (OperationKind.BlockStatement) (Syntax: 'if (p < 0)  ... else p = 1;')
+    IConditionalGotoStatement (JumpIfTrue: False) (OperationKind.ConditionalGotoStatement) (Syntax: 'p < 0')
+      Condition: IBinaryOperatorExpression (BinaryOperatorKind.LessThan) (OperationKind.BinaryOperatorExpression, Type: System.Boolean) (Syntax: 'p < 0')
+          Left: IParameterReferenceExpression: p (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'p')
+          Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: '0')
+    IExpressionStatement (OperationKind.ExpressionStatement) (Syntax: 'p = 0;')
+      Expression: ISimpleAssignmentExpression (OperationKind.SimpleAssignmentExpression, Type: System.Int32) (Syntax: 'p = 0')
+          Left: IParameterReferenceExpression: p (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'p')
+          Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: '0')
+    IBranchStatement (BranchKind.GoTo) (OperationKind.BranchStatement) (Syntax: 'if (p < 0)  ... else p = 1;')
+    ILabeledStatement (OperationKind.LabeledStatement) (Syntax: 'if (p < 0)  ... else p = 1;')
+      Statement: null
+    IExpressionStatement (OperationKind.ExpressionStatement) (Syntax: 'p = 1;')
+      Expression: ISimpleAssignmentExpression (OperationKind.SimpleAssignmentExpression, Type: System.Int32) (Syntax: 'p = 1')
+          Left: IParameterReferenceExpression: p (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'p')
+          Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
+    ILabeledStatement (OperationKind.LabeledStatement) (Syntax: 'if (p < 0)  ... else p = 1;')
+      Statement: null
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+            VerifyOperationTreeAndDiagnosticsForTest<BaseMethodDeclarationSyntax>(source, expectedOperationTree, expectedDiagnostics, highLevelOperation: false);
+        }
+    }
+}

src/Compilers/Core/Portable/Compilation/Compilation.cs

@@ -1092,6 +1092,29 @@ protected abstract INamedTypeSymbol CommonCreateAnonymousTypeSymbol(
 
         #endregion
 
+        #region Operations
+
+        /// <summary>
+        /// Gets the low-level operation corresponding to the method's body.
+        /// </summary>
+        /// <param name="method">The method symbol.</param>
+        /// <param name="cancellationToken">An optional cancellation token.</param>
+        /// <returns>The low-level operation corresponding to the method's body.</returns>
+        internal IOperation GetOperation(IMethodSymbol method, CancellationToken cancellationToken = default)
+        {
+            return GetOperationCore(method, cancellationToken);
+        }
+
+        /// <summary>
+        /// Gets the low-level operation corresponding to the method's body.
+        /// </summary>
+        /// <param name="method">The method symbol.</param>
+        /// <param name="cancellationToken">An optional cancellation token.</param>
+        /// <returns>The low-level operation corresponding to the method's body.</returns>
+        protected abstract IOperation GetOperationCore(IMethodSymbol method, CancellationToken cancellationToken = default);
+
+        #endregion
+
         #region Diagnostics
 
         internal const CompilationStage DefaultDiagnosticsStage = CompilationStage.Compile;

src/Compilers/Core/Portable/Compilation/CompilationExtensions.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    public static class CompilationExtensions
+    {
+        /// <summary>
+        /// Gets the low-level operation corresponding to the method's body.
+        /// </summary>
+        /// <param name="compilation">The compilation containing the method symbol.</param>
+        /// <param name="method">The method symbol.</param>
+        /// <param name="cancellationToken">An optional cancellation token.</param>
+        /// <returns>The low-level operation corresponding to the method's body.</returns>
+        public static IOperation GetOperation(this Compilation compilation, IMethodSymbol method, CancellationToken cancellationToken = default)
+        {
+            if (compilation == null)
+            {
+                throw new ArgumentNullException(nameof(compilation));
+            }
+
+            if (method == null)
+            {
+                throw new ArgumentNullException(nameof(method));
+            }
+
+            if (!compilation.IsIOperationFeatureEnabled())
+            {
+                throw new InvalidOperationException(CodeAnalysisResources.IOperationFeatureDisabled);
+            }
+
+            return compilation.GetOperation(method, cancellationToken);
+        }
+    }
+}