Fix merge resolution conflicts and update unit tests to account for new operation dump format

src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs

@@ -481,7 +481,7 @@ public BoundDup Update(RefKind refKind, TypeSymbol type)
 
     internal sealed partial class BoundBadExpression : BoundExpression
     {
-        public BoundBadExpression(SyntaxNode syntax, LookupResultKind resultKind, ImmutableArray<Symbol> symbols, ImmutableArray<BoundNode> childBoundNodes, TypeSymbol type, bool hasErrors = false)
+        public BoundBadExpression(SyntaxNode syntax, LookupResultKind resultKind, ImmutableArray<Symbol> symbols, ImmutableArray<BoundExpression> childBoundNodes, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.BadExpression, syntax, type, hasErrors || childBoundNodes.HasErrors())
         {
 
@@ -499,14 +499,14 @@ public BoundBadExpression(SyntaxNode syntax, LookupResultKind resultKind, Immuta
 
         public ImmutableArray<Symbol> Symbols { get; }
 
-        public ImmutableArray<BoundNode> ChildBoundNodes { get; }
+        public ImmutableArray<BoundExpression> ChildBoundNodes { get; }
 
         public override BoundNode Accept(BoundTreeVisitor visitor)
         {
             return visitor.VisitBadExpression(this);
         }
 
-        public BoundBadExpression Update(LookupResultKind resultKind, ImmutableArray<Symbol> symbols, ImmutableArray<BoundNode> childBoundNodes, TypeSymbol type)
+        public BoundBadExpression Update(LookupResultKind resultKind, ImmutableArray<Symbol> symbols, ImmutableArray<BoundExpression> childBoundNodes, TypeSymbol type)
         {
             if (resultKind != this.ResultKind || symbols != this.Symbols || childBoundNodes != this.ChildBoundNodes || type != this.Type)
             {
@@ -8387,7 +8387,7 @@ public override BoundNode VisitDup(BoundDup node)
         }
         public override BoundNode VisitBadExpression(BoundBadExpression node)
         {
-            ImmutableArray<BoundNode> childBoundNodes = (ImmutableArray<BoundNode>)this.VisitList(node.ChildBoundNodes);
+            ImmutableArray<BoundExpression> childBoundNodes = (ImmutableArray<BoundExpression>)this.VisitList(node.ChildBoundNodes);
             TypeSymbol type = this.VisitType(node.Type);
             return node.Update(node.ResultKind, node.Symbols, childBoundNodes, type);
         }

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

@@ -26,11 +26,29 @@ static void Main(string[] args)
 }
 ";
             string expectedOperationTree = @"
-IVariableDeclarationStatement (2 variables) (OperationKind.VariableDeclarationStatement, IsInvalid)
-  IVariableDeclaration: System.Int32 x (OperationKind.VariableDeclaration)
-  IVariableDeclaration: System.Int32  (OperationKind.VariableDeclaration, IsInvalid)
+IVariableDeclarationStatement (2 variables) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'int x, ( 1 );')
+  IVariableDeclaration: System.Int32 x (OperationKind.VariableDeclaration) (Syntax: 'x')
+  IVariableDeclaration: System.Int32  (OperationKind.VariableDeclaration, IsInvalid) (Syntax: '( 1 ')
 ";
-            VerifyOperationTreeForTest<LocalDeclarationStatementSyntax>(source, expectedOperationTree);
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS1001: Identifier expected
+                //         /*<bind>*/int x, ( 1 );/*</bind>*/
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(8, 26),
+                // CS1528: Expected ; or = (cannot specify constructor arguments in declaration)
+                //         /*<bind>*/int x, ( 1 );/*</bind>*/
+                Diagnostic(ErrorCode.ERR_BadVarDecl, "( 1 ").WithLocation(8, 26),
+                // CS1003: Syntax error, '[' expected
+                //         /*<bind>*/int x, ( 1 );/*</bind>*/
+                Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments("[", "(").WithLocation(8, 26),
+                // CS1003: Syntax error, ']' expected
+                //         /*<bind>*/int x, ( 1 );/*</bind>*/
+                Diagnostic(ErrorCode.ERR_SyntaxError, ")").WithArguments("]", ")").WithLocation(8, 30),
+                // CS0168: The variable 'x' is declared but never used
+                //         /*<bind>*/int x, ( 1 );/*</bind>*/
+                Diagnostic(ErrorCode.WRN_UnreferencedVar, "x").WithArguments("x").WithLocation(8, 23)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<LocalDeclarationStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
         [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18080"), WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
@@ -43,7 +61,7 @@ class Program
 {
     static void Main(string[] args)
     {
-        /*<bind>*/switch(Program)
+        /*<bind>*/switch (Program)
         {
             case 1:
                 break;
@@ -51,13 +69,20 @@ static void Main(string[] args)
     }
 }
 ";
-            // Operation tree must contain the operations for switch case sections.
             string expectedOperationTree = @"
+IOperation:  (OperationKind.None, IsInvalid) (Syntax: 'switch (Pro ... }')
 ";
-            VerifyOperationTreeForTest<SwitchStatementSyntax>(source, expectedOperationTree);
-        }
-
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0119: 'Program' is a type, which is not valid in the given context
+                //         /*<bind>*/switch (Program)
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "Program").WithArguments("Program", "type").WithLocation(8, 27),
+                // CS0029: Cannot implicitly convert type 'int' to 'Program'
+                //             case 1:
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "1").WithArguments("int", "Program").WithLocation(10, 18)
+            };
 
