Added a 'suppressAccessChecks' parameter to Compilation.GetSemanticModel

Calling GetSemanticModel with suppressAccessChecks=true creates a SemanticModel that ignores accessibility rules when answering semantic questions.
This allows consumers to ask semantic questions using the same semantic rules as the ones used in debugger’s Expression Evaluator, where accessibility rules do not matter.

Added unit tests for C# and VB.NET to cover both regular and speculative analysis.

Src/Compilers/CSharp/Test/Semantic/Semantics/SupressAccessibilityChecksTests.cs

+using System.IO;
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Semantics
+{
+    public class SupressAccessibilityChecksTests : CSharpTestBase
+    {
+        private static SemanticModel GetSemanticModelWithSuppressAccessChecks()
+        {
+            var compilationA = CreateCompilationWithMscorlib(@"
+namespace N
+{
+    class A
+    {
+        A M() { return new A(); }
+        int _num;
+    }
+}"
+                );
+        
+            var referenceA = MetadataReference.CreateFromStream(compilationA.EmitToStream());
+
+            var compilationB = CreateCompilationWithMscorlib(@"
+using A = N.A;
+
+class B 
+{
+    void Main() 
+    {
+        new A().M();
+    }
+}
+
+", new MetadataReference[] {referenceA}, TestOptions.ReleaseDll.WithMetadataImportOptions(MetadataImportOptions.All));
+
+            var syntaxTree = compilationB.SyntaxTrees[0];
+            return compilationB.GetSemanticModel(syntaxTree, suppressAccessChecks: true);
+        }
+
+        [Fact]
+        public void TestAccessPrivateMemberOfInternalType()
+        {
+            var semanticModel = GetSemanticModelWithSuppressAccessChecks();
+            var invocation = semanticModel.SyntaxTree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+            var position = invocation.FullSpan.Start;
+
+            Assert.Equal("A", semanticModel.GetTypeInfo(invocation).Type.Name);
+            Assert.Equal("M", semanticModel.GetSymbolInfo(invocation).Symbol.Name);            
+            Assert.NotEmpty(semanticModel.LookupSymbols(position, name: "A"));
+        }
+
+        [Fact]
+        public void TestAccessChecksInSpeculativeExpression()
+        {
+            var semanticModel = GetSemanticModelWithSuppressAccessChecks();
+            var invocation = semanticModel.SyntaxTree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+            var position = invocation.FullSpan.Start;
+
+            var exp = SyntaxFactory.ParseExpression("new A().M()._num");
+            Assert.Equal("Int32",
+                semanticModel.GetSpeculativeTypeInfo(position, exp, SpeculativeBindingOption.BindAsExpression).Type.Name);
+
+            Assert.Equal("_num",
+                semanticModel.GetSpeculativeSymbolInfo(position, exp, SpeculativeBindingOption.BindAsExpression).Symbol.Name);
+        }
+
+        [Fact]
+        public void TestAccessChecksInSpeculativeSemanticModel()
+        {
+            var semanticModel = GetSemanticModelWithSuppressAccessChecks();
+            var invocation = semanticModel.SyntaxTree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+            var position = invocation.FullSpan.Start;
+
+
+            SemanticModel speculativeSemanticModel;
+            var statement = SyntaxFactory.ParseStatement("var foo = new A().M();");
+
+            semanticModel.TryGetSpeculativeSemanticModel(position, statement, out speculativeSemanticModel);
+            var creationExpression =
+                speculativeSemanticModel.GetTypeInfo(
+                    statement.DescendantNodes().OfType<ObjectCreationExpressionSyntax>().Single());
+
+            Assert.Equal("A", creationExpression.Type.Name);
+        }
+
+
+        [Fact]
+        public void TestAccessChecksInsideLambdaExpression()
+        {
+            var source = @"
+using System.Collections.Generic;
+ 
+class P { bool _p; }
+
+class C
+{
+    static void M()
+    {
+        var tmp = new List<P>();
+        tmp.Find(a => true);
+    }
+}
+";
+
+            var tree = SyntaxFactory.ParseSyntaxTree(source);
+            var comp = CreateCompilationWithMscorlib(tree);
+            var model = comp.GetSemanticModel(tree,suppressAccessChecks: true);
+
+            var expr = (ExpressionSyntax)tree.GetCompilationUnitRoot().DescendantNodes().OfType<SimpleLambdaExpressionSyntax>().Single().Body;
+
+            var symbolInfo = model.GetSpeculativeSymbolInfo(expr.FullSpan.Start, 
+                                                           SyntaxFactory.ParseExpression("a._p"), 
+                                                           SpeculativeBindingOption.BindAsExpression);
+
+            Assert.Equal("_p", symbolInfo.Symbol.Name);
+        }
+
+        [Fact]
+        public void TestExtensionMethodInInternalClass()
+        {
+            var compilationA = CreateCompilationWithMscorlibAndSystemCore(@"
+public class A
+{
+    A M() { return new A(); }
+    internal int _num;
+}
+
+internal static class E
+{
+    internal static int InternalExtension(this A theClass, int newNum)
+    {
+        theClass._num = newNum;
+        
+        return newNum;
+    }
+}
+");
+
+            var referenceA = MetadataReference.CreateFromStream(compilationA.EmitToStream());
+
+            var compilationB = CreateCompilationWithMscorlib(@"
+class B 
+{
+    void Main() 
+    {
+        new A().M();
+    }
+}
+
+", new MetadataReference[] { referenceA }, TestOptions.ReleaseDll.WithMetadataImportOptions(MetadataImportOptions.All));
+
+            var syntaxTree = compilationB.SyntaxTrees[0];
+            var semanticModel = compilationB.GetSemanticModel(syntaxTree, suppressAccessChecks: true);
+
+            var invocation = syntaxTree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+            Assert.Equal("A", semanticModel.GetTypeInfo(invocation).Type.Name);
+            Assert.Equal("M", semanticModel.GetSymbolInfo(invocation).Symbol.Name);
+
+            var speculativeInvocation = SyntaxFactory.ParseExpression("new A().InternalExtension(67)");
+            var position = invocation.FullSpan.Start;
+
+            Assert.Equal("Int32", semanticModel.GetSpeculativeTypeInfo(position, speculativeInvocation, SpeculativeBindingOption.BindAsExpression).Type.Name);
+            Assert.Equal("InternalExtension", semanticModel.GetSpeculativeSymbolInfo(position, speculativeInvocation, SpeculativeBindingOption.BindAsExpression).Symbol.Name);            
+        }
+
+        [Fact]
+        public void TestGetSpeculativeSemanticModelForPropertyAccessorBody()
+        {
+            var compilation = CreateCompilationWithMscorlib(@"
+class R
+{
+    private int _p;
+}
+
+class C : R 
+{
+    
+    private int M
+    {
+        set
+        {
+            int y = 1000;
+        }
+    }
+}
+");
+
+            var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@"
+{ 
+   int z = 0; 
+
+   _p = 123L;
+}
+");
+
+            var tree = compilation.SyntaxTrees[0];
+            var root = tree.GetCompilationUnitRoot();
+            var model = compilation.GetSemanticModel(tree, suppressAccessChecks: true);
+
+            AccessorDeclarationSyntax accesorDecl = root.DescendantNodes().OfType<AccessorDeclarationSyntax>().Single();
+            
+            var speculatedMethod = accesorDecl.ReplaceNode(accesorDecl.Body, blockStatement);
+
+            SemanticModel speculativeModel;
+            var success =
+                model.TryGetSpeculativeSemanticModelForMethodBody(
+                    accesorDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel);
+
+            Assert.True(success);
+            Assert.NotNull(speculativeModel);
+
+            var p =
+                speculativeModel.SyntaxTree.GetRoot()
+                    .DescendantNodes()
+                    .OfType<IdentifierNameSyntax>()
+                    .Single(s => s.Identifier.ValueText == "_p");
+
+            var symbolSpeculation =
+                speculativeModel.GetSpeculativeSymbolInfo(p.FullSpan.Start, p, SpeculativeBindingOption.BindAsExpression);
+
+            Assert.Equal("_p", symbolSpeculation.Symbol.Name);
+
+            var typeSpeculation =
+                speculativeModel.GetSpeculativeTypeInfo(p.FullSpan.Start, p, SpeculativeBindingOption.BindAsExpression);
+            
+            Assert.Equal("Int32", typeSpeculation.Type.Name);
+        }
+    }
+}

Src/Compilers/VisualBasic/Test/Semantic/Compilation/SupressAccessibilityChecksTests.vb

+Imports Microsoft.CodeAnalysis
+Imports Microsoft.CodeAnalysis.Test.Utilities
+Imports Microsoft.CodeAnalysis.VisualBasic
+Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
+Imports Microsoft.CodeAnalysis.VisualBasic.UnitTests
+
+Imports Xunit
+
+Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
+    Public Class SupressAccessibilityChecksTests
+        Inherits BasicTestBase
+
+        Private Function GetSemanticModelWithSuppressAccessChecks() As SemanticModel
+
+
+            Dim compilationA = CreateVisualBasicCompilation(<![CDATA[
+Class A
+
+    Private _num As Integer
+
+    Private Function M() As A
+
+        Return New A()
+    
+    End Function
+End Class
+]]>.Value)
+
+            Dim referenceA = MetadataReference.CreateFromStream(compilationA.EmitToStream())
+
+            Dim compilationB = CreateVisualBasicCompilation(<![CDATA[
+Class B
+
+    Sub Main()
+
+        Dim v = New A().M()
+
+    End Sub
+
+End Class
+
+]]>.Value, referencedAssemblies:=New MetadataReference() {referenceA},
+                                                            compilationOptions:=TestOptions.ReleaseDll.WithMetadataImportOptions(MetadataImportOptions.All))
+
+            Dim syntaxTree2 = compilationB.SyntaxTrees(0)
+            Return compilationB.GetSemanticModel(syntaxTree2, suppressAccessChecks:=True)
+        End Function
+
+        <Fact>
+        Public Sub TestAccessPrivateMemberOfInternalType()
+            Dim semanticModel = GetSemanticModelWithSuppressAccessChecks()
+            Dim invocation = semanticModel.SyntaxTree.GetRoot().DescendantNodes().OfType(Of InvocationExpressionSyntax)().Single()
+            Dim position = invocation.FullSpan.Start
+
+            Assert.Equal("A", semanticModel.GetTypeInfo(invocation).Type.Name)
+            Assert.Equal("M", semanticModel.GetSymbolInfo(invocation).Symbol.Name)
+
+            Assert.NotEmpty(semanticModel.LookupSymbols(position, name:="A"))
+
+        End Sub
+
+        <Fact>
+        Public Sub TestAccessChecksInSpeculativeExpression()
+            Dim semanticModel = GetSemanticModelWithSuppressAccessChecks()
+            Dim invocation = semanticModel.SyntaxTree.GetRoot().DescendantNodes().OfType(Of InvocationExpressionSyntax)().Single()
+
+            Dim speculativeInvocation = SyntaxFactory.ParseExpression("New A().M()._num")
+            Dim position = invocation.FullSpan.Start
+
+            Assert.Equal("Int32", semanticModel.GetSpeculativeTypeInfo(position, speculativeInvocation, SpeculativeBindingOption.BindAsExpression).Type.Name)
+            Assert.Equal("_num", semanticModel.GetSpeculativeSymbolInfo(position, speculativeInvocation, SpeculativeBindingOption.BindAsExpression).Symbol.Name)
+        End Sub
+
+        <Fact>
+        Public Sub TestAccessChecksInSpeculativeSemanticModel()
+            Dim semanticModel = GetSemanticModelWithSuppressAccessChecks()
+            Dim syntaxTree = semanticModel.SyntaxTree
+            Dim invocation = syntaxTree.GetRoot().DescendantNodes().OfType(Of InvocationExpressionSyntax)().Single()
+            Dim position = invocation.FullSpan.Start
+
+            Dim speculativeSemanticModel As SemanticModel = Nothing
+            Dim statement = DirectCast(SyntaxFactory.ParseExecutableStatement("Dim v = New A().M()"), ExecutableStatementSyntax)
+
+            semanticModel.TryGetSpeculativeSemanticModel(position, statement, speculativeSemanticModel)
+            Dim creationExpression = speculativeSemanticModel.GetTypeInfo(statement.DescendantNodes().OfType(Of ObjectCreationExpressionSyntax)().Single())
+
+            Assert.Equal("A", creationExpression.Type.Name)
+        End Sub
+
+        <Fact>
+        Public Sub AccessChecksInsideLambdaExpression()
+
+            Dim source = <![CDATA[
+        Imports System.Collections.Generic
+
+        Class P
+            Private _p As Boolean
+        End Class
+
+        Class C
+
+            Shared Sub M()
+
+                Dim tmp = New List(Of P)()
+                Dim answer = tmp.Find(Function(a) a._p)
+
+            End Sub
+        End Class
+        ]]>.Value
+
+            Dim tree = SyntaxFactory.ParseSyntaxTree(source)
+            Dim comp = CreateCompilationWithMscorlib(tree)
+            Dim model = comp.GetSemanticModel(tree, suppressAccessChecks:=True)
+
+            Dim root = tree.GetCompilationUnitRoot()
+            Dim expr = DirectCast(root.DescendantNodes().OfType(Of SingleLineLambdaExpressionSyntax)().Single().Body, ExpressionSyntax)
+
+            Dim symbolInfo = model.GetSpeculativeSymbolInfo(expr.SpanStart, SyntaxFactory.ParseExpression("a._p"), SpeculativeBindingOption.BindAsExpression)
+
+            Assert.Equal("_p", symbolInfo.Symbol.Name)
+        End Sub
+
+        <Fact>
+        Public Sub AccessCheckCrossAssemblyPrivateExtensions()
+
+            Dim source =
+                <compilation name="ext">
+                    <file name="a.vb">
+Imports System.Runtime.CompilerServices
+
+Public Class A
+
+    Function M() As A
+    
+        Return New A()
+
+    End Function
+
+    Friend _num As Integer
+
+End Class
+
+Friend Module E
+
+    &lt;Extension&gt;
+    Friend Function InternalExtension(theClass As A, newNum As Integer) As Integer
+    
+        theClass._num = newNum
+        
+        Return newNum
+
+    End Function
+End Module
+
+Namespace System.Runtime.CompilerServices
+
+    &lt;AttributeUsage(AttributeTargets.Assembly Or AttributeTargets.Class Or AttributeTargets.Method)&gt;
+    Class ExtensionAttribute
+        Inherits Attribute
+    End Class
+
+End Namespace
+
+                    </file>
+                </compilation>
+
+            Dim compilationA = CreateCompilationWithMscorlibAndVBRuntime(source)
+
+            Dim referenceA = MetadataReference.CreateFromStream(compilationA.EmitToStream())
+
+            Dim compilationB = CreateCompilationWithMscorlib(New String() {<![CDATA[
+Class B 
+
+    Sub Main() 
+    
+        Dim t = New A().M()
+
+    End Sub
+End Class
+]]>.Value}, New MetadataReference() {referenceA}, TestOptions.ReleaseDll.WithMetadataImportOptions(MetadataImportOptions.All))
+
+            Dim syntaxTree = compilationB.SyntaxTrees(0)
+            Dim semanticModel = compilationB.GetSemanticModel(syntaxTree, suppressAccessChecks:=True)
+
+            Dim invocation = syntaxTree.GetRoot().DescendantNodes().OfType(Of InvocationExpressionSyntax)().Single()
+
+            Assert.Equal("A", semanticModel.GetTypeInfo(invocation).Type.Name)
+            Assert.Equal("M", semanticModel.GetSymbolInfo(invocation).Symbol.Name)
+
+            Dim speculativeInvocation = SyntaxFactory.ParseExpression("new A().InternalExtension(67)")
+            Dim position = invocation.FullSpan.Start
+
+            Assert.Equal("Int32", semanticModel.GetSpeculativeTypeInfo(position, speculativeInvocation, SpeculativeBindingOption.BindAsExpression).Type.Name)
+            Assert.Equal("InternalExtension", semanticModel.GetSpeculativeSymbolInfo(position, speculativeInvocation, SpeculativeBindingOption.BindAsExpression).Symbol.Name)
+
+            Assert.NotNull(semanticModel.LookupSymbols(position, name:="A"))
+        End Sub
+
+        <Fact>
+        Public Sub TestGetSpeculativeSemanticModelForPropertyAccessorBody()
+
+            Dim source = <![CDATA[
+Class R
+
+    Private _p As Integer
+
+End Class
+
+Class C
+    Inherits R 
+    
+    Private Property M As Integer
+        Set
+            Dim y As Integer = 1000
+        End Set
+    End Property
+End Class
+]]>.Value
+
+            Dim treet = SyntaxFactory.ParseSyntaxTree(source)
+
+            Dim compilationA = CreateCompilationWithMscorlib(treet)
+
+            Dim blockStatement = SyntaxFactory.ParseSyntaxTree(<![CDATA[
+                                                               
+    Private Property M As Integer
+        Set
+           Dim z As Integer = 0
+
+           _p = 123
+        End Set
+    End Property
+]]>.Value).GetRoot()
+
+            Dim tree = compilationA.SyntaxTrees(0)
+            Dim root = tree.GetCompilationUnitRoot()
+            Dim typeDecl = DirectCast(root.Members(1), ClassBlockSyntax)
+            Dim propertyDecl = DirectCast(typeDecl.Members(0), PropertyBlockSyntax)
+            Dim methodDecl = propertyDecl.Accessors(0)
+            Dim model = compilationA.GetSemanticModel(tree, suppressAccessChecks:=True)
+
+            Dim speculatedMethod =
+                propertyDecl.ReplaceNode(propertyDecl.Accessors(0), blockStatement.ChildNodes().OfType(Of PropertyBlockSyntax).Single().Accessors(0))
+
+            Dim speculativeModel As SemanticModel = Nothing
+
+            Dim success =
+                model.TryGetSpeculativeSemanticModelForMethodBody(
+                    methodDecl.Statements(0).SpanStart, speculatedMethod.Accessors(0), speculativeModel)
+
+            Assert.True(success)
+            Assert.NotNull(speculativeModel)
+
+            Dim privateCandidate =
+                speculativeModel.SyntaxTree.GetRoot() _
+                .DescendantNodes() _
+                .OfType(Of IdentifierNameSyntax)() _
+                .Single(Function(s) s.Identifier.ValueText = "_p")
+
+            Dim symbolSpeculation =
+                speculativeModel.GetSpeculativeSymbolInfo(privateCandidate.FullSpan.Start, privateCandidate,
+                    SpeculativeBindingOption.BindAsExpression)
+
+            Dim typeSpeculation =
+                speculativeModel.GetSpeculativeTypeInfo(privateCandidate.FullSpan.Start, privateCandidate,
+                                SpeculativeBindingOption.BindAsExpression)
+
+            Assert.Equal("_p", symbolSpeculation.Symbol.Name)
+            Assert.Equal("Int32", typeSpeculation.Type.Name)
+
+        End Sub
+    End Class
+End Namespace
\ No newline at end of file

src/Compilers/CSharp/Portable/Binder/Binder.cs

@@ -614,13 +614,6 @@ private static ThreeState ReportDiagnosticsIfObsoleteInternal(DiagnosticBag diag
             AssemblySymbol within,
             ref HashSet<DiagnosticInfo> useSiteDiagnostics)
         {
-            if (this.Flags.Includes(BinderFlags.SuppressAccessChecks))
-            {
-                // This is an untested code path. If we
-                // reach here, add a corresponding test.
-                throw ExceptionUtilities.Unreachable;
-            }
-
             return AccessCheck.IsSymbolAccessible(symbol, within, ref useSiteDiagnostics);
         }
 
@@ -630,10 +623,6 @@ private static ThreeState ReportDiagnosticsIfObsoleteInternal(DiagnosticBag diag
             ref HashSet<DiagnosticInfo> useSiteDiagnostics,
             TypeSymbol throughTypeOpt = null)
         {
-            if (this.Flags.Includes(BinderFlags.SuppressAccessChecks))
-            {
-                return true;
-            }
             return AccessCheck.IsSymbolAccessible(symbol, within, ref useSiteDiagnostics, throughTypeOpt);
         }
 
@@ -645,11 +634,6 @@ private static ThreeState ReportDiagnosticsIfObsoleteInternal(DiagnosticBag diag
             ref HashSet<DiagnosticInfo> useSiteDiagnostics,
             ConsList<Symbol> basesBeingResolved = null)
         {
-            if (this.Flags.Includes(BinderFlags.SuppressAccessChecks))
-            {
-                failedThroughTypeCheck = false;
-                return true;
-            }
             return AccessCheck.IsSymbolAccessible(symbol, within, throughTypeOpt, out failedThroughTypeCheck, ref useSiteDiagnostics, basesBeingResolved);
         }
 

src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs

@@ -1262,6 +1262,12 @@ internal bool IsAccessible(Symbol symbol, ref HashSet<DiagnosticInfo> useSiteDia
         /// </summary>
         internal virtual bool IsAccessible(Symbol symbol, TypeSymbol accessThroughType, out bool failedThroughTypeCheck, ref HashSet<DiagnosticInfo> useSiteDiagnostics, ConsList<Symbol> basesBeingResolved = null)
         {
+            if (this.Flags.Includes(BinderFlags.SuppressAccessChecks))
+            {
+                failedThroughTypeCheck = false;
+                return true;
+            }
+
             // By default, just delegate to containing binder.
             return Next.IsAccessible(symbol, accessThroughType, out failedThroughTypeCheck, ref useSiteDiagnostics, basesBeingResolved);
         }

src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs

@@ -1628,7 +1628,7 @@ internal PointerTypeSymbol CreatePointerTypeSymbol(TypeSymbol elementType)
         /// <summary>
         /// Gets a new SyntaxTreeSemanticModel for the specified syntax tree.
         /// </summary>
-        public new SemanticModel GetSemanticModel(SyntaxTree syntaxTree)
+        public new SemanticModel GetSemanticModel(SyntaxTree syntaxTree, bool suppressAccessChecks)
         {
             if (syntaxTree == null)
             {
@@ -1640,7 +1640,7 @@ public new SemanticModel GetSemanticModel(SyntaxTree syntaxTree)
                 throw new ArgumentException("tree");
             }
 
-            return new SyntaxTreeSemanticModel(this, (SyntaxTree)syntaxTree);
+            return new SyntaxTreeSemanticModel(this, (SyntaxTree)syntaxTree, suppressAccessChecks);
         }
 
         // When building symbols from the declaration table (lazily), or inside a type, or when
@@ -2729,9 +2729,9 @@ protected override Compilation CommonPreviousSubmission
             get { return _previousSubmission; }
         }
 
-        protected override SemanticModel CommonGetSemanticModel(SyntaxTree syntaxTree)
+        protected override SemanticModel CommonGetSemanticModel(SyntaxTree syntaxTree, bool suppressAccessChecks)
         {
-            return this.GetSemanticModel((SyntaxTree)syntaxTree);
+            return this.GetSemanticModel((SyntaxTree)syntaxTree, suppressAccessChecks);
         }
 
         protected override IEnumerable<SyntaxTree> CommonSyntaxTrees

src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs

@@ -51,6 +51,7 @@ internal abstract class CSharpSemanticModel : SemanticModel
         /// </summary>
         internal abstract CSharpSyntaxNode Root { get; }
 
+
         // Is this node one that could be successfully interrogated by GetSymbolInfo/GetTypeInfo/GetMemberGroup/GetConstantValue?
         // WARN: If isSpeculative is true, then don't look at .Parent - there might not be one.
         internal static bool CanGetSemanticInfo(CSharpSyntaxNode node, bool allowNamedArgumentName = false, bool isSpeculative = false)
@@ -2747,6 +2748,13 @@ internal Conversion ClassifyConversionForCast(int position, ExpressionSyntax exp
         /// <param name="typeParameter"></param>
         public abstract ITypeParameterSymbol GetDeclaredSymbol(TypeParameterSyntax typeParameter, CancellationToken cancellationToken = default(CancellationToken));
 
+        internal BinderFlags GetSemanticModelBinderFlags()
+        {
+            return this.HasAccessChecksSuppressed
+                ? BinderFlags.SemanticModel | BinderFlags.SuppressAccessChecks
+                : BinderFlags.SemanticModel;
+        }
+
         /// <summary>
         /// Given a foreach statement, get the symbol for the iteration variable
         /// </summary>
@@ -2771,7 +2779,7 @@ public ILocalSymbol GetDeclaredSymbol(ForEachStatementSyntax forEachStatement, C
                     return null;
                 }
 
-                foreachBinder = foreachBinder.WithAdditionalFlags(BinderFlags.SemanticModel);
+                foreachBinder = foreachBinder.WithAdditionalFlags(GetSemanticModelBinderFlags());
                 LocalSymbol local = foreachBinder.Locals.FirstOrDefault();
                 return ((object)local != null && local.DeclarationKind == LocalDeclarationKind.ForEachIterationVariable)
                     ? local
@@ -2805,7 +2813,7 @@ public ILocalSymbol GetDeclaredSymbol(CatchDeclarationSyntax catchDeclaration, C
                     return null;
                 }
 
-                catchBinder = catchBinder.WithAdditionalFlags(BinderFlags.SemanticModel);
+                catchBinder = enclosingBinder.GetBinder(catchClause).WithAdditionalFlags(GetSemanticModelBinderFlags());
                 LocalSymbol local = catchBinder.Locals.FirstOrDefault();
                 return ((object)local != null && local.DeclarationKind == LocalDeclarationKind.CatchVariable)
                     ? local

src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs

@@ -42,7 +42,7 @@ protected MemberSemanticModel(CSharpCompilation compilation, CSharpSyntaxNode ro
             _compilation = compilation;
             _root = root;
             _memberSymbol = memberSymbol;
-            this.RootBinder = rootBinder.WithAdditionalFlags(BinderFlags.SemanticModel);
+            this.RootBinder = rootBinder.WithAdditionalFlags(GetSemanticModelBinderFlags());
             _parentSemanticModelOpt = parentSemanticModelOpt;
             _speculatedPosition = speculatedPosition;
         }
@@ -241,7 +241,7 @@ private Binder GetEnclosingBinder(CSharpSyntaxNode node, int position)
                 binder = new TypeofBinder(typeOfArgument, binder);
             }
 
-            return binder.WithAdditionalFlags(BinderFlags.SemanticModel);
+            return binder.WithAdditionalFlags(GetSemanticModelBinderFlags());
         }
 
         private static Binder AdjustBinderForPositionWithinStatement(int position, Binder binder, StatementSyntax stmt)
@@ -1223,7 +1223,7 @@ internal override Binder GetEnclosingBinderInternal(int position)
             }
 
             Debug.Assert(result != null);
-            return result.WithAdditionalFlags(BinderFlags.SemanticModel);
+            return result.WithAdditionalFlags(GetSemanticModelBinderFlags());
         }
 
         /// <remarks>

src/Compilers/CSharp/Portable/Compilation/MethodBodySemanticModel.cs

@@ -97,7 +97,7 @@ private bool GetSpeculativeSemanticModelForMethodBody(SyntaxTreeSemanticModel pa
 
             var methodSymbol = (MethodSymbol)this.MemberSymbol;
             var executablebinder = new ExecutableCodeBinder(body, methodSymbol, this.RootBinder.Next); // Strip off ExecutableCodeBinder (see ctor).
-            var blockBinder = executablebinder.GetBinder(body).WithAdditionalFlags(BinderFlags.SemanticModel);
+            var blockBinder = executablebinder.GetBinder(body).WithAdditionalFlags(GetSemanticModelBinderFlags());
             speculativeModel = CreateSpeculative(parentModel, methodSymbol, body, blockBinder, position);
             return true;
         }

src/Compilers/CSharp/Portable/Compilation/SyntaxTreeSemanticModel.cs

@@ -26,13 +26,16 @@ internal partial class SyntaxTreeSemanticModel : CSharpSemanticModel
 
         private readonly BinderFactory _binderFactory;
         private Func<CSharpSyntaxNode, MemberSemanticModel> _createMemberModelFunction;
+        private readonly bool _hasAccessChecksSuppressed;
 
         private static readonly Func<CSharpSyntaxNode, bool> s_isMemberDeclarationFunction = IsMemberDeclaration;
 
-        internal SyntaxTreeSemanticModel(CSharpCompilation compilation, SyntaxTree syntaxTree)
+        internal SyntaxTreeSemanticModel(CSharpCompilation compilation, SyntaxTree syntaxTree, bool suppressAccessChecks = false)
         {
             _compilation = compilation;
             _syntaxTree = syntaxTree;
+            _hasAccessChecksSuppressed = suppressAccessChecks;
+
             if (!this.Compilation.SyntaxTrees.Contains(syntaxTree))
             {
                 throw new ArgumentOutOfRangeException("tree", CSharpResources.TreeNotPartOfCompilation);
@@ -81,6 +84,14 @@ public override SyntaxTree SyntaxTree
             }
         }
 
+        /// <summary>
+        /// Returns true if this is a SemanticModel that ignores accessibility rules when answering semantic questions.
+        /// </summary>
+        public override bool HasAccessChecksSuppressed
+        {
+            get { return _hasAccessChecksSuppressed; }
+        }
+
         private void VerifySpanForGetDiagnostics(TextSpan? span)
         {
             if (span.HasValue && !this.Root.FullSpan.Contains(span.Value))
@@ -143,7 +154,7 @@ internal override Binder GetEnclosingBinderInternal(int position)
             // the binder for the compilation unit.
             if (position == 0 && position != token.SpanStart)
             {
-                return _binderFactory.GetBinder(this.Root, position).WithAdditionalFlags(BinderFlags.SemanticModel);
+                return _binderFactory.GetBinder(this.Root, position).WithAdditionalFlags(GetSemanticModelBinderFlags());
             }
 
             MemberSemanticModel memberModel = GetMemberModel(position);
@@ -152,7 +163,7 @@ internal override Binder GetEnclosingBinderInternal(int position)
                 return memberModel.GetEnclosingBinder(position);
             }
 
-            return _binderFactory.GetBinder((CSharpSyntaxNode)token.Parent, position).WithAdditionalFlags(BinderFlags.SemanticModel);
+            return _binderFactory.GetBinder((CSharpSyntaxNode)token.Parent, position).WithAdditionalFlags(GetSemanticModelBinderFlags());
         }
 
         internal override SymbolInfo GetSymbolInfoWorker(CSharpSyntaxNode node, SymbolInfoOptions options, CancellationToken cancellationToken = default(CancellationToken))
