Ref fields feature requires ByRefFields runtime flag

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

@@ -7260,6 +7260,10 @@ protected BoundExpression BindFieldAccess(
                 fieldSymbol.RefKind != RefKind.None)
             {
                 CheckFeatureAvailability(node, MessageID.IDS_FeatureRefFields, diagnostics);
+                if (!Compilation.Assembly.RuntimeSupportsByRefFields)
+                {
+                    diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportRefFields, node.Location);
+                }
             }
 
             TypeSymbol fieldType = fieldSymbol.GetFieldType(this.FieldsBeingBound).Type;

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -7208,4 +7208,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_UnscopedRefAttributeUnsupportedTarget" xml:space="preserve">
     <value>UnscopedRefAttribute can only be applied to 'out' parameters, 'ref' parameters that refer to 'ref struct' types, and instance methods and properties on 'struct' types other than constructors and 'init' accessors.</value>
   </data>
+  <data name="ERR_RuntimeDoesNotSupportRefFields" xml:space="preserve">
+    <value>Target runtime doesn't support ref fields.</value>
+  </data>
 </root>

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

@@ -2112,6 +2112,7 @@ internal enum ErrorCode
         ERR_MisplacedScoped = 9061,
         ERR_ScopedTypeNameDisallowed = 9062,
         ERR_UnscopedRefAttributeUnsupportedTarget = 9063,
+        ERR_RuntimeDoesNotSupportRefFields = 9064,
 
         #endregion
 

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

@@ -2213,6 +2213,7 @@ internal static bool IsBuildOnlyDiagnostic(ErrorCode code)
                 case ErrorCode.ERR_MisplacedScoped:
                 case ErrorCode.ERR_ScopedTypeNameDisallowed:
                 case ErrorCode.ERR_UnscopedRefAttributeUnsupportedTarget:
+                case ErrorCode.ERR_RuntimeDoesNotSupportRefFields:
                     return false;
                 default:
                     // NOTE: All error codes must be explicitly handled in this switch statement

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

@@ -467,8 +467,22 @@ protected bool RuntimeSupportsFeature(SpecialMember feature)
         internal bool RuntimeSupportsUnmanagedSignatureCallingConvention
             => RuntimeSupportsFeature(SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__UnmanagedSignatureCallingConvention);
 
-        internal bool RuntimeSupportsByRefFields
-            => RuntimeSupportsFeature(SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__ByRefFields);
+        internal virtual bool RuntimeSupportsByRefFields
+        {
+            get
+            {
+                // CorLibrary should never be null, but that invariant is broken in some cases for MissingAssemblySymbol.
+                // Tracked by https://github.com/dotnet/roslyn/issues/61262
+                return CorLibrary?.RuntimeSupportsByRefFields == true;
+            }
+
+            set
+            {
+                // The setter should be removed once TargetFramework.Net70 is added
+                // Tracked by https://github.com/dotnet/roslyn/issues/61463
+                CorLibrary.RuntimeSupportsByRefFields = value;
+            }
+        }
 
         /// <summary>
         /// True if the target runtime support covariant returns of methods declared in classes.

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

@@ -33,6 +33,7 @@ internal abstract class MetadataOrSourceAssemblySymbol
 
         private NativeIntegerTypeSymbol[] _lazyNativeIntegerTypes;
         private ThreeState _lazyRuntimeSupportsNumericIntPtr = ThreeState.Unknown;
+        private ThreeState _lazyRuntimeSupportsByRefFields = ThreeState.Unknown;
 
         internal override bool RuntimeSupportsNumericIntPtr
         {
@@ -65,6 +66,37 @@ internal override bool RuntimeSupportsNumericIntPtr
             }
         }
 
+        internal override bool RuntimeSupportsByRefFields
+        {
+            get
+            {
+                if ((object)CorLibrary == this)
+                {
+                    if (!_lazyRuntimeSupportsByRefFields.HasValue())
+                    {
+                        _lazyRuntimeSupportsByRefFields = RuntimeSupportsFeature(SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__ByRefFields).ToThreeState();
+                    }
+
+                    return _lazyRuntimeSupportsByRefFields.Value();
+                }
+
+                return base.RuntimeSupportsByRefFields;
+            }
+            set
+            {
+                Debug.Assert(value);
+                Debug.Assert(!RuntimeSupportsFeature(SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__ByRefFields));
+                if ((object)CorLibrary == this)
+                {
+                    Debug.Assert(!_lazyRuntimeSupportsByRefFields.HasValue());
+                    _lazyRuntimeSupportsByRefFields = value.ToThreeState();
+                    return;
+                }
+
+                base.RuntimeSupportsByRefFields = value;
+            }
+        }
+
         /// <summary>
         /// Lookup declaration for predefined CorLib type in this Assembly.
         /// </summary>

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

@@ -79,5 +79,20 @@ internal override bool RuntimeSupportsNumericIntPtr
                 throw ExceptionUtilities.Unreachable;
             }
         }
+
+        internal override bool RuntimeSupportsByRefFields
+        {
+            get
+            {
+                // For now we assume that it is not supported by default
+                Debug.Assert((object)CorLibrary == this);
+                return false;
+            }
+            set
+            {
+                Debug.Assert((object)CorLibrary == this);
+                throw ExceptionUtilities.Unreachable;
+            }
+        }
     }
 }

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

@@ -485,6 +485,11 @@ private TypeAndRefKind GetTypeAndRefKind(ConsList<FieldSymbol> fieldsBeingBound)
                     if (refKind != RefKind.None)
                     {
                         MessageID.IDS_FeatureRefFields.CheckFeatureAvailability(diagnostics, compilation, typeSyntax.Location);
+                        if (!compilation.Assembly.RuntimeSupportsByRefFields)
+                        {
+                            diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportRefFields, ErrorLocation);
+                        }
+
                         if (!containingType.IsRefLikeType)
                         {
                             diagnostics.Add(ErrorCode.ERR_RefFieldInNonRefStruct, ErrorLocation);