+            VerifyOperationTreeAndDiagnosticsForTest<SwitchStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
 
         [Fact, WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
         public void InvalidSwitchStatementCaseLabel()
@@ -78,18 +103,23 @@ static void Main(string[] args)
     }
 }
 ";
-            // IOperation tree might be affected with https://github.com/dotnet/roslyn/issues/18089
             string expectedOperationTree = @"
-ISwitchStatement (1 cases) (OperationKind.SwitchStatement, IsInvalid)
-  Switch expression: IInvocationExpression (virtual System.String System.Object.ToString()) (OperationKind.InvocationExpression, Type: System.String)
-      Instance Receiver: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
-  ISwitchCase (1 case clauses, 1 statements) (OperationKind.SwitchCase, IsInvalid)
-    Case clauses: ISingleValueCaseClause (Equality operator kind: BinaryOperationKind.StringEquals) (CaseKind.SingleValue) (OperationKind.SingleValueCaseClause, IsInvalid)
-        IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.String, IsInvalid)
-          ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1)
-    Body: IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement)
+ISwitchStatement (1 cases) (OperationKind.SwitchStatement, IsInvalid) (Syntax: 'switch (x.T ... }')
+  Switch expression: IInvocationExpression (virtual System.String System.Object.ToString()) (OperationKind.InvocationExpression, Type: System.String) (Syntax: 'x.ToString()')
+      Instance Receiver: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program) (Syntax: 'x')
+  Sections: ISwitchCase (1 case clauses, 1 statements) (OperationKind.SwitchCase, IsInvalid) (Syntax: 'case 1: ... break;')
+        Clauses: ISingleValueCaseClause (Equality operator kind: BinaryOperationKind.StringEquals) (CaseKind.SingleValue) (OperationKind.SingleValueCaseClause, IsInvalid) (Syntax: 'case 1:')
+            IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.String, IsInvalid) (Syntax: '1')
+              ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
+        Body: IBranchStatement (BranchKind.Break) (OperationKind.BranchStatement) (Syntax: 'break;')
 ";