@@ -891,6 +902,12 @@ private MemberSemanticModel GetOrAddModel(CSharpSyntaxNode node)
         private MemberSemanticModel CreateMemberModel(CSharpSyntaxNode node)
         {
             var outer = _binderFactory.GetBinder(node);
+
+            if (this.HasAccessChecksSuppressed)
+            {
+                outer = outer.WithAdditionalFlags(BinderFlags.SuppressAccessChecks);
+            }
+
             switch (node.Kind())
             {
                 case SyntaxKind.Block:

src/Compilers/CSharp/Portable/PublicAPI.txt

@@ -10,7 +10,7 @@ Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Clone()
 Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree syntaxTree)
 Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDirectiveReference(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax directive)
 Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol assemblySymbol)
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree)
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree, bool suppressAccessChecks)
 Microsoft.CodeAnalysis.CSharp.CSharpCompilation.LanguageVersion.get
 Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Options.get
 Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllReferences()
@@ -2436,7 +2436,7 @@ override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetAssemblyOrModu
 override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol namespaceSymbol)
 override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetEntryPoint(System.Threading.CancellationToken cancellationToken)
 override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol assemblySymbol)
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree)
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree, bool suppressAccessChecks)
 override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetSpecialType(Microsoft.CodeAnalysis.SpecialType specialType)
 override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetSubmissionResultType(out bool hasValue)
 override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CommonGetTypeByMetadataName(string metadataName)

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

