diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
index 5ad18bdce4861aadd094275fea8c3cee2a2e349b..e3b48d3a7c0f12ae9867ba2f8dd510b5f7b1c5ca 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Emit;
@@ -2114,6 +2115,394 @@ static int TestMain()
             Assert.True(false);
         }
 
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_Method()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+class C
+{
+    [ExcludeFromCodeCoverage]
+    void M1() { Console.WriteLine(1); }
+
+    void M2() { Console.WriteLine(1); }
+}
+";
+            var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+
+            AssertNotInstrumented(verifier, "C.M1");
+            AssertInstrumented(verifier, "C.M2");
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_Ctor()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+class C
+{
+    int a = 1;
+
+    [ExcludeFromCodeCoverage]
+    public C() { Console.WriteLine(3); }
+}
+";
+            var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+
+            AssertNotInstrumented(verifier, "C..ctor");
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_Cctor()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+class C
+{
+    static int a = 1;
+
+    [ExcludeFromCodeCoverage]
+    static C() { Console.WriteLine(3); }
+}
+";
+            var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+            AssertNotInstrumented(verifier, "C..cctor");
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_LocalFunctionsAndLambdas_InMethod()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+class C
+{
+    [ExcludeFromCodeCoverage]
+    static void M1() { L1(); void L1() { new Action(() => { Console.WriteLine(1); }).Invoke(); } }
+                                                      
+    static void M2() { L2(); void L2() { new Action(() => { Console.WriteLine(2); }).Invoke(); } }
+}
+";
+            var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+
+            AssertNotInstrumented(verifier, "C.M1");
+            AssertNotInstrumented(verifier, "C.<M1>g__L10_0");
+            AssertNotInstrumented(verifier, "C.<>c.<M1>b__0_1");
+
+            AssertInstrumented(verifier, "C.M2");
+            AssertInstrumented(verifier, "C.<>c__DisplayClass1_0.<M2>g__L20"); // M2:L2
+            AssertInstrumented(verifier, "C.<>c__DisplayClass1_0.<M2>b__1"); // M2:L2 lambda
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_LocalFunctionsAndLambdas_InInitializers()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+class C
+{
+    Action IF = new Action(() => { Console.WriteLine(1); });
+    Action IP { get; } = new Action(() => { Console.WriteLine(2); });
+
+    static Action SF = new Action(() => { Console.WriteLine(3); });
+    static Action SP { get; } = new Action(() => { Console.WriteLine(4); });
+
+    [ExcludeFromCodeCoverage]
+    C() {}
+
+    static C() {}
+}
+";
+            var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+
+            AssertNotInstrumented(verifier, "C..ctor");
+            AssertNotInstrumented(verifier, "C.<>c.<.ctor>b__8_0");
+            AssertNotInstrumented(verifier, "C.<>c.<.ctor>b__8_1");
+
+            AssertInstrumented(verifier, "C..cctor");
+            AssertInstrumented(verifier, "C.<>c__DisplayClass9_0.<.cctor>b__0");
+            AssertInstrumented(verifier, "C.<>c__DisplayClass9_0.<.cctor>b__1");
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_LocalFunctionsAndLambdas_InAccessors()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+class C
+{
+    [ExcludeFromCodeCoverage]
+    int P1 
+    { 
+        get { L1(); void L1() { Console.WriteLine(1); } return 1; } 
+        set { L2(); void L2() { Console.WriteLine(2); } } 
+    }
+
+    int P2
+    { 
+        get { L3(); void L3() { Console.WriteLine(3); } return 3; } 
+        set { L4(); void L4() { Console.WriteLine(4); } } 
+    }
+}
+";
+            var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+            
+            AssertNotInstrumented(verifier, "C.P1.get");
+            AssertNotInstrumented(verifier, "C.P1.set");
+            AssertNotInstrumented(verifier, "C.<get_P1>g__L11_0");
+            AssertNotInstrumented(verifier, "C.<set_P1>g__L22_0");
+
+            AssertInstrumented(verifier, "C.P2.get");
+            AssertInstrumented(verifier, "C.P2.set");
+            AssertInstrumented(verifier, "C.<get_P2>g__L34_0");
+            AssertInstrumented(verifier, "C.<set_P2>g__L45_0");
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_Type()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+[ExcludeFromCodeCoverage]
+class C
+{
+    int x = 1;
+
+    static C() { }
+
+    void M1() { Console.WriteLine(1); }
+
+    int P { get => 1; set { } }
+
+    event Action E { add { } remove { } }
+}
+
+class D
+{
+    int x = 1;
+
+    static D() { }
+
+    void M1() { Console.WriteLine(1); }
+
+    int P { get => 1; set { } }
+
+    event Action E { add { } remove { } }
+}
+";
+            var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+
+            AssertNotInstrumented(verifier, "C..ctor");
+            AssertNotInstrumented(verifier, "C..cctor");
+            AssertNotInstrumented(verifier, "C.M1");
+            AssertNotInstrumented(verifier, "C.P.get");
+            AssertNotInstrumented(verifier, "C.P.set");
+            AssertNotInstrumented(verifier, "C.E.add");
+            AssertNotInstrumented(verifier, "C.E.remove");
+
+            AssertInstrumented(verifier, "D..ctor");
+            AssertInstrumented(verifier, "D..cctor");
+            AssertInstrumented(verifier, "D.M1");
+            AssertInstrumented(verifier, "D.P.get");
+            AssertInstrumented(verifier, "D.P.set");
+            AssertInstrumented(verifier, "D.E.add");
+            AssertInstrumented(verifier, "D.E.remove");
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_NestedType()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+class A
+{
+    class B1
+    {
+        [ExcludeFromCodeCoverage]
+        class C
+        {
+            void M1() { Console.WriteLine(1); }
+        }
+
+        void M2() { Console.WriteLine(2); }
+    }
+
+    [ExcludeFromCodeCoverage]
+    partial class B2
+    {
+        partial class C1
+        {
+            void M3() { Console.WriteLine(3); }
+        }
+
+        class C2
+        {
+            void M4() { Console.WriteLine(4); }
+        }
+
+        void M5() { Console.WriteLine(5); }
+    }
+
+    partial class B2
+    {
+        [ExcludeFromCodeCoverage]
+        partial class C1
+        {
+            void M6() { Console.WriteLine(6); }
+        }
+
+        void M7() { Console.WriteLine(7); }
+    }
+
+    void M8() { Console.WriteLine(8); }
+}
+";
+            var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+
+            AssertNotInstrumented(verifier, "A.B1.C.M1");
+            AssertInstrumented(verifier, "A.B1.M2");
+            AssertNotInstrumented(verifier, "A.B2.C1.M3");
+            AssertNotInstrumented(verifier, "A.B2.C2.M4");
+            AssertNotInstrumented(verifier, "A.B2.C1.M6");
+            AssertNotInstrumented(verifier, "A.B2.M7");
+            AssertInstrumented(verifier, "A.M8");
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_Accessors()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+class C
+{
+    [ExcludeFromCodeCoverage]
+    int P1 { get => 1; set {} }
+          
+    [ExcludeFromCodeCoverage]
+    event Action E1 { add { } remove { } }
+                                            
+    int P2 { get => 1; set {} }
+    event Action E2 { add { } remove { } }
+}
+";
+            var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+            
+            AssertNotInstrumented(verifier, "C.P1.get");
+            AssertNotInstrumented(verifier, "C.P1.set");
+            AssertNotInstrumented(verifier, "C.E1.add");
+            AssertNotInstrumented(verifier, "C.E1.remove");
+
+            AssertInstrumented(verifier, "C.P2.get");
+            AssertInstrumented(verifier, "C.P2.set");
+            AssertInstrumented(verifier, "C.E2.add");
+            AssertInstrumented(verifier, "C.E2.remove");
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_CustomDefinition_Good()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    public sealed class ExcludeFromCodeCoverageAttribute : Attribute
+    {
+        public ExcludeFromCodeCoverageAttribute() {}
+    }
+}
+
+[ExcludeFromCodeCoverage]
+class C
+{
+    void M() {}
+}
+
+class D
+{
+    void M() {}
+}
+";
+            var c = CreateCompilationWithMscorlib(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+            c.VerifyDiagnostics();
+
+            var verifier = CompileAndVerify(c, emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
+            c.VerifyEmitDiagnostics();
+
+            AssertNotInstrumented(verifier, "C.M");
+            AssertInstrumented(verifier, "D.M");
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageAttribute_CustomDefinition_Bad()
+        {
+            string source = @"
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    public sealed class ExcludeFromCodeCoverageAttribute : Attribute
+    {
+        public ExcludeFromCodeCoverageAttribute(int x) {}
+    }
+}
+
+[ExcludeFromCodeCoverage(1)]
+class C
+{
+    void M() {}
+}
+
+class D
+{
+    void M() {}
+}
+";
+            var c = CreateCompilationWithMscorlib(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
+            c.VerifyDiagnostics();
+
+            var verifier = CompileAndVerify(c, emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
+            c.VerifyEmitDiagnostics();
+
+            AssertInstrumented(verifier, "C.M");
+            AssertInstrumented(verifier, "D.M");
+        }
+
+        private static void AssertNotInstrumented(CompilationVerifier verifier, string qualifiedMethodName)
+            => AssertInstrumented(verifier, qualifiedMethodName, expected: false);
+
+        private static void AssertInstrumented(CompilationVerifier verifier, string qualifiedMethodName, bool expected = true)
+        {
+            string il = verifier.VisualizeIL(qualifiedMethodName);
+
+            // Tests using this helper are constructed such that instrumented methods contain a call to CreatePayload, 
+            // lambdas a reference to payload bool array.
+            bool instrumented = il.Contains("CreatePayload") || il.Contains("bool[]");
+
+            Assert.True(expected == instrumented, $"Method '{qualifiedMethodName}' should {(expected ? "be" : "not be")} instrumented. Actual IL:{Environment.NewLine}{il}");
+        }
+
         private CompilationVerifier CompileAndVerify(string source, string expectedOutput = null, CompilationOptions options = null)
         {
             return base.CompileAndVerify(source, expectedOutput: expectedOutput, additionalRefs: s_refs, options: (options ?? TestOptions.ReleaseExe).WithDeterministic(true), emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb
index c529ef1c346ba877c75b07dbc3d8abd7f69aa100..e334b2dd4fa07378af980a4dbc71979e7169f479 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb
@@ -1,24 +1,17 @@
 ' 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
 Imports System.Collections.Immutable
-Imports System.Linq
-Imports System.Reflection.PortableExecutable
 Imports System.Xml.Linq
 Imports Microsoft.CodeAnalysis.Emit
-Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Microsoft.CodeAnalysis.VisualBasic
 Imports Microsoft.CodeAnalysis.VisualBasic.UnitTests
-Imports Roslyn.Test.Utilities
-Imports Xunit
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.DynamicAnalysis.UnitTests
 
     Public Class DynamicInstrumentationTests
         Inherits BasicTestBase
 
-        ReadOnly InstrumentationHelperSource As XElement = <file name="c.vb">
-                                                               <![CDATA[
+        Const InstrumentationHelperSourceStr As String = "
 Namespace Microsoft.CodeAnalysis.Runtime
 
     Public Class Instrumentation
@@ -44,15 +37,15 @@ Namespace Microsoft.CodeAnalysis.Runtime
         End Function
 
         Public Shared Sub FlushPayload()
-            System.Console.WriteLine("Flushing")
+            System.Console.WriteLine(""Flushing"")
             If _payloads Is Nothing Then
                 Return
             End If
             For i As Integer = 0 To _payloads.Length - 1
                 Dim payload As Boolean() = _payloads(i)
                 if payload IsNot Nothing
-                    System.Console.WriteLine("Method " & i.ToString())
-                    System.Console.WriteLine("File " & _fileIndices(i).ToString())
+                    System.Console.WriteLine(""Method "" & i.ToString())
+                    System.Console.WriteLine(""File "" & _fileIndices(i).ToString())
                     For j As Integer = 0 To payload.Length - 1
                         System.Console.WriteLine(payload(j))
                         payload(j) = False
@@ -62,9 +55,11 @@ Namespace Microsoft.CodeAnalysis.Runtime
         End Sub
     End Class
 End Namespace
-]]>
-                                                           </file>
+"
 
+        ReadOnly InstrumentationHelperSource As XElement = <file name="c.vb">
+                                                               <%= InstrumentationHelperSourceStr %>
+                                                           </file>
         <Fact>
         Public Sub SimpleCoverage()
             Dim testSource As XElement = <file name="c.vb">
@@ -1645,14 +1640,502 @@ End Class
             Assert.True(False)
         End Sub
 
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_Method()
+            Dim source = "
+Imports System
+Imports System.Diagnostics.CodeAnalysis
+
+Class C
+    <ExcludeFromCodeCoverage>
+    Sub M1()
+        Console.WriteLine(1)
+    End Sub
+
+    Sub M2()
+        Console.WriteLine(1)
+    End Sub
+End Class
+"
+            Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+            AssertNotInstrumented(verifier, "C.M1")
+            AssertInstrumented(verifier, "C.M2")
+        End Sub
+
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_Ctor()
+            Dim source = "
+Imports System
+Imports System.Diagnostics.CodeAnalysis
+
+Class C
+    Dim a As Integer = 1
+
+    <ExcludeFromCodeCoverage>
+    Public Sub New()
+        Console.WriteLine(3)
+    End Sub
+End Class
+"
+            Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+            AssertNotInstrumented(verifier, "C..ctor")
+        End Sub
+
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_Cctor()
+            Dim source = "
+Imports System
+Imports System.Diagnostics.CodeAnalysis
+
+Class C
+    Shared a As Integer = 1
+
+    <ExcludeFromCodeCoverage>
+    Shared Sub New()
+        Console.WriteLine(3)
+    End Sub
+End Class
+"
+            Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+            AssertNotInstrumented(verifier, "C..cctor")
+        End Sub
+
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_Lambdas_InMethod()
+            Dim source = "
+Imports System
+Imports System.Diagnostics.CodeAnalysis
+
+Class C
+    <ExcludeFromCodeCoverage>
+    Shared Sub M1()
+        Dim s = New Action(Sub() Console.WriteLine(1))
+        s.Invoke()
+    End Sub
+
+    Shared Sub M2()
+        Dim s = New Action(Sub() Console.WriteLine(2))
+        s.Invoke()
+    End Sub
+End Class
+"
+            Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+
+            AssertNotInstrumented(verifier, "C.M1")
+            AssertNotInstrumented(verifier, "C._Closure$__._Lambda$__1-0")
+
+            AssertInstrumented(verifier, "C.M2")
+            AssertInstrumented(verifier, "C._Closure$__2-0._Lambda$__0")
+        End Sub
+
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_Lambdas_InInitializers()
+            Dim source = "
+Imports System
+Imports System.Diagnostics.CodeAnalysis
+
+Class C
+    Dim [IF] As Action = Sub() Console.WriteLine(1)
+
+    ReadOnly Property IP As Action = Sub() Console.WriteLine(2)
+
+    Shared SF As Action = Sub() Console.WriteLine(3)
+
+    Shared ReadOnly Property SP As Action = Sub() Console.WriteLine(4)
+
+    <ExcludeFromCodeCoverage>
+    Sub New()
+    End Sub
+
+    Shared Sub New()
+    End Sub
+End Class
+"
+            Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+            verifier.VerifyDiagnostics()
+
+            AssertNotInstrumented(verifier, "C..ctor")
+            AssertNotInstrumented(verifier, "C._Closure$__._Lambda$__8-0")
+            AssertNotInstrumented(verifier, "C._Closure$__._Lambda$__8-1")
+
+            AssertInstrumented(verifier, "C..cctor")
+            AssertInstrumented(verifier, "C._Closure$__9-0._Lambda$__0")
+            AssertInstrumented(verifier, "C._Closure$__9-0._Lambda$__1")
+        End Sub
+
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_Lambdas_InAccessors()
+            Dim source = "
+Imports System
+Imports System.Diagnostics.CodeAnalysis
+
+Class C
+
+    <ExcludeFromCodeCoverage>
+    Property P1 As Integer
+        Get
+            Dim s = Sub() Console.WriteLine(1)
+            s()
+            Return 1
+        End Get
+
+        Set
+            Dim s = Sub() Console.WriteLine(2)
+            s()
+        End Set
+    End Property
+
+    Property P2 As Integer
+        Get
+            Dim s = Sub() Console.WriteLine(3)
+            s()
+            Return 3
+        End Get
+
+        Set
+            Dim s = Sub() Console.WriteLine(4)
+            s()
+        End Set
+    End Property
+End Class
+"
+            Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+
+            AssertNotInstrumented(verifier, "C.get_P1")
+            AssertNotInstrumented(verifier, "C.set_P1")
+            AssertNotInstrumented(verifier, "C._Closure$__._Lambda$__2-0")
+            AssertNotInstrumented(verifier, "C._Closure$__._Lambda$__3-0")
+
+            AssertInstrumented(verifier, "C.get_P2")
+            AssertInstrumented(verifier, "C.set_P2")
+            AssertInstrumented(verifier, "C._Closure$__6-0._Lambda$__0")
+            AssertInstrumented(verifier, "C._Closure$__5-0._Lambda$__0")
+        End Sub
+
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_Type()
+            Dim source = "
+Imports System
+Imports System.Diagnostics.CodeAnalysis
+
+<ExcludeFromCodeCoverage>
+Class C
+    Dim x As Integer = 1
+
+    Shared Sub New()
+    End Sub
+
+    Sub M1()
+        Console.WriteLine(1)
+    End Sub
+
+    Property P As Integer
+        Get
+            Return 1
+        End Get
+        Set
+        End Set
+    End Property
+
+    Custom Event E As Action
+        AddHandler(v As Action)
+        End AddHandler
+
+        RemoveHandler(v As Action)
+        End RemoveHandler
+
+        RaiseEvent()
+        End RaiseEvent
+    End Event
+End Class
+
+Class D
+    Dim x As Integer = 1
+
+    Shared Sub New()
+    End Sub
+
+    Sub M1()
+        Console.WriteLine(1)
+    End Sub
+
+    Property P As Integer
+        Get
+            Return 1
+        End Get
+        Set
+        End Set
+    End Property
+
+    Custom Event E As Action
+        AddHandler(v As Action)
+        End AddHandler
+
+        RemoveHandler(v As Action)
+        End RemoveHandler
+
+        RaiseEvent()
+        End RaiseEvent
+    End Event
+End Class
+"
+            Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+
+            AssertNotInstrumented(verifier, "C..ctor")
+            AssertNotInstrumented(verifier, "C..cctor")
+            AssertNotInstrumented(verifier, "C.M1")
+            AssertNotInstrumented(verifier, "C.get_P")
+            AssertNotInstrumented(verifier, "C.set_P")
+            AssertNotInstrumented(verifier, "C.add_E")
+            AssertNotInstrumented(verifier, "C.remove_E")
+            AssertNotInstrumented(verifier, "C.raise_E")
+
+            AssertInstrumented(verifier, "D..ctor")
+            AssertInstrumented(verifier, "D..cctor")
+            AssertInstrumented(verifier, "D.M1")
+            AssertInstrumented(verifier, "D.get_P")
+            AssertInstrumented(verifier, "D.set_P")
+            AssertInstrumented(verifier, "D.add_E")
+            AssertInstrumented(verifier, "D.remove_E")
+            AssertInstrumented(verifier, "D.raise_E")
+        End Sub
+
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_NestedType()
+            Dim source = "
+Imports System
+Imports System.Diagnostics.CodeAnalysis
+
+Class A
+    Class B1
+        <ExcludeFromCodeCoverage>
+        Class C
+            Sub M1()
+                Console.WriteLine(1)
+            End Sub
+        End Class
+
+        Sub M2()
+            Console.WriteLine(2)
+        End Sub
+    End Class
+
+    <ExcludeFromCodeCoverage>
+    Partial Class B2
+        Partial Class C1
+            Sub M3()
+                Console.WriteLine(3)
+            End Sub
+        End Class
+
+        Class C2
+            Sub M4()
+                Console.WriteLine(4)
+            End Sub
+        End Class
+
+        Sub M5()
+            Console.WriteLine(5)
+        End Sub
+    End Class
+
+    Partial Class B2
+        <ExcludeFromCodeCoverage>
+        Partial Class C1
+            Sub M6()
+                Console.WriteLine(6)
+            End Sub
+        End Class
+
+        Sub M7()
+            Console.WriteLine(7)
+        End Sub
+    End Class
+
+    Sub M8()
+        Console.WriteLine(8)
+    End Sub
+End Class
+"
+            Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+            AssertNotInstrumented(verifier, "A.B1.C.M1")
+            AssertInstrumented(verifier, "A.B1.M2")
+            AssertNotInstrumented(verifier, "A.B2.C1.M3")
+            AssertNotInstrumented(verifier, "A.B2.C2.M4")
+            AssertNotInstrumented(verifier, "A.B2.C1.M6")
+            AssertNotInstrumented(verifier, "A.B2.M7")
+            AssertInstrumented(verifier, "A.M8")
+        End Sub
+
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_Accessors()
+            Dim source = "
+Imports System
+Imports System.Diagnostics.CodeAnalysis
+
+Class C
+    <ExcludeFromCodeCoverage>
+    Property P1 As Integer
+        Get
+            Return 1
+        End Get
+        Set
+        End Set
+    End Property
+          
+    <ExcludeFromCodeCoverage>
+    Custom Event E1 As Action
+        AddHandler(v As Action)
+        End AddHandler
+
+        RemoveHandler(v As Action)
+        End RemoveHandler
+
+        RaiseEvent()
+        End RaiseEvent
+    End Event
+                                            
+    Property P2 As Integer
+        Get
+            Return 2
+        End Get
+        Set
+        End Set
+    End Property
+
+    Custom Event E2 As Action
+        AddHandler(v As Action)
+        End AddHandler
+
+        RemoveHandler(v As Action)
+        End RemoveHandler
+
+        RaiseEvent()
+        End RaiseEvent
+    End Event
+End Class
+"
+            Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+
+            AssertNotInstrumented(verifier, "C.get_P1")
+            AssertNotInstrumented(verifier, "C.set_P1")
+            AssertNotInstrumented(verifier, "C.add_E1")
+            AssertNotInstrumented(verifier, "C.remove_E1")
+            AssertNotInstrumented(verifier, "C.raise_E1")
+
+            AssertInstrumented(verifier, "C.get_P2")
+            AssertInstrumented(verifier, "C.set_P2")
+            AssertInstrumented(verifier, "C.add_E2")
+            AssertInstrumented(verifier, "C.remove_E2")
+            AssertInstrumented(verifier, "C.raise_E2")
+        End Sub
+
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_CustomDefinition_Good()
+            Dim source = "
+Imports System.Diagnostics.CodeAnalysis
+
+Namespace System.Diagnostics.CodeAnalysis
+
+    <AttributeUsage(AttributeTargets.Class)>
+    Public Class ExcludeFromCodeCoverageAttribute
+        Inherits Attribute
+
+        Public Sub New()
+        End Sub
+    End Class
+End Namespace
+
+<ExcludeFromCodeCoverage>
+Class C
+    Sub M()
+    End Sub
+End Class
+
+Class D
+    Sub M()
+    End Sub
+End Class
+"
+            Dim c = CreateCompilationWithMscorlib(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+            c.VerifyDiagnostics()
+
+            Dim verifier = CompileAndVerify(c, emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))
+            c.VerifyEmitDiagnostics()
+
+            AssertNotInstrumented(verifier, "C.M")
+            AssertInstrumented(verifier, "D.M")
+        End Sub
+
+        <Fact>
+        Public Sub ExcludeFromCodeCoverageAttribute_CustomDefinition_Bad()
+            Dim source = "
+Imports System.Diagnostics.CodeAnalysis
+
+Namespace System.Diagnostics.CodeAnalysis
+
+    <AttributeUsage(AttributeTargets.Class)>
+    Public Class ExcludeFromCodeCoverageAttribute
+        Inherits Attribute
+
+        Public Sub New(x As Integer)
+        End Sub
+    End Class
+End Namespace
+
+<ExcludeFromCodeCoverage(1)>
+Class C
+    Sub M()
+    End Sub
+End Class
+
+Class D
+    Sub M()
+    End Sub
+End Class
+"
+            Dim c = CreateCompilationWithMscorlib(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
+            c.VerifyDiagnostics()
+
+            Dim verifier = CompileAndVerify(c, emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))
+            c.VerifyEmitDiagnostics()
+
+            AssertInstrumented(verifier, "C.M")
+            AssertInstrumented(verifier, "D.M")
+        End Sub
+
+        Private Shared Sub AssertNotInstrumented(verifier As CompilationVerifier, qualifiedMethodName As String)
+            AssertInstrumented(verifier, qualifiedMethodName, expected:=False)
+        End Sub
+
+        Private Shared Sub AssertInstrumented(verifier As CompilationVerifier, qualifiedMethodName As String, Optional expected As Boolean = True)
+            Dim il = verifier.VisualizeIL(qualifiedMethodName)
+
+            ' Tests using this helper are constructed such that instrumented methods contain a call to CreatePayload, 
+            ' lambdas a reference to payload Boolean array.
+            Dim instrumented = il.Contains("CreatePayload") OrElse il.Contains("As Boolean()")
+
+            Assert.True(expected = instrumented, $"Method '{qualifiedMethodName}' should {If(expected, "be", "not be")} instrumented. Actual IL:{Environment.NewLine}{il}")
+        End Sub
+
         Private Function CreateCompilation(source As XElement) As Compilation
-            Return CompilationUtils.CreateCompilationWithReferences(source, references:=New MetadataReference() {}, options:=TestOptions.ReleaseExe.WithDeterministic(True))
+            Return CreateCompilationWithReferences(source, references:=New MetadataReference() {}, options:=TestOptions.ReleaseExe.WithDeterministic(True))
         End Function
 
-        Private Overloads Function CompileAndVerify(source As XElement, expectedOutput As XCData, Optional options As VisualBasicCompilationOptions = Nothing) As CompilationVerifier
-            Return MyBase.CompileAndVerify(source, expectedOutput:=expectedOutput, additionalRefs:=s_refs, options:=If(options IsNot Nothing, options, TestOptions.ReleaseExe).WithDeterministic(True), emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))
+        Private Overloads Function CompileAndVerify(source As XElement, Optional expectedOutput As XCData = Nothing, Optional options As VisualBasicCompilationOptions = Nothing) As CompilationVerifier
+            Return CompileAndVerify(source,
+                                    LatestVbReferences,
+                                    XCDataToString(expectedOutput),
+                                    options:=If(options, TestOptions.ReleaseExe).WithDeterministic(True),
+                                    emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))
         End Function
 
-        Private Shared ReadOnly s_refs As MetadataReference() = New MetadataReference() {MscorlibRef_v4_0_30316_17626, SystemRef_v4_0_30319_17929, SystemCoreRef_v4_0_30319_17929}
+        Private Overloads Function CompileAndVerify(source As String, Optional expectedOutput As String = Nothing, Optional options As VisualBasicCompilationOptions = Nothing) As CompilationVerifier
+            Return CompileAndVerify(source,
+                                    LatestVbReferences,
+                                    expectedOutput,
+                                    options:=If(options, TestOptions.ReleaseExe).WithDeterministic(True),
+                                    emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))
+        End Function
     End Class
 End Namespace
diff --git a/src/Test/Utilities/Desktop/CommonTestBase.CompilationVerifier.cs b/src/Test/Utilities/Desktop/CommonTestBase.CompilationVerifier.cs
index 18be62c522f802cc4a72f9d041db2e6cb37ec266..fb19790712f29a4f03bf5fcca9a2fbfe8d58d954 100644
--- a/src/Test/Utilities/Desktop/CommonTestBase.CompilationVerifier.cs
+++ b/src/Test/Utilities/Desktop/CommonTestBase.CompilationVerifier.cs
@@ -177,19 +177,8 @@ private string Emit(IRuntimeEnvironment testEnvironment, IEnumerable<ResourceDes
                 int callerLine,
                 bool escapeQuotes)
             {
-                // TODO: Currently the qualifiedMethodName is a symbol display name while PDB need metadata name.
-                // So we need to pass the PDB metadata name of the method to sequencePoints (instead of just bool).
-
-                var methodData = _testData.GetMethodData(qualifiedMethodName);
-
-                // verify IL emitted via CCI, if any:
-                string actualCciIL = VisualizeIL(methodData, realIL, sequencePoints, useRefEmitter: false);
-                AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualCciIL, escapeQuotes, callerPath, callerLine);
-
-                // verify IL emitted via ReflectionEmitter, if any:
-                string actualRefEmitIL = VisualizeIL(methodData, realIL, sequencePoints, useRefEmitter: true);
-                AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualRefEmitIL, escapeQuotes, callerPath, callerLine);
-
+                string actualIL = VisualizeIL(qualifiedMethodName, realIL, sequencePoints);
+                AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes, callerPath, callerLine);
                 return this;
             }
 
@@ -249,12 +238,15 @@ public ISymUnmanagedReader3 CreateSymReader()
                 return SymReaderFactory.CreateReader(pdbStream, metadataReaderOpt: null, metadataMemoryOwnerOpt: null);
             }
 
-            public string VisualizeIL(string qualifiedMethodName, bool realIL = false, string sequencePoints = null, bool useRefEmitter = false)
+            public string VisualizeIL(string qualifiedMethodName, bool realIL = false, string sequencePoints = null)
             {
-                return VisualizeIL(_testData.GetMethodData(qualifiedMethodName), realIL, sequencePoints, useRefEmitter);
+                // TODO: Currently the qualifiedMethodName is a symbol display name while PDB need metadata name.
+                // So we need to pass the PDB metadata name of the method to sequencePoints (instead of just bool).
+
+                return VisualizeIL(_testData.GetMethodData(qualifiedMethodName), realIL, sequencePoints);
             }
 
-            internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null, bool useRefEmitter = false)
+            internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null)
             {
                 Dictionary<int, string> markers = null;