-            VerifyOperationTreeForTest<SwitchStatementSyntax>(source, expectedOperationTree);
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0029: Cannot implicitly convert type 'int' to 'string'
+                //             case 1:
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "1").WithArguments("int", "string").WithLocation(11, 18)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<SwitchStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
         [Fact, WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
@@ -110,15 +140,21 @@ static void Main(string[] args)
 }
 ";
             string expectedOperationTree = @"
-IIfStatement (OperationKind.IfStatement, IsInvalid)
-  Condition: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Boolean, IsInvalid)
-      IAssignmentExpression (OperationKind.AssignmentExpression, Type: Program)
-        Left: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
-        Right: IConversionExpression (ConversionKind.Cast, Implicit) (OperationKind.ConversionExpression, Type: Program, Constant: null)
-            ILiteralExpression (Text: null) (OperationKind.LiteralExpression, Type: null, Constant: null)
-  IBlockStatement (0 statements) (OperationKind.BlockStatement)
+IIfStatement (OperationKind.IfStatement, IsInvalid) (Syntax: 'if (x = nul ... }')
+  Condition: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Boolean, IsInvalid) (Syntax: 'x = null')
+      IAssignmentExpression (OperationKind.AssignmentExpression, Type: Program) (Syntax: 'x = null')
+        Left: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program) (Syntax: 'x')
+        Right: IConversionExpression (ConversionKind.Cast, Implicit) (OperationKind.ConversionExpression, Type: Program, Constant: null) (Syntax: 'null')
+            ILiteralExpression (Text: null) (OperationKind.LiteralExpression, Type: null, Constant: null) (Syntax: 'null')
+  IfTrue: IBlockStatement (0 statements) (OperationKind.BlockStatement) (Syntax: '{ ... }')
 ";
-            VerifyOperationTreeForTest<IfStatementSyntax>(source, expectedOperationTree);
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0029: Cannot implicitly convert type 'Program' to 'bool'
+                //         /*<bind>*/if (x = null)
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "x = null").WithArguments("Program", "bool").WithLocation(9, 23)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<IfStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
         [Fact, WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
@@ -141,19 +177,37 @@ static void Main(string[] args)
 }
 ";
             string expectedOperationTree = @"
-IIfStatement (OperationKind.IfStatement, IsInvalid)
-  Condition: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Boolean, IsInvalid)
-      IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
-  IBlockStatement (0 statements) (OperationKind.BlockStatement)
-  IIfStatement (OperationKind.IfStatement, IsInvalid)
-    Condition: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Boolean, IsInvalid)
-        ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
-    IExpressionStatement (OperationKind.ExpressionStatement, IsInvalid)
-      ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
-    IExpressionStatement (OperationKind.ExpressionStatement, IsInvalid)
-      IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+IIfStatement (OperationKind.IfStatement, IsInvalid) (Syntax: 'if () ... else')
+  Condition: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Boolean, IsInvalid) (Syntax: '')
+      IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid) (Syntax: '')
+  IfTrue: IBlockStatement (0 statements) (OperationKind.BlockStatement) (Syntax: '{ ... }')
+  IfFalse: IIfStatement (OperationKind.IfStatement, IsInvalid) (Syntax: 'if (x) x; ... else')
+      Condition: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Boolean, IsInvalid) (Syntax: 'x')
+          ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program) (Syntax: 'x')
+      IfTrue: IExpressionStatement (OperationKind.ExpressionStatement, IsInvalid) (Syntax: 'x;')
+          ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program) (Syntax: 'x')
+      IfFalse: IExpressionStatement (OperationKind.ExpressionStatement, IsInvalid) (Syntax: '')
+          IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid) (Syntax: '')
 ";
