[SR-12096] Index missing references to initializers in Result extensions

[kastiglione]

Previous ID	SR-12096
Radar	rdar://problem/58997223
Original Reporter	@kastiglione
Type	Bug

Attachment: Download

Additional Detail from JIRA

Votes	0
Component/s
Labels	Bug
Assignee	None
Priority	Medium

md5: 1ee7c9ff01d3a11c55b26c435d413b5a

relates to:

• [SR-12047] Types referenced with is Foo not in index #54483
• [SR-12102] Discrepancy in indexstore for function parameter references #54538

Issue Description:

In a specific case, the index is missing references to initializers added in an enum extension. In this case, Result.

This example is two parts. First, an extension on Result that adds initializers:

extension Result {
    public init(value: Success) {
        self = .success(value)
    }

    public init(error: Failure) {
        self = .failure(error)
    }
}

The second part is calling these initializers with explicit types:

let value = Result<Int, SomeError>(value: 5)
let error = Result<Int, SomeError>(error: .mistake)

In this case, the index does not contain a reference to the initializers. This can be seen in Xcode, where searching for references to those initializers produce only the initializers themselves.

This problem only happens when the generic types are explicit. If they're inferred, then the index does correctly include proper references. Compare:

let value: Result<Int, SomeError> = Result(value: 5)
let error: Result<Int, SomeError> = Result(error: .mistake)

In this case, the index works as expected.

In the problem case, the indexstore record files of the callers does not contain references to the initializer's symbol (USR).

Attached is a sample project, and a couple screenshots showing Xcode can't find references even though they exist in the test target.

[benlangmuir]

@swift-ci create

[benlangmuir]

I can reproduce this in swift-5.2.

[keith]

Here's a single file repro case that still repros with Swift 5.8:

extension Result {
    public init(value: Success) {
        self = .success(value)
    }
}

let good: Result<Int, Error> = Result(value: 1)
let bad = Result<Int, Error>(value: 1)

You can see the missing reference with indexutil-annotate:

/*
          enum=Result=s:s6ResultO=reference, extendedBy
          extension.swiftExtensionOfEnum=Result=s:e:s:s6ResultO3fooE5valueAByxq_Gx_tcfc=definition
          v  */
extension Result {
    /*
           constructor=init(value:)=s:s6ResultO3fooE5valueAByxq_Gx_tcfc=definition, childOf
           |    parameter=value=s:s6ResultO3fooE5valueAByxq_Gx_tcfcADL_xvp=definition, childOf
           |    |      typealias.swiftGenericParameter=Success=s:s6ResultO7Successxmfp=reference, containedBy
           v    v      v  */
    public init(value: Success) {
        /*
                enumConstant=success(_:)=s:s6ResultO7successyAByxq_GxcADms5ErrorR_r0_lF=reference, call, calledBy, containedBy
                |       parameter=value=s:s6ResultO3fooE5valueAByxq_Gx_tcfcADL_xvp=reference, read, containedBy
                v       v  */
        self = .success(value)
    }
}

/*
    function.accessorGetter=getter:good=s:3foo4goods6ResultOySis5Error_pGvg=definition, implicit, childOf, accessorOf
    function.accessorSetter=setter:good=s:3foo4goods6ResultOySis5Error_pGvs=definition, implicit, childOf, accessorOf
    variable=good=s:3foo4goods6ResultOySis5Error_pGvp=definition
    |     enum=Result=s:s6ResultO=reference, containedBy
    |     |      struct=Int=s:Si=reference, containedBy
    |     |      |    protocol=Error=s:s5ErrorP=reference, containedBy
    |     |      |    |        enum=Result=s:s6ResultO=reference, containedBy
    |     |      |    |        constructor=init(value:)=s:s6ResultO3fooE5valueAByxq_Gx_tcfc=reference, call, containedBy
    v     v      v    v        v  */
let good: Result<Int, Error> = Result(value: 1)
/*
    function.accessorGetter=getter:bad=s:3foo3bads6ResultOySis5Error_pGvg=definition, implicit, childOf, accessorOf
    function.accessorSetter=setter:bad=s:3foo3bads6ResultOySis5Error_pGvs=definition, implicit, childOf, accessorOf
    variable=bad=s:3foo3bads6ResultOySis5Error_pGvp=definition
    |     enum=Result=s:s6ResultO=reference, containedBy
    |     |      struct=Int=s:Si=reference, containedBy
    |     |      |    protocol=Error=s:s5ErrorP=reference, containedBy
    v     v      v    v  */
let bad = Result<Int, Error>(value: 1)

[keith]

Less noisy case:

struct A<T> {
  init(value: T) {}
}

_ = A(value: 1)
_ = A<Int>(value: 1)

/*
       struct=A=s:3foo1AV=definition
       | typealias.swiftGenericParameter=T=s:3foo1AV1Txmfp=definition, childOf
       v v  */
struct A<T> {
  /*
  constructor=init(value:)=s:3foo1AV5valueACyxGx_tcfc=definition, childOf
  |    parameter=value=s:3foo1AV5valueACyxGx_tcfcADL_xvp=definition, childOf
  |    |      typealias.swiftGenericParameter=T=s:3foo1AV1Txmfp=reference, containedBy
  v    v      v  */
  init(value: T) {}
}

/*
    struct=A=s:3foo1AV=reference
    constructor=init(value:)=s:3foo1AV5valueACyxGx_tcfc=reference, call
    v  */
_ = A(value: 1)
/*
    struct=A=s:3foo1AV=reference
    | struct=Int=s:Si=reference
    v v  */
_ = A<Int>(value: 1)