Add public API for ref like type parameters (#73335)

Related to #73330.
dotnet · May 7, 2024 · 319fc7c · 319fc7c
1 parent 449738c
commit 319fc7c
Show file tree

Hide file tree

Showing 40 changed files with 176 additions and 108 deletions.
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -8673,7 +8673,7 @@ private void CheckReceiverAndRuntimeSupportForSymbolAccess(SyntaxNode node, Boun
                     }
                 }
 
-                if (receiverOpt is { Type: TypeParameterSymbol { AllowByRefLike: true } } &&
+                if (receiverOpt is { Type: TypeParameterSymbol { AllowsByRefLike: true } } &&
                     isNotImplementableInstanceMember(symbol))
                 {
                     Error(diagnostics, ErrorCode.ERR_BadNonVirtualInterfaceMemberAccessOnAllowsRefLike, node);

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs
@@ -3570,28 +3570,28 @@ private BoundExpression BindIsOperator(BinaryExpressionSyntax node, BindingDiagn
                     //   a restricted type cannot be boxed or unboxed into.
                     if (targetType.IsRestrictedType() || operandType.IsRestrictedType())
                     {
-                        if (targetType is TypeParameterSymbol { AllowByRefLike: true })
+                        if (targetType is TypeParameterSymbol { AllowsByRefLike: true })
                         {
                             if (!operandType.IsRefLikeType && operandType is not TypeParameterSymbol)
                             {
                                 return null;
                             }
                         }
-                        else if (operandType is not TypeParameterSymbol { AllowByRefLike: true })
+                        else if (operandType is not TypeParameterSymbol { AllowsByRefLike: true })
                         {
                             if (targetType.IsRefLikeType)
                             {
                                 if (operandType is TypeParameterSymbol)
                                 {
-                                    Debug.Assert(operandType is TypeParameterSymbol { AllowByRefLike: false });
+                                    Debug.Assert(operandType is TypeParameterSymbol { AllowsByRefLike: false });
                                     return ConstantValue.False;
                                 }
                             }
                             else if (operandType.IsRefLikeType)
                             {
                                 if (targetType is TypeParameterSymbol)
                                 {
-                                    Debug.Assert(targetType is TypeParameterSymbol { AllowByRefLike: false });
+                                    Debug.Assert(targetType is TypeParameterSymbol { AllowsByRefLike: false });
                                     return ConstantValue.False;
                                 }
                             }

diff --git a/src/Compilers/CSharp/Portable/Binder/ForEachLoopBinder.cs b/src/Compilers/CSharp/Portable/Binder/ForEachLoopBinder.cs
@@ -1245,7 +1245,7 @@ private void GetDisposalInfoForEnumerator(SyntaxNode syntax, ref ForEachEnumerat
             {
                 Debug.Assert(!enumeratorType.IsRefLikeType); // Ref like types are supposed to be structs, therefore, sealed.
 
-                if (enumeratorType is TypeParameterSymbol { AllowByRefLike: true })
+                if (enumeratorType is TypeParameterSymbol { AllowsByRefLike: true })
                 {
                     Error(diagnostics, ErrorCode.ERR_BadAllowByRefLikeEnumerator, expr.Syntax, enumeratorType);
                 }

diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs
@@ -2829,8 +2829,8 @@ public bool HasImplicitTypeParameterConversion(TypeParameterSymbol source, TypeS
                 return true;
             }
 
-            if (destination is TypeParameterSymbol { AllowByRefLike: false } &&
-                !source.AllowByRefLike &&
+            if (destination is TypeParameterSymbol { AllowsByRefLike: false } &&
+                !source.AllowsByRefLike &&
                 source.DependsOn((TypeParameterSymbol)destination))
             {
                 return true;
@@ -2849,7 +2849,7 @@ private bool HasImplicitReferenceTypeParameterConversion(TypeParameterSymbol sou
                 return false; // Not a reference conversion.
             }
 
-            if (source.AllowByRefLike)
+            if (source.AllowsByRefLike)
             {
                 return false;
             }
@@ -2872,7 +2872,7 @@ private bool HasImplicitReferenceTypeParameterConversion(TypeParameterSymbol sou
             }
 
             // * From T to a type parameter U, provided T depends on U.
-            if (destination is TypeParameterSymbol { AllowByRefLike: false } &&
+            if (destination is TypeParameterSymbol { AllowsByRefLike: false } &&
                 source.DependsOn((TypeParameterSymbol)destination))
             {
                 return true;
@@ -2979,7 +2979,7 @@ private bool IsRefLikeOrAllowsByRefLikeImplementingVarianceCompatibleInterface(T
         {
             if (typeToCheck is TypeParameterSymbol typeParameter)
             {
-                return typeParameter.AllowByRefLike && HasVarianceCompatibleInterfaceInEffectiveInterfaceSet(typeParameter, targetInterfaceType, ref useSiteInfo);
+                return typeParameter.AllowsByRefLike && HasVarianceCompatibleInterfaceInEffectiveInterfaceSet(typeParameter, targetInterfaceType, ref useSiteInfo);
             }
             else if (typeToCheck.IsRefLikeType)
             {
@@ -3202,7 +3202,7 @@ private bool HasImplicitBoxingTypeParameterConversion(TypeParameterSymbol source
                 return false; // Not a boxing conversion; both source and destination are references.
             }
 
-            if (source.AllowByRefLike)
+            if (source.AllowsByRefLike)
             {
                 return false;
             }
@@ -3225,7 +3225,7 @@ private bool HasImplicitBoxingTypeParameterConversion(TypeParameterSymbol source
             }
 
             // SPEC: From T to a type parameter U, provided T depends on U
-            if (destination is TypeParameterSymbol { AllowByRefLike: false } d &&
+            if (destination is TypeParameterSymbol { AllowsByRefLike: false } d &&
                 source.DependsOn(d))
             {
                 return true;
@@ -3480,7 +3480,7 @@ private bool HasExplicitReferenceTypeParameterConversion(TypeSymbol source, Type
             TypeParameterSymbol s = source as TypeParameterSymbol;
             TypeParameterSymbol t = destination as TypeParameterSymbol;
 
-            if (s?.AllowByRefLike == true || t?.AllowByRefLike == true)
+            if (s?.AllowsByRefLike == true || t?.AllowsByRefLike == true)
             {
                 return false;
             }
@@ -3532,7 +3532,7 @@ private bool HasUnboxingTypeParameterConversion(TypeSymbol source, TypeSymbol de
             TypeParameterSymbol s = source as TypeParameterSymbol;
             TypeParameterSymbol t = destination as TypeParameterSymbol;
 
-            if (s?.AllowByRefLike == true || t?.AllowByRefLike == true)
+            if (s?.AllowsByRefLike == true || t?.AllowsByRefLike == true)
             {
                 return false;
             }

diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorOverloadResolution.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorOverloadResolution.cs
@@ -718,8 +718,8 @@ private void GetAllBuiltInOperators(BinaryOperatorKind kind, bool isChecked, Bou
                 GetReferenceEquality(kind, operators);
                 Debug.Assert(operators.Count == 1);
 
-                if ((left.Type is TypeParameterSymbol { AllowByRefLike: true } && right.IsLiteralNull()) ||
-                    (right.Type is TypeParameterSymbol { AllowByRefLike: true } && left.IsLiteralNull()))
+                if ((left.Type is TypeParameterSymbol { AllowsByRefLike: true } && right.IsLiteralNull()) ||
+                    (right.Type is TypeParameterSymbol { AllowsByRefLike: true } && left.IsLiteralNull()))
                 {
                     BinaryOperatorSignature op = operators[0];
                     Debug.Assert(op.LeftType.IsObjectType());
@@ -776,7 +776,7 @@ static bool isUtf8ByteRepresentation(BoundExpression value)
 
             Conversion getOperandConversionForAllowByRefLikeNullCheck(bool isChecked, BoundExpression operand, TypeSymbol objectType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
             {
-                return (operand.Type is TypeParameterSymbol { AllowByRefLike: true }) ? Conversion.Boxing : Conversions.ClassifyConversionFromExpression(operand, objectType, isChecked: isChecked, ref useSiteInfo);
+                return (operand.Type is TypeParameterSymbol { AllowsByRefLike: true }) ? Conversion.Boxing : Conversions.ClassifyConversionFromExpression(operand, objectType, isChecked: isChecked, ref useSiteInfo);
             }
         }
 

diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitOperators.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitOperators.cs
@@ -372,7 +372,7 @@ private void EmitBinaryCondOperator(BoundBinaryOperator binOp, bool sense)
                         {
                             if (!constant.IsFloating)
                             {
-                                if (comparand is BoundConversion { Type.SpecialType: SpecialType.System_Object, ConversionKind: ConversionKind.Boxing, Operand.Type: TypeParameterSymbol { AllowByRefLike: true } } &&
+                                if (comparand is BoundConversion { Type.SpecialType: SpecialType.System_Object, ConversionKind: ConversionKind.Boxing, Operand.Type: TypeParameterSymbol { AllowsByRefLike: true } } &&
                                     constant.IsNull)
                                 {
                                     // Boxing is not supported for ref like type parameters, therefore the code that we usually emit 'box; ldnull; ceq/cgt'

diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpSymbolMatcher.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpSymbolMatcher.cs
@@ -730,7 +730,7 @@ private static bool AreTypeParametersEqual(TypeParameterSymbol type, TypeParamet
                 // edit. Furthermore, comparing constraint types might lead to a cycle.
                 Debug.Assert(type.HasConstructorConstraint == other.HasConstructorConstraint);
                 Debug.Assert(type.HasValueTypeConstraint == other.HasValueTypeConstraint);
-                Debug.Assert(type.AllowByRefLike == other.AllowByRefLike);
+                Debug.Assert(type.AllowsByRefLike == other.AllowsByRefLike);
                 Debug.Assert(type.HasUnmanagedTypeConstraint == other.HasUnmanagedTypeConstraint);
                 Debug.Assert(type.HasReferenceTypeConstraint == other.HasReferenceTypeConstraint);
                 Debug.Assert(type.ConstraintTypesNoUseSiteDiagnostics.Length == other.ConstraintTypesNoUseSiteDiagnostics.Length);

diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/TypeParameterSymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/TypeParameterSymbolAdapter.cs
@@ -306,7 +306,7 @@ bool Cci.IGenericParameter.AllowByRefLike
         {
             get
             {
-                return AdaptedTypeParameterSymbol.AllowByRefLike;
+                return AdaptedTypeParameterSymbol.AllowsByRefLike;
             }
         }
 

diff --git a/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypeParameter.cs b/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypeParameter.cs
@@ -49,7 +49,7 @@ protected override bool AllowByRefLike
         {
             get
             {
-                return UnderlyingTypeParameter.AdaptedTypeParameterSymbol.AllowByRefLike;
+                return UnderlyingTypeParameter.AdaptedTypeParameterSymbol.AllowsByRefLike;
             }
         }
 

diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/LocalStateTracingInstrumenter.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/LocalStateTracingInstrumenter.cs
@@ -236,7 +236,7 @@ private static bool IsSameOrNestedType(NamedTypeSymbol type, NamedTypeSymbol oth
                         => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUnmanaged,
                     _ when variableType.IsRefLikeType && !hasOverriddenToString(variableType)
                         => null, // not possible to invoke ToString on ref struct that doesn't override it
-                    _ when variableType is TypeParameterSymbol { AllowByRefLike: true }
+                    _ when variableType is TypeParameterSymbol { AllowsByRefLike: true }
                         => null, // not possible to invoke ToString on ref struct type parameter
                     _ when variableType.TypeKind is TypeKind.Struct
                         // we'll emit ToString constrained virtcall to avoid boxing the struct

diff --git a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
@@ -1525,7 +1525,7 @@ public BoundExpression Convert(TypeSymbol type, BoundExpression arg, bool allowB
             Conversion c = Compilation.Conversions.ClassifyConversionFromExpression(arg, type, isChecked: false, ref useSiteInfo);
 
             if (allowBoxingByRefLikeTypeParametersToObject && !c.Exists &&
-                arg.Type is TypeParameterSymbol { AllowByRefLike: true } && type.IsObjectType())
+                arg.Type is TypeParameterSymbol { AllowsByRefLike: true } && type.IsObjectType())
             {
                 c = Conversion.Boxing;
             }

diff --git a/src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs b/src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs
@@ -829,7 +829,7 @@ public override void VisitParameter(IParameterSymbol symbol)
 
                     if (symbol.ScopedKind == ScopedKind.ScopedValue &&
                         symbol.RefKind == RefKind.None &&
-                        !(symbol.IsParams && symbol.Type.IsRefLikeType))
+                        !(symbol.IsParams && symbol.Type is { IsRefLikeType: true } or ITypeParameterSymbol { AllowsByRefLike: true }))
                     {
                         AddKeyword(SyntaxKind.ScopedKeyword);
                         AddSpace();

diff --git a/...p/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TypeParameterSymbol.cs b/...p/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TypeParameterSymbol.cs
@@ -91,7 +91,7 @@ public override bool HasValueTypeConstraint
                 get { return false; }
             }
 
-            public override bool AllowByRefLike
+            public override bool AllowsByRefLike
             {
                 get
                 {

diff --git a/src/Compilers/CSharp/Portable/Symbols/AssemblySymbol.cs b/src/Compilers/CSharp/Portable/Symbols/AssemblySymbol.cs
@@ -427,6 +427,8 @@ public bool SupportsRuntimeCapability(RuntimeCapability capability)
                     return this.RuntimeSupportsStaticAbstractMembersInInterfaces;
                 case RuntimeCapability.InlineArrayTypes:
                     return this.RuntimeSupportsInlineArrayTypes;
+                case RuntimeCapability.ByRefLikeGenerics:
+                    return this.RuntimeSupportsByRefLikeGenerics;
             }
 
             return false;
@@ -480,9 +482,8 @@ internal bool RuntimeSupportsInlineArrayTypes
         /// <summary>
         /// Figure out if the target runtime supports inline array types.
         /// </summary>
-        internal bool RuntimeSupportsByRefLikeGenerics // PROTOTYPE(RefStructInterfaces): Implement public API.
+        internal bool RuntimeSupportsByRefLikeGenerics
         {
-            // PROTOTYPE(RefStructInterfaces): Implement VB side.
             // Keep in sync with VB's AssemblySymbol.RuntimeSupportsByRefLikeGenerics
             get
             {

diff --git a/src/Compilers/CSharp/Portable/Symbols/ConstraintsHelper.cs b/src/Compilers/CSharp/Portable/Symbols/ConstraintsHelper.cs
@@ -94,7 +94,7 @@ internal static class ConstraintsHelper
 
             diagnosticsBuilder.Free();
 
-            if (typeParameter.AllowByRefLike)
+            if (typeParameter.AllowsByRefLike)
             {
                 if (inherited)
                 {
@@ -936,7 +936,7 @@ private static bool HasDuplicateInterfaces(NamedTypeSymbol type, ConsList<TypeSy
 
             if (typeArgument.Type.IsRefLikeTypeOrAllowsByRefLike())
             {
-                if (typeParameter.AllowByRefLike)
+                if (typeParameter.AllowsByRefLike)
                 {
                     if (args.CurrentCompilation.SourceModule != typeParameter.ContainingModule)
                     {

diff --git a/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.ErrorTypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.ErrorTypeParameterSymbol.cs
@@ -91,7 +91,7 @@ public override bool HasValueTypeConstraint
                 }
             }
 
-            public override bool AllowByRefLike
+            public override bool AllowsByRefLike
             {
                 get
                 {

diff --git a/src/Compilers/CSharp/Portable/Symbols/MemberSignatureComparer.cs b/src/Compilers/CSharp/Portable/Symbols/MemberSignatureComparer.cs
@@ -654,7 +654,7 @@ public static bool HaveSameConstraints(TypeParameterSymbol typeParameter1, TypeM
             if ((typeParameter1.HasConstructorConstraint != typeParameter2.HasConstructorConstraint) ||
                 (typeParameter1.HasReferenceTypeConstraint != typeParameter2.HasReferenceTypeConstraint) ||
                 (typeParameter1.HasValueTypeConstraint != typeParameter2.HasValueTypeConstraint) ||
-                (typeParameter1.AllowByRefLike != typeParameter2.AllowByRefLike) ||
+                (typeParameter1.AllowsByRefLike != typeParameter2.AllowsByRefLike) ||
                 (typeParameter1.HasUnmanagedTypeConstraint != typeParameter2.HasUnmanagedTypeConstraint) ||
                 (typeParameter1.Variance != typeParameter2.Variance))
             {

diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PETypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PETypeParameterSymbol.cs
@@ -567,7 +567,7 @@ public override bool HasValueTypeConstraint
             }
         }
 
-        public override bool AllowByRefLike
+        public override bool AllowsByRefLike
         {
             get
             {

diff --git a/src/Compilers/CSharp/Portable/Symbols/PublicModel/TypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/PublicModel/TypeParameterSymbol.cs
@@ -86,7 +86,9 @@ ITypeParameterSymbol ITypeParameterSymbol.ReducedFrom
 
         bool ITypeParameterSymbol.HasReferenceTypeConstraint => _underlying.HasReferenceTypeConstraint;
 
-        bool ITypeParameterSymbol.HasValueTypeConstraint => _underlying.HasValueTypeConstraint; // PROTOTYPE(RefStructInterfaces): Add AllowByRefLike to public API.
+        bool ITypeParameterSymbol.HasValueTypeConstraint => _underlying.HasValueTypeConstraint;
+
+        bool ITypeParameterSymbol.AllowsByRefLike => _underlying.AllowsByRefLike;
 
         bool ITypeParameterSymbol.HasUnmanagedTypeConstraint => _underlying.HasUnmanagedTypeConstraint;
 

diff --git a/src/Compilers/CSharp/Portable/Symbols/PublicModel/TypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/PublicModel/TypeSymbol.cs
@@ -168,7 +168,7 @@ ImmutableArray<SymbolDisplayPart> ITypeSymbol.ToMinimalDisplayParts(SemanticMode
 
         SpecialType ITypeSymbol.SpecialType => UnderlyingTypeSymbol.SpecialType;
 
-        bool ITypeSymbol.IsRefLikeType => UnderlyingTypeSymbol.IsRefLikeType; // PROTOTYPE(RefStructInterfaces): adjust?
+        bool ITypeSymbol.IsRefLikeType => UnderlyingTypeSymbol.IsRefLikeType;
 
         bool ITypeSymbol.IsReadOnly => UnderlyingTypeSymbol.IsReadOnly;
 

diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/CrefTypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/CrefTypeParameterSymbol.cs
@@ -127,7 +127,7 @@ public override bool HasValueTypeConstraint
             get { return false; }
         }
 
-        public override bool AllowByRefLike
+        public override bool AllowsByRefLike
         {
             get { return false; }
         }

diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/IndexedTypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/IndexedTypeParameterSymbol.cs
@@ -142,7 +142,7 @@ public override bool HasValueTypeConstraint
             get { return false; }
         }
 
-        public override bool AllowByRefLike
+        public override bool AllowsByRefLike
         {
             get { return false; }
         }

diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceTypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceTypeParameterSymbol.cs
@@ -504,7 +504,7 @@ public override bool HasValueTypeConstraint
             }
         }
 
-        public override bool AllowByRefLike
+        public override bool AllowsByRefLike
         {
             get
             {
@@ -646,7 +646,7 @@ public override bool HasValueTypeConstraint
             }
         }
 
-        public override bool AllowByRefLike
+        public override bool AllowsByRefLike
         {
             get
             {
@@ -909,12 +909,12 @@ public override bool HasValueTypeConstraint
             }
         }
 
-        public override bool AllowByRefLike
+        public override bool AllowsByRefLike
         {
             get
             {
                 var typeParameter = this.OverriddenTypeParameter;
-                return ((object)typeParameter != null) && typeParameter.AllowByRefLike;
+                return ((object)typeParameter != null) && typeParameter.AllowsByRefLike;
             }
         }
 

diff --git a/...rtable/Symbols/Synthesized/ReadOnlyListType/SynthesizedReadOnlyListTypeParameterSymbol.cs b/...rtable/Symbols/Synthesized/ReadOnlyListType/SynthesizedReadOnlyListTypeParameterSymbol.cs
@@ -34,7 +34,7 @@ internal SynthesizedReadOnlyListTypeParameterSymbol(SynthesizedReadOnlyListTypeS
 
         public override bool HasValueTypeConstraint => false;
 
-        public override bool AllowByRefLike => false; // The list is a class type and cannot store ref structs as elements.
+        public override bool AllowsByRefLike => false; // The list is a class type and cannot store ref structs as elements.
 
         public override bool IsValueTypeFromConstraintTypes => false;
 

diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedInlineArrayTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedInlineArrayTypeSymbol.cs
@@ -226,7 +226,7 @@ internal InlineArrayTypeParameterSymbol(SynthesizedInlineArrayTypeSymbol contain
 
             public override bool HasValueTypeConstraint => false;
 
-            public override bool AllowByRefLike => false; // Span types do not support ref like type parameters for now
+            public override bool AllowsByRefLike => false; // Span types do not support ref like type parameters for now
 
             public override bool IsValueTypeFromConstraintTypes => false;
 

diff --git a/src/Compilers/CSharp/Portable/Symbols/SynthesizedSimpleMethodTypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/SynthesizedSimpleMethodTypeParameterSymbol.cs
@@ -68,7 +68,7 @@ public override bool HasValueTypeConstraint
             get { return false; }
         }
 
-        public override bool AllowByRefLike
+        public override bool AllowsByRefLike
         {
             get { return false; }
         }

diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/TypeParameterSymbol.cs
@@ -634,7 +634,7 @@ internal sealed override ObsoleteAttributeData ObsoleteAttributeData
 
         public abstract bool HasValueTypeConstraint { get; }
 
-        public abstract bool AllowByRefLike { get; }
+        public abstract bool AllowsByRefLike { get; }
 
         public abstract bool IsValueTypeFromConstraintTypes { get; }