Add unit tests for invalid expressions (C# and VB)

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

@@ -60,6 +60,7 @@
     <Compile Include="Diagnostics\DiagnosticAnalyzerTests.cs" />
     <Compile Include="Diagnostics\GetDiagnosticsTests.cs" />
     <Compile Include="IOperation\IOperationTests_ISymbolInitializer.cs" />
+    <Compile Include="IOperation\IOperationTests_InvalidExpression.cs" />
     <Compile Include="IOperation\IOperationTests.cs" />
     <Compile Include="Diagnostics\OperationAnalyzerTests.cs" />
     <Compile Include="FlowAnalysis\FlowDiagnosticTests.cs" />

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_InvalidExpression.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 Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using System.Linq;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public partial class IOperationTests : SemanticModelTestBase
+    {
+        [Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidInvocationExpression_BadReceiver()
+        {
+            string source = @"
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        /*<bind>*/Console.WriteLine2()/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression ( ? ?.()) (OperationKind.InvocationExpression, Type: ?, IsInvalid)
+  Instance Receiver: IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+      IOperation:  (OperationKind.None)
+";
+            VerifyOperationTreeForTest<InvocationExpressionSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidInvocationExpression_OverloadResolutionFailureBadArgument()
+        {
+            string source = @"
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        /*<bind>*/F(string.Empty)/*</bind>*/;
+    }
+
+    void F(int x)
+    {
+    }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression ( void Program.F(System.Int32 x)) (OperationKind.InvocationExpression, Type: System.Void, IsInvalid)
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: Program)
+  IArgument (Matching Parameter: x) (OperationKind.Argument)
+    IFieldReferenceExpression: System.String System.String.Empty (Static) (OperationKind.FieldReferenceExpression, Type: System.String)
+";
+            VerifyOperationTreeForTest<InvocationExpressionSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/8813"), WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidInvocationExpression_OverloadResolutionFailureExtraArgument()
+        {
+            string source = @"
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        /*<bind>*/F(string.Empty)/*</bind>*/;
+    }
+
+    void F()
+    {
+    }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression ( void Program.F(System.Int32 x)) (OperationKind.InvocationExpression, Type: System.Void, IsInvalid)
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: Program)
+  IArgument (Matching Parameter: x) (OperationKind.Argument)
+    IFieldReferenceExpression: System.String System.String.Empty (Static) (OperationKind.FieldReferenceExpression, Type: System.String)
+";
+            VerifyOperationTreeForTest<InvocationExpressionSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidFieldReferenceExpression()
+        {
+            string source = @"
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        var x = new Program();
+        var y /*<bind>*/= x.MissingField/*</bind>*/;
+    }
+
+    void F()
+    {
+    }
+}
+";
+            string expectedOperationTree = @"
+IVariableDeclarationStatement (1 variables) (OperationKind.VariableDeclarationStatement, IsInvalid)
+  IVariableDeclaration: ? y (OperationKind.VariableDeclaration, IsInvalid)
+    Initializer: IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+        ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
+";
+            VerifyOperationTreeForTest<EqualsValueClauseSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidConversionExpression_ImplicitCast()
+        {
+            string source = @"
+using System;
+
+class Program
+{
+    int i1;
+    static void Main(string[] args)
+    {
+        var x = new Program();
+        string y /*<bind>*/= x.i1/*</bind>*/;
+    }
+
+    void F()
+    {
+    }
+}
+";
+            string expectedOperationTree = @"
+IVariableDeclarationStatement (1 variables) (OperationKind.VariableDeclarationStatement, IsInvalid)
+  IVariableDeclaration: System.String y (OperationKind.VariableDeclaration, IsInvalid)
+    Initializer: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.String, IsInvalid)
+        IFieldReferenceExpression: System.Int32 Program.i1 (OperationKind.FieldReferenceExpression, Type: System.Int32)
+          Instance Receiver: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
+";
+            VerifyOperationTreeForTest<EqualsValueClauseSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidConversionExpression_ExplicitCast()
+        {
+            string source = @"
+using System;
+
+class Program
+{
+    int i1;
+    static void Main(string[] args)
+    {
+        var x = new Program();
+        Program y /*<bind>*/= (Program)x.i1/*</bind>*/;
+    }
+
+    void F()
+    {
+    }
+}
+";
+            string expectedOperationTree = @"
+IVariableDeclarationStatement (1 variables) (OperationKind.VariableDeclarationStatement, IsInvalid)
+  IVariableDeclaration: Program y (OperationKind.VariableDeclaration, IsInvalid)
+    Initializer: IConversionExpression (ConversionKind.Invalid, Explicit) (OperationKind.ConversionExpression, Type: Program, IsInvalid)
+        IFieldReferenceExpression: System.Int32 Program.i1 (OperationKind.FieldReferenceExpression, Type: System.Int32)
+          Instance Receiver: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
+";
+            VerifyOperationTreeForTest<EqualsValueClauseSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18056"), WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidUnaryExpression()
+        {
+            string source = @"
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        var x = new Program();
+        Console.Write(/*<bind>*/++x/*</bind>*/);
+    }
+
+    void F()
+    {
+    }
+}
+";
+            string expectedOperationTree = @"
+IIncrementExpression (UnaryOperandKind.Invalid) (OperationKind.IncrementExpression, Type: System.Object, IsInvalid)
+  Left: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
+  Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Object, Constant: 1)
+";
+            VerifyOperationTreeForTest<PrefixUnaryExpressionSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidBinaryExpression()
+        {
+            string source = @"
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        var x = new Program();
+        Console.Write(/*<bind>*/x + (y * args.Length)/*</bind>*/);
+    }
+
+    void F()
+    {
+    }
+}
+";
+            string expectedOperationTree = @"
+IBinaryOperatorExpression (BinaryOperationKind.Invalid) (OperationKind.BinaryOperatorExpression, Type: ?, IsInvalid)
+  Left: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
+  Right: IBinaryOperatorExpression (BinaryOperationKind.Invalid) (OperationKind.BinaryOperatorExpression, Type: ?, IsInvalid)
+      Left: IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+      Right: IPropertyReferenceExpression: System.Int32 System.Array.Length { get; } (OperationKind.PropertyReferenceExpression, Type: System.Int32)
+          Instance Receiver: IParameterReferenceExpression: args (OperationKind.ParameterReferenceExpression, Type: System.String[])
+";
+            VerifyOperationTreeForTest<BinaryExpressionSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18057"), WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidLambdaBinding_UnboundLambda()
+        {
+            string source = @"
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        var x /*<bind>*/= () => F()/*</bind>*/;
+    }
+
+    static void F()
+    {
+    }
+}
+";
+
+            string expectedLambdaOperationTree = @"
+ILambdaExpression (Signature: lambda expression) (OperationKind.LambdaExpression, Type: null)
+  IBlockStatement (1 statements) (OperationKind.BlockStatement)
+    IExpressionStatement (OperationKind.ExpressionStatement)
+      IInvocationExpression (static void Program.F()) (OperationKind.InvocationExpression, Type: System.Void)
+";
+            VerifyOperationTreeForTest<ParenthesizedLambdaExpressionSyntax>(source, expectedLambdaOperationTree);
+
+            string expectedEqualsValueOperationTree = @"
+IVariableDeclarationStatement (1 variables) (OperationKind.VariableDeclarationStatement, IsInvalid)
+  IVariableDeclaration: var x (OperationKind.VariableDeclaration)
+    Initializer: IUnboundLambdaExpression (OperationKind.UnboundLambdaExpression, Type: null)
+        ILambdaExpression (Signature: lambda expression) (OperationKind.LambdaExpression, Type: null)
+          IBlockStatement (1 statements) (OperationKind.BlockStatement)
+            IExpressionStatement (OperationKind.ExpressionStatement)
+              IInvocationExpression (static void Program.F()) (OperationKind.InvocationExpression, Type: System.Void)
+";
+            VerifyOperationTreeForTest<EqualsValueClauseSyntax>(source, expectedEqualsValueOperationTree);
+        }
+
+        [Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidFieldInitializer()
+        {
+            string source = @"
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+class Program
+{
+    int x /*<bind>*/= Program/*</bind>*/;
+    static void Main(string[] args)
+    {
+        var x = new Program() { x = Program };
+    }
+}
+";
+            string expectedOperationTree = @"
+IFieldInitializer (Field: System.Int32 Program.x) (OperationKind.FieldInitializerAtDeclaration, IsInvalid)
+  IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Int32, IsInvalid)
+    IInvalidExpression (OperationKind.InvalidExpression, Type: Program, IsInvalid)
+      IOperation:  (OperationKind.None)
+";
+            VerifyOperationTreeForTest<EqualsValueClauseSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidArrayInitializer()
+        {
+            string source = @"
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        var x = new int[2, 2] /*<bind>*/{ { { 1, 1 } }, { 2, 2 } }/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IArrayInitializer (2 elements) (OperationKind.ArrayInitializer, IsInvalid)
+  IArrayInitializer (1 elements) (OperationKind.ArrayInitializer, IsInvalid)
+    IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Int32, IsInvalid)
+      IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+        IArrayInitializer (2 elements) (OperationKind.ArrayInitializer, IsInvalid)
+          IConversionExpression (ConversionKind.Cast, Implicit) (OperationKind.ConversionExpression, Type: System.Object)
+            ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1)
+          IConversionExpression (ConversionKind.Cast, Implicit) (OperationKind.ConversionExpression, Type: System.Object)
+            ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1)
+  IArrayInitializer (2 elements) (OperationKind.ArrayInitializer)
+    ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2)
+    ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2)
+";
+            VerifyOperationTreeForTest<InitializerExpressionSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidArrayCreation()
+        {
+            string source = @"
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        var x = /*<bind>*/new X[Program] { { 1 } }/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IArrayCreationExpression (Dimension sizes: 1, Element Type: X) (OperationKind.ArrayCreationExpression, Type: X[], IsInvalid)
+  IInvalidExpression (OperationKind.InvalidExpression, Type: Program, IsInvalid)
+    IOperation:  (OperationKind.None)
+  IArrayInitializer (1 elements) (OperationKind.ArrayInitializer, IsInvalid)
+    IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: X, IsInvalid)
+      IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+        IArrayInitializer (1 elements) (OperationKind.ArrayInitializer, IsInvalid)
+          IConversionExpression (ConversionKind.Cast, Implicit) (OperationKind.ConversionExpression, Type: System.Object)
+            ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1)
+";
+            VerifyOperationTreeForTest<ArrayCreationExpressionSyntax>(source, expectedOperationTree);
+        }
+
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18059"), WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
+        public void InvalidParameterDefaultValueInitializer()
+        {
+            string source = @"
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+class Program
+{
+    static int M() { return 0; }
+    void F(int p /*<bind>*/= M()/*</bind>*/)
+    {
+    }
+}
+";
+            string expectedOperationTree = @"
+IParameterInitializer (Parameter: [System.Int32 p = default(System.Int32)]) (OperationKind.ParameterInitializerAtDeclaration, IsInvalid)
+  IInvocationExpression (static System.Int32 Program.M()) (OperationKind.InvocationExpression, Type: System.Int32, IsInvalid)
+";
+            VerifyOperationTreeForTest<EqualsValueClauseSyntax>(source, expectedOperationTree);
+        }
+    }
+}
\ No newline at end of file

