Forbid unsafe types in records

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

@@ -156,3 +156,30 @@ struct S
     public static void M([UnscopedRef] ref int x) { }
 }
 ```
+
+## `record` and `record struct` types cannot define pointer type members, even when providing their own Equals implementations
+
+PROTOTYPE: Figure what version this is going into
+
+***Introduced in Visual Studio 2022 version 17.14***
+
+The specification for `record class` and `record struct` types indicated that any unsafe types are disallowed. However, this was not
+enforced correctly in 2 scenarios:
+
+1. When the `record class` or `record struct` type defined its own `Equals` implementation.
+2. When the field type only used the unsafe type in a nested context, such as `int*[]`.
+
+The compiler now correctly forbids both scenarios.
+
+```cs
+unsafe record struct R1(
+    int* P // Previously fine, now CS8908
+)
+{
+    public bool Equals(R other) => true;
+}
+
+unsafe record struct R2(
+    int*[] P // Previously fine, now CS8908
+);
+```

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

@@ -3022,7 +3022,7 @@ private bool MethodGroupConversionHasErrors(
                 return true;
             }
 
-            if ((selectedMethod.HasParameterContainingPointerType() || selectedMethod.ReturnType.ContainsPointer())
+            if ((selectedMethod.HasParameterContainingPointerType() || selectedMethod.ReturnType.ContainsPointerOrFunctionPointer())
                 && ReportUnsafeIfNotAllowed(syntax, diagnostics))
             {
                 return true;

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

@@ -561,7 +561,7 @@ private void CheckContextForPointerTypes(ExpressionSyntax node, BindingDiagnosti
             if (!expr.HasAnyErrors && !IsInsideNameof)
             {
                 TypeSymbol exprType = expr.Type;
-                if ((object)exprType != null && exprType.ContainsPointer())
+                if ((object)exprType != null && exprType.ContainsPointerOrFunctionPointer())
                 {
                     ReportUnsafeIfNotAllowed(node, diagnostics);
                     //CONSIDER: Return a bad expression so that HasErrors is true?
@@ -3666,7 +3666,7 @@ void createParamsCollection(
             void reportUnsafeIfNeeded(MemberResolutionResult<TMember> methodResult, BindingDiagnosticBag diagnostics, BoundExpression argument, TypeWithAnnotations parameterTypeWithAnnotations)
             {
                 // NOTE: for some reason, dev10 doesn't report this for indexer accesses.
-                if (!methodResult.Member.IsIndexer() && !argument.HasAnyErrors && parameterTypeWithAnnotations.Type.ContainsPointer())
+                if (!methodResult.Member.IsIndexer() && !argument.HasAnyErrors && parameterTypeWithAnnotations.Type.ContainsPointerOrFunctionPointer())
                 {
                     // CONSIDER: dev10 uses the call syntax, but this seems clearer.
                     ReportUnsafeIfNotAllowed(argument.Syntax, diagnostics);

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

@@ -915,7 +915,7 @@ protected NamespaceOrTypeOrAliasSymbolWithAnnotations BindNonGenericSimpleNamesp
                             ReportUseSiteDiagnosticForDynamic(diagnostics, node);
                         }
 
-                        if (type.ContainsPointer())
+                        if (type.ContainsPointerOrFunctionPointer())
                         {
                             ReportUnsafeIfNotAllowed(node, diagnostics);
                         }

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

@@ -919,7 +919,7 @@ private void ValidateUnsafeParameters(BindingDiagnosticBag diagnostics, Immutabl
                 var numParametersToCheck = Math.Min(targetParameterTypes.Length, ParameterCount);
                 for (int i = 0; i < numParametersToCheck; i++)
                 {
-                    if (targetParameterTypes[i].Type.ContainsPointer())
+                    if (targetParameterTypes[i].Type.ContainsPointerOrFunctionPointer())
                     {
                         this.Binder.ReportUnsafeIfNotAllowed(this.ParameterLocation(i), diagnostics);
                     }

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

@@ -115,7 +115,7 @@ internal static bool HasParameterContainingPointerType(this Symbol member)
         {
             foreach (var parameterType in member.GetParameterTypes())
             {
-                if (parameterType.Type.ContainsPointer())
+                if (parameterType.Type.ContainsPointerOrFunctionPointer())
                 {
                     return true;
                 }

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

@@ -57,15 +57,20 @@ protected void TypeChecks(TypeSymbol type, BindingDiagnosticBag diagnostics)
             }
             else if (type.IsVoidType())
             {
-                diagnostics.Add(ErrorCode.ERR_FieldCantHaveVoidType, TypeSyntax?.Location ?? this.GetFirstLocation());
+                diagnostics.Add(ErrorCode.ERR_FieldCantHaveVoidType, getTypeErrorLocation());
             }
             else if (type.IsRestrictedType(ignoreSpanLikeTypes: true))
             {
-                diagnostics.Add(ErrorCode.ERR_FieldCantBeRefAny, TypeSyntax?.Location ?? this.GetFirstLocation(), type);
+                diagnostics.Add(ErrorCode.ERR_FieldCantBeRefAny, getTypeErrorLocation(), type);
             }
             else if (type.IsRefLikeOrAllowsRefLikeType() && (this.IsStatic || !containingType.IsRefLikeType))
             {
-                diagnostics.Add(ErrorCode.ERR_FieldAutoPropCantBeByRefLike, TypeSyntax?.Location ?? this.GetFirstLocation(), type);
+                diagnostics.Add(ErrorCode.ERR_FieldAutoPropCantBeByRefLike, getTypeErrorLocation(), type);
+            }
+            else if (!this.IsStatic && type.ContainsPointerOrFunctionPointer() && (ContainingType.IsRecord || ContainingType.IsRecordStruct))
+            {
+                // The type '{0}' may not be used for a field of a record.
+                diagnostics.Add(ErrorCode.ERR_BadFieldTypeInRecord, getTypeErrorLocation(), type);
             }
             else if (IsConst && !type.CanBeConst())
             {
@@ -96,6 +101,11 @@ protected void TypeChecks(TypeSymbol type, BindingDiagnosticBag diagnostics)
             }
 
             diagnostics.Add(this.ErrorLocation, useSiteInfo);
+
+            Location getTypeErrorLocation()
+            {
+                return TypeSyntax?.Location ?? this.GetFirstLocation();
+            }
         }
 
         public abstract bool HasInitializer { get; }

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

@@ -1839,9 +1839,18 @@ protected virtual void ValidatePropertyType(BindingDiagnosticBag diagnostics)
             {
                 diagnostics.Add(ErrorCode.ERR_FieldCantBeRefAny, TypeLocation, type);
             }
-            else if (this.IsAutoPropertyOrUsesFieldKeyword && type.IsRefLikeOrAllowsRefLikeType() && (this.IsStatic || !this.ContainingType.IsRefLikeType))
+
+            if (this.IsAutoPropertyOrUsesFieldKeyword)
             {
-                diagnostics.Add(ErrorCode.ERR_FieldAutoPropCantBeByRefLike, TypeLocation, type);
+                if (!this.IsStatic && type.ContainsPointerOrFunctionPointer() && (ContainingType.IsRecord || ContainingType.IsRecordStruct))
+                {
+                    // The type '{0}' may not be used for a field of a record.
+                    diagnostics.Add(ErrorCode.ERR_BadFieldTypeInRecord, TypeLocation, type);
+                }
+                else if (type.IsRefLikeOrAllowsRefLikeType() && (this.IsStatic || !this.ContainingType.IsRefLikeType))
+                {
+                    diagnostics.Add(ErrorCode.ERR_FieldAutoPropCantBeByRefLike, TypeLocation, type);
+                }
             }
 
             if (type.IsStatic)

src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordEquals.cs

@@ -136,12 +136,7 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
                         fields.Add(f);
 
                         var parameterType = f.Type;
-                        if (parameterType.IsPointerOrFunctionPointer())
-                        {
-                            diagnostics.Add(ErrorCode.ERR_BadFieldTypeInRecord, f.GetFirstLocationOrNone(), parameterType);
-                            foundBadField = true;
-                        }
-                        else if (parameterType.IsRestrictedType())
+                        if (parameterType.ContainsPointerOrFunctionPointer() || parameterType.IsRestrictedType())
                         {
                             // We'll have reported a diagnostic elsewhere (SourceMemberFieldSymbol.TypeChecks)
                             foundBadField = true;

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

@@ -1278,7 +1278,7 @@ internal static bool ContainsTupleNames(this TypeSymbol type) =>
         internal static bool ContainsFunctionPointer(this TypeSymbol type) =>
             type.VisitType((TypeSymbol t, object? _, bool _) => t.IsFunctionPointer(), null) is object;
 
-        internal static bool ContainsPointer(this TypeSymbol type) =>
+        internal static bool ContainsPointerOrFunctionPointer(this TypeSymbol type) =>
             type.VisitType((TypeSymbol t, object? _, bool _) => t.TypeKind is TypeKind.Pointer or TypeKind.FunctionPointer, null) is object;
 
         /// <summary>