-            VerifyOperationTreeForTest<IfStatementSyntax>(source, expectedOperationTree);
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS1525: Invalid expression term ')'
+                //         /*<bind>*/if ()
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ")").WithArguments(")").WithLocation(9, 23),
+                // CS1525: Invalid expression term '}'
+                //         else
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "").WithArguments("}").WithLocation(13, 13),
+                // CS1002: ; expected
+                //         else
+                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(13, 13),
+                // CS0029: Cannot implicitly convert type 'Program' to 'bool'
+                //         else if (x) x;
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "x").WithArguments("Program", "bool").WithLocation(12, 18),
+                // CS0201: Only assignment, call, increment, decrement, and new object expressions can be used as a statement
+                //         else if (x) x;
+                Diagnostic(ErrorCode.ERR_IllegalStatement, "x").WithLocation(12, 21)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<IfStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
         [Fact, WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
@@ -167,21 +221,33 @@ class Program
     static void Main(string[] args)
     {
         var x = new Program();
-        /*<bind>*/for (P; x; )
+        /*<bind>*/for (P; x;)
         {
         }/*</bind>*/
     }
 }
 ";
             string expectedOperationTree = @"
-IForLoopStatement (LoopKind.For) (OperationKind.LoopStatement, IsInvalid)
-  Condition: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Boolean, IsInvalid)
-      ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
-  Before: IExpressionStatement (OperationKind.ExpressionStatement, IsInvalid)
-      IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
-  IBlockStatement (0 statements) (OperationKind.BlockStatement)
+IForLoopStatement (LoopKind.For) (OperationKind.LoopStatement, IsInvalid) (Syntax: 'for (P; x;) ... }')
+  Condition: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Boolean, IsInvalid) (Syntax: 'x')
+      ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program) (Syntax: 'x')
+  Before: IExpressionStatement (OperationKind.ExpressionStatement, IsInvalid) (Syntax: 'P')
+      IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid) (Syntax: 'P')
+  Body: IBlockStatement (0 statements) (OperationKind.BlockStatement) (Syntax: '{ ... }')
 ";
-            VerifyOperationTreeForTest<ForStatementSyntax>(source, expectedOperationTree);
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0103: The name 'P' does not exist in the current context
+                //         /*<bind>*/for (P; x;)
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "P").WithArguments("P").WithLocation(9, 24),
+                // CS0201: Only assignment, call, increment, decrement, and new object expressions can be used as a statement
+                //         /*<bind>*/for (P; x;)
+                Diagnostic(ErrorCode.ERR_IllegalStatement, "P").WithLocation(9, 24),
+                // CS0029: Cannot implicitly convert type 'Program' to 'bool'
+                //         /*<bind>*/for (P; x;)
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "x").WithArguments("Program", "bool").WithLocation(9, 27)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<ForStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
         [Fact, WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
@@ -204,10 +270,16 @@ static void Main(string[] args)
 }
 ";
             string expectedOperationTree = @"
-IInvalidStatement (OperationKind.InvalidStatement, IsInvalid)
-  ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1)
+IInvalidStatement (OperationKind.InvalidStatement, IsInvalid) (Syntax: 'goto case 1;')
+  Children(1): ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
 ";
-            VerifyOperationTreeForTest<GotoStatementSyntax>(source, expectedOperationTree);
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0159: No such label 'case 1:' within the scope of the goto statement
+                //                 /*<bind>*/goto case 1;/*</bind>*/
+                Diagnostic(ErrorCode.ERR_LabelNotFound, "goto case 1;").WithArguments("case 1:").WithLocation(11, 27)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<GotoStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
         [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18225"), WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
@@ -225,13 +297,19 @@ static void Main(string[] args)
 }
 ";
             string expectedOperationTree = @"
-IInvalidStatement (OperationKind.InvalidStatement, IsInvalid)
-  ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1)
+IInvalidStatement (OperationKind.InvalidStatement, IsInvalid) (Syntax: 'goto case 1;')
+  ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
 ";