@@ -128,6 +128,7 @@
     <Compile Include="Semantics\SemanticAnalyzerTests.cs" />
     <Compile Include="Semantics\SemanticErrorTests.cs" />
     <Compile Include="Semantics\StructsTests.cs" />
+    <Compile Include="Semantics\SupressAccessibilityChecksTests.cs" />
     <Compile Include="Semantics\SwitchTests.cs" />
     <Compile Include="Semantics\SyntaxTreeRootTests.cs" />
     <Compile Include="Semantics\SynthesizedStaticConstructorTests.cs" />

src/Compilers/Core/Portable/Compilation/Compilation.cs

@@ -159,12 +159,16 @@ public Compilation Clone()
         /// <summary>
         /// Gets a new <see cref="SemanticModel"/> for the specified syntax tree.
         /// </summary>
-        public SemanticModel GetSemanticModel(SyntaxTree syntaxTree)
+        /// <param name="syntaxTree">The specificed syntax tree.</param>
+        /// <param name="suppressAccessChecks">
+        /// True if the SemanticModel should ignore accessibility rules when answering semantic questions.
+		/// </param>
+        public SemanticModel GetSemanticModel(SyntaxTree syntaxTree, bool suppressAccessChecks = false)
         {
-            return CommonGetSemanticModel(syntaxTree);
+            return CommonGetSemanticModel(syntaxTree, suppressAccessChecks);
         }
 
