Skip to content

GROOVY-11492: add support for Type[] a = {} style array initialization - #3054

Open
eric-milles wants to merge 3 commits into
masterfrom
GROOVY-11492
Open

eric-milles wants to merge 3 commits into
masterfrom
GROOVY-11492

Conversation

@eric-milles

Copy link
Copy Markdown
Member

@daniellansun @paulk-asert Could you have a look at this and let me know if I'm heading in the right direction? I did mean to get this into 6.0 but missed the train.

GROOVY-8561 discusses Closure or SAM-type array promotion behavior that is impacted by this change.

The adoc updates are very hastily done to get this to the evaluation stage.

@asf-gitbox-commits
asf-gitbox-commits force-pushed the GROOVY-11492 branch 2 times, most recently from ba0fbfe to 79c4f01 Compare October 27, 2026 18:46
@paulk-asert

Copy link
Copy Markdown
Contributor

AI read:

Thanks Eric, I think the direction is promising. The predicate gating on type.dim0() holds up in practice. Untyped declarations, Object o = {}, and closures with params, ->, ; or labels all stay closures, so the change only kicks in where it should. For non-closure element types it's a clear win:

Code master PR
String[] a = {} 1-element array holding the closure []
Boolean[] a = { false } [true] (closure β†’ asBoolean) [false]
final int[] a = {1}, int[] a = {1,}, Object[] a = {1, 2} fail work
@CompileStatic String[] s = { 'a' } STC error works

