Sanitize dollar identifiers with leading zeros in Identifier.

[MAJKFL]

This PR introduces sanitization of dollar identifiers with leading zeros to Identifier.

The compiler doesn't treat dollar identifiers with leading zeros differently than the "canonical" ones, so for the following piece of code:

var foo = {
  print($0, $00000000, $1, $00001)
}

foo(4, 2)

The result will be:

4 4 2 2

This PR will also enable SwiftLexicalLookup to properly handle this edge case when introducing dollar identifiers as names in closures.

[MAJKFL]

@swift-ci Please test

[ahoppen]

How did you find that, Jakub?

[ahoppen]

What’s the reason why you added the staticString argument label?

[MAJKFL]

I noticed this used to produce a compilation error

let identifier = Identifier("smth") // Error: Ambiguous use of 'init(_:)'

Interestingly, these two worked absolutely fine

let x: StaticString = "smth"
let identifier1 = Identifier(x)
let identifier2: Identifier = Identifier("smth")

It seemed to me a bit odd overloading the initializer worked like that in this case. Is there a reason where a string literal could be used with the other init?(_ token: TokenSyntax)?

This behavior doesn't happen with an explicit argument label so that's why I changed that. Do you think there could be a better way to fix this?

[ahoppen]

Oh, I see. TokenSyntax is expressible by string literal as well, that’s why it’s ambiguous.

I’m not a fan of the staticString label. How about we use the argument label to convey that the string needs to be canonical? That way a user will get the overload via TokenSyntax that canonicalizes the name by default and they need to opt into this faster but more restrictive overload.

Ie. change it to init(canonicalName:) or something of the sort.

[MAJKFL]

Oh that makes sense why it didn't work with string literals, thanks for explanation. I also like the idea of init(canonicalName:). I changed it.

[MAJKFL]

How did you find that, Jakub?

We’ve discovered this with @DougGregor when validating SwiftLexicalLookup against ASTScope. We were trying out different edge cases and noticed this behavior.

SwiftLexicalLookup handles dollar identifiers slightly differently for anonymous lookup than the compiler. When encountering a closure without parameters, the lookup just prompts clients with LookupResult.mightIntroduceDollarIdentifiers result flag.

For a lookup with a particular identifier, it does introduce a specific dollar identifier name (LookupName.dollarIdentifier), and that’s where we need its canonical representation to not introduce a monstrosity such as $000000000042.

[MAJKFL]

@swift-ci Please test Windows

[DougGregor]

Looks reasonable to me, thank you

[MAJKFL]

@swift-ci Please test

[MAJKFL]

@swift-ci Please test Windows

[ahoppen]

@swift-ci Please test Windows

[DougGregor]

@swift-ci Please test Windows