-        protected abstract SemanticModel CommonGetSemanticModel(SyntaxTree syntaxTree);
+        protected abstract SemanticModel CommonGetSemanticModel(SyntaxTree syntaxTree, bool suppressAccessChecks);
 
         /// <summary>
         /// Returns a new INamedTypeSymbol representing an error type with the given name and arity

src/Compilers/Core/Portable/Compilation/SemanticModel.cs

@@ -62,6 +62,14 @@ public SyntaxTree SyntaxTree
         /// </summary>
         protected abstract SyntaxTree SyntaxTreeCore { get; }
 
+        /// <summary>
+        /// Returns true if this is a SemanticModel that ignores accessibility rules when answering semantic questions.
+        /// </summary>
+        public virtual bool HasAccessChecksSuppressed
+        {
+            get { return false; }
+        }
+
         /// <summary>
         /// Gets symbol information about a syntax node.
         /// </summary>

src/Compilers/Core/Portable/PublicAPI.txt

@@ -117,7 +117,7 @@ Microsoft.CodeAnalysis.Compilation.GetAssemblyOrModuleSymbol(Microsoft.CodeAnaly
 Microsoft.CodeAnalysis.Compilation.GetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol namespaceSymbol)
 Microsoft.CodeAnalysis.Compilation.GetEntryPoint(System.Threading.CancellationToken cancellationToken)
 Microsoft.CodeAnalysis.Compilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol assemblySymbol)
