Ensure that modreq(InAttribute) is emitted for synthesized ref readonly returning methods (#80893)

Closes #76847

Author: AlekseyTs

docs/compilers/CSharp/Compiler Breaking Changes - DotNet 11.md

@@ -59,3 +59,47 @@ foreach (var x in new[] { 1, 2 })
 ```
 
 See also https://github.com/dotnet/csharplang/issues/9750.
+
+
+## Scenarios requiring compiler to synthesize a `ref readonly` returning delegate now require availability of `System.Runtime.InteropServices.InAttribute` type.
+
+***Introduced in Visual Studio 2026 version 18.3***
+
+The C# compiler made a breaking change in order to properly emit metadata for `ref readonly` returning
+[synthesized delegates](https://github.com/dotnet/csharplang/blob/main/proposals/csharp-10.0/lambda-improvements.md#delegate-types)
+
+This can cause an "error CS0518: Predefined type 'System.Runtime.InteropServices.InAttribute' is not defined or imported"
+to appear in existing code, such as in the scenarios below:
+
+```cs
+var d = this.MethodWithRefReadonlyReturn;
+```
+
+```cs
+var d = ref readonly int () => ref x;
+```
+
+If your code is impacted by this breaking change, consider adding a reference to an assembly defining `System.Runtime.InteropServices.InAttribute` 
+to your project.
+
+## Scenarios utilizing `ref readonly` local functions now require availability of `System.Runtime.InteropServices.InAttribute` type.
+
+***Introduced in Visual Studio 2026 version 18.3***
+
+The C# compiler made a breaking change in order to properly emit metadata for `ref readonly` returning local functions.
+
+This can cause an "error CS0518: Predefined type 'System.Runtime.InteropServices.InAttribute' is not defined or imported"
+to appear in existing code, such as in the scenario below:
+
+```cs
+void Method()
+{
+    ...
+    ref readonly int local() => ref x;
+    ...
+}
+```
+
+If your code is impacted by this breaking change, consider adding a reference to an assembly defining `System.Runtime.InteropServices.InAttribute` 
+to your project.
+

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

@@ -177,7 +177,7 @@ private bool CheckLambda(AnonymousFunctionExpressionSyntax lambdaSyntax, Binder
 
             private static ExecutableCodeBinder CreateLambdaBodyBinder(Binder enclosingBinder, UnboundLambda unboundLambda)
             {
-                unboundLambda.HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType);
+                unboundLambda.HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType);
                 var lambdaSymbol = new LambdaSymbol(
                                         enclosingBinder,
                                         enclosingBinder.Compilation,
@@ -186,6 +186,7 @@ private static ExecutableCodeBinder CreateLambdaBodyBinder(Binder enclosingBinde
                                         ImmutableArray<TypeWithAnnotations>.Empty,
                                         ImmutableArray<RefKind>.Empty,
                                         refKind,
+                                        refCustomModifiers,
                                         returnType);
 
                 return new ExecutableCodeBinder(unboundLambda.Syntax, lambdaSymbol, unboundLambda.GetWithParametersBinder(lambdaSymbol, enclosingBinder));

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

@@ -35,9 +35,10 @@ public QueryUnboundLambdaState(Binder binder, RangeVariableMap rangeVariableMap,
             public override SyntaxList<AttributeListSyntax> ParameterAttributes(int index) => default;
             public override bool HasSignature { get { return true; } }
 
-            public override bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType)
+            public override bool HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType)
             {
                 refKind = default;
+                refCustomModifiers = [];
                 returnType = default;
                 return false;
             }

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

@@ -2167,7 +2167,7 @@ private ImmutableArray<BoundExpression> BuildArgumentsForErrorRecovery(AnalyzedA
                             // But if the lambda is explicitly typed, we can bind only once.
                             // https://github.com/dotnet/roslyn/issues/69093
                             if (unboundArgument.HasExplicitlyTypedParameterList &&
-                                unboundArgument.HasExplicitReturnType(out _, out _) &&
+                                unboundArgument.HasExplicitReturnType(out _, out _, out _) &&
                                 unboundArgument.FunctionType is { } functionType &&
                                 functionType.GetInternalDelegateType() is { } delegateType)
                             {

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

@@ -49,6 +49,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
             ImmutableArray<TypeWithAnnotations> types = default;
             ImmutableArray<EqualsValueClauseSyntax?> defaultValues = default;
             RefKind returnRefKind = RefKind.None;
+            ImmutableArray<CustomModifier> refCustomModifiers = [];
             TypeWithAnnotations returnType = default;
             ImmutableArray<SyntaxList<AttributeListSyntax>> parameterAttributes = default;
 
@@ -81,7 +82,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
                     var paren = (ParenthesizedLambdaExpressionSyntax)syntax;
                     if (paren.ReturnType is { } returnTypeSyntax)
                     {
-                        (returnRefKind, returnType) = BindExplicitLambdaReturnType(returnTypeSyntax, diagnostics);
+                        (returnRefKind, refCustomModifiers, returnType) = BindExplicitLambdaReturnType(returnTypeSyntax, diagnostics);
                     }
 
                     parameterSyntaxListOpt = paren.ParameterList.Parameters;
@@ -252,7 +253,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
 
             namesBuilder.Free();
 
-            return UnboundLambda.Create(syntax, this, diagnostics.AccumulatesDependencies, returnRefKind, returnType, parameterAttributes, refKinds, scopes, types, names, discardsOpt, parameterSyntaxListOpt, defaultValues, isAsync: isAsync, isStatic: isStatic);
+            return UnboundLambda.Create(syntax, this, diagnostics.AccumulatesDependencies, returnRefKind, refCustomModifiers, returnType, parameterAttributes, refKinds, scopes, types, names, discardsOpt, parameterSyntaxListOpt, defaultValues, isAsync: isAsync, isStatic: isStatic);
 
             static ImmutableArray<bool> computeDiscards(SeparatedSyntaxList<ParameterSyntax> parameters, int underscoresCount)
             {
@@ -288,7 +289,7 @@ static void checkAttributes(AnonymousFunctionExpressionSyntax syntax, SyntaxList
 
         }
 
-        private (RefKind, TypeWithAnnotations) BindExplicitLambdaReturnType(TypeSyntax syntax, BindingDiagnosticBag diagnostics)
+        private (RefKind, ImmutableArray<CustomModifier> refCustomModifiers, TypeWithAnnotations) BindExplicitLambdaReturnType(TypeSyntax syntax, BindingDiagnosticBag diagnostics)
         {
             MessageID.IDS_FeatureLambdaReturnType.CheckFeatureAvailability(diagnostics, syntax);
 
@@ -311,7 +312,13 @@ static void checkAttributes(AnonymousFunctionExpressionSyntax syntax, SyntaxList
                 diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, syntax.Location, type);
             }
 
-            return (refKind, returnType);
+            ImmutableArray<CustomModifier> refCustomModifiers = [];
+            if (refKind == RefKind.RefReadOnly)
+            {
+                refCustomModifiers = [CSharpCustomModifier.CreateRequired(Binder.GetWellKnownType(Compilation, WellKnownType.System_Runtime_InteropServices_InAttribute, diagnostics, syntax.Location))];
+            }
+
+            return (refKind, refCustomModifiers, returnType);
         }
 
         private static void CheckParenthesizedLambdaParameters(

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

@@ -3536,7 +3536,7 @@ internal BoundBlock CreateBlockFromExpression(CSharpSyntaxNode node, ImmutableAr
                 {
                     Error(diagnostics, ErrorCode.ERR_ReturnInIterator, syntax);
                     expression = BindToTypeForErrorRecovery(expression);
-                    statement = new BoundReturnStatement(syntax, returnRefKind, expression, @checked: CheckOverflowAtRuntime) { WasCompilerGenerated = true };
+                    statement = new BoundReturnStatement(syntax, refKind, expression, @checked: CheckOverflowAtRuntime) { WasCompilerGenerated = true };
                 }
                 else
                 {
@@ -3548,7 +3548,7 @@ internal BoundBlock CreateBlockFromExpression(CSharpSyntaxNode node, ImmutableAr
                     {
                         expression = CreateReturnConversion(syntax, diagnostics, expression, refKind, returnType);
                     }
-                    statement = new BoundReturnStatement(syntax, returnRefKind, expression, @checked: CheckOverflowAtRuntime) { WasCompilerGenerated = true };
+                    statement = new BoundReturnStatement(syntax, refKind, expression, @checked: CheckOverflowAtRuntime) { WasCompilerGenerated = true };
                 }
             }
             else if (expression.Type?.SpecialType == SpecialType.System_Void)

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs

@@ -1482,7 +1482,7 @@ private static LambdaConversionResult IsAnonymousFunctionCompatibleWithDelegate(
                 return LambdaConversionResult.BadTargetType;
             }
 
-            if (anonymousFunction.HasExplicitReturnType(out var refKind, out var returnType))
+            if (anonymousFunction.HasExplicitReturnType(out var refKind, refCustomModifiers: out _, out var returnType))
             {
                 if (invokeMethod.RefKind != refKind ||
                     !invokeMethod.ReturnType.Equals(returnType.Type, TypeCompareKind.AllIgnoreOptions))

src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/MethodTypeInference.cs

@@ -1616,7 +1616,7 @@ private void ExplicitReturnTypeInference(BoundExpression source, TypeWithAnnotat
             }
 
             UnboundLambda anonymousFunction = (UnboundLambda)source;
-            if (!anonymousFunction.HasExplicitReturnType(out _, out TypeWithAnnotations anonymousFunctionReturnType))
+            if (!anonymousFunction.HasExplicitReturnType(out _, out _, out TypeWithAnnotations anonymousFunctionReturnType))
             {
                 return;
             }

src/Compilers/CSharp/Portable/BoundTree/BoundExpressionExtensions.cs

@@ -138,6 +138,16 @@ public static bool HasDynamicType(this BoundExpression node)
 
             var delegateType = expr.GetFunctionType()?.GetInternalDelegateType();
             delegateType?.AddUseSiteInfo(ref useSiteInfo);
+
+            // Report bad or missing System.Runtime.InteropServices.InAttribute for a 'ref readonly' returning delegate
+            // unless the delegate type is inferred from a lambda or a local fuction. In those cases the check is performed
+            // while binding the lambda or local function declaration.
+            if (expr is BoundMethodGroup { Methods: not [{ MethodKind: MethodKind.LocalFunction }] } &&
+                delegateType is { DelegateInvokeMethod.OriginalDefinition: SynthesizedDelegateInvokeMethod { RefKind: RefKind.RefReadOnly } })
+            {
+                delegateType.DeclaringCompilation.GetWellKnownType(WellKnownType.System_Runtime_InteropServices_InAttribute).AddUseSiteInfo(ref useSiteInfo);
+            }
+
             return delegateType;
         }
 

src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml

@@ -1149,7 +1149,7 @@
     <Field Name="Flavor" Type="NoOpStatementFlavor"/>
   </Node>
 
-  <Node Name="BoundReturnStatement" Base="BoundStatement">
+  <Node Name="BoundReturnStatement" Base="BoundStatement" HasValidate="true">
     <Field Name="RefKind" Type="RefKind"/>
     <Field Name="ExpressionOpt" Type="BoundExpression?"/>
     <!--