diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index 51181fe1c68f6cb88941f56e57bce47ac3c16745..402b5bfc745e2115ff67ca881e99344339230e03 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -1201,8 +1201,7 @@ private BoundStatement ChainImplicitStructConstructor(MethodSymbol methodSymbol,
                     lazyVariableSlotAllocator,
                     compilationState,
                     diagnostics,
-                    assignLocals: false,
-                    allowNonPublicTypeArguments: false);
+                    assignLocals: false);
             }
 
             if (bodyWithoutLambdas.HasErrors)
diff --git a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/ExpressionLambdaRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/ExpressionLambdaRewriter.cs
index c65e9d9c376b7ed3fe581dbe2b91d728e368adeb..1c1cdeec0b1c9e2ce71d47ed73989b4d93a85fc9 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/ExpressionLambdaRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/ExpressionLambdaRewriter.cs
@@ -14,7 +14,7 @@ internal class ExpressionLambdaRewriter // this is like a bound tree rewriter, b
         private readonly SyntheticBoundNodeFactory _bound;
         private readonly TypeMap _typeMap;
         private readonly Dictionary<ParameterSymbol, BoundExpression> _parameterMap = new Dictionary<ParameterSymbol, BoundExpression>();
-        private readonly bool _allowNonPublicTypeArguments;
+        private readonly bool _ignoreAccessibility;
 
         private NamedTypeSymbol _ExpressionType;
         private NamedTypeSymbol ExpressionType
@@ -92,10 +92,10 @@ private NamedTypeSymbol MemberInfoType
 
         private DiagnosticBag Diagnostics { get { return _bound.Diagnostics; } }
 