-Microsoft.CodeAnalysis.Compilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree)
+Microsoft.CodeAnalysis.Compilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree, bool suppressAccessChecks = false)
 Microsoft.CodeAnalysis.Compilation.GetSpecialType(Microsoft.CodeAnalysis.SpecialType specialType)
 Microsoft.CodeAnalysis.Compilation.GetSubmissionResultType(out bool hasValue)
 Microsoft.CodeAnalysis.Compilation.GetTypeByMetadataName(string fullyQualifiedMetadataName)
@@ -1448,7 +1448,7 @@ abstract Microsoft.CodeAnalysis.Compilation.CommonGetAssemblyOrModuleSymbol(Micr
 abstract Microsoft.CodeAnalysis.Compilation.CommonGetCompilationNamespace(Microsoft.CodeAnalysis.INamespaceSymbol namespaceSymbol)
 abstract Microsoft.CodeAnalysis.Compilation.CommonGetEntryPoint(System.Threading.CancellationToken cancellationToken)
 abstract Microsoft.CodeAnalysis.Compilation.CommonGetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol assemblySymbol)
-abstract Microsoft.CodeAnalysis.Compilation.CommonGetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree)
+abstract Microsoft.CodeAnalysis.Compilation.CommonGetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree, bool suppressAccessChecks)
 abstract Microsoft.CodeAnalysis.Compilation.CommonGetSpecialType(Microsoft.CodeAnalysis.SpecialType specialType)
 abstract Microsoft.CodeAnalysis.Compilation.CommonGetSubmissionResultType(out bool hasValue)
 abstract Microsoft.CodeAnalysis.Compilation.CommonGetTypeByMetadataName(string metadataName)
