From f0e265d8ce34e7d45df9657a76093bf8cad9b731 Mon Sep 17 00:00:00 2001 From: Andy Gocke Date: Fri, 20 Sep 2019 16:34:36 -0700 Subject: [PATCH] Add LDM notes for 2019-09-18 --- meetings/2019/LDM-2019-09-18.md | 97 +++++++++++++++++++++++++++++++++ meetings/2019/README.md | 35 +++++++----- 2 files changed, 118 insertions(+), 14 deletions(-) create mode 100644 meetings/2019/LDM-2019-09-18.md diff --git a/meetings/2019/LDM-2019-09-18.md b/meetings/2019/LDM-2019-09-18.md new file mode 100644 index 0000000..e86c028 --- /dev/null +++ b/meetings/2019/LDM-2019-09-18.md @@ -0,0 +1,97 @@ + +# C# Language Design Meeting for September 18th, 2019 + +## Agenda + +Triage: + +1. Proposals with complete designs: + + - https://github.com/dotnet/csharplang/issues/1888 Champion "Permit attributes on local functions" + - https://github.com/dotnet/csharplang/issues/100 Champion "Target-typed new expression" + +2. Target typing and best-common-type features: + + - https://github.com/dotnet/csharplang/issues/2473 Proposal: Target typed null coalescing (??) expression + - https://github.com/dotnet/csharplang/issues/2460 Champion: target-typed conditional expression + - https://github.com/dotnet/csharplang/issues/881 Permit ternary operation with int? and double operands + - https://github.com/dotnet/csharplang/issues/33 Champion "Nullable-enhanced common type" + +## Discussion + +### Attributes on local functions + +Issue #1888 + +The only major concern about the feature is whether or not the attributes are guaranteed to be emitted to +the lowered method, assuming there is a lowered method. For all current lowering strategies, there is a +specific place to put the attributes. The proposal is that we always emit attributes for our current +scenarios, but don't guarantee in the language that all attributes will survive rewriting. + +There is one exception to the above, which is static local functions. Static local functions are specified +to always emit a static method with the same signature as the local function (although there are bugs about +this today). Attributes on static local function would have a similar guarantee, meaning that they are always +emitted to the lowered methods, on the exact same parameters they were applied to. + +**Conclusion** + +Proposal accepted, attributes will be allowed on local functions. + +### Target-typed new + +Issue #100 + +We like the feature and already have a design. However, we want to do a quick review that we still like the +design, taking into account all the changes we've made to the language since it was proposed. + +**Conclusion** + +Accepted, pending review. + +### Target-typed conditional expression and nullable-enhanced common type + +Issue #2460 and issue #33 + +The main problem is that providing a target-typing for the switch expression +may have made issue #33 a breaking change. In general, additional target-typing +(on top of a natural type) works by calculating the target type if there is no +viable natural type. By allowing more natural types, it reduces the ability to +use target-typing, which may allow more resulting types than the natural type +inference. + +Overload resolution is a good example. If you have two methods + +```C# +void M(int? x) { ... } +void M(short? y) { ... } +``` + +and a call `M(e switch { ... => 1, ... => null })`, when we do overload resolution +we consider the target type for the `switch`, which consists of the target type +for each of the candidates. For target type, `short` is a better target for `int`. +If we improved the natural type, then the natural type of `1` would be `int`. Then, +if we improve the natural type of `e switch { ... => 1, ... => null}` to be `int?`, +then a different overload (`M(int? x)`) will be chosen. + +There's also a pretty clear trade-off here. Target-typing may allow more viable +types, but it falls over in the presence of type inference or if the target is +so broad as to be useless (like if the target-type is `object`). + +Additionally, the proposal for target-typing the conditional expression (`?:`) will have +different semantics from the target-typing for the switch expression, to avoid a breaking change. +It may be desirable to unify the behavior of things like `?:` and switch expression, even if that +means that the switch expression would be more limited, due to the backwards compatibility +constraints of `?:`. + +**Conclusion** + +Let's do some work to see if we can alter the interaction of target-typing and common type +inference to add the proposed new common types without introducing breaking changes with +target-typing. The hope is that such a rule could be general enough to apply to other potential +breaks in the future (in case we find more potential improvements to common type). + +In addition, we would like to know the effect of changing switch expressions to prefer the common +type, if one exists. We hope that any difference would be uncommon in practice, but it would be +useful to know if there are common instances where this would break. This would be used to decide +if we would adjust the behavior of the switch expression to match the proposed behavior for the +conditional expression. \ No newline at end of file diff --git a/meetings/2019/README.md b/meetings/2019/README.md index 80fd507..61b00c4 100644 --- a/meetings/2019/README.md +++ b/meetings/2019/README.md @@ -8,6 +8,9 @@ ## Recurring topics - *Triage championed features* + - https://github.com/dotnet/csharplang/issues/2632 Champion: Switch expression as a statement expression + - https://github.com/dotnet/csharplang/issues/2608 module initializers + - *Triage milestones* - *Design review* @@ -21,20 +24,6 @@ - Records and related features (Andy) -## Sep 18, 2019 - -- Target typing and best-common-type features: - - https://github.com/dotnet/csharplang/issues/2473 Proposal: Target typed null coalescing (`??`) expression - - https://github.com/dotnet/csharplang/issues/2460 Champion: target-typed conditional expression - - https://github.com/dotnet/csharplang/issues/881 Permit ternary operation with int? and double operands - - https://github.com/dotnet/csharplang/issues/33 Champion "Nullable-enhanced common type" -- These have complete designs. Are we good to go? - - https://github.com/dotnet/csharplang/issues/1888 Champion "Permit attributes on local functions" - - https://github.com/dotnet/csharplang/issues/100 Champion "Target-typed `new` expression" -- These may be quick (famous last words): - - https://github.com/dotnet/csharplang/issues/2632 Champion: Switch expression as a statement expression - - https://github.com/dotnet/csharplang/issues/2608 module initializers - ## Aug 26, 2019 - Triage language features @@ -52,6 +41,24 @@ Overview of meetings and agendas for 2019 +## Sep 18, 2019 + +[C# Language Design Notes for Sep 18, 2019](LDM-2019-09-18.md) + +Triage: + +1. Proposals with complete designs: + + - https://github.com/dotnet/csharplang/issues/1888 Champion "Permit attributes on local functions" + - https://github.com/dotnet/csharplang/issues/100 Champion "Target-typed new expression" + +2. Target typing and best-common-type features: + + - https://github.com/dotnet/csharplang/issues/2473 Proposal: Target typed null coalescing (??) expression + - https://github.com/dotnet/csharplang/issues/2460 Champion: target-typed conditional expression + - https://github.com/dotnet/csharplang/issues/881 Permit ternary operation with int? and double operands + - https://github.com/dotnet/csharplang/issues/33 Champion "Nullable-enhanced common type" + ## Sep 16, 2019 [C# Language Design Notes for Sep 16, 2019](LDM-2019-09-16.md)