Add IOperation support for anonymous object creation expressions.

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

@@ -7,6 +7,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Semantics
 {
@@ -179,12 +180,16 @@ private IOperation CreateInternal(BoundNode boundNode)
                     return CreateBoundInterpolationOperation((BoundStringInsert)boundNode);
                 case BoundKind.LocalFunctionStatement:
                     return CreateBoundLocalFunctionStatementOperation((BoundLocalFunctionStatement)boundNode);
+                case BoundKind.AnonymousObjectCreationExpression:
+                    return CreateBoundAnonymousObjectCreationExpressionOperation((BoundAnonymousObjectCreationExpression)boundNode);
+                case BoundKind.AnonymousPropertyDeclaration:
+                    return CreateBoundAnonymousPropertyDeclarationOperation((BoundAnonymousPropertyDeclaration)boundNode);
                 case BoundKind.ConstantPattern:
                     return CreateBoundConstantPatternOperation((BoundConstantPattern)boundNode);
                 case BoundKind.DeclarationPattern:
                     return CreateBoundDeclarationPatternOperation((BoundDeclarationPattern)boundNode);
                 case BoundKind.WildcardPattern:
-                    return null;
+                    throw ExceptionUtilities.Unreachable;
                 case BoundKind.PatternSwitchStatement:
                     return CreateBoundPatternSwitchStatementOperation((BoundPatternSwitchStatement)boundNode);
                 case BoundKind.PatternSwitchLabel:
@@ -352,6 +357,29 @@ private ILiteralExpression CreateBoundLiteralOperation(BoundLiteral boundLiteral
             return new LiteralExpression(text, isInvalid, syntax, type, constantValue);
         }
 
+        private IAnonymousObjectCreationExpression CreateBoundAnonymousObjectCreationExpressionOperation(BoundAnonymousObjectCreationExpression boundAnonymousObjectCreationExpression)
+        {
+            Lazy<ImmutableArray<IOperation>> memberInitializers = new Lazy<ImmutableArray<IOperation>>(() => GetAnonymousObjectCreationInitializers(boundAnonymousObjectCreationExpression));
+            bool isInvalid = boundAnonymousObjectCreationExpression.HasErrors;
+            SyntaxNode syntax = boundAnonymousObjectCreationExpression.Syntax;
+            ITypeSymbol type = boundAnonymousObjectCreationExpression.Type;
+            Optional<object> constantValue = ConvertToOptional(boundAnonymousObjectCreationExpression.ConstantValue);
+            return new LazyAnonymousObjectCreationExpression(memberInitializers, isInvalid, syntax, type, constantValue);
+        }
+
+        private IPropertyReferenceExpression CreateBoundAnonymousPropertyDeclarationOperation(BoundAnonymousPropertyDeclaration boundAnonymousPropertyDeclaration)
+        {
+            PropertySymbol property = boundAnonymousPropertyDeclaration.Property;
+            Lazy<IOperation> instance = new Lazy<IOperation>(() => null);
+            ISymbol member = boundAnonymousPropertyDeclaration.Property;
+            Lazy<ImmutableArray<IArgument>> argumentsInEvaluationOrder = new Lazy<ImmutableArray<IArgument>>(() => ImmutableArray<IArgument>.Empty);
+            bool isInvalid = boundAnonymousPropertyDeclaration.HasErrors;
+            SyntaxNode syntax = boundAnonymousPropertyDeclaration.Syntax;
+            ITypeSymbol type = boundAnonymousPropertyDeclaration.Type;
+            Optional<object> constantValue = ConvertToOptional(boundAnonymousPropertyDeclaration.ConstantValue);
+            return new LazyPropertyReferenceExpression(property, instance, member, argumentsInEvaluationOrder, isInvalid, syntax, type, constantValue);
+        }
+
         private IObjectCreationExpression CreateBoundObjectCreationExpressionOperation(BoundObjectCreationExpression boundObjectCreationExpression)
         {
             IMethodSymbol constructor = boundObjectCreationExpression.Constructor;

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

@@ -1,6 +1,8 @@
 // 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;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -92,6 +94,33 @@ private ImmutableArray<IArgument> DeriveArguments(
                  invokedAsExtensionMethod: invokedAsExtensionMethod);
         }
 