The friction is where the element type can accept a closure, i.e. the GROOVY-8561 territory from 2018 (PR 691 didn't get the three +1s back then). Here are the edge cases I found, all run against your branch:

Behaviour changes for Closure/SAM/Object element types

Code master PR
Closure[] a = {} [Closure] []
def m(Closure[] cs = {}) [Closure] []
Object[] o = {} [Closure] []
Closure[] a = { 1 } [Closure] runtime failure
Closure[] a = { it } [Closure] runtime failure (no it)
String[] s = { it } 1-element array holding the closure runtime failure
Runnable[] r = { println 'x' } [Closure] compile error (command chain not allowed in array initializer)
Closure[] a = { println('x') } [Closure] prints x at declaration time and stores [null]

The last one worries me most because it changes behaviour silently. Any Closure[]/Runnable[]/Callable[] declaration whose single body expression isn't a command chain now runs eagerly, and its result (often null) passes the cast.

Body shape decides the meaning. Closure[] a = { it } is an array but { it -> it } is a closure. String[] s = { 'a' } is an array but { 'a'; 'b' } and { 'a' }.call() are closures. It's consistent with the grammar, but hard to explain to users.

Nested braces crash the parser. Object[] o = { {} } and Closure[] cs = { {}, {} } fail with "General error during parsing: Cannot invoke ClassNode.makeArray() because base is null". This already happens on master with the long form (new Object[]{{}}), see the //if (subType == null) produce closure or throw exception TODO in visitArrayInitializer. Your branch just makes it much easier to hit. It also blocks the escape hatch 8561 documented (Closure[] fns = { { } }). Taking the "produce closure" branch of that TODO would fix the crash and restore the escape hatch.

Other bits

  • Only a single declarator is handled: int[] a = {1}, b = {2} (valid Java) falls through to the closure path and fails at runtime with a cast error.
  • def m( { now reports the missing ) at line 2 col 2 instead of at the { (line 1 col 8). That comes from the formalParameter restructuring.
  • String[] a = { ['a', 'b'] } gives ["[a, b]"] (length 1, element is a String) in both dynamic and @CompileStatic: the list is coerced via toString. The long form new String[]{ ['a','b'] } does exactly that on master too, so it isn't new, but the terse form makes it easier to write, and Java would reject it.

Possible paths forward

  • A. Keep the current semantics (Java-faithful). This has the simplest rule but is a breaking change for Closure/SAM/Object arrays, including the silent eager-evaluation case. We'd need a dev-list decision (given the 8561 precedent), a COMPATIBILITY note, and ideally a compile-time diagnostic when a Closure/SAM-typed array element isn't a closure/lambda/method ref. That diagnostic can't be exact in dynamic code, e.g. { getHandler() } is legitimate.
  • B. Type-aware fallback (my preference). Use the array reading, except when the initializer is empty or has a single element and the leaf component type is Closure, a SAM type, or (TBD) Object. In that case keep today's closure promotion. Multi-element and nested initializers would always be arrays. Nothing that works today breaks, and Java users get the forms they actually paste (String[], int[], int[][], …). The catch is that SAM-ness is only known after resolution. AstBuilder could build both readings for the empty/single-element shapes and pick one post-resolution. I'm not sure where that hook best lives, and I'm curious what you think.
  • C. Only shapes no closure body can parse as. Treat the braces as an array only when there's a top-level comma or nested braces. It's cheap and non-breaking, but String[] s = {}, probably the most common pasted Java idiom, would keep today's odd result, so it doesn't really meet the ticket's goal.

Whichever way we go, fixing the nested-brace NPE seems worthwhile on its own, since it's a crash on master today. Tests pinning down the chosen semantics for {}, { it }, { -> }, { { } }, Runnable[] r = { … } and Object[] o = {} would also help.

@asf-gitbox-commits
asf-gitbox-commits force-pushed the GROOVY-11492 branch 2 times, most recently from 2b149a8 to 57980d8 Compare October 28, 2026 13:30
@eric-milles
eric-milles marked this pull request as ready for review October 28, 2026 13:31

@daniellansun daniellansun left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Thanks for pushing this, Eric β€” the dim0()-gated reading is the right place to attack GROOVY-11492, and the non-closure cases (primitives, String[], multi-dim, multi-declarator, parameter defaults) look much better than master.

I do not think this tip is mergeable yet, mainly because of Closure/SAM/Object element types.

  1. Silent behaviour change
    Closure[] a = { println('x') } (and similar Runnable/Callable bodies that are not command chains) no longer stores a closure; the body runs at initialisation and the element is typically null. That is a silent semantic change, which is harder to deal with than a hard failure. The same class of issue affects Object[] o = {}, Closure[] a = {}, and default parameters. COMPATIBILITY currently documents the Java-faithful reading, but there is no diagnostic and no tests locking these cases down.

  2. Nested "produce closure" path drops expressions
    When elementType.getComponentType() is null, visitArrayInitializer always keeps emptyOrValue.get(0) even if there are several initialisers. The comment says "0..1"; the code should either reject size() > 1 or build a proper multi-statement closure. As written, nested braces can quietly lose elements.

  3. Error quality regression
    def m( { now points at the closing } instead of the {. Prefer restoring the old recovery/location rather than updating the negative tests to accept the worse message.

  4. Design choice
    Paul's A/B/C write-up still stands. If we keep A, I would like a short dev-list confirmation, a stronger COMPATIBILITY note, and an explicit test matrix for {} / { it } / { -> } / { { } } / Runnable[] / Object[] / @CompileStatic. Path B (array reading except empty/singleton when the leaf type is Closure, SAM, or possibly Object) would avoid breaking working Groovy while still unlocking the Java forms people actually paste.

  5. Docs
    Happy to see the terse form documented, but the differences-from-Java / syntax pages still need a precise statement of when {} is an array vs a closure (and how to spell the old promotion).

Happy to re-review quickly once the Closure/SAM story and the nested truncation are settled.

@eric-milles

Copy link
Copy Markdown
Member Author

@daniellansun

re point 2: The goal was to move Object[] a = { {} } forward from a NPE to something usable. If there are still cases of mismatched dimensions, those could be filed as separate bugs.

re point 3: I looked at the other similar failure messages and found the new error location more consistent than the previous behavior.

re point 4: An email was sent to the dev list.

@daniellansun

Copy link
Copy Markdown
Contributor

@eric-milles Thanks for the follow-up.

2. Agreed β€” getting Object[] a = { {} } off the NPE path is the important win. Remaining mismatched-dimension / multi-expression nested cases can be separate tickets rather than blockers for this PR.

3. If the new caret lines up with the other similar recovery messages, I’m fine leaving the negative tests as updated.

4. Thanks for writing the list β€” I’ll follow that thread.

1 is still my main merge concern: Closure[] a = { println('x') } (and similar non-command-chain Runnable/Callable bodies) running at initialisation and storing null is a silent behaviour change. COMPATIBILITY covers the empty-{} promotion flip, but not that eager-eval case. Until the list settles A vs B, I’d still like either a compile-time diagnostic for Closure/SAM leaves, or path B (array reading except empty/singleton when the leaf is Closure/SAM, and possibly Object), plus tests for {} / { it } / { -> } / { { } } / Runnable[] / Object[] / @CompileStatic.

5. Happy with the terse form in the docs; a short explicit rule on the differences/syntax pages for when a non-empty {…} body is an array vs a closure (and how to spell the old promotion) would still help.

Happy to re-review quickly once the list direction is clear, or if you push diagnostics / B.

@eric-milles

eric-milles commented Oct 29, 2026 •

Copy link
Copy Markdown
Member Author

I added a test for the various behavior changes discussed above. 0029968 The silent failures appear to be restricted to Closure/SAM expression evaluation with the intent of coercion. I don't have an immediate plan to single those out for alternate parsing or some compiler warning or something else.

I did not include the @CompileStatic test case as STC does not support array promotion. All are STC errors.

@eric-milles

Copy link
Copy Markdown
Member Author

I added a warning for possible instances of closure coercion: 25ecea6

@daniellansun daniellansun left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Thanks for the follow-ups, Eric β€” the edge-case matrix in Groovy11492 and the new warning are real progress on the GROOVY-8561 concern from the earlier review. The non-closure paths (primitives, String[], multi-dim, multi-declarator) still look solid, and I’m fine leaving points 2/3 as previously agreed.

I still need two fixes before I can clear the prior REQUEST_CHANGES:

  1. Warning scope is too broad
    checkArrayInitEdgeCase currently warns for every single-element, non-ClosureExpression initializer when the leaf type is non-primitive. That fires on the main Java idioms this ticket unlocks, e.g. String[] a = {'x'} and Boolean[] a = { false } (and the docs example). Those should stay quiet.

    Please gate the diagnostic on leaves that could previously have meant β€œclosure promotion” β€” at least Closure and SAM-capable types, and Object if we want to cover that promotion flip too β€” rather than all reference component types. AstBuilder-time SAM detection is imperfect; a conservative Closure / Object / interface (or ClassHelper.isSAMType when resolved) gate is enough for this pass. Please also assert that the String/Boolean happy paths are warning-free.

  2. Formal-parameter defaults still skip the warning
    visitVariableDeclarator calls checkArrayInitEdgeCase, but visitFormalParameter does not. So def m(Closure[] cs = { println('x') }) can still eager-eval and store [null] with no diagnostic β€” the silent case that blocked the earlier review. Please run the same check on parameter array initializers (and cover it in Groovy11492).

Soft / non-blocking for a re-review once 1–2 land:

  • Docs still say β€œcommon scenarios” / β€œexcept for auto-promotion cases” without a precise array-vs-closure rule or how to spell the old promotion ({ -> }, outer braces/brackets). A short note in differences-from-Java / syntax (and optionally COMPATIBILITY for non-empty Closure/SAM bodies) would help.
  • Tip 25ecea64 is dirty vs master and has no checks reported yet; prior tip was all green. Please rebase and let tip CI finish.
  • Remaining exotic nested-dimension NPE/truncation can stay on follow-up tickets as discussed.

Happy to re-review quickly after the warning predicate is tightened and wired through parameter defaults.

if (ctx.arrayInitializer() != null) {
ClassNode elementType = parameterType.getComponentType();
ctx.arrayInitializer().putNodeMetaData("elementType", elementType);
init = configureAST(

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

After building this ArrayExpression, please also call checkArrayInitEdgeCase(init) (same as visitVariableDeclarator). Parameter defaults such as Closure[] cs = { println('x') } otherwise keep the silent eager-eval behaviour with no diagnostic.

@daniellansun daniellansun left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Thanks Eric β€” re-reviewed tip 25ecea64 against your inline reply on the warning predicate and the earlier edge-case / warning commits.

Progress since the first pass is real: the Groovy11492 matrix documents the Closure/SAM behaviour changes, and emitting some diagnostic for the eager-eval case is the right instinct. I still cannot clear the prior Request changes, for two concrete tip gaps:

  1. Warning predicate is still too broad.
    checkArrayInitEdgeCase warns on every single-element, non-ClosureExpression initializer whose leaf type is non-primitive. That fires on the main Java idioms this ticket unlocks β€” String[] a = {'x'}, Boolean[] a = { false }, and the docs examples β€” which should stay quiet.

    I hear that the type is unresolved at AstBuilder time and that a precise Closure/SAM gate is therefore unavailable. That does not force β€œwarn for all reference leaves”. Please pick one of:

    • Name-based heuristic on the unresolved ClassNode: warn only when the leaf’s name is Closure, Object, or a small allow-list of common SAM simple names (Runnable, Callable, Comparator, …), optionally plus β€œname looks like an interface” if you can do that cheaply from the node; or
    • Defer the diagnostic to a later phase that sees resolved types (ResolveVisitor / a small custom visitor) and then use ClassHelper.isSAMType / isDerivedFrom(CLOSURE_TYPE); or
    • Drop the warning for this PR and instead land path B (array reading except empty/singleton when the leaf is Closure/SAM/Object) once types are known β€” which avoids the silent eager-eval case without noisy warnings on String[].

    Please also assert in Groovy11492 that String[] / Boolean[] happy paths are warning-free.

  2. Formal-parameter defaults still skip the warning.
    visitVariableDeclarator calls checkArrayInitEdgeCase, but visitFormalParameter still builds the ArrayExpression without calling it. So def m(Closure[] cs = { println('x') }) can still eager-eval and store [null] with no diagnostic β€” the silent case that blocked the earlier review. Please wire the same check there and cover it in the test matrix.

Soft / non-blocking once 1–2 land:

  • Docs still need a precise array-vs-closure rule (and how to spell the old promotion: { -> }, outer braces/brackets), beyond β€œcommon scenarios”.
  • Tip still needs a clean CI run on current master.
  • Remaining exotic nested-dimension issues can stay on follow-up tickets as discussed.

Happy to re-review quickly after the predicate is narrowed (by name heuristic or deferred resolution) and parameter defaults emit the same diagnostic.

Request changes.

@apache apache deleted a comment from sonarqubecloud Bot Nov 15, 2026
@apache apache deleted a comment from github-actions Bot Nov 15, 2026
@apache apache deleted a comment from github-actions Bot Nov 15, 2026
@apache apache deleted a comment from codecov-commenter Nov 15, 2026
@apache apache deleted a comment from testlens-app Bot Nov 15, 2026
@codecov-commenter

Copy link
Copy Markdown

Codecov Report

❌ Patch coverage is 94.33962% with 3 lines in your changes missing coverage. Please review.
βœ… Project coverage is 74.5036%. Comparing base (a8e491b) to head (add5261).

Files with missing lines Patch % Lines
...va/org/apache/groovy/parser/antlr4/AstBuilder.java 94.3396% 1 Missing and 2 partials ⚠️
Additional details and impacted files

Impacted file tree graph

@@                Coverage Diff                 @@
##               master      #3054        +/-   ##
==================================================
+ Coverage     74.4991%   74.5036%   +0.0045%     
- Complexity      44952      44961         +9     
==================================================
  Files            1703       1703                
  Lines          152332     152359        +27     
  Branches        29187      29194         +7     
==================================================
+ Hits           113486     113513        +27     
+ Misses          28416      28413         -3     
- Partials        10430      10433         +3     
Files with missing lines Coverage Ξ”
...va/org/apache/groovy/parser/antlr4/AstBuilder.java 87.2421% <94.3396%> (+0.0154%) ⬆️

... and 14 files with indirect coverage changes

πŸš€ New features to boost your workflow:
  • ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
  • πŸ“¦ JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

@sonarqubecloud

Copy link
Copy Markdown

@github-actions

Copy link
Copy Markdown
Contributor

JMH summary β€” classic (commit 93d1a2e)

Speedup vs trailing 90-day baseline on gh-pages. Higher = faster.
1.00 = in line with history. Per-benchmark ratio, geomean within group.
Time-per-op units inverted so direction is consistent. The calibrated
column divides out this runner's speed vs the baseline hardware, as
measured by Groovy-independent pure-Java ruler benchmarks.

Group Speedup Calibrated n
bench 1.562 Γ— 0.941 Γ— 134
core 1.110 Γ— 1.130 Γ— 108
grails 1.260 Γ— 1.016 Γ— 80

⚠️ 1 benchmark at least 1.5Γ— slower than the 90-day baseline:

  • org.apache.groovy.bench.AryBench.groovyCS ( {"n":"10"} ) β€” 1.70Γ— slower (calibrated)

⚠️ Runner speed differs β‰₯15% from the historical baseline hardware for: bench, grails-ad, grails-ez. Raw speedups are not meaningful for those parts β€” use the calibrated column.

Runner calibration (this run vs baseline hardware): bench 1.63Γ— (27 rulers) Β· core-ag 1.04Γ— (3 rulers) Β· core-hz 0.89Γ— (3 rulers) Β· grails-ad 1.22Γ— (3 rulers) Β· grails-ez 1.26Γ— (3 rulers)

Baseline: dev/bench/jmh/<part>/classic/data.js on gh-pages, trailing 90 days. Daily dashboard Β· Per-suite raw data

@github-actions

Copy link
Copy Markdown
Contributor

JMH summary β€” indy (commit 93d1a2e)

Speedup vs trailing 90-day baseline on gh-pages. Higher = faster.
1.00 = in line with history. Per-benchmark ratio, geomean within group.
Time-per-op units inverted so direction is consistent. The calibrated
column divides out this runner's speed vs the baseline hardware, as
measured by Groovy-independent pure-Java ruler benchmarks.

Group Speedup Calibrated n
bench 0.952 Γ— 0.974 Γ— 134
core 2.280 Γ— 2.031 Γ— 108
grails 1.492 Γ— 1.201 Γ— 80

⚠️ 3 benchmarks at least 1.5Γ— slower than the 90-day baseline:

  • org.apache.groovy.bench.AryBench.groovyCS ( {"n":"1000000"} ) β€” 1.98Γ— slower (calibrated)
  • org.apache.groovy.bench.ClosureDoCallBench.each_mono ( {"pack":"true"} ) β€” 1.84Γ— slower (calibrated)
  • org.apache.groovy.bench.StaticMethodCallIndyBench.staticChain_groovyCS β€” 1.54Γ— slower (calibrated)

⚠️ Runner speed differs β‰₯15% from the historical baseline hardware for: core-ag, grails-ad, grails-ez. Raw speedups are not meaningful for those parts β€” use the calibrated column.

Runner calibration (this run vs baseline hardware): bench 0.97Γ— (27 rulers) Β· core-ag 1.23Γ— (3 rulers) Β· core-hz 0.96Γ— (3 rulers) Β· grails-ad 1.31Γ— (3 rulers) Β· grails-ez 1.19Γ— (3 rulers)

Baseline: dev/bench/jmh/<part>/indy/data.js on gh-pages, trailing 90 days. Daily dashboard Β· Per-suite raw data

@testlens-app

testlens-app Bot commented Nov 15, 2026

Copy link
Copy Markdown

βœ… All tests passed βœ…

🏷️ Commit: add5261
▢️ Tests: 132108 executed
βšͺ️ Checks: 26/26 completed


Learn more about TestLens at testlens.app/docs.

@daniellansun daniellansun left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Thanks Eric β€” I re-reviewed the current tip (add52613) after the rebase onto present master.

The rebase itself looks clean, and tip CI is green, which addresses the earlier request to land this on current master and let the checks finish. The non-closure paths (primitives, the String[] behaviour, multi-dimensional initializers, multi-declarator, { -> } / { { } } escape hatches) still look solid, and the Groovy11492 matrix remains useful documentation of the GROOVY-8561 edge. I also appreciate the work to get Object[] a = { {} } off the NPE path.

I am afraid I still cannot clear the prior Request changes. The two concrete gaps from the 30 October / 8 November reviews appear unchanged on this tip (the array-initializer methods match the previously reviewed warning commit; only the branch has been rebased).

  1. The warning predicate is still too broad.

    checkArrayInitEdgeCase still warns on every single-element, non-ClosureExpression initializer whose leaf type is non-primitive. That includes the main Java idioms this ticket unlocks β€” String[] a = {'x'}, Boolean[] a = { false }, Integer[] a = {1}, a single-element String[][] inner array, the field form, @CompileStatic / @TypeChecked of the same, and the docs example String[] javaBooks = {'Java in Action'}. Those should stay quiet. (int[] a = {1} correctly stays silent, which is helpful.)

    I quite understand that the type is not resolved at AstBuilder time, and that a precise Closure / SAM gate is therefore unavailable there. That does not force β€œwarn for all reference leaves”. Would you be willing to pick one of:

    • a name-based heuristic on the unresolved ClassNode: warn only when the leaf’s name is Closure, Object, or a small allow-list of common SAM simple names (Runnable, Callable, Comparator, …); or
    • defer the diagnostic to a later phase that sees resolved types (ResolveVisitor or a small custom visitor) and then use ClassHelper.isSAMType / isDerivedFrom(CLOSURE_TYPE); or
    • path B (array reading, except empty/singleton when the leaf is Closure/SAM/Object), once types are known β€” which avoids the silent eager-eval case without noisy warnings on String[].

    It would also help to assert in Groovy11492 that the String[] / Boolean[] happy paths (and the docs example) are warning-free.

  2. Formal-parameter defaults still skip the warning.

    visitVariableDeclarator calls checkArrayInitEdgeCase, but visitFormalParameter still builds the ArrayExpression without calling it. So

    def m(Closure[] cs = { println('x') }) { cs }
    m()

    still eagerly evaluates the body when the default is applied, stores [null], and emits no diagnostic β€” the silent case that blocked the earlier review. The same pattern is quiet for Runnable / Callable / Comparator parameter defaults, and constructor, closure, and lambda parameter defaults share this path. Locals of those types at least warn; parameters do not. Could you wire the same check through and cover it in the test matrix?

    (Under @CompileStatic this particular example is a hard type-checking error, which is safer; the dynamic parameter path is the one that remains silent.)

Soft / non-blocking once 1–2 land:

  • The docs still describe the new syntax as applying in β€œcommon scenarios”, with ambiguity only β€œexcept for auto-promotion cases”, without a precise array-versus-closure rule or how to spell the old promotion ({ -> }, { { } }, or outer brackets). A short note on the differences-from-Java / syntax pages would help. COMPATIBILITY documents the empty-{} flip well; it does not yet mention the non-empty eager-evaluation case.
  • Remaining exotic nested-dimension issues can stay on follow-up tickets, as we discussed earlier.

Happy to re-review quickly after the predicate is narrowed (by name heuristic or deferred resolution, or by path B) and parameter defaults emit the same diagnostic.

Request changes.

}

if (!elementType.isArray()) {
if (array.getExpressions().size() == 1 && !(array.getExpression(0) instanceof ClosureExpression)) {

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Please narrow this predicate so we only warn when the leaf element type could previously have been closure / SAM / (optional) Object promotion β€” not for String[] / Boolean[] / Integer[] / other ordinary reference arrays. As written, the primary Java single-element idiom, including the docs example String[] javaBooks = {'Java in Action'}, gets a warning on every use. I understand the type is unresolved here; a name-based heuristic, or deferring the diagnostic until types are resolved, would be enough for this pass.

if (ctx.arrayInitializer() != null) {
ClassNode elementType = parameterType.getComponentType();
ctx.arrayInitializer().putNodeMetaData("elementType", elementType);
init = configureAST(

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

After building this ArrayExpression, please also call checkArrayInitEdgeCase(init) (same as visitVariableDeclarator). Parameter defaults such as Closure[] cs = { println('x') } otherwise keep the silent eager-eval behaviour with no diagnostic. Constructor, closure, and lambda parameter defaults share this path.

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants