Allow implicit implementation of non-public interface members

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6077,7 +6077,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
  <value>The modifier '{0}' is not valid for this item in C# {1}. Please use language version '{2}' or greater.</value>
  </data>
  <data name="ERR_ImplicitImplementationOfNonPublicInterfaceMember" xml:space="preserve">
- <value>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</value>
+ <value>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</value>
  </data>
  <data name="ERR_MostSpecificImplementationIsNotFound" xml:space="preserve">
  <value>Interface member '{0}' does not have a most specific implementation. Neither '{1}', nor '{2}' are most specific.</value>

src/Compilers/CSharp/Portable/Errors/MessageID.cs

@@ -228,6 +228,7 @@ internal enum MessageID
  IDS_FeatureStaticAbstractMembersInInterfaces = MessageBase + 12803,
  IDS_FeatureLambdaReturnType = MessageBase + 12804,
  IDS_AsyncMethodBuilderOverride = MessageBase + 12805,
+ IDS_FeatureImplicitImplementationOfNonPublicMemebers = MessageBase + 12806,
  }
 
  // Message IDs may refer to strings that need to be localized.
@@ -352,6 +353,7 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
  case MessageID.IDS_FeatureLambdaReturnType: // semantic check
  case MessageID.IDS_AsyncMethodBuilderOverride: // semantic check
  case MessageID.IDS_FeatureConstantInterpolatedStrings: // semantic check
+ case MessageID.IDS_FeatureImplicitImplementationOfNonPublicMemebers: // semantic check
  return LanguageVersion.CSharp10;
 
  // C# 9.0 features.

src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol_ImplementationChecks.cs

@@ -1588,18 +1588,9 @@ private void CheckInterfaceUnification(BindingDiagnosticBag diagnostics)
  private (SynthesizedExplicitImplementationForwardingMethod? ForwardingMethod, (MethodSymbol Body, MethodSymbol Implemented)? MethodImpl)
  SynthesizeInterfaceMemberImplementation(SymbolAndDiagnostics implementingMemberAndDiagnostics, Symbol interfaceMember)
  {
- if (interfaceMember.DeclaredAccessibility != Accessibility.Public)
- {
- // Non-public interface members cannot be implemented implicitly,
- // appropriate errors are reported elsewhere. Let's not synthesize
- // forwarding methods, or modify metadata virtualness of the
- // implementing methods.
- return default;
- }
-
  foreach (Diagnostic diagnostic in implementingMemberAndDiagnostics.Diagnostics.Diagnostics)
  {
- if (diagnostic.Severity == DiagnosticSeverity.Error)
+ if (diagnostic.Severity == DiagnosticSeverity.Error && diagnostic.Code is not (int)ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember)
  {
  return default;
  }
@@ -1616,15 +1607,6 @@ private void CheckInterfaceUnification(BindingDiagnosticBag diagnostics)
  MethodSymbol interfaceMethod = (MethodSymbol)interfaceMember;
  MethodSymbol implementingMethod = (MethodSymbol)implementingMember;
 
- // Interface properties/events with non-public accessors cannot be implemented implicitly,
- // appropriate errors are reported elsewhere. Let's not synthesize
- // forwarding methods, or modify metadata virtualness of the
- // implementing accessors, even for public ones.
- if (interfaceMethod.AssociatedSymbol?.IsEventOrPropertyWithImplementableNonPublicAccessor() == true)
- {
- return default;
- }
-
  //explicit implementations are always respected by the CLR
  if (implementingMethod.ExplicitInterfaceImplementations.Contains(interfaceMethod, ExplicitInterfaceImplementationTargetMemberEqualityComparer.Instance))
  {

src/Compilers/CSharp/Portable/Symbols/TypeSymbol.cs

@@ -834,7 +834,7 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
 
  Symbol implicitImpl = null;
  Symbol closestMismatch = null;
- bool canBeImplementedImplicitly = interfaceMember.DeclaredAccessibility == Accessibility.Public && !interfaceMember.IsEventOrPropertyWithImplementableNonPublicAccessor();
+ bool canBeImplementedImplicitlyInCSharp9 = interfaceMember.DeclaredAccessibility == Accessibility.Public && !interfaceMember.IsEventOrPropertyWithImplementableNonPublicAccessor();
  TypeSymbol implementingBaseOpt = null; // Calculated only if canBeImplementedImplicitly == false
  bool implementingTypeImplementsInterface = false;
  CSharpCompilation compilation = implementingType.DeclaringCompilation;
@@ -891,7 +891,7 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
  }
 
  if (!seenTypeDeclaringInterface ||
- (!canBeImplementedImplicitly && (object)implementingBaseOpt == null))
+ (!canBeImplementedImplicitlyInCSharp9 && (object)implementingBaseOpt == null))
  {
  if (currType.InterfacesAndTheirBaseInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteInfo).ContainsKey(interfaceType))
  {
@@ -905,7 +905,7 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
  {
  implementingTypeImplementsInterface = true;
  }
- else if (!canBeImplementedImplicitly && (object)implementingBaseOpt == null)
+ else if (!canBeImplementedImplicitlyInCSharp9 && (object)implementingBaseOpt == null)
  {
  implementingBaseOpt = currType;
  }
@@ -941,7 +941,7 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
  }
  }
 