+        private ImmutableArray<IOperation> GetAnonymousObjectCreationInitializers(BoundAnonymousObjectCreationExpression expression)
+        {
+            // For error cases, the binder generates only the argument.
+            Debug.Assert(expression.Arguments.Length >= expression.Declarations.Length);
+
+            var builder = ArrayBuilder<IOperation>.GetInstance(expression.Arguments.Length);
+            for (int i = 0; i < expression.Arguments.Length; i++)
+            {
+                IOperation value = Create(expression.Arguments[i]);
+                if (i >= expression.Declarations.Length)
+                {
+                    builder.Add(value);
+                    continue;
+                }
+
+                IOperation target = Create(expression.Declarations[i]);
+                bool isInvalid = target.IsInvalid || value.IsInvalid;
+                SyntaxNode syntax = value.Syntax?.Parent ?? expression.Syntax;
+                ITypeSymbol type = target.Type;
+                Optional<object> constantValue = value.ConstantValue;
+                var assignment = new SimpleAssignmentExpression(target, value, isInvalid, syntax, type, constantValue);
+                builder.Add(assignment);
+            }
+
+            return builder.ToImmutableAndFree();
+        }
+
         private ImmutableArray<IOperation> GetObjectCreationInitializers(BoundObjectCreationExpression expression)
         {
             return BoundObjectCreationExpression.GetChildInitializers(expression.InitializerExpressionOpt).SelectAsArray(n => Create(n));

src/Compilers/CSharp/Test/Semantic/FlowAnalysis/FlowTestBase.cs

@@ -93,8 +93,8 @@ protected T CompileAndGetModelAndExpression<T>(string program, Func<SemanticMode
             var comp = CreateStandardCompilation(program, new[] { LinqAssemblyRef });
             var tree = comp.SyntaxTrees[0];
             var model = comp.GetSemanticModel(tree);
-            int start = program.IndexOf(startString, StringComparison.Ordinal) + startString.Length;
-            int end = program.IndexOf(endString, StringComparison.Ordinal);
+            int start = program.IndexOf(StartString, StringComparison.Ordinal) + StartString.Length;
+            int end = program.IndexOf(EndString, StringComparison.Ordinal);
             ExpressionSyntax syntaxToBind = null;
             foreach (var expr in GetSyntaxNodeList(tree).OfType<ExpressionSyntax>())
             {
@@ -114,8 +114,8 @@ protected T CompileAndGetModelAndStatements<T>(string program, Func<SemanticMode
             var comp = CreateStandardCompilation(program, new[] { LinqAssemblyRef });
             var tree = comp.SyntaxTrees[0];
             var model = comp.GetSemanticModel(tree);
-            int start = program.IndexOf(startString, StringComparison.Ordinal) + startString.Length;
-            int end = program.IndexOf(endString, StringComparison.Ordinal);
+            int start = program.IndexOf(StartString, StringComparison.Ordinal) + StartString.Length;
+            int end = program.IndexOf(EndString, StringComparison.Ordinal);
             StatementSyntax firstStatement = null, lastStatement = null;
             foreach (var stmt in GetSyntaxNodeList(tree).OfType<StatementSyntax>())
             {

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

@@ -90,11 +90,15 @@ public void M(int x, string y)
 }
 ";
             string expectedOperationTree = @"
-IOperation:  (OperationKind.None) (Syntax: 'new { Amoun ... ello"" + y }')
-  Children(2): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
-    IBinaryOperatorExpression (BinaryOperationKind.StringConcatenate) (OperationKind.BinaryOperatorExpression, Type: System.String) (Syntax: '""Hello"" + y')
-      Left: ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""Hello"") (Syntax: '""Hello""')
-      Right: IParameterReferenceExpression: y (OperationKind.ParameterReferenceExpression, Type: System.String) (Syntax: 'y')
+IAnonymousObjectCreationExpression (OperationKind.AnonymousObjectCreationExpression, Type: <anonymous type: System.Int32 Amount, System.String Message>) (Syntax: 'new { Amoun ... ello"" + y }')
+  Initializers(2): ISimpleAssignmentExpression (OperationKind.SimpleAssignmentExpression, Type: System.Int32) (Syntax: 'Amount = x')
+      Left: IPropertyReferenceExpression: System.Int32 <anonymous type: System.Int32 Amount, System.String Message>.Amount { get; } (Static) (OperationKind.PropertyReferenceExpression, Type: System.Int32) (Syntax: 'Amount')
+      Right: IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+    ISimpleAssignmentExpression (OperationKind.SimpleAssignmentExpression, Type: System.String) (Syntax: 'Message = ""Hello"" + y')
+      Left: IPropertyReferenceExpression: System.String <anonymous type: System.Int32 Amount, System.String Message>.Message { get; } (Static) (OperationKind.PropertyReferenceExpression, Type: System.String) (Syntax: 'Message')
+      Right: IBinaryOperatorExpression (BinaryOperationKind.StringConcatenate) (OperationKind.BinaryOperatorExpression, Type: System.String) (Syntax: '""Hello"" + y')
+          Left: ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""Hello"") (Syntax: '""Hello""')
+          Right: IParameterReferenceExpression: y (OperationKind.ParameterReferenceExpression, Type: System.String) (Syntax: 'y')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 

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

@@ -675,5 +675,54 @@ void M(int? x)
 
             VerifyOperationTreeAndDiagnosticsForTest<CaseSwitchLabelSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
+
+        [Fact, WorkItem(19927, "https://github.com/dotnet/roslyn/issues/19927")]
+        public void TestPatternCaseClause_RedundantPatternDeclarationClauses()
+        {
+            string source = @"
+using System;
+class X
+{
+    void M(object p)
+    {
+        /*<bind>*/switch (p)
+        {
+            case int x:
+                break;
+            case int y:
+                break;
+            case X z:
+                break;
+        }/*</bind>*/
+    }
+}
+";
+            string expectedOperationTree = @"
+ISwitchStatement (3 cases) (OperationKind.SwitchStatement) (Syntax: 'switch (p) ... }')
+  Switch expression: IParameterReferenceExpression: p (OperationKind.ParameterReferenceExpression, Type: System.Object) (Syntax: 'p')
+  Sections: ISwitchCase (1 case clauses, 1 statements) (OperationKind.SwitchCase) (Syntax: 'case int x: ... break;')
+        Clauses: IPatternCaseClause (Label Symbol: case int x:) (CaseKind.Pattern) (OperationKind.PatternCaseClause) (Syntax: 'case int x:')
+            Pattern: IDeclarationPattern (Declared Symbol: System.Int32 x) (OperationKind.DeclarationPattern) (Syntax: 'int x')
+        Body: IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement) (Syntax: 'break;')
+    ISwitchCase (1 case clauses, 1 statements) (OperationKind.SwitchCase) (Syntax: 'case int y: ... break;')
+        Clauses: IPatternCaseClause (Label Symbol: case int y:) (CaseKind.Pattern) (OperationKind.PatternCaseClause) (Syntax: 'case int y:')
+            Pattern: IDeclarationPattern (Declared Symbol: System.Int32 y) (OperationKind.DeclarationPattern) (Syntax: 'int y')
+        Body: IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement) (Syntax: 'break;')
+    ISwitchCase (1 case clauses, 1 statements) (OperationKind.SwitchCase) (Syntax: 'case X z: ... break;')
+        Clauses: IPatternCaseClause (Label Symbol: case X z:) (CaseKind.Pattern) (OperationKind.PatternCaseClause) (Syntax: 'case X z:')
+            Pattern: IDeclarationPattern (Declared Symbol: X z) (OperationKind.DeclarationPattern) (Syntax: 'X z')
+        Body: IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement) (Syntax: 'break;')
+";
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS8120: The switch case has already been handled by a previous case.
+                //             case int y:
+                Diagnostic(ErrorCode.ERR_PatternIsSubsumed, "int y").WithLocation(11, 18),
+                // CS0162: Unreachable code detected
+                //                 break;
+                Diagnostic(ErrorCode.WRN_UnreachableCode, "break").WithLocation(12, 17)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<SwitchStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
     }
 }

