Add IOperation support for C# patterns

Fixes #19927

src/Compilers/CSharp/Portable/BoundTree/Expression.cs

@@ -69,26 +69,6 @@ internal partial class BoundQueryClause
         protected override ImmutableArray<BoundNode> Children => ImmutableArray.Create<BoundNode>(this.Value);
     }
 
-    internal partial class BoundPattern
-    {
-        protected override abstract ImmutableArray<BoundNode> Children { get; }
-    }
-
-    internal partial class BoundDeclarationPattern
-    {
-        protected override ImmutableArray<BoundNode> Children => ImmutableArray.Create<BoundNode>(this.VariableAccess);
-    }
-
-    internal partial class BoundConstantPattern
-    {
-        protected override ImmutableArray<BoundNode> Children => ImmutableArray.Create<BoundNode>(this.Value);
-    }
-
-    internal partial class BoundWildcardPattern
-    {
-        protected override ImmutableArray<BoundNode> Children => ImmutableArray<BoundNode>.Empty;
-    }
-
     internal partial class BoundArgListOperator
     {
         protected override ImmutableArray<BoundNode> Children => StaticCast<BoundNode>.From(this.Arguments);
@@ -173,9 +153,4 @@ partial class BoundThrowExpression
     {
         protected override ImmutableArray<BoundNode> Children => ImmutableArray.Create<BoundNode>(this.Expression);
     }
-
-    partial class BoundIsPatternExpression
-    {
-        protected override ImmutableArray<BoundNode> Children => ImmutableArray.Create<BoundNode>(this.Expression, this.Pattern);
-    }
 }

src/Compilers/CSharp/Portable/BoundTree/Statement.cs

@@ -25,19 +25,4 @@ partial class BoundLocalFunctionStatement
     {
         protected override ImmutableArray<BoundNode> Children => ImmutableArray.Create<BoundNode>(this.Body);
     }
-
-    partial class BoundPatternSwitchStatement
-    {
-        protected override ImmutableArray<BoundNode> Children => StaticCast<BoundNode>.From(this.SwitchSections).Insert(0, this.Expression);
-    }
-
-    partial class BoundPatternSwitchSection
-    {
-        protected override ImmutableArray<BoundNode> Children => StaticCast<BoundNode>.From(this.SwitchLabels).AddRange(this.Statements);
-    }
-
-    partial class BoundPatternSwitchLabel
-    {
-        protected override ImmutableArray<BoundNode> Children => ImmutableArray.Create<BoundNode>(this.Pattern, this.Guard);
-    }
 }

src/Compilers/CSharp/Portable/CSharpCodeAnalysis.csproj

@@ -291,9 +291,7 @@
     <Compile Include="Emitter\Model\NamedTypeReference.cs" />
     <Compile Include="Emitter\Model\NamedTypeSymbolAdapter.cs" />
     <Compile Include="Emitter\Model\NamespaceSymbolAdapter.cs" />
-    <Compile Include="Emitter\Model\ParameterSymbolAdapter.cs">
-      <SubType>Code</SubType>
-    </Compile>
+    <Compile Include="Emitter\Model\ParameterSymbolAdapter.cs" />
     <Compile Include="Emitter\Model\ParameterTypeInformation.cs" />
     <Compile Include="Emitter\Model\PEAssemblyBuilder.cs" />
     <Compile Include="Emitter\Model\PEModuleBuilder.cs" />

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

@@ -179,6 +179,18 @@ private IOperation CreateInternal(BoundNode boundNode)
                     return CreateBoundInterpolationOperation((BoundStringInsert)boundNode);
                 case BoundKind.LocalFunctionStatement:
                     return CreateBoundLocalFunctionStatementOperation((BoundLocalFunctionStatement)boundNode);
+                case BoundKind.ConstantPattern:
+                    return CreateBoundConstantPatternOperation((BoundConstantPattern)boundNode);
+                case BoundKind.DeclarationPattern:
+                    return CreateBoundDeclarationPatternOperation((BoundDeclarationPattern)boundNode);
+                case BoundKind.WildcardPattern:
+                    return null;
+                case BoundKind.PatternSwitchStatement:
+                    return CreateBoundPatternSwitchStatementOperation((BoundPatternSwitchStatement)boundNode);
+                case BoundKind.PatternSwitchLabel:
+                    return CreateBoundPatternSwitchLabelOperation((BoundPatternSwitchLabel)boundNode);
+                case BoundKind.IsPatternExpression:
+                    return CreateBoundIsPatternExpressionOperation((BoundIsPatternExpression)boundNode);
                 default:
                     var constantValue = ConvertToOptional((boundNode as BoundExpression)?.ConstantValue);
                     return Operation.CreateOperationNone(boundNode.HasErrors, boundNode.Syntax, constantValue, getChildren: () => GetIOperationChildren(boundNode));
@@ -1099,5 +1111,59 @@ private IInterpolatedStringText CreateBoundInterpolatedStringTextOperation(Bound
             Optional<object> constantValue = default(Optional<object>);
             return new LazyInterpolatedStringText(text, isInvalid, syntax, type, constantValue);
         }