@@ -2060,6 +2060,7 @@ virtual Microsoft.CodeAnalysis.Location.MetadataModule.get
 virtual Microsoft.CodeAnalysis.Location.SourceSpan.get
 virtual Microsoft.CodeAnalysis.Location.SourceTree.get
 virtual Microsoft.CodeAnalysis.MetadataReference.Display.get
+virtual Microsoft.CodeAnalysis.SemanticModel.HasAccessChecksSuppressed.get
 virtual Microsoft.CodeAnalysis.SemanticModel.GetTopmostNodeForDiagnosticAnalysis(Microsoft.CodeAnalysis.ISymbol symbol, Microsoft.CodeAnalysis.SyntaxNode declaringSyntax)
 virtual Microsoft.CodeAnalysis.SymbolVisitor.DefaultVisit(Microsoft.CodeAnalysis.ISymbol symbol)
 virtual Microsoft.CodeAnalysis.SymbolVisitor.Visit(Microsoft.CodeAnalysis.ISymbol symbol)

src/Compilers/VisualBasic/Portable/Binding/AttributeSemanticModel.vb

@@ -11,15 +11,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Friend NotInheritable Class AttributeSemanticModel
         Inherits MemberSemanticModel
 
-        Private Sub New(root As VisualBasicSyntaxNode, binder As Binder, Optional parentSemanticModelOpt As SyntaxTreeSemanticModel = Nothing, Optional speculatedPosition As Integer = 0)
-            MyBase.New(root, binder, parentSemanticModelOpt, speculatedPosition)
+        Private Sub New(root As VisualBasicSyntaxNode, binder As Binder, Optional parentSemanticModelOpt As SyntaxTreeSemanticModel = Nothing, Optional speculatedPosition As Integer = 0, Optional isSupressingAccessChecks As Boolean = False)
+            MyBase.New(root, binder, parentSemanticModelOpt, speculatedPosition, isSupressingAccessChecks)
         End Sub
 
         ''' <summary>
         ''' Creates an AttributeSemanticModel that allows asking semantic questions about an attribute node.
         ''' </summary>
-        Friend Shared Function Create(binder As AttributeBinder) As AttributeSemanticModel
-            Return New AttributeSemanticModel(binder.Root, binder)
+        Friend Shared Function Create(binder As AttributeBinder, Optional isSupressingAccessChecks As Boolean = False) As AttributeSemanticModel
+            Return New AttributeSemanticModel(binder.Root, binder, isSupressingAccessChecks:=isSupressingAccessChecks)
         End Function
 
         ''' <summary>

src/Compilers/VisualBasic/Portable/Binding/Binder.vb

@@ -114,7 +114,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return m_containingBinder.BinderSpecificLookupOptions(options)
         End Function
 
-        Protected ReadOnly Property IgnoresAccessibility As Boolean
+        Friend ReadOnly Property IgnoresAccessibility As Boolean
             Get
                 Return (BinderSpecificLookupOptions(Nothing) And LookupOptions.IgnoreAccessibility) =
                     LookupOptions.IgnoreAccessibility

src/Compilers/VisualBasic/Portable/Binding/InitializerSemanticModel.vb

@@ -10,15 +10,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Friend NotInheritable Class InitializerSemanticModel
         Inherits MemberSemanticModel
 
-        Private Sub New(root As VisualBasicSyntaxNode, binder As Binder, Optional parentSemanticModelOpt As SyntaxTreeSemanticModel = Nothing, Optional speculatedPosition As Integer = 0)
-            MyBase.New(root, binder, parentSemanticModelOpt, speculatedPosition)
+        Private Sub New(root As VisualBasicSyntaxNode, binder As Binder, Optional parentSemanticModelOpt As SyntaxTreeSemanticModel = Nothing, Optional speculatedPosition As Integer = 0, Optional isSupressingAccessChecks As Boolean = False)
+            MyBase.New(root, binder, parentSemanticModelOpt, speculatedPosition, isSupressingAccessChecks)
         End Sub
 
         ''' <summary>
         ''' Creates an InitializerSemanticModel that allows asking semantic questions about an initializer node.
         ''' </summary>
-        Friend Shared Function Create(binder As DeclarationInitializerBinder) As InitializerSemanticModel
-            Return New InitializerSemanticModel(binder.Root, binder)
+        Friend Shared Function Create(binder As DeclarationInitializerBinder, Optional isSupressingAccessChecks As Boolean = False) As InitializerSemanticModel
+            Return New InitializerSemanticModel(binder.Root, binder, isSupressingAccessChecks:=isSupressingAccessChecks)
         End Function
 
         ''' <summary>

src/Compilers/VisualBasic/Portable/Binding/MemberSemanticModel.vb

@@ -22,12 +22,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ' Fields specific to speculative MemberSemanticModel
         Private ReadOnly m_parentSemanticModelOpt As SyntaxTreeSemanticModel
         Private ReadOnly m_speculatedPosition As Integer
+        Private ReadOnly m_hasAccessChecksSuppressed As Boolean
 
-        Friend Sub New(root As VisualBasicSyntaxNode, rootBinder As Binder, parentSemanticModelOpt As SyntaxTreeSemanticModel, speculatedPosition As Integer)
+        Friend Sub New(root As VisualBasicSyntaxNode, rootBinder As Binder, parentSemanticModelOpt As SyntaxTreeSemanticModel, speculatedPosition As Integer, Optional isSupressingAccessChecks As Boolean = False)
             Debug.Assert(parentSemanticModelOpt Is Nothing OrElse Not parentSemanticModelOpt.IsSpeculativeSemanticModel, VBResources.ChainingSpeculativeModelIsNotSupported)
 
             m_Root = root
-            m_RootBinder = SemanticModelBinder.Mark(rootBinder)
+            m_hasAccessChecksSuppressed = isSupressingAccessChecks
+            m_RootBinder = SemanticModelBinder.Mark(rootBinder, isSupressingAccessChecks)
             m_parentSemanticModelOpt = parentSemanticModelOpt
             m_speculatedPosition = speculatedPosition
         End Sub
@@ -62,16 +64,22 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
+        Public NotOverridable Overrides ReadOnly Property HasAccessChecksSuppressed As Boolean
+            Get
+                Return Me.m_hasAccessChecksSuppressed
+            End Get
+        End Property
+
         Friend NotOverridable Overloads Overrides Function GetEnclosingBinder(position As Integer) As Binder
             Dim binder = GetEnclosingBinderInternal(Me.RootBinder, Me.Root, FindInitialNodeFromPosition(position), position)
             Debug.Assert(binder IsNot Nothing)
-            Return SemanticModelBinder.Mark(binder)
+            Return SemanticModelBinder.Mark(binder, HasAccessChecksSuppressed)
         End Function
 
         Private Overloads Function GetEnclosingBinder(node As VisualBasicSyntaxNode) As Binder
             Dim binder = GetEnclosingBinderInternal(Me.RootBinder, Me.Root, node, node.SpanStart)
             Debug.Assert(binder IsNot Nothing)
-            Return SemanticModelBinder.Mark(binder)
+            Return SemanticModelBinder.Mark(binder, HasAccessChecksSuppressed)
         End Function
 
         ' Get the bound node corresponding to the root.

