Comprehension indexing picks wrong candidates

[tsandall]

The comprehension indexing feature is picking the wrong candidates for index keys (or is not restrictive enough) when there are nested comprehensions that close over variables in the outer-most body. For example:

p := {x: vs |
        some x
        q[x]

        vs := {y: vs2 |
                some y
                r[y]

                vs2 := {z |         # index created with 'y' as key
                        some z
                        s[z]
                        z[0] = x    # indexer excludes 'x' as a candidate
                        z[1] = y    # indexer includes 'y' as a candidate
                        # f(z, x, y)  # uncomment this line and comment previous two to see correct result
                }
        }
}

q["A"]
q["B"]
r["C"]
r["D"]
s[["A", "C"]]
s[["A", "D"]]
s[["B", "C"]]

In this case, the correct result for p is:

{
        "A": {
            "C": [
                [
                    "A",
                    "C"
                ]
            ],
            "D": [
                [
                    "A",
                    "D"
                ]
            ]
        },
        "B": {
            "C": [
                [
                    "B",
                    "C"
                ]
            ],
            "D": []
        }
    }

However, because the compiler decides to index with only y as the index key, the actual result is:

{
        "A": {
            "C": [
                [
                    "A",
                    "C"
                ],
                [
                    "B",
                    "C"
                ]
            ],
            "D": [
                [
                    "A",
                    "D"
                ]
            ]
        },
        "B": {
            "C": [
                [
                    "A",
                    "C"
                ],
                [
                    "B",
                    "C"
                ]
            ],
            "D": [
                [
                    "A",
                    "D"
                ]
            ]
        }
    }

This appears to be a bug in the comprehension index build here. The indexer should either exclude the nested comprehension entirely (safer but worse performance) or it should include the correct candidates in the key.