-            VerifyOperationTreeForTest<GotoStatementSyntax>(source, expectedOperationTree);
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0153: A goto case is only valid inside a switch statement
+                //         /*<bind>*/goto case 1;/*</bind>*/
+                Diagnostic(ErrorCode.ERR_InvalidGotoCase, "goto case 1;").WithLocation(8, 19)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<GotoStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18225"), WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
+        [Fact, WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
         public void InvalidBreakStatement_OutsideLoopOrSwitch()
         {
             string source = @"
@@ -246,12 +324,18 @@ static void Main(string[] args)
 }
 ";
             string expectedOperationTree = @"
-IInvalidStatement (OperationKind.InvalidStatement, IsInvalid)
+IInvalidStatement (OperationKind.InvalidStatement, IsInvalid) (Syntax: 'break;')
 ";
-            VerifyOperationTreeForTest<BreakStatementSyntax>(source, expectedOperationTree);
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0139: No enclosing loop out of which to break or continue
+                //         /*<bind>*/break;/*</bind>*/
+                Diagnostic(ErrorCode.ERR_NoBreakOrCont, "break;").WithLocation(8, 19)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<BreakStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18225"), WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
+        [Fact, WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
         public void InvalidContinueStatement_OutsideLoopOrSwitch()
         {
             string source = @"
@@ -266,9 +350,15 @@ static void Main(string[] args)
 }
 ";
             string expectedOperationTree = @"
-IInvalidStatement (OperationKind.InvalidStatement, IsInvalid)
+IInvalidStatement (OperationKind.InvalidStatement, IsInvalid) (Syntax: 'continue;')
 ";
-            VerifyOperationTreeForTest<ContinueStatementSyntax>(source, expectedOperationTree);
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0139: No enclosing loop out of which to break or continue
+                //         /*<bind>*/continue;/*</bind>*/
+                Diagnostic(ErrorCode.ERR_NoBreakOrCont, "continue;").WithLocation(8, 19)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<ContinueStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
     }
 }
\ No newline at end of file

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

