Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Reword callable reference and class literal resolution algorithm, explain some corner cases (#5) #43

Merged
merged 7 commits into from
Aug 15, 2016
Merged

Reword callable reference and class literal resolution algorithm, explain some corner cases (#5) #43

Changes from 1 commit
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
867de35
Update LHS resolution algorithm with a special case for objects (#5)
udalov Aug 9, 2016
add2b2d
Minor clarifications about function type and function/property refere…
udalov Aug 9, 2016
ce3fd7f
Clarify class literals for primitive types (#5)
udalov Aug 10, 2016
fc82924
Substitution of arguments with stars in class literals (#5)
udalov Aug 10, 2016
80e9cd3
Fix typo (#5)
udalov Aug 10, 2016
0cbc08e
Do not erase arguments of Array expressions in class literals, add ex…
udalov Aug 12, 2016
4587f89
Add TODO about Array type arguments in JS (#5)
udalov Aug 15, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 16 additions & 4 deletions proposals/bound-callable-references.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -162,12 +162,24 @@ fun test() {
}
```

Once the LHS is type-checked and its type is determined to be `T`, the type of the whole class literal expression is `kotlin.reflect.KClass<T'>` where `T'` is a type obtained by _substituting `T`'s arguments with star projections (`*`)_. Example:
Once the LHS is type-checked and its type is determined to be `T`, the type of the whole class literal expression is `KClass<erase(T)>`, where `erase(T)` represents the most accurate possible type-safe representation of the type `T` and is obtained by substituting `T`'s arguments with star projections (`*`), except when the type is an array.
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Type-arguments of arrays are not fully known at runtime either: their nullability is unclear. Does it matter in this context?

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It does matter, and we may revisit it in the future, but type-checking arrayOfStrings::class to KClass<Array<*>> would be rather unhelpful from Java user's point of view. We've briefly discussed this with @erokhins and decided (for now) to type-check arrayOfStrings::class to KClass<Array<String>>. We should discuss this in detail later anyway.

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Note in JS we don't know anything about type-arguments of arrays at runtime.


More formally, let `T` = `C<A1, ..., AN>`, where `C` is a class and `N`, the number of type arguments, might be zero. `erase(T)` is then defined as follows:
- if `C` = `kotlin.Array`:
- if `A1` is a projection of some type (covariant, contravariant, or star), `erase(T)` = `kotlin.Array<*>`
- otherwise `erase(T)` = `kotlin.Array<erase(A1)>`
- otherwise `erase(T)` = `C<*, ..., *>`

Examples:
```
fun test() {
"a"::class // KClass<String>
listOf("a")::class // KClass<List<*>> (not "KClass<List<String>>"!)
mapOf("a" to 42)::class // KClass<Map<*, *>>
"a"::class // KClass<String>
listOf("a")::class // KClass<List<*>> (not "KClass<List<String>>"!)
listOf(listOf("a"))::class // KClass<List<*>> (not "KClass<List<List<String>>>"!)
mapOf("a" to 42)::class // KClass<Map<*, *>>
arrayOf("a")::class // KClass<Array<String>>
arrayOf(arrayOf("a"))::class // KClass<Array<Array<String>>>
arrayOf(listOf("a"))::class // KClass<Array<List<*>>>
}
```

Expand Down