src/Compilers/VisualBasic/Portable/Binding/MethodBodySemanticModel.vb

@@ -9,15 +9,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Friend NotInheritable Class MethodBodySemanticModel
         Inherits MemberSemanticModel
 
-        Private Sub New(root As VisualBasicSyntaxNode, binder As Binder, Optional parentSemanticModelOpt As SyntaxTreeSemanticModel = Nothing, Optional speculatedPosition As Integer = 0)
-            MyBase.New(root, binder, parentSemanticModelOpt, speculatedPosition)
+        Private Sub New(root As VisualBasicSyntaxNode, binder As Binder, Optional parentSemanticModelOpt As SyntaxTreeSemanticModel = Nothing, Optional speculatedPosition As Integer = 0, Optional isSupressingAccessChecks As Boolean = False)
+            MyBase.New(root, binder, parentSemanticModelOpt, speculatedPosition, isSupressingAccessChecks:=isSupressingAccessChecks)
         End Sub
 
         ''' <summary>
         ''' Creates an MethodBodySemanticModel that allows asking semantic questions about an attribute node.
         ''' </summary>
-        Friend Shared Function Create(binder As MethodBodyBinder) As MethodBodySemanticModel
-            Return New MethodBodySemanticModel(binder.Root, binder)
+        Friend Shared Function Create(binder As MethodBodyBinder, Optional isSupressingAccessChecks As Boolean = False) As MethodBodySemanticModel
+            Return New MethodBodySemanticModel(binder.Root, binder, isSupressingAccessChecks:=isSupressingAccessChecks)
         End Function
 
         ''' <summary>
@@ -53,7 +53,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 containingBinder = containingBinder.ContainingBinder
             Loop
 
-            Dim methodBodyBinder = BinderBuilder.CreateBinderForMethodBody(methodSymbol, method, SemanticModelBinder.Mark(namedTypeBinder))
+            Dim methodBodyBinder = BinderBuilder.CreateBinderForMethodBody(methodSymbol, method, SemanticModelBinder.Mark(namedTypeBinder, HasAccessChecksSuppressed))
 
             ' Wrap this binder with a BlockBaseBinder to hold onto the locals declared within the statement.
             Dim binder = New StatementListBinder(methodBodyBinder, method.Statements)
@@ -91,8 +91,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Friend NotInheritable Class TopLevelCodeSemanticModel
         Inherits MemberSemanticModel
 
-        Public Sub New(binder As TopLevelCodeBinder)
-            MyBase.New(binder.Root, binder, parentSemanticModelOpt:=Nothing, speculatedPosition:=0)
+        Public Sub New(binder As TopLevelCodeBinder, Optional isSupressingAccessChecks As Boolean = False)
+            MyBase.New(binder.Root, binder, parentSemanticModelOpt:=Nothing, speculatedPosition:=0, isSupressingAccessChecks:=isSupressingAccessChecks)
         End Sub
 
         Friend Overrides Function TryGetSpeculativeSemanticModelForMethodBodyCore(parentModel As SyntaxTreeSemanticModel, position As Integer, method As MethodBlockBaseSyntax, <Out> ByRef speculativeModel As SemanticModel) As Boolean

src/Compilers/VisualBasic/Portable/Binding/SemanticModelBinder.vb

@@ -8,15 +8,27 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Friend Class SemanticModelBinder
         Inherits Binder
 
-        Protected Sub New(containingBinder As Binder)
+        Private ReadOnly _ignoreAccessibility As Boolean = False
+
+        Protected Sub New(containingBinder As Binder, Optional ignoreAccessibility As Boolean = False)
             MyBase.New(containingBinder)
+
+            _ignoreAccessibility = ignoreAccessibility
         End Sub
 
-        Public Shared Function Mark(binder As Binder) As Binder
+        Public Shared Function Mark(binder As Binder, Optional ignoreAccessibility As Boolean = False) As Binder
             Return If(
-                binder.IsSemanticModelBinder,
+                binder.IsSemanticModelBinder AndAlso binder.IgnoresAccessibility = ignoreAccessibility,
                 binder,
-                New SemanticModelBinder(binder))
+                New SemanticModelBinder(binder, ignoreAccessibility))
+        End Function
+
+        Friend Overrides Function BinderSpecificLookupOptions(ByVal options As LookupOptions) As LookupOptions
+            If (_ignoreAccessibility) Then
+                Return MyBase.BinderSpecificLookupOptions(options) Or LookupOptions.IgnoreAccessibility
+            Else
+                Return MyBase.BinderSpecificLookupOptions(options)
+            End If
         End Function
 
         Public NotOverridable Overrides ReadOnly Property IsSemanticModelBinder As Boolean

src/Compilers/VisualBasic/Portable/Compilation/SyntaxTreeSemanticModel.vb

@@ -25,14 +25,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Private ReadOnly _sourceModule As SourceModuleSymbol
         Private ReadOnly _syntaxTree As SyntaxTree
         Private ReadOnly _binderFactory As BinderFactory
+        Private ReadOnly _hasAccessChecksSuppressed As Boolean
 
         ' maps from a higher-level binder to an appropriate SemanticModel for the construct (such as a method, or initializer).
-        Private ReadOnly _semanticModelCache As New ConcurrentDictionary(Of Binder, MemberSemanticModel)()
+        Private ReadOnly _semanticModelCache As New ConcurrentDictionary(Of Tuple(Of Binder, Boolean), MemberSemanticModel)()
 
-        Friend Sub New(compilation As VisualBasicCompilation, sourceModule As SourceModuleSymbol, syntaxTree As SyntaxTree)
+        Friend Sub New(compilation As VisualBasicCompilation, sourceModule As SourceModuleSymbol, syntaxTree As SyntaxTree, Optional suppressAccessChecks As Boolean = False)
             _compilation = compilation
             _sourceModule = sourceModule
             _syntaxTree = syntaxTree
+            _hasAccessChecksSuppressed = suppressAccessChecks
             _binderFactory = New BinderFactory(sourceModule, syntaxTree)
         End Sub
 
@@ -63,6 +65,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
+        ''' <summary>
+        ''' Returns true if this Is a SemanticModel that ignores accessibility rules when answering semantic questions.
+        ''' </summary>
+        Public NotOverridable Overrides ReadOnly Property HasAccessChecksSuppressed As Boolean
+            Get
+                Return Me._hasAccessChecksSuppressed
+            End Get
+        End Property
+
+
         ''' <summary>
         ''' Get all the errors within the syntax tree associated with this object. Includes errors involving compiling
         ''' method bodies or initializers, in addition to the errors returned by GetDeclarationDiagnostics and parse errors.
@@ -131,27 +143,27 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         End Function
 
         ' PERF: These shared variables avoid repeated allocation of Func(Of Binder, MemberSemanticModel) in GetMemberSemanticModel