@@ -1082,10 +1082,15 @@ public override void Accept(OperationVisitor visitor)
     /// </remarks>
     internal sealed partial class InvalidExpression : Operation, IInvalidExpression
     {
-        public InvalidExpression(bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+        public InvalidExpression(ImmutableArray<IOperation> children, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
             base(OperationKind.InvalidExpression, isInvalid, syntax, type, constantValue)
         {
+            Children = children;
         }
+        /// <summary>
+        /// Child operations.
+        /// </summary>
+        public ImmutableArray<IOperation> Children { get; }
         public override void Accept(OperationVisitor visitor)
         {
             visitor.VisitInvalidExpression(this);
@@ -1105,10 +1110,15 @@ public override void Accept(OperationVisitor visitor)
     /// </remarks>
     internal sealed partial class InvalidStatement : Operation, IInvalidStatement
     {
-        public InvalidStatement(bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+        public InvalidStatement(ImmutableArray<IOperation> children, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
             base(OperationKind.InvalidStatement, isInvalid, syntax, type, constantValue)
         {
+            Children = children;
         }
+        /// <summary>
+        /// Child operations.
+        /// </summary>
+        public ImmutableArray<IOperation> Children { get; }
         public override void Accept(OperationVisitor visitor)
         {
             visitor.VisitInvalidStatement(this);

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

@@ -108,8 +108,8 @@ internal sealed partial class ArrayCreationExpression : IArrayCreationExpression
 
     internal partial class InvalidExpression : IInvalidExpression
     {
-        public InvalidExpression(SyntaxNode syntax) :
-            this(isInvalid: true, syntax: syntax, type: null, constantValue: default(Optional<object>))
+        public InvalidExpression(SyntaxNode syntax, ImmutableArray<IOperation> children) :
+            this(children: children, isInvalid: true, syntax: syntax, type: null, constantValue: default(Optional<object>))
         {
         }
     }

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

@@ -10,6 +10,10 @@ namespace Microsoft.CodeAnalysis.Semantics
     /// </remarks>
     public interface IInvalidExpression : IOperation
     {
+        /// <summary>
+        /// Child operations.
+        /// </summary>
+        ImmutableArray<IOperation> Children { get; }
     }
 }
 

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

@@ -13,6 +13,10 @@ namespace Microsoft.CodeAnalysis.Semantics
     /// </remarks>
     public interface IInvalidStatement : IOperation
     {
+        /// <summary>
+        /// Child operations.
+        /// </summary>
+        ImmutableArray<IOperation> Children { get; }
     }
 }
 

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

@@ -5,6 +5,8 @@ Microsoft.CodeAnalysis.CommandLineReference.CommandLineReference(string referenc
 Microsoft.CodeAnalysis.CommandLineSourceFile.CommandLineSourceFile(string path, bool isScript) -> void
 Microsoft.CodeAnalysis.ParseOptions.Errors.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic>
 Microsoft.CodeAnalysis.ParseOptions.SpecifiedKind.get -> Microsoft.CodeAnalysis.SourceCodeKind
+Microsoft.CodeAnalysis.Semantics.IInvalidExpression.Children.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IOperation>
+Microsoft.CodeAnalysis.Semantics.IInvalidStatement.Children.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IOperation>
 override Microsoft.CodeAnalysis.Semantics.OperationWalker.VisitCatchClause(Microsoft.CodeAnalysis.Semantics.ICatchClause operation) -> void
 static Microsoft.CodeAnalysis.Compilation.GetRequiredLanguageVersion(Microsoft.CodeAnalysis.Diagnostic diagnostic) -> string
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitCatchClause(Microsoft.CodeAnalysis.Semantics.ICatchClause operation) -> void

src/Compilers/VisualBasic/Portable/Generated/BoundNodes.xml.Generated.vb

@@ -606,7 +606,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Friend NotInheritable Partial Class BoundBadExpression
         Inherits BoundExpression
 
-        Public Sub New(syntax As SyntaxNode, resultKind As LookupResultKind, symbols As ImmutableArray(Of Symbol), childBoundNodes As ImmutableArray(Of BoundNode), type As TypeSymbol, Optional hasErrors As Boolean = False)
+        Public Sub New(syntax As SyntaxNode, resultKind As LookupResultKind, symbols As ImmutableArray(Of Symbol), childBoundNodes As ImmutableArray(Of BoundExpression), type As TypeSymbol, Optional hasErrors As Boolean = False)
             MyBase.New(BoundKind.BadExpression, syntax, type, hasErrors OrElse childBoundNodes.NonNullAndHasErrors())
 
             Debug.Assert(Not (symbols.IsDefault), "Field 'symbols' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
@@ -637,8 +637,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
-        Private ReadOnly _ChildBoundNodes As ImmutableArray(Of BoundNode)
-        Public ReadOnly Property ChildBoundNodes As ImmutableArray(Of BoundNode)
+        Private ReadOnly _ChildBoundNodes As ImmutableArray(Of BoundExpression)
+        Public ReadOnly Property ChildBoundNodes As ImmutableArray(Of BoundExpression)
             Get
                 Return _ChildBoundNodes
             End Get
@@ -648,14 +648,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return visitor.VisitBadExpression(Me)
         End Function
 
-        Public Function Update(resultKind As LookupResultKind, symbols As ImmutableArray(Of Symbol), childBoundNodes As ImmutableArray(Of BoundNode), type As TypeSymbol) As BoundBadExpression
+        Public Function Update(resultKind As LookupResultKind, symbols As ImmutableArray(Of Symbol), childBoundNodes As ImmutableArray(Of BoundExpression), type As TypeSymbol) As BoundBadExpression
             If resultKind <> Me.ResultKind OrElse symbols <> Me.Symbols OrElse childBoundNodes <> Me.ChildBoundNodes OrElse type IsNot Me.Type Then
                 Dim result = New BoundBadExpression(Me.Syntax, resultKind, symbols, childBoundNodes, type, Me.HasErrors)
-                
+
                 If Me.WasCompilerGenerated Then
                     result.SetWasCompilerGenerated()
                 End If
-                
+
                 Return result
             End If
             Return Me
@@ -12467,7 +12467,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         End Function
 
         Public Overrides Function VisitBadExpression(node As BoundBadExpression) As BoundNode
-            Dim childBoundNodes As ImmutableArray(Of BoundNode) = Me.VisitList(node.ChildBoundNodes)
+            Dim childBoundNodes As ImmutableArray(Of BoundExpression) = Me.VisitList(node.ChildBoundNodes)
             Dim type as TypeSymbol = Me.VisitType(node.Type)
             Return node.Update(node.ResultKind, node.Symbols, childBoundNodes, type)
         End Function

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests.vb

@@ -336,13 +336,21 @@ BC30581: 'AddressOf' expression cannot be converted to 'Integer' because 'Intege
         ILiteralExpression (OperationKind.LiteralExpression, Type: null, Constant: null) (Syntax: 'Nothing')")
 
             comp.VerifyOperationTree(nodes(1), expectedOperationTree:=
-"IInvalidExpression (OperationKind.InvalidExpression, Type: System.Void, IsInvalid) (Syntax: 'Test2(New S ... ), Nothing)')")
+"IInvalidExpression (OperationKind.InvalidExpression, Type: System.Void, IsInvalid) (Syntax: 'Test2(New S ... ), Nothing)')
+  Children(3): IOperation:  (OperationKind.None) (Syntax: 'Test2')
+    IObjectCreationExpression (Constructor: Sub System.Guid..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Guid) (Syntax: 'New System.Guid()')
+    ILiteralExpression (OperationKind.LiteralExpression, Type: null, Constant: null) (Syntax: 'Nothing')")
 
             comp.VerifyOperationTree(nodes(2), expectedOperationTree:=
-"IInvalidExpression (OperationKind.InvalidExpression, Type: System.Void, IsInvalid) (Syntax: 'Test1(AddressOf Main)')")
+"IInvalidExpression (OperationKind.InvalidExpression, Type: System.Void, IsInvalid) (Syntax: 'Test1(AddressOf Main)')
+  Children(2): IOperation:  (OperationKind.None) (Syntax: 'Test1')
+    IOperation:  (OperationKind.None) (Syntax: 'AddressOf Main')")
 
             comp.VerifyOperationTree(nodes(3), expectedOperationTree:=
-"IInvalidExpression (OperationKind.InvalidExpression, Type: System.Void, IsInvalid) (Syntax: 'Test2(New S ... essOf Main)')")
+"IInvalidExpression (OperationKind.InvalidExpression, Type: System.Void, IsInvalid) (Syntax: 'Test2(New S ... essOf Main)')
+  Children(3): IOperation:  (OperationKind.None) (Syntax: 'Test2')
+    IObjectCreationExpression (Constructor: Sub System.Guid..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Guid) (Syntax: 'New System.Guid()')
+    IOperation:  (OperationKind.None) (Syntax: 'AddressOf Main')")
         End Sub
     End Class
 End Namespace

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IVariableDeclaration.vb

@@ -518,6 +518,7 @@ End Module]]>.Value
 IVariableDeclarationStatement (1 variables) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'Dim i1(2) As New Integer')
   IVariableDeclaration: i1 As System.Int32() (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'i1(2)')
     Initializer: IInvalidExpression (OperationKind.InvalidExpression, Type: System.Int32(), IsInvalid) (Syntax: 'As New Integer')
+        Children(1): IObjectCreationExpression (Constructor: Sub System.Int32..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Int32) (Syntax: 'New Integer')
 ]]>.Value
 
             Dim expectedDiagnostics = <![CDATA[
@@ -841,6 +842,7 @@ End Module]]>.Value
 IVariableDeclarationStatement (1 variables) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'Const i1 = Int1()')
   IVariableDeclaration: i1 As System.Object (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'i1')
     Initializer: IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid) (Syntax: 'Int1()')
+        Children(1): IInvocationExpression (static Function Program.Int1() As System.Int32) (OperationKind.InvocationExpression, Type: System.Int32) (Syntax: 'Int1()')
 ]]>.Value
 
             Dim expectedDiagnostics = <![CDATA[
@@ -869,8 +871,10 @@ End Module]]>.Value
 IVariableDeclarationStatement (2 variables) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'Const i1 =  ... i2 = Int1()')
   IVariableDeclaration: i1 As System.Object (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'i1')
     Initializer: IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid) (Syntax: 'Int1()')
