[IDE] Resolve [.]Type completion for (any P). to produce singleton metatype instead of existential metatype

[Rajveer100]

Resolves #65843

The type completion for (any P). is a singleton meta type which currently falsely produces any P., i.e, an existential meta type.

[Rajveer100]

@AnthonyLatsis
Could you trigger the CI to see if it breaks other tests?

[AnthonyLatsis]

@swift-ci please smoke test Linux

[Rajveer100]

Currently IDE/complete_value_expr.swift test fails. Would the following also be considered a singleton meta type:

protocol ExistentialProto {
  static func staticMethod()
  func instanceMethod()
}

func testExistential() {
  let _ = ExistentialProto.#^PROTOCOLTYPE_DOT_1^#
// PROTOCOLTYPE_DOT_1: Begin completions, 3 items
// PROTOCOLTYPE_DOT_1-DAG: Keyword[self]/CurrNominal:          self[#(any ExistentialProto).Type#]; name=self
// PROTOCOLTYPE_DOT_1-DAG: Keyword/CurrNominal:                Protocol[#(any ExistentialProto).Type#]; name=Protocol
// PROTOCOLTYPE_DOT_1-DAG: Keyword/CurrNominal:                Type[#any ExistentialProto.Type#]; name=Type

[AnthonyLatsis]

What are your thoughts on these three completions: Does either look incorrect to you? If so, why?

[Rajveer100]

I think according to my changes since we are checking the canonical type to be ExistentialMetatypeType, the completion should be Type[#(any ExistentialProto).Type#]

[AnthonyLatsis]

P.Type is equivalent to any P.Type.

I think accordingly my changes since we are checking the canonical type to be ExistentialMetatypeType

According to this logic, the result of appending .Type is:

• An existential metatype if the type we are completing is also an existential metatype. This is not true: appending .Type to (any P.Type), which is an existential metatype, produces the singleton metatype (any P.Type).Type.
• A singleton metatype otherwise. This is also not true: appending .Type to any P, which is not an existential metatype, produces the existential metatype any P.Type.

[Rajveer100]

At the moment, the expected output as per my logic is Type[#(any ExistentialProto).Type#] which obviously fails. What I meant to say is, if the test is right, i.e, it's an existential meta type, the canonical type parameter which I added to the conditional check should succeed yielding the result.

[AnthonyLatsis]

#65843 (comment)

[Rajveer100]

In terms of the implementation, I feel like the syntactic sugar for parenthesis, i.e (...) affects the outcome although the canonical type is correctly parsed for the AST?

[AnthonyLatsis]

What do you mean by outcome, and what type are you referring to?

[Rajveer100]

With the latest changes, the test passes.

[AnthonyLatsis]

Please check that other IDE tests pass too.

[Rajveer100]

All tests pass:

Testing Time: 40.10s
  Excluded         : 9854
  Unsupported      :    6
  Passed           :  480
  Expectedly Failed:    1

2 warning(s) in tests

[AnthonyLatsis]

@swift-ci please smoke test Linux

[Rajveer100]

@AnthonyLatsis
Are there any other changes needed?

[Rajveer100]

@AnthonyLatsis

[Rajveer100]

@ahoppen
Could you review this?

[AnthonyLatsis]

Have you tried running the test locally?

[Rajveer100]

Yes, of course I did.

[Rajveer100]

Could you trigger the CI bot?

[AnthonyLatsis]

@swift-ci please smoke test macOS

[Rajveer100]

Build failure seems unrelated?

[Rajveer100]

Could you trigger CI once again?

[AnthonyLatsis]

@swift-ci please smoke test macOS

[Rajveer100]

CI looks good now.

[Rajveer100]

@AnthonyLatsis
Ping :)

[AnthonyLatsis]

Please make sure these cases work too:

P.#^TOKEN1^#             // Type[#any P.Type#]
((P)).#^TOKEN2^#         // Type[#any P.Type#]
(P.Type).#^TOKEN3^#      // Type[#any P.Type.Type#]
(any P).Type.#^TOKEN4^#  // Type[#(any P).Type.Type#]
(any P.Type).#^TOKEN5^#  // Type[#(any P.Type).Type#]

[Rajveer100]

Quick clarification:

((P)). can be deduced to (P). which is (any P)., so it shouldn't be existential right?