-        Private Shared ReadOnly _methodBodySemanticModelCreator As Func(Of Binder, MemberSemanticModel) = Function(key As Binder) MethodBodySemanticModel.Create(DirectCast(key, MethodBodyBinder))
-        Private Shared ReadOnly _initializerSemanticModelCreator As Func(Of Binder, MemberSemanticModel) = Function(key As Binder) InitializerSemanticModel.Create(DirectCast(key, DeclarationInitializerBinder))
-        Private Shared ReadOnly _attributeSemanticModelCreator As Func(Of Binder, MemberSemanticModel) = Function(key As Binder) AttributeSemanticModel.Create(DirectCast(key, AttributeBinder))
-        Private Shared ReadOnly _topLevelCodeSemanticModelCreator As Func(Of Binder, MemberSemanticModel) = Function(key As Binder) New TopLevelCodeSemanticModel(DirectCast(key, TopLevelCodeBinder))
+        Private Shared ReadOnly _methodBodySemanticModelCreator As Func(Of Tuple(Of Binder, Boolean), MemberSemanticModel) = Function(key As Tuple(Of Binder, Boolean)) MethodBodySemanticModel.Create(DirectCast(key.Item1, MethodBodyBinder), key.Item2)
+        Private Shared ReadOnly _initializerSemanticModelCreator As Func(Of Tuple(Of Binder, Boolean), MemberSemanticModel) = Function(key As Tuple(Of Binder, Boolean)) InitializerSemanticModel.Create(DirectCast(key.Item1, DeclarationInitializerBinder), key.Item2)
+        Private Shared ReadOnly _attributeSemanticModelCreator As Func(Of Tuple(Of Binder, Boolean), MemberSemanticModel) = Function(key As Tuple(Of Binder, Boolean)) AttributeSemanticModel.Create(DirectCast(key.Item1, AttributeBinder), key.Item2)
+        Private Shared ReadOnly _topLevelCodeSemanticModelCreator As Func(Of Tuple(Of Binder, Boolean), MemberSemanticModel) = Function(key As Tuple(Of Binder, Boolean)) New TopLevelCodeSemanticModel(DirectCast(key.Item1, TopLevelCodeBinder), key.Item2)
 
         Public Function GetMemberSemanticModel(binder As Binder) As MemberSemanticModel
 
             If TypeOf binder Is MethodBodyBinder Then
-                Return _semanticModelCache.GetOrAdd(binder, _methodBodySemanticModelCreator)
+                Return _semanticModelCache.GetOrAdd(Tuple.Create(binder, HasAccessChecksSuppressed), _methodBodySemanticModelCreator)
             End If
 
             If TypeOf binder Is DeclarationInitializerBinder Then
-                Return _semanticModelCache.GetOrAdd(binder, _initializerSemanticModelCreator)
+                Return _semanticModelCache.GetOrAdd(Tuple.Create(binder, HasAccessChecksSuppressed), _initializerSemanticModelCreator)
             End If
 
             If TypeOf binder Is AttributeBinder Then
-                Return _semanticModelCache.GetOrAdd(binder, _attributeSemanticModelCreator)
+                Return _semanticModelCache.GetOrAdd(Tuple.Create(binder, HasAccessChecksSuppressed), _attributeSemanticModelCreator)
             End If
 
             If TypeOf binder Is TopLevelCodeBinder Then
-                Return _semanticModelCache.GetOrAdd(binder, _topLevelCodeSemanticModelCreator)
+                Return _semanticModelCache.GetOrAdd(Tuple.Create(binder, HasAccessChecksSuppressed), _topLevelCodeSemanticModelCreator)
             End If
 
             Return Nothing
@@ -177,7 +189,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Return model.GetEnclosingBinder(position)
             Else
                 Dim binder As binder = _binderFactory.GetBinderForPosition(FindInitialNodeFromPosition(position), position)
-                Return SemanticModelBinder.Mark(binder)
+                Return SemanticModelBinder.Mark(binder, HasAccessChecksSuppressed)
             End If
         End Function
 
@@ -571,7 +583,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End If
 
             Dim docCommentBinder = Me._binderFactory.GetBinderForPosition(node, node.SpanStart)
-            docCommentBinder = SemanticModelBinder.Mark(docCommentBinder)
+            docCommentBinder = SemanticModelBinder.Mark(docCommentBinder, HasAccessChecksSuppressed)
 
             If isCrefAttribute Then
                 Dim symbols As ImmutableArray(Of Symbol)

src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb

@@ -1829,8 +1829,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ''' which has a cache.  Therefore, one effectively clears the cache by discarding the
         ''' SemanticModel.
         '''</summary> 
-        Public Shadows Function GetSemanticModel(syntaxTree As SyntaxTree) As SemanticModel
-            Return New SyntaxTreeSemanticModel(Me, DirectCast(Me.SourceModule, SourceModuleSymbol), syntaxTree)
+        Public Shadows Function GetSemanticModel(syntaxTree As SyntaxTree, Optional suppressAccessChecks As Boolean = False) As SemanticModel
+            Return New SyntaxTreeSemanticModel(Me, DirectCast(Me.SourceModule, SourceModuleSymbol), syntaxTree, suppressAccessChecks)
         End Function
 
 #End Region
@@ -2504,8 +2504,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
-        Protected Overrides Function CommonGetSemanticModel(syntaxTree As SyntaxTree) As SemanticModel
-            Return Me.GetSemanticModel(syntaxTree)
+        Protected Overrides Function CommonGetSemanticModel(syntaxTree As SyntaxTree, suppressAccessChecks As Boolean) As SemanticModel
+            Return Me.GetSemanticModel(syntaxTree, suppressAccessChecks)
         End Function
 
         Protected Overrides ReadOnly Property CommonSyntaxTrees As IEnumerable(Of SyntaxTree)

src/Compilers/VisualBasic/Portable/PublicAPI.txt

@@ -3048,7 +3048,7 @@ Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.AddSyntaxTrees(trees A
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.ClassifyConversion(source As Microsoft.CodeAnalysis.ITypeSymbol, destination As Microsoft.CodeAnalysis.ITypeSymbol)
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.Clone()
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.ContainsSyntaxTree(syntaxTree As Microsoft.CodeAnalysis.SyntaxTree)
-Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.GetSemanticModel(syntaxTree As Microsoft.CodeAnalysis.SyntaxTree)
+Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.GetSemanticModel(syntaxTree As Microsoft.CodeAnalysis.SyntaxTree, suppressAccessChecks As Boolean = False)
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.LanguageVersion()
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.Options()
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.RemoveAllReferences()
@@ -4360,7 +4360,7 @@ Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CommonGetAss
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CommonGetCompilationNamespace(namespaceSymbol As Microsoft.CodeAnalysis.INamespaceSymbol)
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CommonGetEntryPoint(cancellationToken As System.Threading.CancellationToken)
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CommonGetMetadataReference(_assemblySymbol As Microsoft.CodeAnalysis.IAssemblySymbol)
-Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CommonGetSemanticModel(syntaxTree As Microsoft.CodeAnalysis.SyntaxTree)
+Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CommonGetSemanticModel(syntaxTree As Microsoft.CodeAnalysis.SyntaxTree, suppressAccessChecks As Boolean)
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CommonGetSpecialType(specialType As Microsoft.CodeAnalysis.SpecialType)
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CommonGetSubmissionResultType(ByRef hasValue As Boolean)
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CommonGetTypeByMetadataName(metadataName As String)

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

@@ -120,6 +120,7 @@
     <Compile Include="Binding\MethodBodyBindingTests.vb" />
     <Compile Include="Binding\SyncLockTests.vb" />
     <Compile Include="Binding\UsingTests.vb" />
+    <Compile Include="Compilation\SupressAccessibilityChecksTests.vb" />
     <Compile Include="Compilation\CompilationAPITests.vb" />
     <Compile Include="Compilation\GetSemanticInfoBrokenCodeTests.vb" />
     <Compile Include="Compilation\MyTemplateTests.vb" />