+        Children(1): IInvocationExpression (static Function Program.Int1() As System.Int32) (OperationKind.InvocationExpression, Type: System.Int32) (Syntax: 'Int1()')
   IVariableDeclaration: i2 As System.Object (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'i2')
     Initializer: IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid) (Syntax: 'Int1()')
+        Children(1): IInvocationExpression (static Function Program.Int1() As System.Int32) (OperationKind.InvocationExpression, Type: System.Int32) (Syntax: 'Int1()')
 ]]>.Value
 
             Dim expectedDiagnostics = <![CDATA[

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

@@ -229,7 +229,7 @@ private void Visit(IOperation operation, string header)
             Unindent();
         }
 
-        private void VisitArray<T>(ImmutableArray<T> list, string header, bool logElementCount = false)
+        private void VisitArray<T>(ImmutableArray<T> list, string header, bool logElementCount)
             where T : IOperation
         {
             Debug.Assert(!string.IsNullOrEmpty(header));
@@ -299,7 +299,7 @@ public override void VisitSwitchStatement(ISwitchStatement operation)
             LogCommonPropertiesAndNewLine(operation);
 
             Visit(operation.Value, header: "Switch expression");
-            VisitArray(operation.Cases, "Sections");
+            VisitArray(operation.Cases, "Sections", logElementCount: false);
         }
 
         public override void VisitSwitchCase(ISwitchCase operation)
@@ -310,8 +310,8 @@ public override void VisitSwitchCase(ISwitchCase operation)
             LogCommonPropertiesAndNewLine(operation);
 
             Indent();
-            VisitArray(operation.Clauses, "Clauses");
-            VisitArray(operation.Body, "Body");
+            VisitArray(operation.Clauses, "Clauses", logElementCount: false);
+            VisitArray(operation.Body, "Body", logElementCount: false);
             Unindent();
         }
 