src/Compilers/VisualBasic/Test/Semantic/BasicCompilerSemanticTest.vbproj

@@ -96,6 +96,7 @@
     <Compile Include="Diagnostics\DiagnosticAnalyzerTests.vb" />
     <Compile Include="Diagnostics\DiagnosticTests.vb" />
     <Compile Include="Diagnostics\GetDiagnosticsTests.vb" />
+    <Compile Include="IOperation\IOperationTests_InvalidExpression.vb" />
     <Compile Include="IOperation\IOperationTests_ISymbolInitializer.vb" />
     <Compile Include="IOperation\IOperationTests.vb" />
     <Compile Include="Diagnostics\OperationAnalyzerTests.vb" />

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

+' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+Imports Microsoft.CodeAnalysis.Semantics
+Imports Microsoft.CodeAnalysis.Test.Utilities
+Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
+Imports Roslyn.Test.Utilities
+
+Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Semantics
+
+    Partial Public Class IOperationTests
+        Inherits SemanticModelTestBase
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidInvocationExpression_BadReceiver()
+            Dim source = <![CDATA[
+Imports System
+
+Class Program
+    Private Shared Sub Main(args As String())
+        Console.WriteLine2()'BIND:"Console.WriteLine2()"
+    End Sub
+End Class
+    ]]>.Value
+
+            ' This might change with https://github.com/dotnet/roslyn/issues/18069
+            Dim expectedOperationTree = <![CDATA[
+IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+  IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+    IOperation:  (OperationKind.None)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of InvocationExpressionSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidInvocationExpression_OverloadResolutionFailureBadArgument()
+            Dim source = <![CDATA[
+Class Program
+    Private Shared Sub Main(args As String())
+        F(String.Empty)'BIND:"F(String.Empty)"
+    End Sub
+
+    Private Sub F(x As Integer)
+    End Sub
+End Class
+    ]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IInvocationExpression ( Sub Program.F(x As System.Int32)) (OperationKind.InvocationExpression, Type: System.Void, IsInvalid)
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: Program)
+  IArgument (Matching Parameter: x) (OperationKind.Argument)
+    IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: System.Int32)
+      IFieldReferenceExpression: System.String.Empty As System.String (Static) (OperationKind.FieldReferenceExpression, Type: System.String)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of InvocationExpressionSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidInvocationExpression_OverloadResolutionFailureExtraArgument()
+            Dim source = <![CDATA[
+
+Class Program
+    Private Shared Sub Main(args As String())
+        F(String.Empty)'BIND:"F(String.Empty)"
+    End Sub
+
+    Private Sub F()
+    End Sub
+End Class
+    ]]>.Value
+
+            ' This might change with https://github.com/dotnet/roslyn/issues/18069
+            Dim expectedOperationTree = <![CDATA[
+IInvalidExpression (OperationKind.InvalidExpression, Type: System.Void, IsInvalid)
+  IOperation:  (OperationKind.None)
+  IFieldReferenceExpression: System.String.Empty As System.String (Static) (OperationKind.FieldReferenceExpression, Type: System.String)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of InvocationExpressionSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidFieldReferenceExpression()
+            Dim source = <![CDATA[
+Class Program
+    Private Shared Sub Main(args As String())
+        Dim x = New Program()
+        Dim y = x.MissingField'BIND:"x.MissingField"
+    End Sub
+
+    Private Sub F()
+    End Sub
+End Class
+    ]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+  ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of MemberAccessExpressionSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidConversionExpression_ImplicitCast()
+            Dim source = <![CDATA[
+Class Program
+    Private i1 As Integer
+    Private Shared Sub Main(args As String())
+        Dim x = New Program()
+        Dim y As Program = x.i1'BIND:"x.i1"
+    End Sub
+
+    Private Sub F()
+    End Sub
+End Class
+    ]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: Program, IsInvalid)
+  IFieldReferenceExpression: Program.i1 As System.Int32 (OperationKind.FieldReferenceExpression, Type: System.Int32)
+    Instance Receiver: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of MemberAccessExpressionSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidConversionExpression_ExplicitCast()
+            Dim source = <![CDATA[
+Class Program
+    Private i1 As Integer
+    Private Shared Sub Main(args As String())
+        Dim x = New Program()
+        Dim y As Program = DirectCast(x.i1, Program)'BIND:"DirectCast(x.i1, Program)"
+    End Sub
+
+    Private Sub F()
+    End Sub
+End Class
+    ]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IConversionExpression (ConversionKind.Cast, Explicit) (OperationKind.ConversionExpression, Type: Program, IsInvalid)
+  IFieldReferenceExpression: Program.i1 As System.Int32 (OperationKind.FieldReferenceExpression, Type: System.Int32)
+    Instance Receiver: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of DirectCastExpressionSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidUnaryExpression()
+            Dim source = <![CDATA[
+Class Program
+    Private Shared Sub Main(args As String())
+        Dim x = New Program()
+        Console.Write(+x)'BIND:"+x"
+    End Sub
+
+    Private Sub F()
+    End Sub
+End Class
+    ]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IUnaryOperatorExpression (UnaryOperationKind.Invalid) (OperationKind.UnaryOperatorExpression, Type: ?, IsInvalid)
+  ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of UnaryExpressionSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidBinaryExpression()
+            Dim source = <![CDATA[
+Class Program
+    Private Shared Sub Main(args As String())
+        Dim x = New Program()
+        Console.Write(x + (y * args.Length))'BIND:"x + (y * args.Length)"
+    End Sub
+
+    Private Sub F()
+    End Sub
+End Class
+
+    ]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IBinaryOperatorExpression (BinaryOperationKind.Invalid) (OperationKind.BinaryOperatorExpression, Type: ?, IsInvalid)
+  Left: ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: Program)
+  Right: IParenthesizedExpression (OperationKind.ParenthesizedExpression, Type: ?, IsInvalid)
+      IBinaryOperatorExpression (BinaryOperationKind.Invalid) (OperationKind.BinaryOperatorExpression, Type: ?, IsInvalid)
+        Left: IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+        Right: IIndexedPropertyReferenceExpression: ReadOnly Property System.Array.Length As System.Int32 (OperationKind.PropertyReferenceExpression, Type: System.Int32)
+            Instance Receiver: IParameterReferenceExpression: args (OperationKind.ParameterReferenceExpression, Type: System.String())
+]]>.Value
+
+            VerifyOperationTreeForTest(Of BinaryExpressionSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact(Skip:="https://github.com/dotnet/roslyn/issues/18073"), WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidLambdaBinding_UnboundLambda()
+            Dim source = <![CDATA[
+Class Program
+    Private Shared Sub Main(args As String())
+        Dim x = Function() F()'BIND:"Function() F()"
+    End Sub
+
+    Private Shared Sub F()
+    End Sub
+End Class
+    ]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+]]>.Value
+
+            VerifyOperationTreeForTest(Of SingleLineLambdaExpressionSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidFieldInitializer()
+            Dim source = <![CDATA[
+Imports System.Collections.Generic
+Imports System.Linq
+Imports System.Threading.Tasks
+
+Class Program
+    Private x As Integer = Program'BIND:"= Program"
+    Private Shared Sub Main(args As String())
+        Dim x = New Program() With {
+            .x = Program
+        }
+    End Sub
+End Class
+    ]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IFieldInitializer (Field: Program.x As System.Int32) (OperationKind.FieldInitializerAtDeclaration, IsInvalid)
+  IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: System.Int32, IsInvalid)
+    IOperation:  (OperationKind.None, IsInvalid)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of EqualsValueSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact(Skip:="https://github.com/dotnet/roslyn/issues/18074"), WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidArrayInitializer()
+            Dim source = <![CDATA[
+Imports System.Collections.Generic
+Imports System.Linq
+Imports System.Threading.Tasks
+
+Class Program
+    Private Shared Sub Main(args As String())
+        Dim x = New Integer(1, 1) {{{1, 1}}, {2, 2}}'BIND:"{{1, 1}}"
+    End Sub
+End Class
+    ]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IArrayInitializer (1 elements) (OperationKind.ArrayInitializer, IsInvalid)
+  IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+    ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1)
+    ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of CollectionInitializerSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidArrayCreation()
+            Dim source = <![CDATA[
+Imports System.Collections.Generic
+Imports System.Linq
+Imports System.Threading.Tasks
+
+Class Program
+    Private Shared Sub Main(args As String())
+        Dim x = New X(Program - 1) {{1}}'BIND:"New X(Program - 1) {{1}}"
+    End Sub
+End Class
+    ]]>.Value
+
+            ' The operation tree might get affected with https://github.com/dotnet/roslyn/issues/18074
+            Dim expectedOperationTree = <![CDATA[
+IArrayCreationExpression (Dimension sizes: 1, Element Type: X) (OperationKind.ArrayCreationExpression, Type: X(), IsInvalid)
+  IBinaryOperatorExpression (BinaryOperationKind.IntegerAdd) (OperationKind.BinaryOperatorExpression, Type: System.Int32, IsInvalid)
+    Left: IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: System.Int32, IsInvalid)
+        IBinaryOperatorExpression (BinaryOperationKind.Invalid) (OperationKind.BinaryOperatorExpression, Type: ?, IsInvalid)
+          Left: IOperation:  (OperationKind.None, IsInvalid)
+          Right: ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1)
+    Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1)
+  IArrayInitializer (1 elements) (OperationKind.ArrayInitializer, IsInvalid)
+    IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of ArrayCreationExpressionSyntax)(source, expectedOperationTree)
+        End Sub
+
+        <Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")>
+        Public Sub InvalidParameterDefaultValueInitializer()
+            Dim source = <![CDATA[
+Imports System.Collections.Generic
+Imports System.Linq
+Imports System.Threading.Tasks
+
+Class Program
+    Private Shared Function M() As Integer
+        Return 0
+    End Function
+    Private Sub F(Optional p As Integer = M())'BIND:"= M()"
+    End Sub
+End Class
+
+    ]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IParameterInitializer (Parameter: [p As System.Int32]) (OperationKind.ParameterInitializerAtDeclaration, IsInvalid)
+  IInvalidExpression (OperationKind.InvalidExpression, Type: System.Int32, IsInvalid)
+    IInvocationExpression (static Function Program.M() As System.Int32) (OperationKind.InvocationExpression, Type: System.Int32)
+]]>.Value
+
+            VerifyOperationTreeForTest(Of EqualsValueSyntax)(source, expectedOperationTree)
+        End Sub
+    End Class
+End Namespace

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

@@ -675,7 +675,6 @@ public override void VisitIndexedPropertyReferenceExpression(IIndexedPropertyRef
             LogString(nameof(IIndexedPropertyReferenceExpression));
 
             LogString($": {operation.Property.ToTestDisplayString()}");
-            LogCommonPropertiesAndNewLine(operation);
 
             VisitMemberReferenceExpressionCommon(operation);
         }
@@ -905,6 +904,7 @@ public override void VisitArrayCreationExpression(IArrayCreationExpression opera
         public override void VisitArrayInitializer(IArrayInitializer operation)
         {
             LogString(nameof(IArrayInitializer));
+            LogString($" ({operation.ElementValues.Length} elements)");
             LogCommonPropertiesAndNewLine(operation);
 
             base.VisitArrayInitializer(operation);