+
+        private IConstantPattern CreateBoundConstantPatternOperation(BoundConstantPattern boundConstantPattern)
+        {
+            Lazy<IOperation> value = new Lazy<IOperation>(() => Create(boundConstantPattern.Value));
+            bool isInvalid = boundConstantPattern.HasErrors;
+            SyntaxNode syntax = boundConstantPattern.Syntax;
+            ITypeSymbol type = null;
+            Optional<object> constantValue = default(Optional<object>);
+            return new LazyConstantPattern(value, isInvalid, syntax, type, constantValue);
+        }
+
+        private IDeclarationPattern CreateBoundDeclarationPatternOperation(BoundDeclarationPattern boundDeclarationPattern)
+        {
+            ISymbol variable = boundDeclarationPattern.Variable;
+            bool isInvalid = boundDeclarationPattern.HasErrors;
+            SyntaxNode syntax = boundDeclarationPattern.Syntax;
+            ITypeSymbol type = null;
+            Optional<object> constantValue = default(Optional<object>);
+            return new DeclarationPattern(variable, isInvalid, syntax, type, constantValue);
+        }
+
+        private ISwitchStatement CreateBoundPatternSwitchStatementOperation(BoundPatternSwitchStatement boundPatternSwitchStatement)
+        {
+            Lazy<IOperation> value = new Lazy<IOperation>(() => Create(boundPatternSwitchStatement.Expression));
+            Lazy<ImmutableArray<ISwitchCase>> cases = new Lazy<ImmutableArray<ISwitchCase>>(() => GetPatternSwitchStatementCases(boundPatternSwitchStatement));
+            bool isInvalid = boundPatternSwitchStatement.HasErrors;
+            SyntaxNode syntax = boundPatternSwitchStatement.Syntax;
+            ITypeSymbol type = null;
+            Optional<object> constantValue = default(Optional<object>);
+            return new LazySwitchStatement(value, cases, isInvalid, syntax, type, constantValue);
+        }
+
+        private IPatternCaseClause CreateBoundPatternSwitchLabelOperation(BoundPatternSwitchLabel boundPatternSwitchLabel)
+        {
+            LabelSymbol label = boundPatternSwitchLabel.Label;
+            Lazy<IPattern> pattern = new Lazy<IPattern>(() => (IPattern)Create(boundPatternSwitchLabel.Pattern));
+            Lazy<IOperation> guardExpression = new Lazy<IOperation>(() => Create(boundPatternSwitchLabel.Guard));
+            bool isInvalid = boundPatternSwitchLabel.HasErrors;
+            SyntaxNode syntax = boundPatternSwitchLabel.Syntax;
+            ITypeSymbol type = null;
+            Optional<object> constantValue = default(Optional<object>);
+            return new LazyPatternCaseClause(label, pattern, guardExpression, isInvalid, syntax, type, constantValue);
+        }
+
+        private IIsPatternExpression CreateBoundIsPatternExpressionOperation(BoundIsPatternExpression boundIsPatternExpression)
+        {
+            Lazy<IOperation> expression = new Lazy<IOperation>(() => Create(boundIsPatternExpression.Expression));
+            Lazy<IPattern> pattern = new Lazy<IPattern>(() => (IPattern)Create(boundIsPatternExpression.Pattern));
+            bool isInvalid = boundIsPatternExpression.HasErrors;
+            SyntaxNode syntax = boundIsPatternExpression.Syntax;
+            ITypeSymbol type = boundIsPatternExpression.Type;
+            Optional<object> constantValue = ConvertToOptional(boundIsPatternExpression.ConstantValue);
+            return new LazyIsPatternExpression(expression, pattern, isInvalid, syntax, type, constantValue);
+        }
     }
 }

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

@@ -166,6 +166,17 @@ private ImmutableArray<ISwitchCase> GetSwitchStatementCases(BoundSwitchStatement
             });
         }
 
+        private ImmutableArray<ISwitchCase> GetPatternSwitchStatementCases(BoundPatternSwitchStatement statement)
+        {
+            return statement.SwitchSections.SelectAsArray(switchSection =>
+            {
+                var clauses = switchSection.SwitchLabels.SelectAsArray(s => (ICaseClause)Create(s));
+                var body = switchSection.Statements.SelectAsArray(s => Create(s));
+
+                return (ISwitchCase)new SwitchCase(clauses, body, switchSection.HasErrors, switchSection.Syntax, type: null, constantValue: default(Optional<object>));
+            });
+        }
+
         private static BinaryOperationKind GetLabelEqualityKind(BoundSwitchLabel label)
         {
             BoundExpression caseValue = label.ExpressionOpt;

src/Compilers/CSharp/Test/Semantic/CSharpCompilerSemanticTest.csproj

@@ -66,7 +66,9 @@
     <Compile Include="IOperation\IOperationTests_IIfStatement.cs" />
     <Compile Include="IOperation\IOperationTests_IFieldReferenceExpression.cs" />
     <Compile Include="IOperation\IOperationTests_ILambdaExpression.cs" />
+    <Compile Include="IOperation\IOperationTests_IPatternSwitchCase.cs" />
     <Compile Include="IOperation\IOperationTests_IObjectCreationExpression.cs" />
+    <Compile Include="IOperation\IOperationTests_IIsPatternExpression.cs" />
     <Compile Include="IOperation\IOperationTests_IParameterReferenceExpression.cs" />
     <Compile Include="IOperation\IOperationTests_ILocalFunctionStatement.cs" />
     <Compile Include="IOperation\IOperationTests_IReturnStatement.cs" />

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

@@ -487,10 +487,9 @@ private static void A(bool flag, int number)
       IExpressionStatement (OperationKind.ExpressionStatement) (Syntax: 'A(o is int i, 1);')
         IInvocationExpression (static void Program.A(System.Boolean flag, System.Int32 number)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'A(o is int i, 1)')
           Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: flag) (OperationKind.Argument) (Syntax: 'o is int i')
-              IOperation:  (OperationKind.None) (Syntax: 'o is int i')
-                Children(2): ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
-                  IOperation:  (OperationKind.None) (Syntax: 'int i')
-                    Children(1): ILocalReferenceExpression: i (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'int i')
+              IIsPatternExpression (OperationKind.IsPatternExpression, Type: System.Boolean) (Syntax: 'o is int i')
+                Expression: ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
+                Pattern: IDeclarationPattern (Declared Symbol: System.Int32 i) (OperationKind.DeclarationPattern) (Syntax: 'int i')
             IArgument (ArgumentKind.Explicit, Matching Parameter: number) (OperationKind.Argument) (Syntax: '1')
               ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
 ";
@@ -520,10 +519,9 @@ private void M()
 ";
             string expectedOperationTree = @"
 IIfStatement (OperationKind.IfStatement) (Syntax: 'if (obj is  ... }')
-  Condition: IOperation:  (OperationKind.None) (Syntax: 'obj is string str')
-      Children(2): ILocalReferenceExpression: obj (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'obj')
-        IOperation:  (OperationKind.None) (Syntax: 'string str')
-          Children(1): ILocalReferenceExpression: str (OperationKind.LocalReferenceExpression, Type: System.String) (Syntax: 'string str')
+  Condition: IIsPatternExpression (OperationKind.IsPatternExpression, Type: System.Boolean) (Syntax: 'obj is string str')
+      Expression: ILocalReferenceExpression: obj (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'obj')
+      Pattern: IDeclarationPattern (Declared Symbol: System.String str) (OperationKind.DeclarationPattern) (Syntax: 'string str')
   IfTrue: IBlockStatement (1 statements) (OperationKind.BlockStatement) (Syntax: '{ ... }')
       IExpressionStatement (OperationKind.ExpressionStatement) (Syntax: 'Console.WriteLine(str);')
         IInvocationExpression (static void System.Console.WriteLine(System.String value)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'Console.WriteLine(str)')
@@ -601,10 +599,9 @@ private static void A(bool flag, int number)
       IExpressionStatement (OperationKind.ExpressionStatement) (Syntax: 'A(o is int i, 1);')
         IInvocationExpression (static void Program.A(System.Boolean flag, System.Int32 number)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'A(o is int i, 1)')
           Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: flag) (OperationKind.Argument) (Syntax: 'o is int i')
-              IOperation:  (OperationKind.None) (Syntax: 'o is int i')
-                Children(2): ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
-                  IOperation:  (OperationKind.None) (Syntax: 'int i')
-                    Children(1): ILocalReferenceExpression: i (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'int i')
+              IIsPatternExpression (OperationKind.IsPatternExpression, Type: System.Boolean) (Syntax: 'o is int i')
+                Expression: ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
+                Pattern: IDeclarationPattern (Declared Symbol: System.Int32 i) (OperationKind.DeclarationPattern) (Syntax: 'int i')
             IArgument (ArgumentKind.Explicit, Matching Parameter: number) (OperationKind.Argument) (Syntax: '1')
               ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
 ";