- Debug.Assert(!canBeImplementedImplicitly || (object)implementingBaseOpt == null);
+ Debug.Assert(!canBeImplementedImplicitlyInCSharp9 || (object)implementingBaseOpt == null);
 
  bool tryDefaultInterfaceImplementation = !interfaceMember.IsStatic;
 
@@ -1002,24 +1002,26 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
  {
  if ((object)implicitImpl != null)
  {
- if (!canBeImplementedImplicitly)
+ if (!canBeImplementedImplicitlyInCSharp9)
  {
  if (interfaceMember.Kind == SymbolKind.Method &&
  (object)implementingBaseOpt == null) // Otherwise any approprite errors are going to be reported for the base.
  {
- diagnostics.Add(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, GetInterfaceLocation(interfaceMember, implementingType),
- implementingType, interfaceMember, implicitImpl);
+ LanguageVersion requiredVersion = MessageID.IDS_FeatureImplicitImplementationOfNonPublicMemebers.RequiredVersion();
+ LanguageVersion? availableVersion = implementingType.DeclaringCompilation?.LanguageVersion;
+ if (requiredVersion > availableVersion)
+ {
+ diagnostics.Add(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, GetInterfaceLocation(interfaceMember, implementingType),
+ implementingType, interfaceMember, implicitImpl,
+ availableVersion.GetValueOrDefault().ToDisplayString(), new CSharpRequiredLanguageVersion(requiredVersion));
+ }
  }
  }
- else
- {
- ReportImplicitImplementationMatchDiagnostics(interfaceMember, implementingType, implicitImpl, diagnostics);
- }
+
+ ReportImplicitImplementationMatchDiagnostics(interfaceMember, implementingType, implicitImpl, diagnostics);
  }
  else if ((object)closestMismatch != null)
  {
- Debug.Assert(interfaceMember.DeclaredAccessibility == Accessibility.Public);
- Debug.Assert(!interfaceMember.IsEventOrPropertyWithImplementableNonPublicAccessor());
  ReportImplicitImplementationMismatchDiagnostics(interfaceMember, implementingType, closestMismatch, diagnostics);
  }
  }
@@ -2063,11 +2065,7 @@ private static void FindPotentialImplicitImplementationMemberDeclaredInType(
  }
 
  // If we haven't found a match, do a weaker comparison that ignores static-ness, accessibility, and return type.
- // But do this only if interface member is public because language doesn't allow implicit implementations for
- // non-public members and, since candidate's signature doesn't match, runtime will never pick it up either. 
- else if ((object)closeMismatch == null && implementingTypeIsFromSomeCompilation &&
- interfaceMember.DeclaredAccessibility == Accessibility.Public &&
- !interfaceMember.IsEventOrPropertyWithImplementableNonPublicAccessor())
+ else if ((object)closeMismatch == null && implementingTypeIsFromSomeCompilation)
  {
  // We can ignore custom modifiers here, because our goal is to improve the helpfulness
  // of an error we're already giving, rather than to generate a new error.