src/Compilers/CSharp/Test/Semantic/Semantics/InteractiveSemanticModelTests.cs

@@ -265,60 +265,6 @@ public void BindQueryVariable()
 
         #region helpers
 
-        protected List<SyntaxNode> GetSyntaxNodeList(SyntaxTree syntaxTree)
-        {
-            return GetSyntaxNodeList(syntaxTree.GetCompilationUnitRoot(), null);
-        }
-
-        protected List<SyntaxNode> GetSyntaxNodeList(SyntaxNode node, List<SyntaxNode> synList)
-        {
-            if (synList == null)
-                synList = new List<SyntaxNode>();
-
-            synList.Add(node);
-
-            foreach (var child in node.ChildNodesAndTokens())
-            {
-                if (child.IsNode)
-                    synList = GetSyntaxNodeList(child.AsNode(), synList);
-            }
-
-            return synList;
-        }
-
-        protected SyntaxNode GetSyntaxNodeForBinding(List<SyntaxNode> synList)
-        {
-            foreach (var node in synList)
-            {
-                string exprFullText = node.ToFullString();
-                exprFullText = exprFullText.Trim();
-
-                if (exprFullText.StartsWith("/*<bind>*/", StringComparison.Ordinal))
-                {
-                    if (exprFullText.Contains("/*</bind>*/"))
-                        if (exprFullText.EndsWith("/*</bind>*/", StringComparison.Ordinal))
-                            return node;
-                        else
-                            continue;
-                    else
-                        return node;
-                }
-
-                if (exprFullText.EndsWith("/*</bind>*/", StringComparison.Ordinal))
-                {
-                    if (exprFullText.Contains("/*<bind>*/"))
-                        if (exprFullText.StartsWith("/*<bind>*/", StringComparison.Ordinal))
-                            return node;
-                        else
-                            continue;
-                    else
-                        return node;
-                }
-            }
-
-            return null;
-        }
-
         private List<ExpressionSyntax> GetExprSyntaxList(SyntaxTree syntaxTree)
         {
             return GetExprSyntaxList(syntaxTree.GetCompilationUnitRoot(), null);