@@ -635,10 +632,9 @@ private void M()
 ";
             string expectedOperationTree = @"
 IIfStatement (OperationKind.IfStatement, IsInvalid) (Syntax: 'if (obj is  ... else')
-  Condition: IOperation:  (OperationKind.None) (Syntax: 'obj is string str')
-      Children(2): ILocalReferenceExpression: obj (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'obj')
-        IOperation:  (OperationKind.None) (Syntax: 'string str')
-          Children(1): ILocalReferenceExpression: str (OperationKind.LocalReferenceExpression, Type: System.String) (Syntax: 'string str')
+  Condition: IIsPatternExpression (OperationKind.IsPatternExpression, Type: System.Boolean) (Syntax: 'obj is string str')
+      Expression: ILocalReferenceExpression: obj (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'obj')
+      Pattern: IDeclarationPattern (Declared Symbol: System.String str) (OperationKind.DeclarationPattern) (Syntax: 'string str')
   IfTrue: IBlockStatement (1 statements) (OperationKind.BlockStatement) (Syntax: '{ ... }')
       IExpressionStatement (OperationKind.ExpressionStatement) (Syntax: 'Console.WriteLine(str);')
         IInvocationExpression (static void System.Console.WriteLine(System.String value)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'Console.WriteLine(str)')

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

@@ -657,16 +657,15 @@ public void M(int x)
 }
 ";
             string expectedOperationTree = @"
-IOperation:  (OperationKind.None) (Syntax: 'switch (x) ... }')
-  Children(2): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
-    IOperation:  (OperationKind.None) (Syntax: 'case var y  ... break;')
-      Children(2): IOperation:  (OperationKind.None) (Syntax: 'case var y  ...  (x >= 10):')
-          Children(2): IOperation:  (OperationKind.None) (Syntax: 'var y')
-              Children(1): ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'var y')
-            IBinaryOperatorExpression (BinaryOperationKind.IntegerGreaterThanOrEqual) (OperationKind.BinaryOperatorExpression, Type: System.Boolean) (Syntax: 'x >= 10')
+ISwitchStatement (1 cases) (OperationKind.SwitchStatement) (Syntax: 'switch (x) ... }')
+  Switch expression: IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+  Sections: ISwitchCase (1 case clauses, 1 statements) (OperationKind.SwitchCase) (Syntax: 'case var y  ... break;')
+        Clauses: IPatternCaseClause (Label Symbol: case var y when (x >= 10):) (OperationKind.PatternCaseClause) (Syntax: 'case var y  ...  (x >= 10):')
+            Pattern: IDeclarationPattern (Declared Symbol: System.Int32 y) (OperationKind.DeclarationPattern) (Syntax: 'var y')
+            Guard Expression: IBinaryOperatorExpression (BinaryOperationKind.IntegerGreaterThanOrEqual) (OperationKind.BinaryOperatorExpression, Type: System.Boolean) (Syntax: 'x >= 10')
                 Left: IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
                 Right: ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
-        IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement) (Syntax: 'break;')
+        Body: IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement) (Syntax: 'break;')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -693,20 +692,18 @@ public void M(int x)
 }
 ";
             string expectedOperationTree = @"
-IOperation:  (OperationKind.None) (Syntax: 'switch (x) ... }')
-  Children(3): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
-    IOperation:  (OperationKind.None) (Syntax: 'case var y  ... break;')
-      Children(2): IOperation:  (OperationKind.None) (Syntax: 'case var y  ...  (x >= 10):')
-          Children(2): IOperation:  (OperationKind.None) (Syntax: 'var y')
-              Children(1): ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'var y')
-            IBinaryOperatorExpression (BinaryOperationKind.IntegerGreaterThanOrEqual) (OperationKind.BinaryOperatorExpression, Type: System.Boolean) (Syntax: 'x >= 10')
+ISwitchStatement (2 cases) (OperationKind.SwitchStatement) (Syntax: 'switch (x) ... }')
+  Switch expression: IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+  Sections: ISwitchCase (1 case clauses, 1 statements) (OperationKind.SwitchCase) (Syntax: 'case var y  ... break;')
+        Clauses: IPatternCaseClause (Label Symbol: case var y when (x >= 10):) (OperationKind.PatternCaseClause) (Syntax: 'case var y  ...  (x >= 10):')
+            Pattern: IDeclarationPattern (Declared Symbol: System.Int32 y) (OperationKind.DeclarationPattern) (Syntax: 'var y')
+            Guard Expression: IBinaryOperatorExpression (BinaryOperationKind.IntegerGreaterThanOrEqual) (OperationKind.BinaryOperatorExpression, Type: System.Boolean) (Syntax: 'x >= 10')
                 Left: IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
                 Right: ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
-        IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement) (Syntax: 'break;')
-    IOperation:  (OperationKind.None) (Syntax: 'default:/*< ... break;')
-      Children(2): IOperation:  (OperationKind.None) (Syntax: 'default:')
-          Children(1): IOperation:  (OperationKind.None) (Syntax: 'default:')
-        IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement) (Syntax: 'break;')
+        Body: IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement) (Syntax: 'break;')
+    ISwitchCase (1 case clauses, 1 statements) (OperationKind.SwitchCase) (Syntax: 'default:/*< ... break;')
+        Clauses: IPatternCaseClause (Label Symbol: default:) (OperationKind.PatternCaseClause) (Syntax: 'default:')
+        Body: IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement) (Syntax: 'break;')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -844,10 +841,9 @@ public void Method1(object x)
 }
 ";
             string expectedOperationTree = @"
-IOperation:  (OperationKind.None) (Syntax: 'x is int y')
-  Children(2): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Object) (Syntax: 'x')
-    IOperation:  (OperationKind.None) (Syntax: 'int y')
-      Children(1): ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'int y')
+IIsPatternExpression (OperationKind.IsPatternExpression, Type: System.Boolean) (Syntax: 'x is int y')
+  Expression: IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Object) (Syntax: 'x')
+  Pattern: IDeclarationPattern (Declared Symbol: System.Int32 y) (OperationKind.DeclarationPattern) (Syntax: 'int y')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 

src/Compilers/Core/Portable/CodeAnalysis.csproj

@@ -50,6 +50,11 @@
     <Compile Include="Operations\IAssignmentExpression.cs" />
     <Compile Include="Operations\IAwaitExpression.cs" />
     <Compile Include="Operations\IBinaryOperatorExpression.cs" />