-        private ExpressionLambdaRewriter(TypeCompilationState compilationState, TypeMap typeMap, bool allowNonPublicTypeArguments, CSharpSyntaxNode node, DiagnosticBag diagnostics)
+        private ExpressionLambdaRewriter(TypeCompilationState compilationState, TypeMap typeMap, CSharpSyntaxNode node, DiagnosticBag diagnostics)
         {
             _bound = new SyntheticBoundNodeFactory(null, compilationState.Type, node, compilationState, diagnostics);
-            _allowNonPublicTypeArguments = allowNonPublicTypeArguments;
+            _ignoreAccessibility = compilationState.ModuleBuilderOpt.IgnoreAccessibility;
             _int32Type = _bound.SpecialType(SpecialType.System_Int32);
             _objectType = _bound.SpecialType(SpecialType.System_Object);
             _nullableType = _bound.SpecialType(SpecialType.System_Nullable_T);
@@ -104,11 +104,11 @@ private ExpressionLambdaRewriter(TypeCompilationState compilationState, TypeMap
             _typeMap = typeMap;
         }
 
-        internal static BoundNode RewriteLambda(BoundLambda node, TypeCompilationState compilationState, TypeMap typeMap, bool allowNonPublicTypeArguments, DiagnosticBag diagnostics)
+        internal static BoundNode RewriteLambda(BoundLambda node, TypeCompilationState compilationState, TypeMap typeMap, DiagnosticBag diagnostics)
         {
             try
             {
-                var r = new ExpressionLambdaRewriter(compilationState, typeMap, allowNonPublicTypeArguments, node.Syntax, diagnostics);
+                var r = new ExpressionLambdaRewriter(compilationState, typeMap, node.Syntax, diagnostics);
                 var result = r.VisitLambdaInternal(node);
                 if (node.Type != result.Type)
                 {
@@ -972,7 +972,7 @@ private BoundExpression ExprFactory(string name, params BoundExpression[] argume
 
         private BoundExpression ExprFactory(string name, ImmutableArray<TypeSymbol> typeArgs, params BoundExpression[] arguments)
         {
-            return _bound.StaticCall(_allowNonPublicTypeArguments ? BinderFlags.IgnoreAccessibility : BinderFlags.None, ExpressionType, name, typeArgs, arguments);
+            return _bound.StaticCall(_ignoreAccessibility ? BinderFlags.IgnoreAccessibility : BinderFlags.None, ExpressionType, name, typeArgs, arguments);
         }
 
         private BoundExpression ExprFactory(WellKnownMember method, ImmutableArray<TypeSymbol> typeArgs, params BoundExpression[] arguments)
diff --git a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
index 7bdc5c2149cb61fa929b2b165a94d514ca4f22dc..91010af790d5dc17ee938ac65eef1443bdf1af54 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
@@ -79,9 +79,6 @@ internal sealed partial class LambdaRewriter : MethodToClassRewriter
         // expression evaluator where the original locals are left as is.
         private readonly bool _assignLocals;
 
-        // Allow type arguments of constructed methods to be non-public.
-        private readonly bool _allowNonPublicTypeArguments;
-
         // The current method or lambda being processed.
         private MethodSymbol _currentMethod;
 
@@ -131,8 +128,7 @@ internal sealed partial class LambdaRewriter : MethodToClassRewriter
             VariableSlotAllocator slotAllocatorOpt,
             TypeCompilationState compilationState,
             DiagnosticBag diagnostics,
-            bool assignLocals,
-            bool allowNonPublicTypeArguments)
+            bool assignLocals)
             : base(slotAllocatorOpt, compilationState, diagnostics)
         {
             Debug.Assert(analysis != null);
@@ -147,7 +143,6 @@ internal sealed partial class LambdaRewriter : MethodToClassRewriter
             _currentMethod = method;
             _analysis = analysis;
             _assignLocals = assignLocals;
-            _allowNonPublicTypeArguments = allowNonPublicTypeArguments;
             _currentTypeParameters = method.TypeParameters;
             _currentLambdaBodyTypeMap = TypeMap.Empty;
             _innermostFramePointer = _currentFrameThis = thisParameterOpt;
@@ -179,7 +174,6 @@ protected override bool NeedsProxy(Symbol localOrParameter)
         /// <param name="compilationState">The caller's buffer into which we produce additional methods to be emitted by the caller</param>
         /// <param name="diagnostics">Diagnostic bag for diagnostics</param>
         /// <param name="assignLocals">The rewritten tree should include assignments of the original locals to the lifted proxies</param>
-        /// <param name="allowNonPublicTypeArguments">Allow type arguments of constructed methods to be non-public</param>
         public static BoundStatement Rewrite(
             BoundStatement loweredBody,
             NamedTypeSymbol thisType,
@@ -191,8 +185,7 @@ protected override bool NeedsProxy(Symbol localOrParameter)
             VariableSlotAllocator slotAllocatorOpt,
             TypeCompilationState compilationState,
             DiagnosticBag diagnostics,
-            bool assignLocals,
-            bool allowNonPublicTypeArguments)
+            bool assignLocals)
         {
             Debug.Assert((object)thisType != null);
             Debug.Assert(((object)thisParameter == null) || (thisParameter.Type == thisType));
@@ -220,8 +213,7 @@ protected override bool NeedsProxy(Symbol localOrParameter)
                 slotAllocatorOpt,
                 compilationState,
                 diagnostics,
-                assignLocals,
-                allowNonPublicTypeArguments);
+                assignLocals);
 
             analysis.ComputeLambdaScopesAndFrameCaptures();
             rewriter.MakeFrames(closureDebugInfoBuilder);
@@ -999,7 +991,7 @@ private BoundNode RewriteLambdaConversion(BoundLambda node)
                 var newType = VisitType(node.Type);
                 var newBody = (BoundBlock)Visit(node.Body);
                 node = node.Update(node.Symbol, newBody, node.Diagnostics, node.Binder, newType);
-                var result0 = wasInExpressionLambda ? node : ExpressionLambdaRewriter.RewriteLambda(node, CompilationState, TypeMap, _allowNonPublicTypeArguments, Diagnostics);
+                var result0 = wasInExpressionLambda ? node : ExpressionLambdaRewriter.RewriteLambda(node, CompilationState, TypeMap, Diagnostics);
                 _inExpressionLambda = wasInExpressionLambda;
                 return result0;
             }
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs
index a41111e00adf59b5a27bed75fe807c001013523f..dcf2ddba650176554cb4e8ab53147b407d680a7f 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs
@@ -565,8 +565,7 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
                     slotAllocatorOpt: null,
                     compilationState: compilationState,
                     diagnostics: diagnostics,
-                    assignLocals: true,
-                    allowNonPublicTypeArguments: true);
+                    assignLocals: true);
 
                 // we don't need this information:
                 closureDebugInfoBuilder.Free();