@@ -333,8 +333,8 @@ public override void VisitForLoopStatement(IForLoopStatement operation)
 
             Visit(operation.Condition, "Condition");
             LogLocals(operation.Locals);
-            VisitArray(operation.Before, "Before");
-            VisitArray(operation.AtLoopBottom, "AtLoopBottom");
+            VisitArray(operation.Before, "Before", logElementCount: false);
+            VisitArray(operation.AtLoopBottom, "AtLoopBottom", logElementCount: false);
             Visit(operation.Body, "Body");
         }
 
@@ -1022,7 +1022,7 @@ public override void VisitInvalidStatement(IInvalidStatement operation)
             LogString(nameof(IInvalidStatement));
             LogCommonPropertiesAndNewLine(operation);
 
-            base.VisitInvalidStatement(operation);
+            VisitArray(operation.Children, "Children", logElementCount: true);
         }
 
         public override void VisitInvalidExpression(IInvalidExpression operation)
@@ -1030,7 +1030,7 @@ public override void VisitInvalidExpression(IInvalidExpression operation)
             LogString(nameof(IInvalidExpression));
             LogCommonPropertiesAndNewLine(operation);
 
-            base.VisitInvalidExpression(operation);
+            VisitArray(operation.Children, "Children", logElementCount: true);
         }
 
         public override void VisitIfStatement(IIfStatement operation)