+    <Compile Include="Operations\IIsPatternExpression.cs" />
+    <Compile Include="Operations\IPatternCaseClause.cs" />
+    <Compile Include="Operations\IConstantPattern.cs" />
+    <Compile Include="Operations\IDeclarationPattern.cs" />
+    <Compile Include="Operations\IPattern.cs" />
     <Compile Include="Operations\IBlockStatement.cs" />
     <Compile Include="Operations\IBranchStatement.cs" />
     <Compile Include="Operations\ICaseClause.cs" />

src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs

@@ -4607,4 +4607,234 @@ public LazyLocalFunctionStatement(IMethodSymbol localFunctionSymbol, Lazy<IBlock
         /// </summary>
         public override IBlockStatement Body => _lazyBody.Value;
     }
+
+    /// <summary>
+    /// Represents a C# constant pattern.
+    /// </summary>
+    internal abstract partial class BaseConstantPattern : Operation, IConstantPattern
+    {
+        protected BaseConstantPattern(bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+                    base(OperationKind.ConstantPattern, isInvalid, syntax, type, constantValue)
+        {
+        }
+        /// <summary>
+        /// Constant value of the pattern.
+        /// </summary>
+        public abstract IOperation Value { get; }
+        public override void Accept(OperationVisitor visitor)
+        {
+            visitor.VisitConstantPattern(this);
+        }
+        public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, TResult> visitor, TArgument argument)
+        {
+            return visitor.VisitConstantPattern(this, argument);
+        }
+    }
+
+    /// <summary>
+    /// Represents a C# constant pattern.
+    /// </summary>
+    internal sealed partial class ConstantPattern : BaseConstantPattern, IConstantPattern
+    {
+        public ConstantPattern(IOperation value, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+            base(isInvalid, syntax, type, constantValue)
+        {
+            Value = value;
+        }
+        /// <summary>
+        /// Constant value of the pattern.
+        /// </summary>
+        public override IOperation Value { get; }
+    }
+
+    /// <summary>
+    /// Represents a C# constant pattern.
+    /// </summary>
+    internal sealed partial class LazyConstantPattern : BaseConstantPattern, IConstantPattern
+    {
+        private readonly Lazy<IOperation> _lazyValue;
+
+        public LazyConstantPattern(Lazy<IOperation> value, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue)
+            : base(isInvalid, syntax, type, constantValue)
+        {
+            _lazyValue = value ?? throw new System.ArgumentNullException("value");
+        }
+        /// <summary>
+        /// Constant value of the pattern.
+        /// </summary>
+        public override IOperation Value => _lazyValue.Value;
+    }
+
+    /// <summary>
+    /// Represents a C# declaration pattern.
+    /// </summary>
+    internal sealed partial class DeclarationPattern : Operation, IDeclarationPattern
+    {
+        public DeclarationPattern(ISymbol declaredSymbol, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+                    base(OperationKind.DeclarationPattern, isInvalid, syntax, type, constantValue)
+        {
+            DeclaredSymbol = declaredSymbol;
+        }
+        /// <summary>
+        /// Symbol declared by the pattern.
+        /// </summary>
+        public ISymbol DeclaredSymbol { get; }
+        public override void Accept(OperationVisitor visitor)
+        {
+            visitor.VisitDeclarationPattern(this);
+        }
+        public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, TResult> visitor, TArgument argument)
+        {
+            return visitor.VisitDeclarationPattern(this, argument);
+        }
+    }
+
+    /// <summary>
+    /// Represents a C# pattern case clause.
+    /// </summary>
+    internal abstract partial class BasePatternCaseClause : CaseClause, IPatternCaseClause
+    {
+        protected BasePatternCaseClause(ILabelSymbol label, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+                    base(CaseKind.Pattern, OperationKind.PatternCaseClause, isInvalid, syntax, type, constantValue)
+        {
+            Label = label;
+        }
+        /// <summary>
+        /// Label associated with the case clause.
+        /// </summary>
+        public ILabelSymbol Label { get; }
+        /// <summary>
+        /// Pattern associated with case clause.
+        /// </summary>
+        public abstract IPattern Pattern { get; }
+        /// <summary>
+        /// Guard expression associated with the pattern case clause.
+        /// </summary>
+        public abstract IOperation GuardExpression { get; }
+        public override void Accept(OperationVisitor visitor)
+        {
+            visitor.VisitPatternCaseClause(this);
+        }
+        public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, TResult> visitor, TArgument argument)
+        {
+            return visitor.VisitPatternCaseClause(this, argument);
+        }
+    }
+
+    /// <summary>
+    /// Represents a C# pattern case clause.
+    /// </summary>
+    internal sealed partial class PatternCaseClause : BasePatternCaseClause, IPatternCaseClause
+    {
+        public PatternCaseClause(ILabelSymbol label, IPattern pattern, IOperation guardExpression, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+            base(label, isInvalid, syntax, type, constantValue)
+        {
+            Pattern = pattern;
+            GuardExpression = guardExpression;
+        }
+        /// <summary>
+        /// Pattern associated with case clause.
+        /// </summary>
+        public override IPattern Pattern { get; }
+        /// <summary>
+        /// Guard expression associated with the pattern case clause.
+        /// </summary>
+        public override IOperation GuardExpression { get; }
+    }
+
+    /// <summary>
+    /// Represents a C# pattern case clause.
+    /// </summary>
+    internal sealed partial class LazyPatternCaseClause : BasePatternCaseClause, IPatternCaseClause
+    {
+        private readonly Lazy<IPattern> _lazyPattern;
+        private readonly Lazy<IOperation> _lazyGuardExpression;
+
+        public LazyPatternCaseClause(ILabelSymbol label, Lazy<IPattern> lazyPattern, Lazy<IOperation> lazyGuardExpression, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue)
+            : base(label, isInvalid, syntax, type, constantValue)
+        {
+            _lazyPattern = lazyPattern ?? throw new System.ArgumentNullException("lazyPattern");
+            _lazyGuardExpression = lazyGuardExpression ?? throw new System.ArgumentNullException("lazyGuardExpression");
+        }
+        /// <summary>
+        /// Pattern associated with case clause.
+        /// </summary>
+        public override IPattern Pattern => _lazyPattern.Value;
+        /// <summary>
+        /// Guard expression associated with the pattern case clause.
+        /// </summary>
+        public override IOperation GuardExpression => _lazyGuardExpression.Value;
+    }
+
+    /// <summary>
+    /// Represents a C# is pattern expression. For example, "x is int i".
+    /// </summary>
+    internal abstract partial class BaseIsPatternExpression : Operation, IIsPatternExpression
+    {
+        protected BaseIsPatternExpression(bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+            base(OperationKind.IsPatternExpression, isInvalid, syntax, type, constantValue)
+        {
+        }
+        /// <summary>
+        /// Expression.
+        /// </summary>
+        public abstract IOperation Expression { get; }
+        /// <summary>
+        /// Pattern.
+        /// </summary>
+        public abstract IPattern Pattern { get; }
+        public override void Accept(OperationVisitor visitor)
+        {
+            visitor.VisitIsPatternExpression(this);
+        }
+        public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, TResult> visitor, TArgument argument)
+        {
+            return visitor.VisitIsPatternExpression(this, argument);
+        }
+    }
+
+    /// <summary>
+    /// Represents a C# is pattern expression. For example, "x is int i".
+    /// </summary>
+    internal sealed partial class IsPatternExpression : BaseIsPatternExpression, IIsPatternExpression
+    {
+        public IsPatternExpression(IOperation expression, IPattern pattern, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+            base(isInvalid, syntax, type, constantValue)
+        {
+            Expression = expression;
+            Pattern = pattern;
+        }
+        /// <summary>
+        /// Expression.
+        /// </summary>
+        public override IOperation Expression { get; }
+        /// <summary>
+        /// Pattern.
+        /// </summary>
+        public override IPattern Pattern { get; }
+    }
+
+    /// <summary>
+    /// Represents a C# is pattern expression. For example, "x is int i".
+    /// </summary>
+    internal sealed partial class LazyIsPatternExpression : BaseIsPatternExpression, IIsPatternExpression
+    {
+        private readonly Lazy<IOperation> _lazyExpression;
+        private readonly Lazy<IPattern> _lazyPattern;
+        
+        public LazyIsPatternExpression(Lazy<IOperation> lazyExpression, Lazy<IPattern> lazyPattern, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue)
+            : base(isInvalid, syntax, type, constantValue)
+        {
+            _lazyExpression = lazyExpression ?? throw new System.ArgumentNullException("lazyExpression");
+            _lazyPattern = lazyPattern ?? throw new System.ArgumentNullException("lazyPattern");
+        }
+        /// <summary>
+        /// Expression.
+        /// </summary>
+        public override IOperation Expression => _lazyExpression.Value;
+        /// <summary>
+        /// Pattern.
+        /// </summary>
+        public override IPattern Pattern => _lazyPattern.Value;
+    }
 }

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

@@ -26,7 +26,11 @@ public enum CaseKind
         /// <summary>
         /// Indicates default in C# or Case Else in VB.
         /// </summary>
-        Default = 0x4
+        Default = 0x4,
+        /// <summary>
+        /// Indicates pattern case in C#.
+        /// </summary>
+        Pattern = 0x5
     }
 }
 

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

