diff --git a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs
index 8b7c8788ce7684073dc7e855e7eaaee5afe9c30b..83040adddda2b381e4df1effe371780998ecc962 100644
--- a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs
+++ b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs
@@ -715,9 +715,10 @@ private IIsTypeExpression CreateBoundIsOperatorOperation(BoundIsOperator boundIs
             ITypeSymbol isType = boundIsOperator.TargetType.Type;
             SyntaxNode syntax = boundIsOperator.Syntax;
             ITypeSymbol type = boundIsOperator.Type;
+            bool isNotTypeExpression = false;
             Optional<object> constantValue = ConvertToOptional(boundIsOperator.ConstantValue);
             bool isImplicit = boundIsOperator.WasCompilerGenerated;
-            return new LazyIsTypeExpression(operand, isType, _semanticModel, syntax, type, constantValue, isImplicit);
+            return new LazyIsTypeExpression(operand, isType, isNotTypeExpression, _semanticModel, syntax, type, constantValue, isImplicit);
         }
 
         private ISizeOfExpression CreateBoundSizeOfOperatorOperation(BoundSizeOfOperator boundSizeOfOperator)
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIsTypeExpression.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIsTypeExpression.cs
new file mode 100644
index 0000000000000000000000000000000000000000..01574225c1d8e6eaec1ab2d3b1f518786eb31b65
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIsTypeExpression.cs
@@ -0,0 +1,287 @@
+// 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.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public partial class IOperationTests : SemanticModelTestBase
+    {
+        [CompilerTrait(CompilerFeature.IOperation)]
+        [Fact]
+        public void TestIsOperator_ObjectExpressionStringType()
+        {
+            string source = @"
+namespace TestIsOperator
+{
+    class TestType
+    {
+    }
+
+    class C
+    {
+        static void M(string myStr)
+        {
+            object o = myStr;
+            bool b = /*<bind>*/o is string/*</bind>*/;
+        }
+    }
+}
+";
+            string expectedOperationTree = @"
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'o is string')
+  Operand: ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
+  IsType: System.String
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<BinaryExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [CompilerTrait(CompilerFeature.IOperation)]
+        [Fact]
+        public void TestIsOperator_IntExpressionIntType()
+        {
+            string source = @"
+namespace TestIsOperator
+{
+    class TestType
+    {
+    }
+
+    class C
+    {
+        static void M(string myStr)
+        {
+            int myInt = 3;
+            bool b = /*<bind>*/myInt is int/*</bind>*/;
+        }
+    }
+}
+";
+            string expectedOperationTree = @"
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'myInt is int')
+  Operand: ILocalReferenceExpression: myInt (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'myInt')
+  IsType: System.Int32
+";
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0183: The given expression is always of the provided ('int') type
+                //             bool b = /*<bind>*/myInt is int/*</bind>*/;
+                Diagnostic(ErrorCode.WRN_IsAlwaysTrue, "myInt is int").WithArguments("int").WithLocation(13, 32)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<BinaryExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [CompilerTrait(CompilerFeature.IOperation)]
+        [Fact]
+        public void TestIsOperator_ObjectExpressionUserDefinedType()
+        {
+            string source = @"
+namespace TestIsOperator
+{
+    class TestType
+    {
+    }
+
+    class C
+    {
+        static void M(string myStr)
+        {
+            TestType tt = null;
+            object o = tt;
+            bool b = /*<bind>*/o is TestType/*</bind>*/;
+        }
+    }
+}
+";
+            string expectedOperationTree = @"
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'o is TestType')
+  Operand: ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
+  IsType: TestIsOperator.TestType
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<BinaryExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [CompilerTrait(CompilerFeature.IOperation)]
+        [Fact]
+        public void TestIsOperator_NullExpressionUserDefinedType()
+        {
+            string source = @"
+namespace TestIsOperator
+{
+    class TestType
+    {
+    }
+
+    class C
+    {
+        static void M(string myStr)
+        {
+            TestType tt = null;
+            object o = tt;
+            bool b = /*<bind>*/null is TestType/*</bind>*/;
+        }
+    }
+}
+";
+            string expectedOperationTree = @"
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'null is TestType')
+  Operand: ILiteralExpression (OperationKind.LiteralExpression, Type: null, Constant: null) (Syntax: 'null')
+  IsType: TestIsOperator.TestType
+";
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0184: The given expression is never of the provided ('TestType') type
+                //             bool b = /*<bind>*/null is TestType/*</bind>*/;
+                Diagnostic(ErrorCode.WRN_IsAlwaysFalse, "null is TestType").WithArguments("TestIsOperator.TestType").WithLocation(14, 32)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<BinaryExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [CompilerTrait(CompilerFeature.IOperation)]
+        [Fact]
+        public void TestIsOperator_IntExpressionEnumType()
+        {
+            string source = @"
+class IsTest
+{
+    static void Main()
+    {
+        var b = /*<bind>*/1 is color/*</bind>*/;
+        System.Console.WriteLine(b);
+    }
+}
+enum color
+{ }
+";
+            string expectedOperationTree = @"
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: '1 is color')
+  Operand: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
+  IsType: color
+";
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0184: The given expression is never of the provided ('color') type
+                //         var b = /*<bind>*/1 is color/*</bind>*/;
+                Diagnostic(ErrorCode.WRN_IsAlwaysFalse, "1 is color").WithArguments("color").WithLocation(6, 27)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<BinaryExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [CompilerTrait(CompilerFeature.IOperation)]
+        [Fact]
+        public void TestIsOperatorGeneric_TypeParameterExpressionIntType()
+        {
+            string source = @"
+namespace TestIsOperatorGeneric
+{
+    class C
+    {
+        public static void M<T, U, W>(T t, U u)
+            where T : class
+            where U : class
+        {
+            bool test = /*<bind>*/t is int/*</bind>*/;
+        }
+    }
+}
+";
+            string expectedOperationTree = @"
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 't is int')
+  Operand: IParameterReferenceExpression: t (OperationKind.ParameterReferenceExpression, Type: T) (Syntax: 't')
+  IsType: System.Int32
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<BinaryExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [CompilerTrait(CompilerFeature.IOperation)]
+        [Fact]
+        public void TestIsOperatorGeneric_TypeParameterExpressionObjectType()
+        {
+            string source = @"
+namespace TestIsOperatorGeneric
+{
+    class C
+    {
+        public static void M<T, U, W>(T t, U u)
+            where T : class
+            where U : class
+        {
+            bool test = /*<bind>*/u is object/*</bind>*/;
+        }
+    }
+}
+";
+            string expectedOperationTree = @"
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'u is object')
+  Operand: IParameterReferenceExpression: u (OperationKind.ParameterReferenceExpression, Type: U) (Syntax: 'u')
+  IsType: System.Object
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<BinaryExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [CompilerTrait(CompilerFeature.IOperation)]
+        [Fact]
+        public void TestIsOperatorGeneric_TypeParameterExpressionDifferentTypeParameterType()
+        {
+            string source = @"
+namespace TestIsOperatorGeneric
+{
+    class C
+    {
+        public static void M<T, U, W>(T t, U u)
+            where T : class
+            where U : class
+        {
+            bool test = /*<bind>*/t is U/*</bind>*/;
+        }
+    }
+}
+";
+            string expectedOperationTree = @"
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 't is U')
+  Operand: IParameterReferenceExpression: t (OperationKind.ParameterReferenceExpression, Type: T) (Syntax: 't')
+  IsType: U
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<BinaryExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [CompilerTrait(CompilerFeature.IOperation)]
+        [Fact]
+        public void TestIsOperatorGeneric_TypeParameterExpressionSameTypeParameterType()
+        {
+            string source = @"
+namespace TestIsOperatorGeneric
+{
+    class C
+    {
+        public static void M<T, U, W>(T t, U u)
+            where T : class
+            where U : class
+        {
+            bool test = /*<bind>*/t is T/*</bind>*/;
+        }
+    }
+}
+";
+            string expectedOperationTree = @"
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 't is T')
+  Operand: IParameterReferenceExpression: t (OperationKind.ParameterReferenceExpression, Type: T) (Syntax: 't')
+  IsType: T
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<BinaryExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IWhileUntilLoopStatement.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IWhileUntilLoopStatement.cs
index 5df0e1aaf0c434d7a43f9c2d6ca7ebfd3485b716..4092f7316f31b83f00698b97267c6e7129c58da8 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IWhileUntilLoopStatement.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IWhileUntilLoopStatement.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+// 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.Test.Utilities;
diff --git a/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs b/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs
index b7b9ed291a46230a750e55e54cbb3c41cd39e9b7..1bd554fc98b91bbe49cc728a35c6082ea6486316 100644
--- a/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs
+++ b/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs
@@ -2553,10 +2553,11 @@ public LazyInvocationExpression(IMethodSymbol targetMethod, Lazy<IOperation> ins
     /// </summary>
     internal abstract partial class BaseIsTypeExpression : Operation, IIsTypeExpression
     {
-        protected BaseIsTypeExpression(ITypeSymbol isType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue, bool isImplicit) :
+        protected BaseIsTypeExpression(ITypeSymbol isType, bool isNotTypeExpression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue, bool isImplicit) :
                     base(OperationKind.IsTypeExpression, semanticModel, syntax, type, constantValue, isImplicit)
         {
             IsType = isType;
+            IsNotTypeExpression = isNotTypeExpression;
         }
 
         protected abstract IOperation OperandImpl { get; }
@@ -2564,6 +2565,12 @@ internal abstract partial class BaseIsTypeExpression : Operation, IIsTypeExpress
         /// Type for which to test.
         /// </summary>
         public ITypeSymbol IsType { get; }
+        /// <summary>
+        /// Flag indicating if this is an "is not" type expression.
+        /// True for VB "TypeOf ... IsNot ..." expression.
+        /// False, otherwise.
+        /// </summary>
+        public bool IsNotTypeExpression { get; }
         public override IEnumerable<IOperation> Children
         {
             get
@@ -2590,8 +2597,8 @@ public override void Accept(OperationVisitor visitor)
     /// </summary>
     internal sealed partial class IsTypeExpression : BaseIsTypeExpression, IIsTypeExpression
     {
-        public IsTypeExpression(IOperation operand, ITypeSymbol isType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue, bool isImplicit) :
-            base(isType, semanticModel, syntax, type, constantValue, isImplicit)
+        public IsTypeExpression(IOperation operand, ITypeSymbol isType, bool isNotTypeExpression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue, bool isImplicit) :
+            base(isType, isNotTypeExpression, semanticModel, syntax, type, constantValue, isImplicit)
         {
             OperandImpl = operand;
         }
@@ -2606,7 +2613,7 @@ internal sealed partial class LazyIsTypeExpression : BaseIsTypeExpression, IIsTy
     {
         private readonly Lazy<IOperation> _lazyOperand;
 
-        public LazyIsTypeExpression(Lazy<IOperation> operand, ITypeSymbol isType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue, bool isImplicit) : base(isType, semanticModel, syntax, type, constantValue, isImplicit)
+        public LazyIsTypeExpression(Lazy<IOperation> operand, ITypeSymbol isType, bool isNotTypeExpression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue, bool isImplicit) : base(isType, isNotTypeExpression, semanticModel, syntax, type, constantValue, isImplicit)
         {
             _lazyOperand = operand ?? throw new System.ArgumentNullException(nameof(operand));
         }
diff --git a/src/Compilers/Core/Portable/Operations/IIsTypeExpression.cs b/src/Compilers/Core/Portable/Operations/IIsTypeExpression.cs
index b06f159c9ff383c16ac9f3aee7b2048dd7e172fc..89cdd50ddb7fe7091c453651432059a7b75f2650 100644
--- a/src/Compilers/Core/Portable/Operations/IIsTypeExpression.cs
+++ b/src/Compilers/Core/Portable/Operations/IIsTypeExpression.cs
@@ -1,7 +1,5 @@
 // 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>
@@ -17,10 +15,17 @@ public interface IIsTypeExpression : IOperation
         /// Value to test.
         /// </summary>
         IOperation Operand { get; }
+
         /// <summary>
         /// Type for which to test.
         /// </summary>
         ITypeSymbol IsType { get; }
+
+        /// <summary>
+        /// Flag indicating if this is an "is not" type expression.
+        /// True for VB "TypeOf ... IsNot ..." expression.
+        /// False, otherwise.
+        /// </summary>
+        bool IsNotTypeExpression { get; }
     }
 }
-
diff --git a/src/Compilers/Core/Portable/Operations/OperationCloner.cs b/src/Compilers/Core/Portable/Operations/OperationCloner.cs
index fc33e539db6bceee72684bc0232ad86523f09637..5456a93835a7d455740edc52d79b2a33f34c1d76 100644
--- a/src/Compilers/Core/Portable/Operations/OperationCloner.cs
+++ b/src/Compilers/Core/Portable/Operations/OperationCloner.cs
@@ -276,7 +276,7 @@ public override IOperation VisitCoalesceExpression(ICoalesceExpression operation
 
         public override IOperation VisitIsTypeExpression(IIsTypeExpression operation, object argument)
         {
-            return new IsTypeExpression(Visit(operation.Operand), operation.IsType, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit);
+            return new IsTypeExpression(Visit(operation.Operand), operation.IsType, operation.IsNotTypeExpression, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit);
         }
 
         public override IOperation VisitSizeOfExpression(ISizeOfExpression operation, object argument)
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index 879fe82df108da14e9de1c11b0ffb196a5fbf085..8b65a558ebc1cd3fce989e13055a315ba03d3b6d 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -344,6 +344,7 @@ Microsoft.CodeAnalysis.Semantics.IIsPatternExpression.Expression.get -> Microsof
 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.IsNotTypeExpression.get -> bool
 Microsoft.CodeAnalysis.Semantics.IIsTypeExpression.Operand.get -> Microsoft.CodeAnalysis.IOperation
 Microsoft.CodeAnalysis.Semantics.ILabeledStatement
 Microsoft.CodeAnalysis.Semantics.ILabeledStatement.Label.get -> Microsoft.CodeAnalysis.ILabelSymbol
diff --git a/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory.vb b/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory.vb
index 8ef0b35f89787c5b308291360eefd395f9158990..390da1d149203b3c09893bd8e876db48c681d450 100644
--- a/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory.vb
+++ b/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory.vb
@@ -565,11 +565,12 @@ Namespace Microsoft.CodeAnalysis.Semantics
         Private Function CreateBoundTypeOfOperation(boundTypeOf As BoundTypeOf) As IIsTypeExpression
             Dim operand As Lazy(Of IOperation) = New Lazy(Of IOperation)(Function() Create(boundTypeOf.Operand))
             Dim isType As ITypeSymbol = boundTypeOf.TargetType
+            Dim isNotTypeExpression As Boolean = boundTypeOf.IsTypeOfIsNotExpression
             Dim syntax As SyntaxNode = boundTypeOf.Syntax
             Dim type As ITypeSymbol = boundTypeOf.Type
             Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundTypeOf.ConstantValueOpt)
             Dim isImplicit As Boolean = boundTypeOf.WasCompilerGenerated
-            Return New LazyIsTypeExpression(operand, isType, _semanticModel, syntax, type, constantValue, isImplicit)
+            Return New LazyIsTypeExpression(operand, isType, isNotTypeExpression, _semanticModel, syntax, type, constantValue, isImplicit)
         End Function
 
         Private Function CreateBoundObjectCreationExpressionOperation(boundObjectCreationExpression As BoundObjectCreationExpression) As IObjectCreationExpression
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/TypeOfTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/TypeOfTests.vb
index 7f00618a1ffe68151ba73052997dce7b25eb2270..b9881248e6ecfb20cdea432614093555defd227a 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/TypeOfTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/TypeOfTests.vb
@@ -1,21 +1,18 @@
-' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+' 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 System.Collections.Immutable
-Imports Microsoft.CodeAnalysis.Text
-Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
+Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 Imports Roslyn.Test.Utilities
-Imports VB = Microsoft.CodeAnalysis.VisualBasic
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Semantics
     Public Class TypeOfTests
         Inherits BasicTestBase
 
+        <CompilerTrait(CompilerFeature.IOperation)>
         <Fact>
-        Public Sub ProducesNoErrorsOnBoxedValueTypes()
-            Dim source =
-<compilation name="TypeOfBoxedValueTypes">
-    <file name="Program.vb">
+        Public Sub ProducesNoErrorsOnBoxedValueTypes_ObjectExpressionAndPrimitiveType()
+            Dim source = <![CDATA[
 Option Strict On
 
 Imports System
@@ -25,44 +22,122 @@ Module Program
 
         Dim o As Object = 1
 
-        If TypeOf o Is Integer Then
+        If TypeOf o Is Integer Then'BIND:"TypeOf o Is Integer"
             Console.WriteLine("Boxed as System.Object")
         End If
+    End Sub
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf o Is Integer')
+  Operand: ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
+  IsType: System.Int32
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact>
+        Public Sub ProducesNoErrorsOnBoxedValueTypes_ObjectExpressionAndIComparableType()
+            Dim source = <![CDATA[
+Option Strict On
+
+Imports System
+
+Module Program
+    Sub Main(args As String())
+
+        Dim o As Object = 1
 
-        If TypeOf o Is IComparable Then
+        If TypeOf o Is IComparable Then'BIND:"TypeOf o Is IComparable"
             Console.WriteLine("Boxed as System.Object to interface type")
         End If
+    End Sub
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf o Is IComparable')
+  Operand: ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
+  IsType: System.IComparable
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact>
+        Public Sub ProducesNoErrorsOnBoxedValueTypes_ValueTypeExpressionAndEnumType()
+            Dim source = <![CDATA[
+Option Strict On
+
+Imports System
+
+Module Program
+    Sub Main(args As String())
 
         Dim v As ValueType = DayOfWeek.Monday
 
-        If TypeOf v Is DayOfWeek Then
+        If TypeOf v Is DayOfWeek Then'BIND:"TypeOf v Is DayOfWeek"
             v = 1
 
             If TypeOf v Is Integer Then
                 Console.WriteLine("Boxed as System.ValueType")
             End If
         End If
+    End Sub
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf v Is DayOfWeek')
+  Operand: ILocalReferenceExpression: v (OperationKind.LocalReferenceExpression, Type: System.ValueType) (Syntax: 'v')
+  IsType: System.DayOfWeek
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact>
+        Public Sub ProducesNoErrorsOnBoxedValueTypes_EnumTypeExpressionAndEnumType()
+            Dim source = <![CDATA[
+Option Strict On
+
+Imports System
+
+Module Program
+    Sub Main(args As String())
 
         Dim e As [Enum] = DayOfWeek.Tuesday
 
-        If TypeOf e Is DayOfWeek Then
+        If TypeOf e Is DayOfWeek Then'BIND:"TypeOf e Is DayOfWeek"
             Console.WriteLine("Boxed as System.Enum")
         End If
 
     End Sub
-End Module
-    </file>
-</compilation>
+End Module]]>.Value
 
-            Dim compilation = CompilationUtils.CreateCompilationWithMscorlibAndVBRuntime(source)
-            CompilationUtils.AssertNoErrors(compilation)
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf e Is DayOfWeek')
+  Operand: ILocalReferenceExpression: e (OperationKind.LocalReferenceExpression, Type: System.Enum) (Syntax: 'e')
+  IsType: System.DayOfWeek
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
         End Sub
 
+        <CompilerTrait(CompilerFeature.IOperation)>
         <Fact()>
-        Public Sub ProducesNoErrorsWithClassTypeUnconstrainedTypeParameterTargetTypes()
-            Dim source =
-<compilation name="ProducesNoErrorsWithClassTypeUnconstrainedTypeParameterTargetTypes">
-    <file name="Program.vb">
+        Public Sub ProducesNoErrorsWithClassTypeUnconstrainedTypeParameterTargetTypes_ClassConstraint()
+            Dim source = <![CDATA[
 Option Strict On
 Imports System
 Module Program
@@ -74,38 +149,135 @@ Module Program
 
         Dim oT As T = Nothing
 
-        If TypeOf oT Is TRef Then
-            
+        If TypeOf oT Is TRef Then'BIND:"TypeOf oT Is TRef"
+
         End If
 
-        If TypeOf oT Is TVal Then
+    End Sub
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf oT Is TRef')
+  Operand: IConversionExpression (Implicit, TryCast: False, Unchecked) (OperationKind.ConversionExpression, Type: System.Object) (Syntax: 'TypeOf oT Is TRef')
+      Conversion: CommonConversion (Exists: False, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+      Operand: ILocalReferenceExpression: oT (OperationKind.LocalReferenceExpression, Type: T) (Syntax: 'oT')
+  IsType: TRef
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact()>
+        Public Sub ProducesNoErrorsWithClassTypeUnconstrainedTypeParameterTargetTypes_StructureConstraint()
+            Dim source = <![CDATA[
+Option Strict On
+Imports System
+Module Program
+    Sub Main(args As String())
+
+    End Sub
+
+    Sub M(Of T, TRef As Class, TVal As Structure, TBase As Class, TDerived As TBase)()
+
+        Dim oT As T = Nothing
+
+        If TypeOf oT Is TVal Then'BIND:"TypeOf oT Is TVal"
 
         End If
 
+    End Sub
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf oT Is TVal')
+  Operand: IConversionExpression (Implicit, TryCast: False, Unchecked) (OperationKind.ConversionExpression, Type: System.Object) (Syntax: 'TypeOf oT Is TVal')
+      Conversion: CommonConversion (Exists: False, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+      Operand: ILocalReferenceExpression: oT (OperationKind.LocalReferenceExpression, Type: T) (Syntax: 'oT')
+  IsType: TVal
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact()>
+        Public Sub ProducesNoErrorsWithClassTypeUnconstrainedTypeParameterTargetTypes_StructureAndClassConstraint()
+            Dim source = <![CDATA[
+Option Strict On
+Imports System
+Module Program
+    Sub Main(args As String())
+
+    End Sub
+
+    Sub M(Of T, TRef As Class, TVal As Structure, TBase As Class, TDerived As TBase)()
+
         Dim vVal As TVal = Nothing
 
-        If TypeOf vVal Is TRef Then
+        If TypeOf vVal Is TRef Then'BIND:"TypeOf vVal Is TRef"
 
         End If
 
-        If TypeOf oT Is String Then
+    End Sub
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf vVal Is TRef')
+  Operand: IConversionExpression (Implicit, TryCast: False, Unchecked) (OperationKind.ConversionExpression, Type: System.Object) (Syntax: 'TypeOf vVal Is TRef')
+      Conversion: CommonConversion (Exists: False, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+      Operand: ILocalReferenceExpression: vVal (OperationKind.LocalReferenceExpression, Type: TVal) (Syntax: 'vVal')
+  IsType: TRef
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact()>
+        Public Sub ProducesNoErrorsWithClassTypeUnconstrainedTypeParameterTargetTypes_StringType()
+            Dim source = <![CDATA[
+Option Strict On
+Imports System
+Module Program
+    Sub Main(args As String())
+
+    End Sub
+
+    Sub M(Of T, TRef As Class, TVal As Structure, TBase As Class, TDerived As TBase)()
+
+        Dim oT As T = Nothing
+
+        If TypeOf oT Is String Then'BIND:"TypeOf oT Is String"
 
         End If
 
     End Sub
-End Module
-    </file>
-</compilation>
+End Module]]>.Value
 
-            Dim compilation = CompilationUtils.CreateCompilationWithMscorlibAndVBRuntime(source)
-            CompilationUtils.AssertNoErrors(compilation)
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf oT Is String')
+  Operand: IConversionExpression (Implicit, TryCast: False, Unchecked) (OperationKind.ConversionExpression, Type: System.Object) (Syntax: 'TypeOf oT Is String')
+      Conversion: CommonConversion (Exists: False, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+      Operand: ILocalReferenceExpression: oT (OperationKind.LocalReferenceExpression, Type: T) (Syntax: 'oT')
+  IsType: System.String
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
         End Sub
 
+        <CompilerTrait(CompilerFeature.IOperation)>
         <Fact>
-        Public Sub ProducesErrorsWhenNoReferenceConversionExists()
-            Dim source =
-<compilation name="TypeOfDiagnostics">
-    <file name="Program.vb">
+        Public Sub ProducesErrorsWhenNoReferenceConversionExists_BC30371()
+            Dim source = <![CDATA[
 Option Strict On
 Imports System
 Module Program
@@ -113,50 +285,128 @@ Module Program
 
         Dim obj As Object = ""
 
-        If TypeOf obj Is Program Then
+        If TypeOf obj Is Program Then'BIND:"TypeOf obj Is Program"
 
         End If
+    End Sub
+
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean, IsInvalid) (Syntax: 'TypeOf obj Is Program')
+  Operand: ILocalReferenceExpression: obj (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'obj')
+  IsType: Program
+]]>.Value
+
+            Dim expectedDiagnostics = <![CDATA[
+BC30371: Module 'Program' cannot be used as a type.
+        If TypeOf obj Is Program Then'BIND:"TypeOf obj Is Program"
+                         ~~~~~~~
+]]>.Value
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact>
+        Public Sub ProducesErrorsWhenNoReferenceConversionExists_BC31430()
+            Dim source = <![CDATA[
+Option Strict On
+Imports System
+Module Program
+    Public Sub Main()
 
         Dim s As String = Nothing
 
-        If TypeOf s Is AppDomain Then
-        
+        If TypeOf s Is AppDomain Then'BIND:"TypeOf s Is AppDomain"
+
         ElseIf TypeOf s Is IDisposable Then
-        
+
         End If
+    End Sub
+
+End Module]]>.Value
 
-        If TypeOf s Is Integer Then
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean, IsInvalid) (Syntax: 'TypeOf s Is AppDomain')
+  Operand: ILocalReferenceExpression: s (OperationKind.LocalReferenceExpression, Type: System.String, IsInvalid) (Syntax: 's')
+  IsType: System.AppDomain
+]]>.Value
+
+            Dim expectedDiagnostics = <![CDATA[
+BC31430: Expression of type 'String' can never be of type 'AppDomain'.
+        If TypeOf s Is AppDomain Then'BIND:"TypeOf s Is AppDomain"
+           ~~~~~~~~~~~~~~~~~~~~~
+]]>.Value
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact>
+        Public Sub ProducesErrorsWhenNoReferenceConversionExists_BC31430_02()
+            Dim source = <![CDATA[
+Option Strict On
+Imports System
+Module Program
+    Public Sub Main()
+
+        Dim s As String = Nothing
+
+        If TypeOf s Is Integer Then'BIND:"TypeOf s Is Integer"
 
         End If
+    End Sub
+
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean, IsInvalid) (Syntax: 'TypeOf s Is Integer')
+  Operand: ILocalReferenceExpression: s (OperationKind.LocalReferenceExpression, Type: System.String, IsInvalid) (Syntax: 's')
+  IsType: System.Int32
+]]>.Value
+
+            Dim expectedDiagnostics = <![CDATA[
+BC31430: Expression of type 'String' can never be of type 'Integer'.
+        If TypeOf s Is Integer Then'BIND:"TypeOf s Is Integer"
+           ~~~~~~~~~~~~~~~~~~~
+]]>.Value
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact>
+        Public Sub ProducesErrorsWhenNoReferenceConversionExists_BC30021()
+            Dim source = <![CDATA[
+Option Strict On
+Imports System
+Module Program
+    Public Sub Main()
 
         Dim i As Integer = 0
 
-        If TypeOf i Is String Then
+        If TypeOf i Is String Then'BIND:"TypeOf i Is String"
 
         End If
 
     End Sub
 
-End Module
-    </file>
-</compilation>
+End Module]]>.Value
 
-            Dim compilation = CompilationUtils.CreateCompilationWithMscorlibAndVBRuntimeAndReferences(source, , TestOptions.ReleaseExe)
-            CompilationUtils.AssertTheseDiagnostics(compilation,
-<expected>
-BC30371: Module 'Program' cannot be used as a type.
-        If TypeOf obj Is Program Then
-                         ~~~~~~~
-BC31430: Expression of type 'String' can never be of type 'AppDomain'.
-        If TypeOf s Is AppDomain Then
-           ~~~~~~~~~~~~~~~~~~~~~
-BC31430: Expression of type 'String' can never be of type 'Integer'.
-        If TypeOf s Is Integer Then
-           ~~~~~~~~~~~~~~~~~~~
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean, IsInvalid) (Syntax: 'TypeOf i Is String')
+  Operand: ILocalReferenceExpression: i (OperationKind.LocalReferenceExpression, Type: System.Int32, IsInvalid) (Syntax: 'i')
+  IsType: System.String
+]]>.Value
+
+            Dim expectedDiagnostics = <![CDATA[
 BC30021: 'TypeOf ... Is' requires its left operand to have a reference type, but this operand has the value type 'Integer'.
-        If TypeOf i Is String Then
+        If TypeOf i Is String Then'BIND:"TypeOf i Is String"
                   ~
-</expected>)
+]]>.Value
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
         End Sub
 
         <Fact()>
@@ -167,49 +417,49 @@ BC30021: 'TypeOf ... Is' requires its left operand to have a reference type, but
 Option Strict On
 Imports System
 Module Program
-
+ 
     Sub Main()
     End Sub
-
+ 
     Class A : End Class
     Class B : End Class
-
+ 
     Sub M(Of T, TA As A, TB As B, TC As Structure, TD As IDisposable)(x As T, a As TA, b As TB, c As TC, d As TD, s As String)
-
+ 
         If TypeOf x Is TA OrElse TypeOf x Is TB OrElse TypeOf x Is TC OrElse TypeOf x Is TD OrElse TypeOf x Is String Then
             Console.WriteLine("Success!")
         End If
-
+ 
         If TypeOf a Is TB OrElse TypeOf a Is TC OrElse TypeOf a Is String Then
             Console.WriteLine("Fail!")
         ElseIf TypeOf a Is T OrElse TypeOf a Is TD Then
             Console.WriteLine("Success!")
         End If
-
+ 
         If TypeOf b Is TA OrElse TypeOf b Is TC OrElse TypeOf b Is String Then
             Console.WriteLine("Fail!")
         ElseIf TypeOf b Is T OrElse TypeOf b Is TD Then
             Console.WriteLine("Success!")
         End If
-
+ 
         If TypeOf c Is TA OrElse TypeOf c Is TB OrElse TypeOf c Is String Then
             Console.WriteLine("Fail!")
         ElseIf TypeOf c Is T OrElse TypeOf c Is TD Then
             Console.WriteLine("Success!")
         End If
-
+ 
         If TypeOf d Is T OrElse TypeOf d Is TA OrElse TypeOf d Is TB OrElse TypeOf d Is TC OrElse TypeOf d Is String Then
             Console.WriteLine("Success!")
         End If
-
+ 
         If TypeOf s Is TA OrElse TypeOf s Is TB OrElse TypeOf s Is TC Then
             Console.WriteLine("Fail!")
         ElseIf TypeOf s Is T OrElse TypeOf s Is T OrElse TypeOf s Is TD Then
             Console.WriteLine("Success!")
         End If
-
+ 
     End Sub
-
+ 
 End Module
     </file>
 </compilation>
@@ -262,28 +512,28 @@ BC31430: Expression of type 'String' can never be of type 'TC'.
 <compilation name="SeesThroughTypeAndNamespaceAliases">
     <file name="Program.vb">
 Option Strict On
-
+ 
 Imports HRESULT = System.Int32
 Imports CharacterSequence = System.String
-
+ 
 Module Program
     Sub Main(args As String())
-
+ 
         Dim o As Object = ""
-
+ 
         Dim isString = TypeOf o Is CharacterSequence
-
+ 
         Dim isInteger = TypeOf o Is HRESULT
-
+ 
         Dim isNotString = TypeOf o IsNot CharacterSequence
-
+ 
         Dim isNotInteger = TypeOf o IsNot HRESULT 
-
+ 
         System.Console.WriteLine(isString)
         System.Console.WriteLine(isInteger)
         System.Console.WriteLine(isNotString)
         System.Console.WriteLine(isNotInteger)
-
+ 
     End Sub
 End Module
     </file>
@@ -302,6 +552,125 @@ True
 
         End Sub
 
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact>
+        Public Sub SeesThroughTypeAndNamespaceAliases_IsStringAliasIOperationTest()
+            Dim source = <![CDATA[
+Option Strict On
+
+Imports HRESULT = System.Int32
+Imports CharacterSequence = System.String
+
+Module Program
+    Sub Main(args As String())
+
+        Dim o As Object = ""
+
+        Dim isString = TypeOf o Is CharacterSequence'BIND:"TypeOf o Is CharacterSequence"
+    End Sub
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf o Is ... terSequence')
+  Operand: ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
+  IsType: System.String
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact>
+        Public Sub SeesThroughTypeAndNamespaceAliases_IsIntegerAliasIOperationTest()
+            Dim source = <![CDATA[
+Option Strict On
+
+Imports HRESULT = System.Int32
+Imports CharacterSequence = System.String
+
+Module Program
+    Sub Main(args As String())
+
+        Dim o As Object = ""
+
+        Dim isInteger = TypeOf o Is HRESULT'BIND:"TypeOf o Is HRESULT"
+
+    End Sub
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf o Is HRESULT')
+  Operand: ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
+  IsType: System.Int32
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact>
+        Public Sub SeesThroughTypeAndNamespaceAliases_IsNotStringAliasIOperationTest()
+            Dim source = <![CDATA[
+Option Strict On
+
+Imports HRESULT = System.Int32
+Imports CharacterSequence = System.String
+
+Module Program
+    Sub Main(args As String())
+
+        Dim o As Object = ""
+
+        Dim isNotString = TypeOf o IsNot CharacterSequence'BIND:"TypeOf o IsNot CharacterSequence"
+
+    End Sub
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (IsNotExpression) (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf o Is ... terSequence')
+  Operand: ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
+  IsType: System.String
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <CompilerTrait(CompilerFeature.IOperation)>
+        <Fact>
+        Public Sub SeesThroughTypeAndNamespaceAliases_IsNotIntegerAliasIOperationTest()
+            Dim source = <![CDATA[
+Option Strict On
+
+Imports HRESULT = System.Int32
+Imports CharacterSequence = System.String
+
+Module Program
+    Sub Main(args As String())
+
+        Dim o As Object = ""
+
+        Dim isNotInteger = TypeOf o IsNot HRESULT'BIND:"TypeOf o IsNot HRESULT"
+
+    End Sub
+End Module]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IIsTypeExpression (IsNotExpression) (OperationKind.IsTypeExpression, Type: System.Boolean) (Syntax: 'TypeOf o IsNot HRESULT')
+  Operand: ILocalReferenceExpression: o (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'o')
+  IsType: System.Int32
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of TypeOfExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
         <Fact>
         Public Sub ReturnsExpectedValuesFromSemanticModelApi()
 
diff --git a/src/Test/Utilities/Portable/Compilation/OperationTreeVerifier.cs b/src/Test/Utilities/Portable/Compilation/OperationTreeVerifier.cs
index 548ef993067ced84961ecff6111e1aa5c8eef667..5b314b0471492b0140f5ad8b3f50c14af4ee0638 100644
--- a/src/Test/Utilities/Portable/Compilation/OperationTreeVerifier.cs
+++ b/src/Test/Utilities/Portable/Compilation/OperationTreeVerifier.cs
@@ -886,12 +886,18 @@ public override void VisitCoalesceExpression(ICoalesceExpression operation)
         public override void VisitIsTypeExpression(IIsTypeExpression operation)
         {
             LogString(nameof(IIsTypeExpression));
+            if (operation.IsNotTypeExpression)
+            {
+                LogString(" (IsNotExpression)");
+            }
+
             LogCommonPropertiesAndNewLine(operation);
 
             Visit(operation.Operand, "Operand");
 
             Indent();
-            LogType(operation.Type);
+            LogType(operation.IsType, "IsType");
+            LogNewLine();
             Unindent();
         }