It looks like IsEqualEvaluation is missing a type check for indexer evaluations

[AlekseyTs]

In theory slicing can result in a collection with an element type that is different from the element type of the original collection. Therefore, I think the case at

roslyn/src/Compilers/CSharp/Portable/Binder/DecisionDagBuilder.cs

Line 1719 in 76ad580

case (BoundDagIndexerEvaluation s1, BoundDagIndexerEvaluation s2):

should also check that the result type for both indexer evaluations is equal.

[AlekseyTs]

I think the following unit-test demonstrates the problem (reflects the current behavior):

    [Fact]
    [WorkItem("https://github.com/dotnet/roslyn/issues/82398")]
    public void IndexerEvaluation_DifferentResultTypes()
    {
        var source = """
            #nullable disable

            using System;
            
            class CollectionA
            {
                public int Length => 3;
                public int this[int i] => 101;
                public CollectionB Slice(int start, int length) => new CollectionB();
            }
            
            class CollectionB
            {
                public int Length => 1;
                public string this[int i] => "102";
            }
            
            class Program
            {
                static bool Test(CollectionA a1)
                {
                    return a1 is [100, ..] or [.. ["102", ..]];
                }
                
                static void Main()
                {
                    var a1 = new CollectionA();
                    Console.WriteLine(Test(a1));
                }
            }
            """;

        var compilation = CreateCompilationWithIndexAndRange(source, options: TestOptions.DebugExe, parseOptions: TestOptions.RegularPreview.WithFeature(Feature.RunNullableAnalysis, "never"));

        VerifyDecisionDagDump<IsPatternExpressionSyntax>(compilation,
@"[0]: t0 != null ? [1] : [7]
[1]: t1 = t0.Length; [2]
[2]: t1 >= 1 ? [3] : [7]
[3]: t2 = t0[0]; [4]
[4]: t2 == 100 ? [6] : [5]
[5]: t2 == ""102"" ? [6] : [7]
[6]: leaf <isPatternSuccess> `[100, ..] or [.. [""102"", ..]]`
[7]: leaf <isPatternFailure> `[100, ..] or [.. [""102"", ..]]`
");

        var verifier = CompileAndVerify(compilation, expectedOutput: "False").VerifyDiagnostics();

        verifier.VerifyIL("Program.Test", @"
{
  // Code size       57 (0x39)
  .maxstack  2
  .locals init (int V_0,
            int V_1,
            string V_2,
            bool V_3,
            bool V_4)
  IL_0000:  nop
  IL_0001:  ldarg.0
  IL_0002:  brfalse.s  IL_002f
  IL_0004:  ldarg.0
  IL_0005:  callvirt   ""int CollectionA.Length.get""
  IL_000a:  stloc.0
  IL_000b:  ldloc.0
  IL_000c:  ldc.i4.1
  IL_000d:  blt.s      IL_002f
  IL_000f:  ldarg.0
  IL_0010:  ldc.i4.0
  IL_0011:  callvirt   ""int CollectionA.this[int].get""
  IL_0016:  stloc.1
  IL_0017:  ldloc.1
  IL_0018:  ldc.i4.s   100
  IL_001a:  beq.s      IL_002b
  IL_001c:  ldloc.2
  IL_001d:  ldstr      ""102""
  IL_0022:  call       ""bool string.op_Equality(string, string)""
  IL_0027:  brtrue.s   IL_002b
  IL_0029:  br.s       IL_002f
  IL_002b:  ldc.i4.1
  IL_002c:  stloc.3
  IL_002d:  br.s       IL_0031
  IL_002f:  ldc.i4.0
  IL_0030:  stloc.3
  IL_0031:  ldloc.3
  IL_0032:  stloc.s    V_4
  IL_0034:  br.s       IL_0036
  IL_0036:  ldloc.s    V_4
  IL_0038:  ret
}
");
    }

Note the same Dag Temp is compared to values of different type:

[4]: t2 == 100 ? [6] : [5]
[5]: t2 == ""102"" ? [6] : [7]

In IL, an uninitialized local is compared with string:

  IL_001c:  ldloc.2
  IL_001d:  ldstr      ""102""
  IL_0022:  call       ""bool string.op_Equality(string, string)""