+// 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.Collections.Immutable;
+
+namespace Microsoft.CodeAnalysis.Semantics
+{
+    /// <summary>
+    /// Represents a C# constant pattern.
+    /// </summary>
+    /// <remarks>
+    /// This interface is reserved for implementation by its associated APIs. We reserve the right to
+    /// change it in the future.
+    /// </remarks>
+    public interface IConstantPattern : IPattern
+    {
+        /// <summary>
+        /// Constant value of the pattern.
+        /// </summary>
+        IOperation Value { get; }
+    }
+}
+

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

+// 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.Collections.Immutable;
+
+namespace Microsoft.CodeAnalysis.Semantics
+{
+    /// <summary>
+    /// Represents a C# declaration pattern.
+    /// </summary>
+    /// <remarks>
+    /// This interface is reserved for implementation by its associated APIs. We reserve the right to
+    /// change it in the future.
+    /// </remarks>
+    public interface IDeclarationPattern : IPattern
+    {
+        /// <summary>
+        /// Symbol declared by the pattern.
+        /// </summary>
+        ISymbol DeclaredSymbol { get; }
+    }
+}
+

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

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+namespace Microsoft.CodeAnalysis.Semantics
+{
+    /// <summary>
+    /// Represents a C# is pattern expression. For example, "x is int i".
+    /// </summary>
+    /// <remarks>
+    /// This interface is reserved for implementation by its associated APIs. We reserve the right to
+    /// change it in the future.
+    /// </remarks>
+    public interface IIsPatternExpression : IOperation
+    {
+        /// <summary>
+        /// Expression.
+        /// </summary>
+        IOperation Expression { get; }
+
+        /// <summary>
+        /// Pattern.
+        /// </summary>
+        IPattern Pattern { get; }
+    }
+}
+

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

+// 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.Collections.Immutable;
+
+namespace Microsoft.CodeAnalysis.Semantics
+{
+    /// <summary>
+    /// Represents a C# pattern.
+    /// </summary>
+    /// <remarks>
+    /// This interface is reserved for implementation by its associated APIs. We reserve the right to
+    /// change it in the future.
+    /// </remarks>
+    public interface IPattern : IOperation
+    {
+    }
+}
+

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

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+namespace Microsoft.CodeAnalysis.Semantics
+{
+    /// <summary>
+    /// Represents a C# pattern case clause.
+    /// </summary>
+    /// <remarks>
+    /// This interface is reserved for implementation by its associated APIs. We reserve the right to
+    /// change it in the future.
+    /// </remarks>
+    public interface IPatternCaseClause : ICaseClause
+    {
+        /// <summary>
+        /// Label associated with the case clause.
+        /// </summary>
+        ILabelSymbol Label { get; }
+
+        /// <summary>
+        /// Pattern associated with case clause.
+        /// </summary>
+        IPattern Pattern { get; }
+
+        /// <summary>
+        /// Guard expression associated with the pattern case clause.
+        /// </summary>
+        IOperation GuardExpression { get; }
+    }
+}
+

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

@@ -144,6 +144,8 @@ public enum OperationKind
         // 0x205 is open for future use.
         /// <summary>Indicates an <see cref="IIncrementExpression"/>.</summary>
         IncrementExpression = 0x206,
+        /// <summary>Indicates an <see cref="IIsPatternExpression"/>.</summary>
+        IsPatternExpression = 0x207,
 
         // Expressions that occur only in Visual Basic.
 
@@ -191,5 +193,12 @@ public enum OperationKind
         InterpolatedStringText = 0x40d,
         /// <summary>Indicates an <see cref="IInterpolation"/>.</summary>
         Interpolation = 0x40e,
+
+        /// <summary>Indicates an <see cref="IConstantPattern"/>.</summary>
+        ConstantPattern = 0x40f,
+        /// <summary>Indicates an <see cref="IDeclarationPattern"/>.</summary>
+        DeclarationPattern = 0x410,
+        /// <summary>Indicates an <see cref="IPatternCaseClause"/>.</summary>
+        PatternCaseClause = 0x411,
     }
 }

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

@@ -404,6 +404,26 @@ public virtual void VisitInterpolation(IInterpolation operation)
         {
             DefaultVisit(operation);
         }
