🔧 For readability I would prefer to clean-up the layout a little bit and keep an empty line between the two boolean statements
🤔 Any links to background material that we can add here for future reference?

No real background material actually, besides the link already posted in the linked issue (https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-10.0/record-structs#open-questions) where it is stated that recognizing record structs is an open point.
This pull request is based on common sense and heuristic testing, apparently giving good results but not supported by official documentation.

I would mention exactly using in-line comments

While this is probably the best we can currently do, I wonder a bit if this is still too broad a check?

I'm afraid of this too. This is backed by MSDN too (see comment). I've tried my best to "crack" this test and was not able to, but please feel free to add counter-examples.

Checking for one operator should be enough.

var isRecordStruct = t.BaseType == typeof(ValueType) &&
                     t.GetMethod("op_Equality", BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly, null, new[] { t, t }, null)?
                        .GetCustomAttribute(typeof(CompilerGeneratedAttribute)) is not null;

I had another look at creating a heuristic to identify record structs with few false positives.

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-10.0/record-structs#printing-members-printmembers-and-tostring-methods

specifies that a record struct contains a synthesized (read has [CompilerGenerated])

private bool PrintMembers(System.Text.StringBuilder builder)

The name PrintMembers is also a public part of Roslyn.

var isRecordStruct = t.BaseType == typeof(ValueType) &&
                     t.GetMethod("PrintMembers", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(StringBuilder) }, null)?
                        .GetCustomAttribute(typeof(CompilerGeneratedAttribute)) is { };

What do you think about this?

That may be a good catch. I'll look into it!

Not sure I understand you here 🤔
As a record struct currently doesn't have any unspeakable parts, it's always possible to write a struct in plain C# that looks like a record struct.

E.g. this is valid C# code, SharpLab

public struct A
{
    [CompilerGenerated]
    public static bool operator ==(A x, A y) => true;
    
    [CompilerGenerated]
    public static bool operator !=(A x, A y) => false 
}

I tried another thing.

I made a record struct Auto {} and copied its output back into regular C# code.
The only thing I wasn't allowed to was using [IsReadOnly] as that gave a compiler error.

error CS8335: Do not use 'System.Runtime.CompilerServices.IsReadOnlyAttribute'. This is reserved for compiler usage.

PrintMembers is annotated with [IsReadOnly]

So what do you think about checking for this?

var isRecordStruct = t.BaseType == typeof(ValueType) &&
                     t.GetMethod("PrintMembers", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(StringBuilder) }, null)?
                        .GetCustomAttribute(typeof(IsReadOnlyAttribute)) is { };

I don't know if an arbitrary source generator is allowed to use [IsReadOnly].
IL weaving would most likely be able to circumvent CS8335, but we aren't looking for a bullet proof solution.

SharpLab

Interesting! I didn't know one could annotate with [CompilerGenerated] in source code; it looks a little silly to me that you can, but it is what it is I suppose :)
In this case, I definitely like your proposal with PrintMembers and IsReadOnly more. Let me try to give a couple of final touches and I'll be back with a new commit.

@jnyrup I have just tried the last proposal checking for a PrintMembers annotated with IsReadOnly. IsReadOnly is not available on NET47 and NETSTANDARD2_0, so it does not compile on those target, but here the problem is just my ignorance on properly handling multi-target.
The major problem for me is that the check fails for the MyReadOnlyRecordStruct and MyRecordStructWithCustomPrintMembers tests, for which PrintMembers has not the IsReadOnly attribute.
For this reason, at the end of the day (literally, for me 😄 ) I believe the lesser evil for now is checking for compiler generated equality, knowing that we can have a false positive if someone uses the [CompilerGenerated] attribute in source code (I have added a test to document this).

Aha!
I hadn't thought about the case in MyRecordStructWithCustomPrintMembers where one implements PrintMembers themselves such that the compiler doesn't create one.
Well found 👍

So it seems there will always be a PrintMembers, but we don't know who wrote it.

This code handles all your test cases and the false positive.

public static bool IsRecord(this Type type)
{
    return TypeIsRecordCache.GetOrAdd(type, static t => t.IsRecordClass() || t.IsRecordStruct());
}

private static bool IsRecordClass(this Type type)
{
    return type.GetMethod("<Clone>$", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) is { } &&
            type.GetProperty("EqualityContract", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)?
                .GetMethod?.IsDecoratedWith<CompilerGeneratedAttribute>() == true;
}

private static bool IsRecordStruct(this Type type)
{
    // As noted here: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-10.0/record-structs#open-questions
    // recognizing record structs from metadata is an open point. The following check is based on common sense
    // and heuristic testing, apparently giving good results but not supported by official documentation.
    return type.BaseType == typeof(ValueType) &&
            type.GetMethod("PrintMembers", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(StringBuilder) }, null) is { } &&
            type.GetMethod("op_Equality", BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly, null, new[] { type, type }, null)?
                .IsDecoratedWith<CompilerGeneratedAttribute>() == true;
}

I would be confident enough with this one.

Good idea: this way we rely on the two documented behaviors of record structs!
There is still a small possibility of a false positive, where one both implements a PrintMember and annotates equality with [CompilerGenerated] (I have added a test for reference), but I'd consider such code as deliberate sabotage 😄

Checking for one operator should be enough.

var isRecordStruct = t.BaseType == typeof(ValueType) &&
                     t.GetMethod("op_Equality", BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly, null, new[] { t, t }, null)?
                        .GetCustomAttribute(typeof(CompilerGeneratedAttribute)) is not null;