Change the way hard splits are handled.

Change the way hard splits are handled.

By having a separate rule for hard splits, we lose any constraints the
original soft rule may have had or -- more importantly -- other rules
may have had on it.

For constraints where hardening the rule forces other rules to fully
harden, it's fine because we propagate those constraints when the rule
is hardened. The problem comes with "cannot split" constraints. If rule
A has a "cannot split" constraint on rule B when rule A has some value,
we need to remember that even if B is hardened so that we prevent A
from taking that value.

Instead of swapping out the rule with a separate hard split rule, the
idea is to keep the rule (and thus preserve references to it) but change
it to a "hardened" state.

R=kevmoo@google.com

Committed: https://github.com/dart-lang/dart_style/commit/d960898412cccb989c0f1fab416357994a22e15a

[Bob Nystrom, 2015-12-01 23:59:14]

rnystrom@google.com changed reviewers:
+ kevmoo@google.com

[Bob Nystrom, 2015-12-01 23:59:15]

This was intended to just be a refactoring to get some stuff in place for a
later patch but it turned out to also reveal and fix a subtle bug.

Win!

[kevmoo, 2015-12-02 00:26:27]

LGTM

but i noticed tests fail on 1.14-dev.1 unless I upgrade dependencies

Might be good to look at...

[Bob Nystrom, 2015-12-02 00:47:02]

On 2015/12/02 00:26:27, kevmoo wrote:
> LGTM
> 
> but i noticed tests fail on 1.14-dev.1 unless I upgrade dependencies

I'll do that in a later patch.

– bob

[Bob Nystrom, 2015-12-02 00:47:21]

Description was changed from

==========
Change the way hard splits are handled.

By having a separate rule for hard splits, we lose any constraints the
original soft rule may have had or -- more importantly -- other rules
may have had on it.

For constraints where hardening the rule forces other rules to fully
harden, it's fine because we propagate those constraints when the rule
is hardened. The problem comes with "cannot split" constraints. If rule
A has a "cannot split" constraint on rule B when rule A has some value,
we need to remember that even if B is hardened so that we prevent A
from taking that value.

Instead of swapping out the rule with a separate hard split rule, the
idea is to keep the rule (and thus preserve references to it) but change
it to a "hardened" state.
==========

to

==========
Change the way hard splits are handled.

By having a separate rule for hard splits, we lose any constraints the
original soft rule may have had or -- more importantly -- other rules
may have had on it.

For constraints where hardening the rule forces other rules to fully
harden, it's fine because we propagate those constraints when the rule
is hardened. The problem comes with "cannot split" constraints. If rule
A has a "cannot split" constraint on rule B when rule A has some value,
we need to remember that even if B is hardened so that we prevent A
from taking that value.

Instead of swapping out the rule with a separate hard split rule, the
idea is to keep the rule (and thus preserve references to it) but change
it to a "hardened" state.

R=kevmoo@google.com

Committed:
https://github.com/dart-lang/dart_style/commit/d960898412cccb989c0f1fab416357...
==========

[Bob Nystrom, 2015-12-02 00:47:22]

Committed patchset #1 (id:1) manually as
d960898412cccb989c0f1fab416357994a22e15a (presubmit successful).