+
+        public virtual void VisitIsPatternExpression(IIsPatternExpression operation)
+        {
+            DefaultVisit(operation);
+        }
+
+        public virtual void VisitConstantPattern(IConstantPattern operation)
+        {
+            DefaultVisit(operation);
+        }
+
+        public virtual void VisitDeclarationPattern(IDeclarationPattern operation)
+        {
+            DefaultVisit(operation);
+        }
+
+        public virtual void VisitPatternCaseClause(IPatternCaseClause operation)
+        {
+            DefaultVisit(operation);
+        }
     }
 
     /// <summary>
@@ -814,5 +834,25 @@ public virtual TResult VisitInterpolation(IInterpolation operation, TArgument ar
         {
             return DefaultVisit(operation, argument);
         }
+
+        public virtual TResult VisitIsPatternExpression(IIsPatternExpression operation, TArgument argument)
+        {
+            return DefaultVisit(operation, argument);
+        }
+
+        public virtual TResult VisitConstantPattern(IConstantPattern operation, TArgument argument)
+        {
+            return DefaultVisit(operation, argument);
+        }
+
+        public virtual TResult VisitDeclarationPattern(IDeclarationPattern operation, TArgument argument)
+        {
+            return DefaultVisit(operation, argument);
+        }
+
+        public virtual TResult VisitPatternCaseClause(IPatternCaseClause operation, TArgument argument)
+        {
+            return DefaultVisit(operation, argument);
+        }
     }
 }

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

@@ -439,5 +439,26 @@ public override void VisitInterpolation(IInterpolation operation)
             Visit(operation.Alignment);
             Visit(operation.FormatString);
         }
+
+        public override void VisitConstantPattern(IConstantPattern operation)
+        {
+            Visit(operation.Value);
+        }
+
+        public override void VisitDeclarationPattern(IDeclarationPattern operation)
+        {
+        }
+
+        public override void VisitIsPatternExpression(IIsPatternExpression operation)
+        {
+            Visit(operation.Expression);
+            Visit(operation.Pattern);
+        }
+
+        public override void VisitPatternCaseClause(IPatternCaseClause operation)
+        {
+            Visit(operation.Pattern);
+            Visit(operation.GuardExpression);
+        }
     }
 }

src/Compilers/Core/Portable/PublicAPI.Unshipped.txt

@@ -65,7 +65,9 @@ Microsoft.CodeAnalysis.OperationKind.CompoundAssignmentExpression = 281 -> Micro
 Microsoft.CodeAnalysis.OperationKind.ConditionalAccessExpression = 284 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.ConditionalAccessInstanceExpression = 285 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.ConditionalChoiceExpression = 271 -> Microsoft.CodeAnalysis.OperationKind
+Microsoft.CodeAnalysis.OperationKind.ConstantPattern = 1039 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.ConversionExpression = 258 -> Microsoft.CodeAnalysis.OperationKind
+Microsoft.CodeAnalysis.OperationKind.DeclarationPattern = 1040 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.DefaultValueExpression = 512 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.EmptyStatement = 9 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.EndStatement = 81 -> Microsoft.CodeAnalysis.OperationKind
@@ -86,6 +88,7 @@ Microsoft.CodeAnalysis.OperationKind.Interpolation = 1038 -> Microsoft.CodeAnaly
 Microsoft.CodeAnalysis.OperationKind.InvalidExpression = 256 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.InvalidStatement = 1 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.InvocationExpression = 259 -> Microsoft.CodeAnalysis.OperationKind
+Microsoft.CodeAnalysis.OperationKind.IsPatternExpression = 519 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.IsTypeExpression = 278 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.LabelStatement = 7 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.LambdaExpression = 273 -> Microsoft.CodeAnalysis.OperationKind
@@ -103,6 +106,7 @@ Microsoft.CodeAnalysis.OperationKind.OmittedArgumentExpression = 768 -> Microsof
 Microsoft.CodeAnalysis.OperationKind.ParameterInitializerAtDeclaration = 1028 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.ParameterReferenceExpression = 262 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.ParenthesizedExpression = 282 -> Microsoft.CodeAnalysis.OperationKind
+Microsoft.CodeAnalysis.OperationKind.PatternCaseClause = 1041 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.PlaceholderExpression = 770 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.PointerIndirectionReferenceExpression = 516 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.PropertyInitializerAtDeclaration = 1027 -> Microsoft.CodeAnalysis.OperationKind
@@ -313,6 +317,7 @@ Microsoft.CodeAnalysis.Semantics.BranchKind.None = 0 -> Microsoft.CodeAnalysis.S
 Microsoft.CodeAnalysis.Semantics.CaseKind
 Microsoft.CodeAnalysis.Semantics.CaseKind.Default = 4 -> Microsoft.CodeAnalysis.Semantics.CaseKind
 Microsoft.CodeAnalysis.Semantics.CaseKind.None = 0 -> Microsoft.CodeAnalysis.Semantics.CaseKind
+Microsoft.CodeAnalysis.Semantics.CaseKind.Pattern = 5 -> Microsoft.CodeAnalysis.Semantics.CaseKind
 Microsoft.CodeAnalysis.Semantics.CaseKind.Range = 3 -> Microsoft.CodeAnalysis.Semantics.CaseKind
 Microsoft.CodeAnalysis.Semantics.CaseKind.Relational = 2 -> Microsoft.CodeAnalysis.Semantics.CaseKind
 Microsoft.CodeAnalysis.Semantics.CaseKind.SingleValue = 1 -> Microsoft.CodeAnalysis.Semantics.CaseKind
@@ -373,10 +378,14 @@ Microsoft.CodeAnalysis.Semantics.IConditionalChoiceExpression
 Microsoft.CodeAnalysis.Semantics.IConditionalChoiceExpression.Condition.get -> Microsoft.CodeAnalysis.IOperation
 Microsoft.CodeAnalysis.Semantics.IConditionalChoiceExpression.IfFalseValue.get -> Microsoft.CodeAnalysis.IOperation
 Microsoft.CodeAnalysis.Semantics.IConditionalChoiceExpression.IfTrueValue.get -> Microsoft.CodeAnalysis.IOperation
+Microsoft.CodeAnalysis.Semantics.IConstantPattern
+Microsoft.CodeAnalysis.Semantics.IConstantPattern.Value.get -> Microsoft.CodeAnalysis.IOperation
 Microsoft.CodeAnalysis.Semantics.IConversionExpression
 Microsoft.CodeAnalysis.Semantics.IConversionExpression.ConversionKind.get -> Microsoft.CodeAnalysis.Semantics.ConversionKind
 Microsoft.CodeAnalysis.Semantics.IConversionExpression.IsExplicit.get -> bool
 Microsoft.CodeAnalysis.Semantics.IConversionExpression.Operand.get -> Microsoft.CodeAnalysis.IOperation
+Microsoft.CodeAnalysis.Semantics.IDeclarationPattern
+Microsoft.CodeAnalysis.Semantics.IDeclarationPattern.DeclaredSymbol.get -> Microsoft.CodeAnalysis.ISymbol
 Microsoft.CodeAnalysis.Semantics.IDefaultValueExpression
 Microsoft.CodeAnalysis.Semantics.IEmptyStatement
 Microsoft.CodeAnalysis.Semantics.IEndStatement
@@ -436,6 +445,9 @@ Microsoft.CodeAnalysis.Semantics.IInvocationExpression
 Microsoft.CodeAnalysis.Semantics.IInvocationExpression.Instance.get -> Microsoft.CodeAnalysis.IOperation
 Microsoft.CodeAnalysis.Semantics.IInvocationExpression.IsVirtual.get -> bool
 Microsoft.CodeAnalysis.Semantics.IInvocationExpression.TargetMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol
+Microsoft.CodeAnalysis.Semantics.IIsPatternExpression
+Microsoft.CodeAnalysis.Semantics.IIsPatternExpression.Expression.get -> Microsoft.CodeAnalysis.IOperation
+Microsoft.CodeAnalysis.Semantics.IIsPatternExpression.Pattern.get -> Microsoft.CodeAnalysis.Semantics.IPattern
 Microsoft.CodeAnalysis.Semantics.IIsTypeExpression
 Microsoft.CodeAnalysis.Semantics.IIsTypeExpression.IsType.get -> Microsoft.CodeAnalysis.ITypeSymbol
 Microsoft.CodeAnalysis.Semantics.IIsTypeExpression.Operand.get -> Microsoft.CodeAnalysis.IOperation
@@ -480,6 +492,11 @@ Microsoft.CodeAnalysis.Semantics.IParameterReferenceExpression
 Microsoft.CodeAnalysis.Semantics.IParameterReferenceExpression.Parameter.get -> Microsoft.CodeAnalysis.IParameterSymbol
 Microsoft.CodeAnalysis.Semantics.IParenthesizedExpression
 Microsoft.CodeAnalysis.Semantics.IParenthesizedExpression.Operand.get -> Microsoft.CodeAnalysis.IOperation
+Microsoft.CodeAnalysis.Semantics.IPattern
+Microsoft.CodeAnalysis.Semantics.IPatternCaseClause
+Microsoft.CodeAnalysis.Semantics.IPatternCaseClause.GuardExpression.get -> Microsoft.CodeAnalysis.IOperation
+Microsoft.CodeAnalysis.Semantics.IPatternCaseClause.Label.get -> Microsoft.CodeAnalysis.ILabelSymbol
+Microsoft.CodeAnalysis.Semantics.IPatternCaseClause.Pattern.get -> Microsoft.CodeAnalysis.Semantics.IPattern
 Microsoft.CodeAnalysis.Semantics.IPlaceholderExpression
 Microsoft.CodeAnalysis.Semantics.IPointerIndirectionReferenceExpression
 Microsoft.CodeAnalysis.Semantics.IPointerIndirectionReferenceExpression.Pointer.get -> Microsoft.CodeAnalysis.IOperation
@@ -695,7 +712,9 @@ override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitCompoundAssignmen
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.Semantics.IConditionalAccessExpression operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitConditionalAccessInstanceExpression(Microsoft.CodeAnalysis.Semantics.IConditionalAccessInstanceExpression operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitConditionalChoiceExpression(Microsoft.CodeAnalysis.Semantics.IConditionalChoiceExpression operation) -> void
+override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitConstantPattern(Microsoft.CodeAnalysis.Semantics.IConstantPattern operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitConversionExpression(Microsoft.CodeAnalysis.Semantics.IConversionExpression operation) -> void
+override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitDeclarationPattern(Microsoft.CodeAnalysis.Semantics.IDeclarationPattern operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitDefaultValueExpression(Microsoft.CodeAnalysis.Semantics.IDefaultValueExpression operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitEmptyStatement(Microsoft.CodeAnalysis.Semantics.IEmptyStatement operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitEndStatement(Microsoft.CodeAnalysis.Semantics.IEndStatement operation) -> void
@@ -717,6 +736,7 @@ override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitInterpolation(Mic
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitInvalidExpression(Microsoft.CodeAnalysis.Semantics.IInvalidExpression operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitInvalidStatement(Microsoft.CodeAnalysis.Semantics.IInvalidStatement operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitInvocationExpression(Microsoft.CodeAnalysis.Semantics.IInvocationExpression operation) -> void
+override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitIsPatternExpression(Microsoft.CodeAnalysis.Semantics.IIsPatternExpression operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitIsTypeExpression(Microsoft.CodeAnalysis.Semantics.IIsTypeExpression operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitLabelStatement(Microsoft.CodeAnalysis.Semantics.ILabelStatement operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitLambdaExpression(Microsoft.CodeAnalysis.Semantics.ILambdaExpression operation) -> void
@@ -732,6 +752,7 @@ override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitOmittedArgumentEx
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitParameterInitializer(Microsoft.CodeAnalysis.Semantics.IParameterInitializer operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitParameterReferenceExpression(Microsoft.CodeAnalysis.Semantics.IParameterReferenceExpression operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitParenthesizedExpression(Microsoft.CodeAnalysis.Semantics.IParenthesizedExpression operation) -> void
+override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitPatternCaseClause(Microsoft.CodeAnalysis.Semantics.IPatternCaseClause operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitPlaceholderExpression(Microsoft.CodeAnalysis.Semantics.IPlaceholderExpression operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitPointerIndirectionReferenceExpression(Microsoft.CodeAnalysis.Semantics.IPointerIndirectionReferenceExpression operation) -> void
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitPropertyInitializer(Microsoft.CodeAnalysis.Semantics.IPropertyInitializer operation) -> void
@@ -796,7 +817,9 @@ virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitCompoundAssignmen
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.Semantics.IConditionalAccessExpression operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitConditionalAccessInstanceExpression(Microsoft.CodeAnalysis.Semantics.IConditionalAccessInstanceExpression operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitConditionalChoiceExpression(Microsoft.CodeAnalysis.Semantics.IConditionalChoiceExpression operation) -> void
+virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitConstantPattern(Microsoft.CodeAnalysis.Semantics.IConstantPattern operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitConversionExpression(Microsoft.CodeAnalysis.Semantics.IConversionExpression operation) -> void
+virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitDeclarationPattern(Microsoft.CodeAnalysis.Semantics.IDeclarationPattern operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitDefaultValueExpression(Microsoft.CodeAnalysis.Semantics.IDefaultValueExpression operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitEmptyStatement(Microsoft.CodeAnalysis.Semantics.IEmptyStatement operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitEndStatement(Microsoft.CodeAnalysis.Semantics.IEndStatement operation) -> void
@@ -818,6 +841,7 @@ virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitInterpolation(Mic
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitInvalidExpression(Microsoft.CodeAnalysis.Semantics.IInvalidExpression operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitInvalidStatement(Microsoft.CodeAnalysis.Semantics.IInvalidStatement operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitInvocationExpression(Microsoft.CodeAnalysis.Semantics.IInvocationExpression operation) -> void
+virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitIsPatternExpression(Microsoft.CodeAnalysis.Semantics.IIsPatternExpression operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitIsTypeExpression(Microsoft.CodeAnalysis.Semantics.IIsTypeExpression operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitLabelStatement(Microsoft.CodeAnalysis.Semantics.ILabelStatement operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitLambdaExpression(Microsoft.CodeAnalysis.Semantics.ILambdaExpression operation) -> void
@@ -833,6 +857,7 @@ virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitOmittedArgumentEx
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitParameterInitializer(Microsoft.CodeAnalysis.Semantics.IParameterInitializer operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitParameterReferenceExpression(Microsoft.CodeAnalysis.Semantics.IParameterReferenceExpression operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitParenthesizedExpression(Microsoft.CodeAnalysis.Semantics.IParenthesizedExpression operation) -> void
+virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitPatternCaseClause(Microsoft.CodeAnalysis.Semantics.IPatternCaseClause operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitPlaceholderExpression(Microsoft.CodeAnalysis.Semantics.IPlaceholderExpression operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitPointerIndirectionReferenceExpression(Microsoft.CodeAnalysis.Semantics.IPointerIndirectionReferenceExpression operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitPropertyInitializer(Microsoft.CodeAnalysis.Semantics.IPropertyInitializer operation) -> void
@@ -874,7 +899,9 @@ virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.Vi
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.Semantics.IConditionalAccessExpression operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitConditionalAccessInstanceExpression(Microsoft.CodeAnalysis.Semantics.IConditionalAccessInstanceExpression operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitConditionalChoiceExpression(Microsoft.CodeAnalysis.Semantics.IConditionalChoiceExpression operation, TArgument argument) -> TResult
+virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitConstantPattern(Microsoft.CodeAnalysis.Semantics.IConstantPattern operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitConversionExpression(Microsoft.CodeAnalysis.Semantics.IConversionExpression operation, TArgument argument) -> TResult
+virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitDeclarationPattern(Microsoft.CodeAnalysis.Semantics.IDeclarationPattern operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitDefaultValueExpression(Microsoft.CodeAnalysis.Semantics.IDefaultValueExpression operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitEmptyStatement(Microsoft.CodeAnalysis.Semantics.IEmptyStatement operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitEndStatement(Microsoft.CodeAnalysis.Semantics.IEndStatement operation, TArgument argument) -> TResult
@@ -896,6 +923,7 @@ virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.Vi
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitInvalidExpression(Microsoft.CodeAnalysis.Semantics.IInvalidExpression operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitInvalidStatement(Microsoft.CodeAnalysis.Semantics.IInvalidStatement operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitInvocationExpression(Microsoft.CodeAnalysis.Semantics.IInvocationExpression operation, TArgument argument) -> TResult
+virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitIsPatternExpression(Microsoft.CodeAnalysis.Semantics.IIsPatternExpression operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitIsTypeExpression(Microsoft.CodeAnalysis.Semantics.IIsTypeExpression operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitLabelStatement(Microsoft.CodeAnalysis.Semantics.ILabelStatement operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitLambdaExpression(Microsoft.CodeAnalysis.Semantics.ILambdaExpression operation, TArgument argument) -> TResult
@@ -911,6 +939,7 @@ virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.Vi
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitParameterInitializer(Microsoft.CodeAnalysis.Semantics.IParameterInitializer operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitParameterReferenceExpression(Microsoft.CodeAnalysis.Semantics.IParameterReferenceExpression operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitParenthesizedExpression(Microsoft.CodeAnalysis.Semantics.IParenthesizedExpression operation, TArgument argument) -> TResult
+virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitPatternCaseClause(Microsoft.CodeAnalysis.Semantics.IPatternCaseClause operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitPlaceholderExpression(Microsoft.CodeAnalysis.Semantics.IPlaceholderExpression operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitPointerIndirectionReferenceExpression(Microsoft.CodeAnalysis.Semantics.IPointerIndirectionReferenceExpression operation, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor<TArgument, TResult>.VisitPropertyInitializer(Microsoft.CodeAnalysis.Semantics.IPropertyInitializer operation, TArgument argument) -> TResult

src/Test/Utilities/Portable/Compilation/OperationTreeVerifier.cs

@@ -1123,6 +1123,42 @@ public override void VisitInterpolation(IInterpolation operation)
             Visit(operation.FormatString, "FormatString");
         }
 
+        public override void VisitConstantPattern(IConstantPattern operation)
+        {
+            LogString(nameof(IConstantPattern));
+            LogCommonPropertiesAndNewLine(operation);
+
+            Visit(operation.Value, "Value");
+        }
+
+        public override void VisitDeclarationPattern(IDeclarationPattern operation)
+        {
+            LogString(nameof(IDeclarationPattern));
+            LogSymbol(operation.DeclaredSymbol, " (Declared Symbol");
+            LogString(")");
+            LogCommonPropertiesAndNewLine(operation);
+        }
+
+        public override void VisitIsPatternExpression(IIsPatternExpression operation)
+        {
+            LogString(nameof(IIsPatternExpression));
+            LogCommonPropertiesAndNewLine(operation);
+
+            Visit(operation.Expression, "Expression");
+            Visit(operation.Pattern, "Pattern");
+        }
+
+        public override void VisitPatternCaseClause(IPatternCaseClause operation)
+        {
+            LogString(nameof(IPatternCaseClause));
+            LogSymbol(operation.Label, " (Label Symbol");
+            LogString(")");
+            LogCommonPropertiesAndNewLine(operation);
+
+            Visit(operation.Pattern, "Pattern");
+            Visit(operation.GuardExpression, "Guard Expression");
+        }
+
         #endregion
     }
 }
\ No newline at end of file

src/Test/Utilities/Portable/Compilation/TestOperationWalker.cs

@@ -529,5 +529,29 @@ public override void VisitInterpolation(IInterpolation operation)
         {
             base.VisitInterpolation(operation);
         }
+
+        public override void VisitConstantPattern(IConstantPattern operation)
+        {
+            base.VisitConstantPattern(operation);
+        }
+
+        public override void VisitDeclarationPattern(IDeclarationPattern operation)
+        {
+            var declaredSymbol = operation.DeclaredSymbol;
+
+            base.VisitDeclarationPattern(operation);
+        }
+
+        public override void VisitIsPatternExpression(IIsPatternExpression operation)
+        {
+            base.VisitIsPatternExpression(operation);
+        }
+
+        public override void VisitPatternCaseClause(IPatternCaseClause operation)
+        {
+            var label = operation.Label;
+
+            base.VisitPatternCaseClause(operation);
+        }
     }
 }
\ No newline at end of file