Chloe Stefantsova f01126211f [cfe] Implement the desugaring for NullCheckPattern ...

Additionally, fix the revealed variable declaration issues of
VariablePattern and change more remnant mentions of Matchers and
Binders.

Part of https://github.com/dart-lang/sdk/issues/49749

Change-Id: I8f31bb1038f29768c82e0cfa4b55bfee3e0e16c3
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/267581
Commit-Queue: Chloe Stefantsova <cstefantsova@google.com>
Reviewed-by: Johnni Winther <johnniwinther@google.com>

2022-11-04 12:40:26 +00:00

..

boolean_literal_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

boolean_literal_inside_case.dart.strong.expect

…

boolean_literal_inside_case.dart.strong.transformed.expect

…

boolean_literal_inside_case.dart.textual_outline_modelled.expect

…

boolean_literal_inside_case.dart.textual_outline.expect

…

boolean_literal_inside_case.dart.weak.expect

…

boolean_literal_inside_case.dart.weak.modular.expect

…

boolean_literal_inside_case.dart.weak.outline.expect

…

boolean_literal_inside_case.dart.weak.transformed.expect

…

boolean_literal_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

boolean_literal_inside_cast.dart.strong.expect

…

boolean_literal_inside_cast.dart.strong.transformed.expect

…

boolean_literal_inside_cast.dart.textual_outline_modelled.expect

…

boolean_literal_inside_cast.dart.textual_outline.expect

…

boolean_literal_inside_cast.dart.weak.expect

…

boolean_literal_inside_cast.dart.weak.modular.expect

…

boolean_literal_inside_cast.dart.weak.outline.expect

…

boolean_literal_inside_cast.dart.weak.transformed.expect

…

boolean_literal_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

boolean_literal_inside_if_case.dart.strong.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

boolean_literal_inside_if_case.dart.strong.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

boolean_literal_inside_if_case.dart.textual_outline_modelled.expect

…

boolean_literal_inside_if_case.dart.textual_outline.expect

…

boolean_literal_inside_if_case.dart.weak.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

boolean_literal_inside_if_case.dart.weak.modular.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

boolean_literal_inside_if_case.dart.weak.outline.expect

…

boolean_literal_inside_if_case.dart.weak.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

boolean_literal_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

boolean_literal_inside_null_assert.dart.strong.expect

…

boolean_literal_inside_null_assert.dart.strong.transformed.expect

…

boolean_literal_inside_null_assert.dart.textual_outline_modelled.expect

…

boolean_literal_inside_null_assert.dart.textual_outline.expect

…

boolean_literal_inside_null_assert.dart.weak.expect

…

boolean_literal_inside_null_assert.dart.weak.modular.expect

…

boolean_literal_inside_null_assert.dart.weak.outline.expect

…

boolean_literal_inside_null_assert.dart.weak.transformed.expect

…

boolean_literal_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

boolean_literal_inside_null_check.dart.strong.expect

…

boolean_literal_inside_null_check.dart.strong.transformed.expect

…

boolean_literal_inside_null_check.dart.textual_outline_modelled.expect

…

boolean_literal_inside_null_check.dart.textual_outline.expect

…

boolean_literal_inside_null_check.dart.weak.expect

…

boolean_literal_inside_null_check.dart.weak.modular.expect

…

boolean_literal_inside_null_check.dart.weak.outline.expect

…

boolean_literal_inside_null_check.dart.weak.transformed.expect

…

caseHead_withClassicPattern_guarded_insideIfStatement.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

caseHead_withClassicPattern_guarded_insideIfStatement.dart.strong.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

caseHead_withClassicPattern_guarded_insideIfStatement.dart.strong.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

caseHead_withClassicPattern_guarded_insideIfStatement.dart.textual_outline_modelled.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withClassicPattern_guarded_insideIfStatement.dart.textual_outline.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withClassicPattern_guarded_insideIfStatement.dart.weak.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

caseHead_withClassicPattern_guarded_insideIfStatement.dart.weak.modular.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

caseHead_withClassicPattern_guarded_insideIfStatement.dart.weak.outline.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withClassicPattern_guarded_insideIfStatement.dart.weak.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

caseHead_withClassicPattern_guarded_insideSwitchStatement.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.strong.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.strong.transformed.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.textual_outline_modelled.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.textual_outline.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.modular.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.outline.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.transformed.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideIfStatement.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

caseHead_withNewPattern_guarded_insideIfStatement.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

caseHead_withNewPattern_guarded_insideIfStatement.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

caseHead_withNewPattern_guarded_insideIfStatement.dart.textual_outline_modelled.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideIfStatement.dart.textual_outline.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideIfStatement.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

caseHead_withNewPattern_guarded_insideIfStatement.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

caseHead_withNewPattern_guarded_insideIfStatement.dart.weak.outline.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideIfStatement.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

caseHead_withNewPattern_guarded_insideSwitchStatement.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

caseHead_withNewPattern_guarded_insideSwitchStatement.dart.strong.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideSwitchStatement.dart.strong.transformed.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideSwitchStatement.dart.textual_outline_modelled.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideSwitchStatement.dart.textual_outline.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.modular.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.outline.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.transformed.expect

[cfe] Pass on guard in if-case statement

2022-10-26 10:19:58 +00:00

cast_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_case.dart.strong.expect

…

cast_inside_case.dart.strong.transformed.expect

…

cast_inside_case.dart.textual_outline_modelled.expect

…

cast_inside_case.dart.textual_outline.expect

…

cast_inside_case.dart.weak.expect

…

cast_inside_case.dart.weak.modular.expect

…

cast_inside_case.dart.weak.outline.expect

…

cast_inside_case.dart.weak.transformed.expect

…

cast_inside_extractor_pattern_implicitly_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_extractor_pattern_implicitly_named.dart.strong.expect

…

cast_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect

…

cast_inside_extractor_pattern_implicitly_named.dart.textual_outline_modelled.expect

…

cast_inside_extractor_pattern_implicitly_named.dart.textual_outline.expect

…

cast_inside_extractor_pattern_implicitly_named.dart.weak.expect

…

cast_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect

…

cast_inside_extractor_pattern_implicitly_named.dart.weak.outline.expect

…

cast_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect

…

cast_inside_extractor_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_extractor_pattern.dart.strong.expect

…

cast_inside_extractor_pattern.dart.strong.transformed.expect

…

cast_inside_extractor_pattern.dart.textual_outline_modelled.expect

…

cast_inside_extractor_pattern.dart.textual_outline.expect

…

cast_inside_extractor_pattern.dart.weak.expect

…

cast_inside_extractor_pattern.dart.weak.modular.expect

…

cast_inside_extractor_pattern.dart.weak.outline.expect

…

cast_inside_extractor_pattern.dart.weak.transformed.expect

…

cast_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

cast_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

cast_inside_if_case.dart.textual_outline_modelled.expect

…

cast_inside_if_case.dart.textual_outline.expect

…

cast_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

cast_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

cast_inside_if_case.dart.weak.outline.expect

…

cast_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

cast_inside_list_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_list_pattern.dart.strong.expect

…

cast_inside_list_pattern.dart.strong.transformed.expect

…

cast_inside_list_pattern.dart.textual_outline_modelled.expect

…

cast_inside_list_pattern.dart.textual_outline.expect

…

cast_inside_list_pattern.dart.weak.expect

…

cast_inside_list_pattern.dart.weak.modular.expect

…

cast_inside_list_pattern.dart.weak.outline.expect

…

cast_inside_list_pattern.dart.weak.transformed.expect

…

cast_inside_logical_and_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_logical_and_lhs.dart.strong.expect

…

cast_inside_logical_and_lhs.dart.strong.transformed.expect

…

cast_inside_logical_and_lhs.dart.textual_outline_modelled.expect

…

cast_inside_logical_and_lhs.dart.textual_outline.expect

…

cast_inside_logical_and_lhs.dart.weak.expect

…

cast_inside_logical_and_lhs.dart.weak.modular.expect

…

cast_inside_logical_and_lhs.dart.weak.outline.expect

…

cast_inside_logical_and_lhs.dart.weak.transformed.expect

…

cast_inside_logical_and_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_logical_and_rhs.dart.strong.expect

…

cast_inside_logical_and_rhs.dart.strong.transformed.expect

…

cast_inside_logical_and_rhs.dart.textual_outline_modelled.expect

…

cast_inside_logical_and_rhs.dart.textual_outline.expect

…

cast_inside_logical_and_rhs.dart.weak.expect

…

cast_inside_logical_and_rhs.dart.weak.modular.expect

…

cast_inside_logical_and_rhs.dart.weak.outline.expect

…

cast_inside_logical_and_rhs.dart.weak.transformed.expect

…

cast_inside_logical_or_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_logical_or_lhs.dart.strong.expect

…

cast_inside_logical_or_lhs.dart.strong.transformed.expect

…

cast_inside_logical_or_lhs.dart.textual_outline_modelled.expect

…

cast_inside_logical_or_lhs.dart.textual_outline.expect

…

cast_inside_logical_or_lhs.dart.weak.expect

…

cast_inside_logical_or_lhs.dart.weak.modular.expect

…

cast_inside_logical_or_lhs.dart.weak.outline.expect

…

cast_inside_logical_or_lhs.dart.weak.transformed.expect

…

cast_inside_logical_or_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_logical_or_rhs.dart.strong.expect

…

cast_inside_logical_or_rhs.dart.strong.transformed.expect

…

cast_inside_logical_or_rhs.dart.textual_outline_modelled.expect

…

cast_inside_logical_or_rhs.dart.textual_outline.expect

…

cast_inside_logical_or_rhs.dart.weak.expect

…

cast_inside_logical_or_rhs.dart.weak.modular.expect

…

cast_inside_logical_or_rhs.dart.weak.outline.expect

…

cast_inside_logical_or_rhs.dart.weak.transformed.expect

…

cast_inside_map_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_map_pattern.dart.strong.expect

…

cast_inside_map_pattern.dart.strong.transformed.expect

…

cast_inside_map_pattern.dart.textual_outline_modelled.expect

…

cast_inside_map_pattern.dart.textual_outline.expect

…

cast_inside_map_pattern.dart.weak.expect

…

cast_inside_map_pattern.dart.weak.modular.expect

…

cast_inside_map_pattern.dart.weak.outline.expect

…

cast_inside_map_pattern.dart.weak.transformed.expect

…

cast_inside_parenthesized_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_parenthesized_pattern.dart.strong.expect

…

cast_inside_parenthesized_pattern.dart.strong.transformed.expect

…

cast_inside_parenthesized_pattern.dart.textual_outline_modelled.expect

…

cast_inside_parenthesized_pattern.dart.textual_outline.expect

…

cast_inside_parenthesized_pattern.dart.weak.expect

…

cast_inside_parenthesized_pattern.dart.weak.modular.expect

…

cast_inside_parenthesized_pattern.dart.weak.outline.expect

…

cast_inside_parenthesized_pattern.dart.weak.transformed.expect

…

cast_inside_record_pattern_implicitly_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_record_pattern_implicitly_named.dart.strong.expect

…

cast_inside_record_pattern_implicitly_named.dart.strong.transformed.expect

…

cast_inside_record_pattern_implicitly_named.dart.textual_outline_modelled.expect

…

cast_inside_record_pattern_implicitly_named.dart.textual_outline.expect

…

cast_inside_record_pattern_implicitly_named.dart.weak.expect

…

cast_inside_record_pattern_implicitly_named.dart.weak.modular.expect

…

cast_inside_record_pattern_implicitly_named.dart.weak.outline.expect

…

cast_inside_record_pattern_implicitly_named.dart.weak.transformed.expect

…

cast_inside_record_pattern_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_record_pattern_named.dart.strong.expect

…

cast_inside_record_pattern_named.dart.strong.transformed.expect

…

cast_inside_record_pattern_named.dart.textual_outline_modelled.expect

…

cast_inside_record_pattern_named.dart.textual_outline.expect

…

cast_inside_record_pattern_named.dart.weak.expect

…

cast_inside_record_pattern_named.dart.weak.modular.expect

…

cast_inside_record_pattern_named.dart.weak.outline.expect

…

cast_inside_record_pattern_named.dart.weak.transformed.expect

…

cast_inside_record_pattern_unnamed.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

cast_inside_record_pattern_unnamed.dart.strong.expect

…

cast_inside_record_pattern_unnamed.dart.strong.transformed.expect

…

cast_inside_record_pattern_unnamed.dart.textual_outline_modelled.expect

…

cast_inside_record_pattern_unnamed.dart.textual_outline.expect

…

cast_inside_record_pattern_unnamed.dart.weak.expect

…

cast_inside_record_pattern_unnamed.dart.weak.modular.expect

…

cast_inside_record_pattern_unnamed.dart.weak.outline.expect

…

cast_inside_record_pattern_unnamed.dart.weak.transformed.expect

…

constant_identifier_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

constant_identifier_inside_case.dart.strong.expect

…

constant_identifier_inside_case.dart.strong.transformed.expect

…

constant_identifier_inside_case.dart.textual_outline_modelled.expect

…

constant_identifier_inside_case.dart.textual_outline.expect

…

constant_identifier_inside_case.dart.weak.expect

…

constant_identifier_inside_case.dart.weak.modular.expect

…

constant_identifier_inside_case.dart.weak.outline.expect

…

constant_identifier_inside_case.dart.weak.transformed.expect

…

constant_identifier_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

constant_identifier_inside_cast.dart.strong.expect

…

constant_identifier_inside_cast.dart.strong.transformed.expect

…

constant_identifier_inside_cast.dart.textual_outline_modelled.expect

…

constant_identifier_inside_cast.dart.textual_outline.expect

…

constant_identifier_inside_cast.dart.weak.expect

…

constant_identifier_inside_cast.dart.weak.modular.expect

…

constant_identifier_inside_cast.dart.weak.outline.expect

…

constant_identifier_inside_cast.dart.weak.transformed.expect

…

constant_identifier_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

constant_identifier_inside_if_case.dart.strong.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

constant_identifier_inside_if_case.dart.strong.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

constant_identifier_inside_if_case.dart.textual_outline_modelled.expect

…

constant_identifier_inside_if_case.dart.textual_outline.expect

…

constant_identifier_inside_if_case.dart.weak.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

constant_identifier_inside_if_case.dart.weak.modular.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

constant_identifier_inside_if_case.dart.weak.outline.expect

…

constant_identifier_inside_if_case.dart.weak.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

constant_identifier_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

constant_identifier_inside_null_assert.dart.strong.expect

…

constant_identifier_inside_null_assert.dart.strong.transformed.expect

…

constant_identifier_inside_null_assert.dart.textual_outline_modelled.expect

…

constant_identifier_inside_null_assert.dart.textual_outline.expect

…

constant_identifier_inside_null_assert.dart.weak.expect

…

constant_identifier_inside_null_assert.dart.weak.modular.expect

…

constant_identifier_inside_null_assert.dart.weak.outline.expect

…

constant_identifier_inside_null_assert.dart.weak.transformed.expect

…

constant_identifier_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

constant_identifier_inside_null_check.dart.strong.expect

…

constant_identifier_inside_null_check.dart.strong.transformed.expect

…

constant_identifier_inside_null_check.dart.textual_outline_modelled.expect

…

constant_identifier_inside_null_check.dart.textual_outline.expect

…

constant_identifier_inside_null_check.dart.weak.expect

…

constant_identifier_inside_null_check.dart.weak.modular.expect

…

constant_identifier_inside_null_check.dart.weak.outline.expect

…

constant_identifier_inside_null_check.dart.weak.transformed.expect

…

double_literal_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

double_literal_inside_case.dart.strong.expect

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

double_literal_inside_case.dart.strong.transformed.expect

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

double_literal_inside_case.dart.textual_outline_modelled.expect

…

double_literal_inside_case.dart.textual_outline.expect

…

double_literal_inside_case.dart.weak.expect

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

double_literal_inside_case.dart.weak.modular.expect

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

double_literal_inside_case.dart.weak.outline.expect

…

double_literal_inside_case.dart.weak.transformed.expect

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

double_literal_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

double_literal_inside_cast.dart.strong.expect

…

double_literal_inside_cast.dart.strong.transformed.expect

…

double_literal_inside_cast.dart.textual_outline_modelled.expect

…

double_literal_inside_cast.dart.textual_outline.expect

…

double_literal_inside_cast.dart.weak.expect

…

double_literal_inside_cast.dart.weak.modular.expect

…

double_literal_inside_cast.dart.weak.outline.expect

…

double_literal_inside_cast.dart.weak.transformed.expect

…

double_literal_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

double_literal_inside_if_case.dart.strong.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

double_literal_inside_if_case.dart.strong.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

double_literal_inside_if_case.dart.textual_outline_modelled.expect

…

double_literal_inside_if_case.dart.textual_outline.expect

…

double_literal_inside_if_case.dart.weak.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

double_literal_inside_if_case.dart.weak.modular.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

double_literal_inside_if_case.dart.weak.outline.expect

…

double_literal_inside_if_case.dart.weak.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

double_literal_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

double_literal_inside_null_assert.dart.strong.expect

…

double_literal_inside_null_assert.dart.strong.transformed.expect

…

double_literal_inside_null_assert.dart.textual_outline_modelled.expect

…

double_literal_inside_null_assert.dart.textual_outline.expect

…

double_literal_inside_null_assert.dart.weak.expect

…

double_literal_inside_null_assert.dart.weak.modular.expect

…

double_literal_inside_null_assert.dart.weak.outline.expect

…

double_literal_inside_null_assert.dart.weak.transformed.expect

…

double_literal_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

double_literal_inside_null_check.dart.strong.expect

…

double_literal_inside_null_check.dart.strong.transformed.expect

…

double_literal_inside_null_check.dart.textual_outline_modelled.expect

…

double_literal_inside_null_check.dart.textual_outline.expect

…

double_literal_inside_null_check.dart.weak.expect

…

double_literal_inside_null_check.dart.weak.modular.expect

…

double_literal_inside_null_check.dart.weak.outline.expect

…

double_literal_inside_null_check.dart.weak.transformed.expect

…

error_recovery_after_question_suffix_in_expression.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

error_recovery_after_question_suffix_in_expression.dart.strong.expect

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

error_recovery_after_question_suffix_in_expression.dart.strong.transformed.expect

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

error_recovery_after_question_suffix_in_expression.dart.textual_outline_modelled.expect

…

error_recovery_after_question_suffix_in_expression.dart.textual_outline.expect

…

error_recovery_after_question_suffix_in_expression.dart.weak.expect

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

error_recovery_after_question_suffix_in_expression.dart.weak.modular.expect

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

error_recovery_after_question_suffix_in_expression.dart.weak.outline.expect

…

error_recovery_after_question_suffix_in_expression.dart.weak.transformed.expect

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

extractor_pattern_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

extractor_pattern_inside_cast.dart.strong.expect

…

extractor_pattern_inside_cast.dart.strong.transformed.expect

…

extractor_pattern_inside_cast.dart.textual_outline_modelled.expect

…

extractor_pattern_inside_cast.dart.textual_outline.expect

…

extractor_pattern_inside_cast.dart.weak.expect

…

extractor_pattern_inside_cast.dart.weak.modular.expect

…

extractor_pattern_inside_cast.dart.weak.outline.expect

…

extractor_pattern_inside_cast.dart.weak.transformed.expect

…

extractor_pattern_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

extractor_pattern_inside_null_assert.dart.strong.expect

…

extractor_pattern_inside_null_assert.dart.strong.transformed.expect

…

extractor_pattern_inside_null_assert.dart.textual_outline_modelled.expect

…

extractor_pattern_inside_null_assert.dart.textual_outline.expect

…

extractor_pattern_inside_null_assert.dart.weak.expect

…

extractor_pattern_inside_null_assert.dart.weak.modular.expect

…

extractor_pattern_inside_null_assert.dart.weak.outline.expect

…

extractor_pattern_inside_null_assert.dart.weak.transformed.expect

…

extractor_pattern_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

extractor_pattern_inside_null_check.dart.strong.expect

…

extractor_pattern_inside_null_check.dart.strong.transformed.expect

…

extractor_pattern_inside_null_check.dart.textual_outline_modelled.expect

…

extractor_pattern_inside_null_check.dart.textual_outline.expect

…

extractor_pattern_inside_null_check.dart.weak.expect

…

extractor_pattern_inside_null_check.dart.weak.modular.expect

…

extractor_pattern_inside_null_check.dart.weak.outline.expect

…

extractor_pattern_inside_null_check.dart.weak.transformed.expect

…

extractor_pattern_with_type_args_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

extractor_pattern_with_type_args_inside_null_assert.dart.strong.expect

…

extractor_pattern_with_type_args_inside_null_assert.dart.strong.transformed.expect

…

extractor_pattern_with_type_args_inside_null_assert.dart.textual_outline_modelled.expect

…

extractor_pattern_with_type_args_inside_null_assert.dart.textual_outline.expect

…

extractor_pattern_with_type_args_inside_null_assert.dart.weak.expect

…

extractor_pattern_with_type_args_inside_null_assert.dart.weak.modular.expect

…

extractor_pattern_with_type_args_inside_null_assert.dart.weak.outline.expect

…

extractor_pattern_with_type_args_inside_null_assert.dart.weak.transformed.expect

…

extractor_pattern_with_type_args.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

extractor_pattern_with_type_args.dart.strong.expect

…

extractor_pattern_with_type_args.dart.strong.transformed.expect

…

extractor_pattern_with_type_args.dart.textual_outline_modelled.expect

…

extractor_pattern_with_type_args.dart.textual_outline.expect

…

extractor_pattern_with_type_args.dart.weak.expect

…

extractor_pattern_with_type_args.dart.weak.modular.expect

…

extractor_pattern_with_type_args.dart.weak.outline.expect

…

extractor_pattern_with_type_args.dart.weak.transformed.expect

…

final_variable_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

final_variable_inside_case.dart.strong.expect

…

final_variable_inside_case.dart.strong.transformed.expect

…

final_variable_inside_case.dart.textual_outline_modelled.expect

…

final_variable_inside_case.dart.textual_outline.expect

…

final_variable_inside_case.dart.weak.expect

…

final_variable_inside_case.dart.weak.modular.expect

…

final_variable_inside_case.dart.weak.outline.expect

…

final_variable_inside_case.dart.weak.transformed.expect

…

final_variable_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

final_variable_inside_cast.dart.strong.expect

…

final_variable_inside_cast.dart.strong.transformed.expect

…

final_variable_inside_cast.dart.textual_outline_modelled.expect

…

final_variable_inside_cast.dart.textual_outline.expect

…

final_variable_inside_cast.dart.weak.expect

…

final_variable_inside_cast.dart.weak.modular.expect

…

final_variable_inside_cast.dart.weak.outline.expect

…

final_variable_inside_cast.dart.weak.transformed.expect

…

final_variable_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

final_variable_inside_if_case.dart.strong.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

final_variable_inside_if_case.dart.strong.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

final_variable_inside_if_case.dart.textual_outline_modelled.expect

…

final_variable_inside_if_case.dart.textual_outline.expect

…

final_variable_inside_if_case.dart.weak.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

final_variable_inside_if_case.dart.weak.modular.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

final_variable_inside_if_case.dart.weak.outline.expect

…

final_variable_inside_if_case.dart.weak.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

final_variable_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

final_variable_inside_null_assert.dart.strong.expect

…

final_variable_inside_null_assert.dart.strong.transformed.expect

…

final_variable_inside_null_assert.dart.textual_outline_modelled.expect

…

final_variable_inside_null_assert.dart.textual_outline.expect

…

final_variable_inside_null_assert.dart.weak.expect

…

final_variable_inside_null_assert.dart.weak.modular.expect

…

final_variable_inside_null_assert.dart.weak.outline.expect

…

final_variable_inside_null_assert.dart.weak.transformed.expect

…

final_variable_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

final_variable_inside_null_check.dart.strong.expect

…

final_variable_inside_null_check.dart.strong.transformed.expect

…

final_variable_inside_null_check.dart.textual_outline_modelled.expect

…

final_variable_inside_null_check.dart.textual_outline.expect

…

final_variable_inside_null_check.dart.weak.expect

…

final_variable_inside_null_check.dart.weak.modular.expect

…

final_variable_inside_null_check.dart.weak.outline.expect

…

final_variable_inside_null_check.dart.weak.transformed.expect

…

folder.options

…

integer_literal_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

integer_literal_inside_case.dart.strong.expect

…

integer_literal_inside_case.dart.strong.transformed.expect

…

integer_literal_inside_case.dart.textual_outline_modelled.expect

…

integer_literal_inside_case.dart.textual_outline.expect

…

integer_literal_inside_case.dart.weak.expect

…

integer_literal_inside_case.dart.weak.modular.expect

…

integer_literal_inside_case.dart.weak.outline.expect

…

integer_literal_inside_case.dart.weak.transformed.expect

…

integer_literal_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

integer_literal_inside_cast.dart.strong.expect

…

integer_literal_inside_cast.dart.strong.transformed.expect

…

integer_literal_inside_cast.dart.textual_outline_modelled.expect

…

integer_literal_inside_cast.dart.textual_outline.expect

…

integer_literal_inside_cast.dart.weak.expect

…

integer_literal_inside_cast.dart.weak.modular.expect

…

integer_literal_inside_cast.dart.weak.outline.expect

…

integer_literal_inside_cast.dart.weak.transformed.expect

…

integer_literal_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

integer_literal_inside_if_case.dart.strong.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

integer_literal_inside_if_case.dart.strong.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

integer_literal_inside_if_case.dart.textual_outline_modelled.expect

…

integer_literal_inside_if_case.dart.textual_outline.expect

…

integer_literal_inside_if_case.dart.weak.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

integer_literal_inside_if_case.dart.weak.modular.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

integer_literal_inside_if_case.dart.weak.outline.expect

…

integer_literal_inside_if_case.dart.weak.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

integer_literal_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

integer_literal_inside_null_assert.dart.strong.expect

…

integer_literal_inside_null_assert.dart.strong.transformed.expect

…

integer_literal_inside_null_assert.dart.textual_outline_modelled.expect

…

integer_literal_inside_null_assert.dart.textual_outline.expect

…

integer_literal_inside_null_assert.dart.weak.expect

…

integer_literal_inside_null_assert.dart.weak.modular.expect

…

integer_literal_inside_null_assert.dart.weak.outline.expect

…

integer_literal_inside_null_assert.dart.weak.transformed.expect

…

integer_literal_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

integer_literal_inside_null_check.dart.strong.expect

…

integer_literal_inside_null_check.dart.strong.transformed.expect

…

integer_literal_inside_null_check.dart.textual_outline_modelled.expect

…

integer_literal_inside_null_check.dart.textual_outline.expect

…

integer_literal_inside_null_check.dart.weak.expect

…

integer_literal_inside_null_check.dart.weak.modular.expect

…

integer_literal_inside_null_check.dart.weak.outline.expect

…

integer_literal_inside_null_check.dart.weak.transformed.expect

…

list_pattern_inside_case_empty_whitespace.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

list_pattern_inside_case_empty_whitespace.dart.strong.expect

…

list_pattern_inside_case_empty_whitespace.dart.strong.transformed.expect

…

list_pattern_inside_case_empty_whitespace.dart.textual_outline_modelled.expect

…

list_pattern_inside_case_empty_whitespace.dart.textual_outline.expect

…

list_pattern_inside_case_empty_whitespace.dart.weak.expect

…

list_pattern_inside_case_empty_whitespace.dart.weak.modular.expect

…

list_pattern_inside_case_empty_whitespace.dart.weak.outline.expect

…

list_pattern_inside_case_empty_whitespace.dart.weak.transformed.expect

…

list_pattern_inside_case_empty.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

list_pattern_inside_case_empty.dart.strong.expect

…

list_pattern_inside_case_empty.dart.strong.transformed.expect

…

list_pattern_inside_case_empty.dart.textual_outline_modelled.expect

…

list_pattern_inside_case_empty.dart.textual_outline.expect

…

list_pattern_inside_case_empty.dart.weak.expect

…

list_pattern_inside_case_empty.dart.weak.modular.expect

…

list_pattern_inside_case_empty.dart.weak.outline.expect

…

list_pattern_inside_case_empty.dart.weak.transformed.expect

…

list_pattern_inside_case_with_type_arguments.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

list_pattern_inside_case_with_type_arguments.dart.strong.expect

…

list_pattern_inside_case_with_type_arguments.dart.strong.transformed.expect

…

list_pattern_inside_case_with_type_arguments.dart.textual_outline_modelled.expect

…

list_pattern_inside_case_with_type_arguments.dart.textual_outline.expect

…

list_pattern_inside_case_with_type_arguments.dart.weak.expect

…

list_pattern_inside_case_with_type_arguments.dart.weak.modular.expect

…

list_pattern_inside_case_with_type_arguments.dart.weak.outline.expect

…

list_pattern_inside_case_with_type_arguments.dart.weak.transformed.expect

…

list_pattern_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

list_pattern_inside_case.dart.strong.expect

…

list_pattern_inside_case.dart.strong.transformed.expect

…

list_pattern_inside_case.dart.textual_outline_modelled.expect

…

list_pattern_inside_case.dart.textual_outline.expect

…

list_pattern_inside_case.dart.weak.expect

…

list_pattern_inside_case.dart.weak.modular.expect

…

list_pattern_inside_case.dart.weak.outline.expect

…

list_pattern_inside_case.dart.weak.transformed.expect

…

list_pattern_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

list_pattern_inside_cast.dart.strong.expect

…

list_pattern_inside_cast.dart.strong.transformed.expect

…

list_pattern_inside_cast.dart.textual_outline_modelled.expect

…

list_pattern_inside_cast.dart.textual_outline.expect

…

list_pattern_inside_cast.dart.weak.expect

…

list_pattern_inside_cast.dart.weak.modular.expect

…

list_pattern_inside_cast.dart.weak.outline.expect

…

list_pattern_inside_cast.dart.weak.transformed.expect

…

list_pattern_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

list_pattern_inside_null_assert.dart.strong.expect

…

list_pattern_inside_null_assert.dart.strong.transformed.expect

…

list_pattern_inside_null_assert.dart.textual_outline_modelled.expect

…

list_pattern_inside_null_assert.dart.textual_outline.expect

…

list_pattern_inside_null_assert.dart.weak.expect

…

list_pattern_inside_null_assert.dart.weak.modular.expect

…

list_pattern_inside_null_assert.dart.weak.outline.expect

…

list_pattern_inside_null_assert.dart.weak.transformed.expect

…

list_pattern_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

list_pattern_inside_null_check.dart.strong.expect

…

list_pattern_inside_null_check.dart.strong.transformed.expect

…

list_pattern_inside_null_check.dart.textual_outline_modelled.expect

…

list_pattern_inside_null_check.dart.textual_outline.expect

…

list_pattern_inside_null_check.dart.weak.expect

…

list_pattern_inside_null_check.dart.weak.modular.expect

…

list_pattern_inside_null_check.dart.weak.outline.expect

…

list_pattern_inside_null_check.dart.weak.transformed.expect

…

logical_and_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

logical_and_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

logical_and_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

logical_and_inside_if_case.dart.textual_outline_modelled.expect

…

logical_and_inside_if_case.dart.textual_outline.expect

…

logical_and_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

logical_and_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

logical_and_inside_if_case.dart.weak.outline.expect

…

logical_and_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

logical_and_inside_logical_and_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

logical_and_inside_logical_and_lhs.dart.strong.expect

…

logical_and_inside_logical_and_lhs.dart.strong.transformed.expect

…

logical_and_inside_logical_and_lhs.dart.textual_outline_modelled.expect

…

logical_and_inside_logical_and_lhs.dart.textual_outline.expect

…

logical_and_inside_logical_and_lhs.dart.weak.expect

…

logical_and_inside_logical_and_lhs.dart.weak.modular.expect

…

logical_and_inside_logical_and_lhs.dart.weak.outline.expect

…

logical_and_inside_logical_and_lhs.dart.weak.transformed.expect

…

logical_and_inside_logical_or_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

logical_and_inside_logical_or_lhs.dart.strong.expect

…

logical_and_inside_logical_or_lhs.dart.strong.transformed.expect

…

logical_and_inside_logical_or_lhs.dart.textual_outline_modelled.expect

…

logical_and_inside_logical_or_lhs.dart.textual_outline.expect

…

logical_and_inside_logical_or_lhs.dart.weak.expect

…

logical_and_inside_logical_or_lhs.dart.weak.modular.expect

…

logical_and_inside_logical_or_lhs.dart.weak.outline.expect

…

logical_and_inside_logical_or_lhs.dart.weak.transformed.expect

…

logical_and_inside_logical_or_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

logical_and_inside_logical_or_rhs.dart.strong.expect

…

logical_and_inside_logical_or_rhs.dart.strong.transformed.expect

…

logical_and_inside_logical_or_rhs.dart.textual_outline_modelled.expect

…

logical_and_inside_logical_or_rhs.dart.textual_outline.expect

…

logical_and_inside_logical_or_rhs.dart.weak.expect

…

logical_and_inside_logical_or_rhs.dart.weak.modular.expect

…

logical_and_inside_logical_or_rhs.dart.weak.outline.expect

…

logical_and_inside_logical_or_rhs.dart.weak.transformed.expect

…

logical_or_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

logical_or_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

logical_or_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

logical_or_inside_if_case.dart.textual_outline_modelled.expect

…

logical_or_inside_if_case.dart.textual_outline.expect

…

logical_or_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

logical_or_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

logical_or_inside_if_case.dart.weak.outline.expect

…

logical_or_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

logical_or_inside_logical_or_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

logical_or_inside_logical_or_lhs.dart.strong.expect

…

logical_or_inside_logical_or_lhs.dart.strong.transformed.expect

…

logical_or_inside_logical_or_lhs.dart.textual_outline_modelled.expect

…

logical_or_inside_logical_or_lhs.dart.textual_outline.expect

…

logical_or_inside_logical_or_lhs.dart.weak.expect

…

logical_or_inside_logical_or_lhs.dart.weak.modular.expect

…

logical_or_inside_logical_or_lhs.dart.weak.outline.expect

…

logical_or_inside_logical_or_lhs.dart.weak.transformed.expect

…

map_pattern_inside_case_empty.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

map_pattern_inside_case_empty.dart.strong.expect

…

map_pattern_inside_case_empty.dart.strong.transformed.expect

…

map_pattern_inside_case_empty.dart.textual_outline_modelled.expect

…

map_pattern_inside_case_empty.dart.textual_outline.expect

…

map_pattern_inside_case_empty.dart.weak.expect

…

map_pattern_inside_case_empty.dart.weak.modular.expect

…

map_pattern_inside_case_empty.dart.weak.outline.expect

…

map_pattern_inside_case_empty.dart.weak.transformed.expect

…

map_pattern_inside_case_with_type_arguments.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

map_pattern_inside_case_with_type_arguments.dart.strong.expect

…

map_pattern_inside_case_with_type_arguments.dart.strong.transformed.expect

…

map_pattern_inside_case_with_type_arguments.dart.textual_outline_modelled.expect

…

map_pattern_inside_case_with_type_arguments.dart.textual_outline.expect

…

map_pattern_inside_case_with_type_arguments.dart.weak.expect

…

map_pattern_inside_case_with_type_arguments.dart.weak.modular.expect

…

map_pattern_inside_case_with_type_arguments.dart.weak.outline.expect

…

map_pattern_inside_case_with_type_arguments.dart.weak.transformed.expect

…

map_pattern_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

map_pattern_inside_case.dart.strong.expect

…

map_pattern_inside_case.dart.strong.transformed.expect

…

map_pattern_inside_case.dart.textual_outline_modelled.expect

…

map_pattern_inside_case.dart.textual_outline.expect

…

map_pattern_inside_case.dart.weak.expect

…

map_pattern_inside_case.dart.weak.modular.expect

…

map_pattern_inside_case.dart.weak.outline.expect

…

map_pattern_inside_case.dart.weak.transformed.expect

…

map_pattern_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

map_pattern_inside_cast.dart.strong.expect

…

map_pattern_inside_cast.dart.strong.transformed.expect

…

map_pattern_inside_cast.dart.textual_outline_modelled.expect

…

map_pattern_inside_cast.dart.textual_outline.expect

…

map_pattern_inside_cast.dart.weak.expect

…

map_pattern_inside_cast.dart.weak.modular.expect

…

map_pattern_inside_cast.dart.weak.outline.expect

…

map_pattern_inside_cast.dart.weak.transformed.expect

…

map_pattern_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

map_pattern_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

map_pattern_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

map_pattern_inside_if_case.dart.textual_outline_modelled.expect

[cfe] Add MapMatcher

2022-10-28 12:02:27 +00:00

map_pattern_inside_if_case.dart.textual_outline.expect

[cfe] Add MapMatcher

2022-10-28 12:02:27 +00:00

map_pattern_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

map_pattern_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

map_pattern_inside_if_case.dart.weak.outline.expect

[cfe] Add MapMatcher

2022-10-28 12:02:27 +00:00

map_pattern_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

map_pattern_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

map_pattern_inside_null_assert.dart.strong.expect

…

map_pattern_inside_null_assert.dart.strong.transformed.expect

…

map_pattern_inside_null_assert.dart.textual_outline_modelled.expect

…

map_pattern_inside_null_assert.dart.textual_outline.expect

…

map_pattern_inside_null_assert.dart.weak.expect

…

map_pattern_inside_null_assert.dart.weak.modular.expect

…

map_pattern_inside_null_assert.dart.weak.outline.expect

…

map_pattern_inside_null_assert.dart.weak.transformed.expect

…

map_pattern_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

map_pattern_inside_null_check.dart.strong.expect

…

map_pattern_inside_null_check.dart.strong.transformed.expect

…

map_pattern_inside_null_check.dart.textual_outline_modelled.expect

…

map_pattern_inside_null_check.dart.textual_outline.expect

…

map_pattern_inside_null_check.dart.weak.expect

…

map_pattern_inside_null_check.dart.weak.modular.expect

…

map_pattern_inside_null_check.dart.weak.outline.expect

…

map_pattern_inside_null_check.dart.weak.transformed.expect

…

null_assert_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_case.dart.strong.expect

…

null_assert_inside_case.dart.strong.transformed.expect

…

null_assert_inside_case.dart.textual_outline_modelled.expect

…

null_assert_inside_case.dart.textual_outline.expect

…

null_assert_inside_case.dart.weak.expect

…

null_assert_inside_case.dart.weak.modular.expect

…

null_assert_inside_case.dart.weak.outline.expect

…

null_assert_inside_case.dart.weak.transformed.expect

…

null_assert_inside_extractor_pattern_implicitly_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_extractor_pattern_implicitly_named.dart.strong.expect

…

null_assert_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect

…

null_assert_inside_extractor_pattern_implicitly_named.dart.textual_outline_modelled.expect

…

null_assert_inside_extractor_pattern_implicitly_named.dart.textual_outline.expect

…

null_assert_inside_extractor_pattern_implicitly_named.dart.weak.expect

…

null_assert_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect

…

null_assert_inside_extractor_pattern_implicitly_named.dart.weak.outline.expect

…

null_assert_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect

…

null_assert_inside_extractor_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_extractor_pattern.dart.strong.expect

…

null_assert_inside_extractor_pattern.dart.strong.transformed.expect

…

null_assert_inside_extractor_pattern.dart.textual_outline_modelled.expect

…

null_assert_inside_extractor_pattern.dart.textual_outline.expect

…

null_assert_inside_extractor_pattern.dart.weak.expect

…

null_assert_inside_extractor_pattern.dart.weak.modular.expect

…

null_assert_inside_extractor_pattern.dart.weak.outline.expect

…

null_assert_inside_extractor_pattern.dart.weak.transformed.expect

…

null_assert_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_assert_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_assert_inside_if_case.dart.textual_outline_modelled.expect

…

null_assert_inside_if_case.dart.textual_outline.expect

…

null_assert_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_assert_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_assert_inside_if_case.dart.weak.outline.expect

…

null_assert_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_assert_inside_list_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_list_pattern.dart.strong.expect

…

null_assert_inside_list_pattern.dart.strong.transformed.expect

…

null_assert_inside_list_pattern.dart.textual_outline_modelled.expect

…

null_assert_inside_list_pattern.dart.textual_outline.expect

…

null_assert_inside_list_pattern.dart.weak.expect

…

null_assert_inside_list_pattern.dart.weak.modular.expect

…

null_assert_inside_list_pattern.dart.weak.outline.expect

…

null_assert_inside_list_pattern.dart.weak.transformed.expect

…

null_assert_inside_logical_and_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_logical_and_lhs.dart.strong.expect

…

null_assert_inside_logical_and_lhs.dart.strong.transformed.expect

…

null_assert_inside_logical_and_lhs.dart.textual_outline_modelled.expect

…

null_assert_inside_logical_and_lhs.dart.textual_outline.expect

…

null_assert_inside_logical_and_lhs.dart.weak.expect

…

null_assert_inside_logical_and_lhs.dart.weak.modular.expect

…

null_assert_inside_logical_and_lhs.dart.weak.outline.expect

…

null_assert_inside_logical_and_lhs.dart.weak.transformed.expect

…

null_assert_inside_logical_and_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_logical_and_rhs.dart.strong.expect

…

null_assert_inside_logical_and_rhs.dart.strong.transformed.expect

…

null_assert_inside_logical_and_rhs.dart.textual_outline_modelled.expect

…

null_assert_inside_logical_and_rhs.dart.textual_outline.expect

…

null_assert_inside_logical_and_rhs.dart.weak.expect

…

null_assert_inside_logical_and_rhs.dart.weak.modular.expect

…

null_assert_inside_logical_and_rhs.dart.weak.outline.expect

…

null_assert_inside_logical_and_rhs.dart.weak.transformed.expect

…

null_assert_inside_logical_or_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_logical_or_lhs.dart.strong.expect

…

null_assert_inside_logical_or_lhs.dart.strong.transformed.expect

…

null_assert_inside_logical_or_lhs.dart.textual_outline_modelled.expect

…

null_assert_inside_logical_or_lhs.dart.textual_outline.expect

…

null_assert_inside_logical_or_lhs.dart.weak.expect

…

null_assert_inside_logical_or_lhs.dart.weak.modular.expect

…

null_assert_inside_logical_or_lhs.dart.weak.outline.expect

…

null_assert_inside_logical_or_lhs.dart.weak.transformed.expect

…

null_assert_inside_logical_or_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_logical_or_rhs.dart.strong.expect

…

null_assert_inside_logical_or_rhs.dart.strong.transformed.expect

…

null_assert_inside_logical_or_rhs.dart.textual_outline_modelled.expect

…

null_assert_inside_logical_or_rhs.dart.textual_outline.expect

…

null_assert_inside_logical_or_rhs.dart.weak.expect

…

null_assert_inside_logical_or_rhs.dart.weak.modular.expect

…

null_assert_inside_logical_or_rhs.dart.weak.outline.expect

…

null_assert_inside_logical_or_rhs.dart.weak.transformed.expect

…

null_assert_inside_map_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_map_pattern.dart.strong.expect

…

null_assert_inside_map_pattern.dart.strong.transformed.expect

…

null_assert_inside_map_pattern.dart.textual_outline_modelled.expect

…

null_assert_inside_map_pattern.dart.textual_outline.expect

…

null_assert_inside_map_pattern.dart.weak.expect

…

null_assert_inside_map_pattern.dart.weak.modular.expect

…

null_assert_inside_map_pattern.dart.weak.outline.expect

…

null_assert_inside_map_pattern.dart.weak.transformed.expect

…

null_assert_inside_parenthesized_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_parenthesized_pattern.dart.strong.expect

…

null_assert_inside_parenthesized_pattern.dart.strong.transformed.expect

…

null_assert_inside_parenthesized_pattern.dart.textual_outline_modelled.expect

…

null_assert_inside_parenthesized_pattern.dart.textual_outline.expect

…

null_assert_inside_parenthesized_pattern.dart.weak.expect

…

null_assert_inside_parenthesized_pattern.dart.weak.modular.expect

…

null_assert_inside_parenthesized_pattern.dart.weak.outline.expect

…

null_assert_inside_parenthesized_pattern.dart.weak.transformed.expect

…

null_assert_inside_record_pattern_implicitly_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_record_pattern_implicitly_named.dart.strong.expect

…

null_assert_inside_record_pattern_implicitly_named.dart.strong.transformed.expect

…

null_assert_inside_record_pattern_implicitly_named.dart.textual_outline_modelled.expect

…

null_assert_inside_record_pattern_implicitly_named.dart.textual_outline.expect

…

null_assert_inside_record_pattern_implicitly_named.dart.weak.expect

…

null_assert_inside_record_pattern_implicitly_named.dart.weak.modular.expect

…

null_assert_inside_record_pattern_implicitly_named.dart.weak.outline.expect

…

null_assert_inside_record_pattern_implicitly_named.dart.weak.transformed.expect

…

null_assert_inside_record_pattern_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_record_pattern_named.dart.strong.expect

…

null_assert_inside_record_pattern_named.dart.strong.transformed.expect

…

null_assert_inside_record_pattern_named.dart.textual_outline_modelled.expect

…

null_assert_inside_record_pattern_named.dart.textual_outline.expect

…

null_assert_inside_record_pattern_named.dart.weak.expect

…

null_assert_inside_record_pattern_named.dart.weak.modular.expect

…

null_assert_inside_record_pattern_named.dart.weak.outline.expect

…

null_assert_inside_record_pattern_named.dart.weak.transformed.expect

…

null_assert_inside_record_pattern_unnamed.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_assert_inside_record_pattern_unnamed.dart.strong.expect

…

null_assert_inside_record_pattern_unnamed.dart.strong.transformed.expect

…

null_assert_inside_record_pattern_unnamed.dart.textual_outline_modelled.expect

…

null_assert_inside_record_pattern_unnamed.dart.textual_outline.expect

…

null_assert_inside_record_pattern_unnamed.dart.weak.expect

…

null_assert_inside_record_pattern_unnamed.dart.weak.modular.expect

…

null_assert_inside_record_pattern_unnamed.dart.weak.outline.expect

…

null_assert_inside_record_pattern_unnamed.dart.weak.transformed.expect

…

null_check_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_case.dart.strong.expect

…

null_check_inside_case.dart.strong.transformed.expect

…

null_check_inside_case.dart.textual_outline_modelled.expect

…

null_check_inside_case.dart.textual_outline.expect

…

null_check_inside_case.dart.weak.expect

…

null_check_inside_case.dart.weak.modular.expect

…

null_check_inside_case.dart.weak.outline.expect

…

null_check_inside_case.dart.weak.transformed.expect

…

null_check_inside_extractor_pattern_implicitly_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_extractor_pattern_implicitly_named.dart.strong.expect

…

null_check_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect

…

null_check_inside_extractor_pattern_implicitly_named.dart.textual_outline_modelled.expect

…

null_check_inside_extractor_pattern_implicitly_named.dart.textual_outline.expect

…

null_check_inside_extractor_pattern_implicitly_named.dart.weak.expect

…

null_check_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect

…

null_check_inside_extractor_pattern_implicitly_named.dart.weak.outline.expect

…

null_check_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect

…

null_check_inside_extractor_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_extractor_pattern.dart.strong.expect

…

null_check_inside_extractor_pattern.dart.strong.transformed.expect

…

null_check_inside_extractor_pattern.dart.textual_outline_modelled.expect

…

null_check_inside_extractor_pattern.dart.textual_outline.expect

…

null_check_inside_extractor_pattern.dart.weak.expect

…

null_check_inside_extractor_pattern.dart.weak.modular.expect

…

null_check_inside_extractor_pattern.dart.weak.outline.expect

…

null_check_inside_extractor_pattern.dart.weak.transformed.expect

…

null_check_inside_if_case.dart

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_check_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_check_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_check_inside_if_case.dart.textual_outline_modelled.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_check_inside_if_case.dart.textual_outline.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_check_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_check_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_check_inside_if_case.dart.weak.outline.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_check_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

null_check_inside_list_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_list_pattern.dart.strong.expect

…

null_check_inside_list_pattern.dart.strong.transformed.expect

…

null_check_inside_list_pattern.dart.textual_outline_modelled.expect

…

null_check_inside_list_pattern.dart.textual_outline.expect

…

null_check_inside_list_pattern.dart.weak.expect

…

null_check_inside_list_pattern.dart.weak.modular.expect

…

null_check_inside_list_pattern.dart.weak.outline.expect

…

null_check_inside_list_pattern.dart.weak.transformed.expect

…

null_check_inside_logical_and_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_logical_and_lhs.dart.strong.expect

…

null_check_inside_logical_and_lhs.dart.strong.transformed.expect

…

null_check_inside_logical_and_lhs.dart.textual_outline_modelled.expect

…

null_check_inside_logical_and_lhs.dart.textual_outline.expect

…

null_check_inside_logical_and_lhs.dart.weak.expect

…

null_check_inside_logical_and_lhs.dart.weak.modular.expect

…

null_check_inside_logical_and_lhs.dart.weak.outline.expect

…

null_check_inside_logical_and_lhs.dart.weak.transformed.expect

…

null_check_inside_logical_and_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_logical_and_rhs.dart.strong.expect

…

null_check_inside_logical_and_rhs.dart.strong.transformed.expect

…

null_check_inside_logical_and_rhs.dart.textual_outline_modelled.expect

…

null_check_inside_logical_and_rhs.dart.textual_outline.expect

…

null_check_inside_logical_and_rhs.dart.weak.expect

…

null_check_inside_logical_and_rhs.dart.weak.modular.expect

…

null_check_inside_logical_and_rhs.dart.weak.outline.expect

…

null_check_inside_logical_and_rhs.dart.weak.transformed.expect

…

null_check_inside_logical_or_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_logical_or_lhs.dart.strong.expect

…

null_check_inside_logical_or_lhs.dart.strong.transformed.expect

…

null_check_inside_logical_or_lhs.dart.textual_outline_modelled.expect

…

null_check_inside_logical_or_lhs.dart.textual_outline.expect

…

null_check_inside_logical_or_lhs.dart.weak.expect

…

null_check_inside_logical_or_lhs.dart.weak.modular.expect

…

null_check_inside_logical_or_lhs.dart.weak.outline.expect

…

null_check_inside_logical_or_lhs.dart.weak.transformed.expect

…

null_check_inside_logical_or_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_logical_or_rhs.dart.strong.expect

…

null_check_inside_logical_or_rhs.dart.strong.transformed.expect

…

null_check_inside_logical_or_rhs.dart.textual_outline_modelled.expect

…

null_check_inside_logical_or_rhs.dart.textual_outline.expect

…

null_check_inside_logical_or_rhs.dart.weak.expect

…

null_check_inside_logical_or_rhs.dart.weak.modular.expect

…

null_check_inside_logical_or_rhs.dart.weak.outline.expect

…

null_check_inside_logical_or_rhs.dart.weak.transformed.expect

…

null_check_inside_map_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_map_pattern.dart.strong.expect

…

null_check_inside_map_pattern.dart.strong.transformed.expect

…

null_check_inside_map_pattern.dart.textual_outline_modelled.expect

…

null_check_inside_map_pattern.dart.textual_outline.expect

…

null_check_inside_map_pattern.dart.weak.expect

…

null_check_inside_map_pattern.dart.weak.modular.expect

…

null_check_inside_map_pattern.dart.weak.outline.expect

…

null_check_inside_map_pattern.dart.weak.transformed.expect

…

null_check_inside_parenthesized_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_parenthesized_pattern.dart.strong.expect

…

null_check_inside_parenthesized_pattern.dart.strong.transformed.expect

…

null_check_inside_parenthesized_pattern.dart.textual_outline_modelled.expect

…

null_check_inside_parenthesized_pattern.dart.textual_outline.expect

…

null_check_inside_parenthesized_pattern.dart.weak.expect

…

null_check_inside_parenthesized_pattern.dart.weak.modular.expect

…

null_check_inside_parenthesized_pattern.dart.weak.outline.expect

…

null_check_inside_parenthesized_pattern.dart.weak.transformed.expect

…

null_check_inside_record_pattern_implicitly_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_record_pattern_implicitly_named.dart.strong.expect

…

null_check_inside_record_pattern_implicitly_named.dart.strong.transformed.expect

…

null_check_inside_record_pattern_implicitly_named.dart.textual_outline_modelled.expect

…

null_check_inside_record_pattern_implicitly_named.dart.textual_outline.expect

…

null_check_inside_record_pattern_implicitly_named.dart.weak.expect

…

null_check_inside_record_pattern_implicitly_named.dart.weak.modular.expect

…

null_check_inside_record_pattern_implicitly_named.dart.weak.outline.expect

…

null_check_inside_record_pattern_implicitly_named.dart.weak.transformed.expect

…

null_check_inside_record_pattern_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_record_pattern_named.dart.strong.expect

…

null_check_inside_record_pattern_named.dart.strong.transformed.expect

…

null_check_inside_record_pattern_named.dart.textual_outline_modelled.expect

…

null_check_inside_record_pattern_named.dart.textual_outline.expect

…

null_check_inside_record_pattern_named.dart.weak.expect

…

null_check_inside_record_pattern_named.dart.weak.modular.expect

…

null_check_inside_record_pattern_named.dart.weak.outline.expect

…

null_check_inside_record_pattern_named.dart.weak.transformed.expect

…

null_check_inside_record_pattern_unnamed.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_check_inside_record_pattern_unnamed.dart.strong.expect

…

null_check_inside_record_pattern_unnamed.dart.strong.transformed.expect

…

null_check_inside_record_pattern_unnamed.dart.textual_outline_modelled.expect

…

null_check_inside_record_pattern_unnamed.dart.textual_outline.expect

…

null_check_inside_record_pattern_unnamed.dart.weak.expect

…

null_check_inside_record_pattern_unnamed.dart.weak.modular.expect

…

null_check_inside_record_pattern_unnamed.dart.weak.outline.expect

…

null_check_inside_record_pattern_unnamed.dart.weak.transformed.expect

…

null_literal_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_literal_inside_case.dart.strong.expect

…

null_literal_inside_case.dart.strong.transformed.expect

…

null_literal_inside_case.dart.textual_outline_modelled.expect

…

null_literal_inside_case.dart.textual_outline.expect

…

null_literal_inside_case.dart.weak.expect

…

null_literal_inside_case.dart.weak.modular.expect

…

null_literal_inside_case.dart.weak.outline.expect

…

null_literal_inside_case.dart.weak.transformed.expect

…

null_literal_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_literal_inside_cast.dart.strong.expect

…

null_literal_inside_cast.dart.strong.transformed.expect

…

null_literal_inside_cast.dart.textual_outline_modelled.expect

…

null_literal_inside_cast.dart.textual_outline.expect

…

null_literal_inside_cast.dart.weak.expect

…

null_literal_inside_cast.dart.weak.modular.expect

…

null_literal_inside_cast.dart.weak.outline.expect

…

null_literal_inside_cast.dart.weak.transformed.expect

…

null_literal_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_literal_inside_if_case.dart.strong.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

null_literal_inside_if_case.dart.strong.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

null_literal_inside_if_case.dart.textual_outline_modelled.expect

…

null_literal_inside_if_case.dart.textual_outline.expect

…

null_literal_inside_if_case.dart.weak.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

null_literal_inside_if_case.dart.weak.modular.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

null_literal_inside_if_case.dart.weak.outline.expect

…

null_literal_inside_if_case.dart.weak.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

null_literal_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_literal_inside_null_assert.dart.strong.expect

…

null_literal_inside_null_assert.dart.strong.transformed.expect

…

null_literal_inside_null_assert.dart.textual_outline_modelled.expect

…

null_literal_inside_null_assert.dart.textual_outline.expect

…

null_literal_inside_null_assert.dart.weak.expect

…

null_literal_inside_null_assert.dart.weak.modular.expect

…

null_literal_inside_null_assert.dart.weak.outline.expect

…

null_literal_inside_null_assert.dart.weak.transformed.expect

…

null_literal_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

null_literal_inside_null_check.dart.strong.expect

…

null_literal_inside_null_check.dart.strong.transformed.expect

…

null_literal_inside_null_check.dart.textual_outline_modelled.expect

…

null_literal_inside_null_check.dart.textual_outline.expect

…

null_literal_inside_null_check.dart.weak.expect

…

null_literal_inside_null_check.dart.weak.modular.expect

…

null_literal_inside_null_check.dart.weak.outline.expect

…

null_literal_inside_null_check.dart.weak.transformed.expect

…

parenthesized_pattern_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

parenthesized_pattern_inside_cast.dart.strong.expect

…

parenthesized_pattern_inside_cast.dart.strong.transformed.expect

…

parenthesized_pattern_inside_cast.dart.textual_outline_modelled.expect

…

parenthesized_pattern_inside_cast.dart.textual_outline.expect

…

parenthesized_pattern_inside_cast.dart.weak.expect

…

parenthesized_pattern_inside_cast.dart.weak.modular.expect

…

parenthesized_pattern_inside_cast.dart.weak.outline.expect

…

parenthesized_pattern_inside_cast.dart.weak.transformed.expect

…

parenthesized_pattern_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

parenthesized_pattern_inside_null_assert.dart.strong.expect

…

parenthesized_pattern_inside_null_assert.dart.strong.transformed.expect

…

parenthesized_pattern_inside_null_assert.dart.textual_outline_modelled.expect

…

parenthesized_pattern_inside_null_assert.dart.textual_outline.expect

…

parenthesized_pattern_inside_null_assert.dart.weak.expect

…

parenthesized_pattern_inside_null_assert.dart.weak.modular.expect

…

parenthesized_pattern_inside_null_assert.dart.weak.outline.expect

…

parenthesized_pattern_inside_null_assert.dart.weak.transformed.expect

…

parenthesized_pattern_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

parenthesized_pattern_inside_null_check.dart.strong.expect

…

parenthesized_pattern_inside_null_check.dart.strong.transformed.expect

…

parenthesized_pattern_inside_null_check.dart.textual_outline_modelled.expect

…

parenthesized_pattern_inside_null_check.dart.textual_outline.expect

…

parenthesized_pattern_inside_null_check.dart.weak.expect

…

parenthesized_pattern_inside_null_check.dart.weak.modular.expect

…

parenthesized_pattern_inside_null_check.dart.weak.outline.expect

…

parenthesized_pattern_inside_null_check.dart.weak.transformed.expect

…

prefixed_extractor_pattern_with_type_args_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

prefixed_extractor_pattern_with_type_args_inside_cast.dart.strong.expect

…

prefixed_extractor_pattern_with_type_args_inside_cast.dart.strong.transformed.expect

…

prefixed_extractor_pattern_with_type_args_inside_cast.dart.textual_outline_modelled.expect

…

prefixed_extractor_pattern_with_type_args_inside_cast.dart.textual_outline.expect

…

prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.expect

…

prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.modular.expect

…

prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.outline.expect

…

prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.transformed.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.strong.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.strong.transformed.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.textual_outline_modelled.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.textual_outline.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.modular.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.outline.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.transformed.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

prefixed_extractor_pattern_with_type_args_inside_null_check.dart.strong.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_check.dart.strong.transformed.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_check.dart.textual_outline_modelled.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_check.dart.textual_outline.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.modular.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.outline.expect

…

prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.transformed.expect

…

prefixed_extractor_pattern_with_type_args.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

prefixed_extractor_pattern_with_type_args.dart.strong.expect

…

prefixed_extractor_pattern_with_type_args.dart.strong.transformed.expect

…

prefixed_extractor_pattern_with_type_args.dart.textual_outline_modelled.expect

…

prefixed_extractor_pattern_with_type_args.dart.textual_outline.expect

…

prefixed_extractor_pattern_with_type_args.dart.weak.expect

…

prefixed_extractor_pattern_with_type_args.dart.weak.modular.expect

…

prefixed_extractor_pattern_with_type_args.dart.weak.outline.expect

…

prefixed_extractor_pattern_with_type_args.dart.weak.transformed.expect

…

record_pattern_inside_case_empty.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

record_pattern_inside_case_empty.dart.strong.expect

…

record_pattern_inside_case_empty.dart.strong.transformed.expect

…

record_pattern_inside_case_empty.dart.textual_outline_modelled.expect

…

record_pattern_inside_case_empty.dart.textual_outline.expect

…

record_pattern_inside_case_empty.dart.weak.expect

…

record_pattern_inside_case_empty.dart.weak.modular.expect

…

record_pattern_inside_case_empty.dart.weak.outline.expect

…

record_pattern_inside_case_empty.dart.weak.transformed.expect

…

record_pattern_inside_case_singleton.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

record_pattern_inside_case_singleton.dart.strong.expect

…

record_pattern_inside_case_singleton.dart.strong.transformed.expect

…

record_pattern_inside_case_singleton.dart.textual_outline_modelled.expect

…

record_pattern_inside_case_singleton.dart.textual_outline.expect

…

record_pattern_inside_case_singleton.dart.weak.expect

…

record_pattern_inside_case_singleton.dart.weak.modular.expect

…

record_pattern_inside_case_singleton.dart.weak.outline.expect

…

record_pattern_inside_case_singleton.dart.weak.transformed.expect

…

record_pattern_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

record_pattern_inside_case.dart.strong.expect

…

record_pattern_inside_case.dart.strong.transformed.expect

…

record_pattern_inside_case.dart.textual_outline_modelled.expect

…

record_pattern_inside_case.dart.textual_outline.expect

…

record_pattern_inside_case.dart.weak.expect

…

record_pattern_inside_case.dart.weak.modular.expect

…

record_pattern_inside_case.dart.weak.outline.expect

…

record_pattern_inside_case.dart.weak.transformed.expect

…

record_pattern_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

record_pattern_inside_cast.dart.strong.expect

…

record_pattern_inside_cast.dart.strong.transformed.expect

…

record_pattern_inside_cast.dart.textual_outline_modelled.expect

…

record_pattern_inside_cast.dart.textual_outline.expect

…

record_pattern_inside_cast.dart.weak.expect

…

record_pattern_inside_cast.dart.weak.modular.expect

…

record_pattern_inside_cast.dart.weak.outline.expect

…

record_pattern_inside_cast.dart.weak.transformed.expect

…

record_pattern_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

record_pattern_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

record_pattern_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

record_pattern_inside_if_case.dart.textual_outline_modelled.expect

[cfe] Add RecordMatcher

2022-10-28 12:02:27 +00:00

record_pattern_inside_if_case.dart.textual_outline.expect

[cfe] Add RecordMatcher

2022-10-28 12:02:27 +00:00

record_pattern_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

record_pattern_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

record_pattern_inside_if_case.dart.weak.outline.expect

[cfe] Add RecordMatcher

2022-10-28 12:02:27 +00:00

record_pattern_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

record_pattern_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

record_pattern_inside_null_assert.dart.strong.expect

…

record_pattern_inside_null_assert.dart.strong.transformed.expect

…

record_pattern_inside_null_assert.dart.textual_outline_modelled.expect

…

record_pattern_inside_null_assert.dart.textual_outline.expect

…

record_pattern_inside_null_assert.dart.weak.expect

…

record_pattern_inside_null_assert.dart.weak.modular.expect

…

record_pattern_inside_null_assert.dart.weak.outline.expect

…

record_pattern_inside_null_assert.dart.weak.transformed.expect

…

record_pattern_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

record_pattern_inside_null_check.dart.strong.expect

…

record_pattern_inside_null_check.dart.strong.transformed.expect

…

record_pattern_inside_null_check.dart.textual_outline_modelled.expect

…

record_pattern_inside_null_check.dart.textual_outline.expect

…

record_pattern_inside_null_check.dart.weak.expect

…

record_pattern_inside_null_check.dart.weak.modular.expect

…

record_pattern_inside_null_check.dart.weak.outline.expect

…

record_pattern_inside_null_check.dart.weak.transformed.expect

…

relational_inside_case_equal.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_case_equal.dart.strong.expect

…

relational_inside_case_equal.dart.strong.transformed.expect

…

relational_inside_case_equal.dart.textual_outline_modelled.expect

…

relational_inside_case_equal.dart.textual_outline.expect

…

relational_inside_case_equal.dart.weak.expect

…

relational_inside_case_equal.dart.weak.modular.expect

…

relational_inside_case_equal.dart.weak.outline.expect

…

relational_inside_case_equal.dart.weak.transformed.expect

…

relational_inside_case_greater_than_or_equal.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_case_greater_than_or_equal.dart.strong.expect

…

relational_inside_case_greater_than_or_equal.dart.strong.transformed.expect

…

relational_inside_case_greater_than_or_equal.dart.textual_outline_modelled.expect

…

relational_inside_case_greater_than_or_equal.dart.textual_outline.expect

…

relational_inside_case_greater_than_or_equal.dart.weak.expect

…

relational_inside_case_greater_than_or_equal.dart.weak.modular.expect

…

relational_inside_case_greater_than_or_equal.dart.weak.outline.expect

…

relational_inside_case_greater_than_or_equal.dart.weak.transformed.expect

…

relational_inside_case_greater_than.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_case_greater_than.dart.strong.expect

…

relational_inside_case_greater_than.dart.strong.transformed.expect

…

relational_inside_case_greater_than.dart.textual_outline_modelled.expect

…

relational_inside_case_greater_than.dart.textual_outline.expect

…

relational_inside_case_greater_than.dart.weak.expect

…

relational_inside_case_greater_than.dart.weak.modular.expect

…

relational_inside_case_greater_than.dart.weak.outline.expect

…

relational_inside_case_greater_than.dart.weak.transformed.expect

…

relational_inside_case_less_than_or_equal.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_case_less_than_or_equal.dart.strong.expect

…

relational_inside_case_less_than_or_equal.dart.strong.transformed.expect

…

relational_inside_case_less_than_or_equal.dart.textual_outline_modelled.expect

…

relational_inside_case_less_than_or_equal.dart.textual_outline.expect

…

relational_inside_case_less_than_or_equal.dart.weak.expect

…

relational_inside_case_less_than_or_equal.dart.weak.modular.expect

…

relational_inside_case_less_than_or_equal.dart.weak.outline.expect

…

relational_inside_case_less_than_or_equal.dart.weak.transformed.expect

…

relational_inside_case_less_than.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_case_less_than.dart.strong.expect

…

relational_inside_case_less_than.dart.strong.transformed.expect

…

relational_inside_case_less_than.dart.textual_outline_modelled.expect

…

relational_inside_case_less_than.dart.textual_outline.expect

…

relational_inside_case_less_than.dart.weak.expect

…

relational_inside_case_less_than.dart.weak.modular.expect

…

relational_inside_case_less_than.dart.weak.outline.expect

…

relational_inside_case_less_than.dart.weak.transformed.expect

…

relational_inside_case_not_equal.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_case_not_equal.dart.strong.expect

…

relational_inside_case_not_equal.dart.strong.transformed.expect

…

relational_inside_case_not_equal.dart.textual_outline_modelled.expect

…

relational_inside_case_not_equal.dart.textual_outline.expect

…

relational_inside_case_not_equal.dart.weak.expect

…

relational_inside_case_not_equal.dart.weak.modular.expect

…

relational_inside_case_not_equal.dart.weak.outline.expect

…

relational_inside_case_not_equal.dart.weak.transformed.expect

…

relational_inside_extractor_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_extractor_pattern.dart.strong.expect

…

relational_inside_extractor_pattern.dart.strong.transformed.expect

…

relational_inside_extractor_pattern.dart.textual_outline_modelled.expect

…

relational_inside_extractor_pattern.dart.textual_outline.expect

…

relational_inside_extractor_pattern.dart.weak.expect

…

relational_inside_extractor_pattern.dart.weak.modular.expect

…

relational_inside_extractor_pattern.dart.weak.outline.expect

…

relational_inside_extractor_pattern.dart.weak.transformed.expect

…

relational_inside_if_case.dart

[cfe] Implement the desugaring for RelationalPattern

2022-11-02 14:45:35 +00:00

relational_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for RelationalPattern

2022-11-02 14:45:35 +00:00

relational_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for RelationalPattern

2022-11-02 14:45:35 +00:00

relational_inside_if_case.dart.textual_outline_modelled.expect

[cfe] Implement the desugaring for RelationalPattern

2022-11-02 14:45:35 +00:00

relational_inside_if_case.dart.textual_outline.expect

[cfe] Implement the desugaring for RelationalPattern

2022-11-02 14:45:35 +00:00

relational_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for RelationalPattern

2022-11-02 14:45:35 +00:00

relational_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for RelationalPattern

2022-11-02 14:45:35 +00:00

relational_inside_if_case.dart.weak.outline.expect

[cfe] Implement the desugaring for RelationalPattern

2022-11-02 14:45:35 +00:00

relational_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for RelationalPattern

2022-11-02 14:45:35 +00:00

relational_inside_list_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_list_pattern.dart.strong.expect

…

relational_inside_list_pattern.dart.strong.transformed.expect

…

relational_inside_list_pattern.dart.textual_outline_modelled.expect

…

relational_inside_list_pattern.dart.textual_outline.expect

…

relational_inside_list_pattern.dart.weak.expect

…

relational_inside_list_pattern.dart.weak.modular.expect

…

relational_inside_list_pattern.dart.weak.outline.expect

…

relational_inside_list_pattern.dart.weak.transformed.expect

…

relational_inside_logical_and_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_logical_and_lhs.dart.strong.expect

…

relational_inside_logical_and_lhs.dart.strong.transformed.expect

…

relational_inside_logical_and_lhs.dart.textual_outline_modelled.expect

…

relational_inside_logical_and_lhs.dart.textual_outline.expect

…

relational_inside_logical_and_lhs.dart.weak.expect

…

relational_inside_logical_and_lhs.dart.weak.modular.expect

…

relational_inside_logical_and_lhs.dart.weak.outline.expect

…

relational_inside_logical_and_lhs.dart.weak.transformed.expect

…

relational_inside_logical_and_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_logical_and_rhs.dart.strong.expect

…

relational_inside_logical_and_rhs.dart.strong.transformed.expect

…

relational_inside_logical_and_rhs.dart.textual_outline_modelled.expect

…

relational_inside_logical_and_rhs.dart.textual_outline.expect

…

relational_inside_logical_and_rhs.dart.weak.expect

…

relational_inside_logical_and_rhs.dart.weak.modular.expect

…

relational_inside_logical_and_rhs.dart.weak.outline.expect

…

relational_inside_logical_and_rhs.dart.weak.transformed.expect

…

relational_inside_logical_or_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_logical_or_lhs.dart.strong.expect

…

relational_inside_logical_or_lhs.dart.strong.transformed.expect

…

relational_inside_logical_or_lhs.dart.textual_outline_modelled.expect

…

relational_inside_logical_or_lhs.dart.textual_outline.expect

…

relational_inside_logical_or_lhs.dart.weak.expect

…

relational_inside_logical_or_lhs.dart.weak.modular.expect

…

relational_inside_logical_or_lhs.dart.weak.outline.expect

…

relational_inside_logical_or_lhs.dart.weak.transformed.expect

…

relational_inside_logical_or_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_logical_or_rhs.dart.strong.expect

…

relational_inside_logical_or_rhs.dart.strong.transformed.expect

…

relational_inside_logical_or_rhs.dart.textual_outline_modelled.expect

…

relational_inside_logical_or_rhs.dart.textual_outline.expect

…

relational_inside_logical_or_rhs.dart.weak.expect

…

relational_inside_logical_or_rhs.dart.weak.modular.expect

…

relational_inside_logical_or_rhs.dart.weak.outline.expect

…

relational_inside_logical_or_rhs.dart.weak.transformed.expect

…

relational_inside_map_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_map_pattern.dart.strong.expect

…

relational_inside_map_pattern.dart.strong.transformed.expect

…

relational_inside_map_pattern.dart.textual_outline_modelled.expect

…

relational_inside_map_pattern.dart.textual_outline.expect

…

relational_inside_map_pattern.dart.weak.expect

…

relational_inside_map_pattern.dart.weak.modular.expect

…

relational_inside_map_pattern.dart.weak.outline.expect

…

relational_inside_map_pattern.dart.weak.transformed.expect

…

relational_inside_parenthesized_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_parenthesized_pattern.dart.strong.expect

…

relational_inside_parenthesized_pattern.dart.strong.transformed.expect

…

relational_inside_parenthesized_pattern.dart.textual_outline_modelled.expect

…

relational_inside_parenthesized_pattern.dart.textual_outline.expect

…

relational_inside_parenthesized_pattern.dart.weak.expect

…

relational_inside_parenthesized_pattern.dart.weak.modular.expect

…

relational_inside_parenthesized_pattern.dart.weak.outline.expect

…

relational_inside_parenthesized_pattern.dart.weak.transformed.expect

…

relational_inside_record_pattern_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_record_pattern_named.dart.strong.expect

…

relational_inside_record_pattern_named.dart.strong.transformed.expect

…

relational_inside_record_pattern_named.dart.textual_outline_modelled.expect

…

relational_inside_record_pattern_named.dart.textual_outline.expect

…

relational_inside_record_pattern_named.dart.weak.expect

…

relational_inside_record_pattern_named.dart.weak.modular.expect

…

relational_inside_record_pattern_named.dart.weak.outline.expect

…

relational_inside_record_pattern_named.dart.weak.transformed.expect

…

relational_inside_record_pattern_unnamed.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

relational_inside_record_pattern_unnamed.dart.strong.expect

…

relational_inside_record_pattern_unnamed.dart.strong.transformed.expect

…

relational_inside_record_pattern_unnamed.dart.textual_outline_modelled.expect

…

relational_inside_record_pattern_unnamed.dart.textual_outline.expect

…

relational_inside_record_pattern_unnamed.dart.weak.expect

…

relational_inside_record_pattern_unnamed.dart.weak.modular.expect

…

relational_inside_record_pattern_unnamed.dart.weak.outline.expect

…

relational_inside_record_pattern_unnamed.dart.weak.transformed.expect

…

string_literal_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

string_literal_inside_case.dart.strong.expect

…

string_literal_inside_case.dart.strong.transformed.expect

…

string_literal_inside_case.dart.textual_outline_modelled.expect

…

string_literal_inside_case.dart.textual_outline.expect

…

string_literal_inside_case.dart.weak.expect

…

string_literal_inside_case.dart.weak.modular.expect

…

string_literal_inside_case.dart.weak.outline.expect

…

string_literal_inside_case.dart.weak.transformed.expect

…

string_literal_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

string_literal_inside_cast.dart.strong.expect

…

string_literal_inside_cast.dart.strong.transformed.expect

…

string_literal_inside_cast.dart.textual_outline_modelled.expect

…

string_literal_inside_cast.dart.textual_outline.expect

…

string_literal_inside_cast.dart.weak.expect

…

string_literal_inside_cast.dart.weak.modular.expect

…

string_literal_inside_cast.dart.weak.outline.expect

…

string_literal_inside_cast.dart.weak.transformed.expect

…

string_literal_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

string_literal_inside_if_case.dart.strong.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

string_literal_inside_if_case.dart.strong.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

string_literal_inside_if_case.dart.textual_outline_modelled.expect

…

string_literal_inside_if_case.dart.textual_outline.expect

…

string_literal_inside_if_case.dart.weak.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

string_literal_inside_if_case.dart.weak.modular.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

string_literal_inside_if_case.dart.weak.outline.expect

…

string_literal_inside_if_case.dart.weak.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

string_literal_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

string_literal_inside_null_assert.dart.strong.expect

…

string_literal_inside_null_assert.dart.strong.transformed.expect

…

string_literal_inside_null_assert.dart.textual_outline_modelled.expect

…

string_literal_inside_null_assert.dart.textual_outline.expect

…

string_literal_inside_null_assert.dart.weak.expect

…

string_literal_inside_null_assert.dart.weak.modular.expect

…

string_literal_inside_null_assert.dart.weak.outline.expect

…

string_literal_inside_null_assert.dart.weak.transformed.expect

…

string_literal_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

string_literal_inside_null_check.dart.strong.expect

…

string_literal_inside_null_check.dart.strong.transformed.expect

…

string_literal_inside_null_check.dart.textual_outline_modelled.expect

…

string_literal_inside_null_check.dart.textual_outline.expect

…

string_literal_inside_null_check.dart.weak.expect

…

string_literal_inside_null_check.dart.weak.modular.expect

…

string_literal_inside_null_check.dart.weak.outline.expect

…

string_literal_inside_null_check.dart.weak.transformed.expect

…

typed_final_variable_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_final_variable_inside_case.dart.strong.expect

…

typed_final_variable_inside_case.dart.strong.transformed.expect

…

typed_final_variable_inside_case.dart.textual_outline_modelled.expect

…

typed_final_variable_inside_case.dart.textual_outline.expect

…

typed_final_variable_inside_case.dart.weak.expect

…

typed_final_variable_inside_case.dart.weak.modular.expect

…

typed_final_variable_inside_case.dart.weak.outline.expect

…

typed_final_variable_inside_case.dart.weak.transformed.expect

…

typed_final_variable_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_final_variable_inside_cast.dart.strong.expect

…

typed_final_variable_inside_cast.dart.strong.transformed.expect

…

typed_final_variable_inside_cast.dart.textual_outline_modelled.expect

…

typed_final_variable_inside_cast.dart.textual_outline.expect

…

typed_final_variable_inside_cast.dart.weak.expect

…

typed_final_variable_inside_cast.dart.weak.modular.expect

…

typed_final_variable_inside_cast.dart.weak.outline.expect

…

typed_final_variable_inside_cast.dart.weak.transformed.expect

…

typed_final_variable_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_final_variable_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_final_variable_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_final_variable_inside_if_case.dart.textual_outline_modelled.expect

…

typed_final_variable_inside_if_case.dart.textual_outline.expect

…

typed_final_variable_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_final_variable_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_final_variable_inside_if_case.dart.weak.outline.expect

…

typed_final_variable_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_final_variable_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_final_variable_inside_null_assert.dart.strong.expect

…

typed_final_variable_inside_null_assert.dart.strong.transformed.expect

…

typed_final_variable_inside_null_assert.dart.textual_outline_modelled.expect

…

typed_final_variable_inside_null_assert.dart.textual_outline.expect

…

typed_final_variable_inside_null_assert.dart.weak.expect

…

typed_final_variable_inside_null_assert.dart.weak.modular.expect

…

typed_final_variable_inside_null_assert.dart.weak.outline.expect

…

typed_final_variable_inside_null_assert.dart.weak.transformed.expect

…

typed_final_variable_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_final_variable_inside_null_check.dart.strong.expect

…

typed_final_variable_inside_null_check.dart.strong.transformed.expect

…

typed_final_variable_inside_null_check.dart.textual_outline_modelled.expect

…

typed_final_variable_inside_null_check.dart.textual_outline.expect

…

typed_final_variable_inside_null_check.dart.weak.expect

…

typed_final_variable_inside_null_check.dart.weak.modular.expect

…

typed_final_variable_inside_null_check.dart.weak.outline.expect

…

typed_final_variable_inside_null_check.dart.weak.transformed.expect

…

typed_variable_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_inside_case.dart.strong.expect

…

typed_variable_inside_case.dart.strong.transformed.expect

…

typed_variable_inside_case.dart.textual_outline_modelled.expect

…

typed_variable_inside_case.dart.textual_outline.expect

…

typed_variable_inside_case.dart.weak.expect

…

typed_variable_inside_case.dart.weak.modular.expect

…

typed_variable_inside_case.dart.weak.outline.expect

…

typed_variable_inside_case.dart.weak.transformed.expect

…

typed_variable_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_inside_cast.dart.strong.expect

…

typed_variable_inside_cast.dart.strong.transformed.expect

…

typed_variable_inside_cast.dart.textual_outline_modelled.expect

…

typed_variable_inside_cast.dart.textual_outline.expect

…

typed_variable_inside_cast.dart.weak.expect

…

typed_variable_inside_cast.dart.weak.modular.expect

…

typed_variable_inside_cast.dart.weak.outline.expect

…

typed_variable_inside_cast.dart.weak.transformed.expect

…

typed_variable_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_variable_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_variable_inside_if_case.dart.textual_outline_modelled.expect

…

typed_variable_inside_if_case.dart.textual_outline.expect

…

typed_variable_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_variable_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_variable_inside_if_case.dart.weak.outline.expect

…

typed_variable_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_variable_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_inside_null_assert.dart.strong.expect

…

typed_variable_inside_null_assert.dart.strong.transformed.expect

…

typed_variable_inside_null_assert.dart.textual_outline_modelled.expect

…

typed_variable_inside_null_assert.dart.textual_outline.expect

…

typed_variable_inside_null_assert.dart.weak.expect

…

typed_variable_inside_null_assert.dart.weak.modular.expect

…

typed_variable_inside_null_assert.dart.weak.outline.expect

…

typed_variable_inside_null_assert.dart.weak.transformed.expect

…

typed_variable_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_inside_null_check.dart.strong.expect

…

typed_variable_inside_null_check.dart.strong.transformed.expect

…

typed_variable_inside_null_check.dart.textual_outline_modelled.expect

…

typed_variable_inside_null_check.dart.textual_outline.expect

…

typed_variable_inside_null_check.dart.weak.expect

…

typed_variable_inside_null_check.dart.weak.modular.expect

…

typed_variable_inside_null_check.dart.weak.outline.expect

…

typed_variable_inside_null_check.dart.weak.transformed.expect

…

typed_variable_named_as_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_case.dart.strong.expect

…

typed_variable_named_as_inside_case.dart.strong.transformed.expect

…

typed_variable_named_as_inside_case.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_case.dart.textual_outline.expect

…

typed_variable_named_as_inside_case.dart.weak.expect

…

typed_variable_named_as_inside_case.dart.weak.modular.expect

…

typed_variable_named_as_inside_case.dart.weak.outline.expect

…

typed_variable_named_as_inside_case.dart.weak.transformed.expect

…

typed_variable_named_as_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_cast.dart.strong.expect

…

typed_variable_named_as_inside_cast.dart.strong.transformed.expect

…

typed_variable_named_as_inside_cast.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_cast.dart.textual_outline.expect

…

typed_variable_named_as_inside_cast.dart.weak.expect

…

typed_variable_named_as_inside_cast.dart.weak.modular.expect

…

typed_variable_named_as_inside_cast.dart.weak.outline.expect

…

typed_variable_named_as_inside_cast.dart.weak.transformed.expect

…

typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.strong.expect

…

typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect

…

typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.textual_outline.expect

…

typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.expect

…

typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect

…

typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.outline.expect

…

typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect

…

typed_variable_named_as_inside_extractor_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_extractor_pattern.dart.strong.expect

…

typed_variable_named_as_inside_extractor_pattern.dart.strong.transformed.expect

…

typed_variable_named_as_inside_extractor_pattern.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_extractor_pattern.dart.textual_outline.expect

…

typed_variable_named_as_inside_extractor_pattern.dart.weak.expect

…

typed_variable_named_as_inside_extractor_pattern.dart.weak.modular.expect

…

typed_variable_named_as_inside_extractor_pattern.dart.weak.outline.expect

…

typed_variable_named_as_inside_extractor_pattern.dart.weak.transformed.expect

…

typed_variable_named_as_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_if_case.dart.strong.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_variable_named_as_inside_if_case.dart.strong.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_variable_named_as_inside_if_case.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_if_case.dart.textual_outline.expect

…

typed_variable_named_as_inside_if_case.dart.weak.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_variable_named_as_inside_if_case.dart.weak.modular.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_variable_named_as_inside_if_case.dart.weak.outline.expect

…

typed_variable_named_as_inside_if_case.dart.weak.transformed.expect

[cfe] Implement the desugaring for NullCheckPattern

2022-11-04 12:40:26 +00:00

typed_variable_named_as_inside_list_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_list_pattern.dart.strong.expect

…

typed_variable_named_as_inside_list_pattern.dart.strong.transformed.expect

…

typed_variable_named_as_inside_list_pattern.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_list_pattern.dart.textual_outline.expect

…

typed_variable_named_as_inside_list_pattern.dart.weak.expect

…

typed_variable_named_as_inside_list_pattern.dart.weak.modular.expect

…

typed_variable_named_as_inside_list_pattern.dart.weak.outline.expect

…

typed_variable_named_as_inside_list_pattern.dart.weak.transformed.expect

…

typed_variable_named_as_inside_logical_and_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_logical_and_lhs.dart.strong.expect

…

typed_variable_named_as_inside_logical_and_lhs.dart.strong.transformed.expect

…

typed_variable_named_as_inside_logical_and_lhs.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_logical_and_lhs.dart.textual_outline.expect

…

typed_variable_named_as_inside_logical_and_lhs.dart.weak.expect

…

typed_variable_named_as_inside_logical_and_lhs.dart.weak.modular.expect

…

typed_variable_named_as_inside_logical_and_lhs.dart.weak.outline.expect

…

typed_variable_named_as_inside_logical_and_lhs.dart.weak.transformed.expect

…

typed_variable_named_as_inside_logical_and_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_logical_and_rhs.dart.strong.expect

…

typed_variable_named_as_inside_logical_and_rhs.dart.strong.transformed.expect

…

typed_variable_named_as_inside_logical_and_rhs.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_logical_and_rhs.dart.textual_outline.expect

…

typed_variable_named_as_inside_logical_and_rhs.dart.weak.expect

…

typed_variable_named_as_inside_logical_and_rhs.dart.weak.modular.expect

…

typed_variable_named_as_inside_logical_and_rhs.dart.weak.outline.expect

…

typed_variable_named_as_inside_logical_and_rhs.dart.weak.transformed.expect

…

typed_variable_named_as_inside_logical_or_lhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_logical_or_lhs.dart.strong.expect

…

typed_variable_named_as_inside_logical_or_lhs.dart.strong.transformed.expect

…

typed_variable_named_as_inside_logical_or_lhs.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_logical_or_lhs.dart.textual_outline.expect

…

typed_variable_named_as_inside_logical_or_lhs.dart.weak.expect

…

typed_variable_named_as_inside_logical_or_lhs.dart.weak.modular.expect

…

typed_variable_named_as_inside_logical_or_lhs.dart.weak.outline.expect

…

typed_variable_named_as_inside_logical_or_lhs.dart.weak.transformed.expect

…

typed_variable_named_as_inside_logical_or_rhs.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_logical_or_rhs.dart.strong.expect

…

typed_variable_named_as_inside_logical_or_rhs.dart.strong.transformed.expect

…

typed_variable_named_as_inside_logical_or_rhs.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_logical_or_rhs.dart.textual_outline.expect

…

typed_variable_named_as_inside_logical_or_rhs.dart.weak.expect

…

typed_variable_named_as_inside_logical_or_rhs.dart.weak.modular.expect

…

typed_variable_named_as_inside_logical_or_rhs.dart.weak.outline.expect

…

typed_variable_named_as_inside_logical_or_rhs.dart.weak.transformed.expect

…

typed_variable_named_as_inside_map_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_map_pattern.dart.strong.expect

…

typed_variable_named_as_inside_map_pattern.dart.strong.transformed.expect

…

typed_variable_named_as_inside_map_pattern.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_map_pattern.dart.textual_outline.expect

…

typed_variable_named_as_inside_map_pattern.dart.weak.expect

…

typed_variable_named_as_inside_map_pattern.dart.weak.modular.expect

…

typed_variable_named_as_inside_map_pattern.dart.weak.outline.expect

…

typed_variable_named_as_inside_map_pattern.dart.weak.transformed.expect

…

typed_variable_named_as_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_null_assert.dart.strong.expect

…

typed_variable_named_as_inside_null_assert.dart.strong.transformed.expect

…

typed_variable_named_as_inside_null_assert.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_null_assert.dart.textual_outline.expect

…

typed_variable_named_as_inside_null_assert.dart.weak.expect

…

typed_variable_named_as_inside_null_assert.dart.weak.modular.expect

…

typed_variable_named_as_inside_null_assert.dart.weak.outline.expect

…

typed_variable_named_as_inside_null_assert.dart.weak.transformed.expect

…

typed_variable_named_as_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_null_check.dart.strong.expect

…

typed_variable_named_as_inside_null_check.dart.strong.transformed.expect

…

typed_variable_named_as_inside_null_check.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_null_check.dart.textual_outline.expect

…

typed_variable_named_as_inside_null_check.dart.weak.expect

…

typed_variable_named_as_inside_null_check.dart.weak.modular.expect

…

typed_variable_named_as_inside_null_check.dart.weak.outline.expect

…

typed_variable_named_as_inside_null_check.dart.weak.transformed.expect

…

typed_variable_named_as_inside_parenthesized_pattern.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_parenthesized_pattern.dart.strong.expect

…

typed_variable_named_as_inside_parenthesized_pattern.dart.strong.transformed.expect

…

typed_variable_named_as_inside_parenthesized_pattern.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_parenthesized_pattern.dart.textual_outline.expect

…

typed_variable_named_as_inside_parenthesized_pattern.dart.weak.expect

…

typed_variable_named_as_inside_parenthesized_pattern.dart.weak.modular.expect

…

typed_variable_named_as_inside_parenthesized_pattern.dart.weak.outline.expect

…

typed_variable_named_as_inside_parenthesized_pattern.dart.weak.transformed.expect

…

typed_variable_named_as_inside_record_pattern_implicitly_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_record_pattern_implicitly_named.dart.strong.expect

…

typed_variable_named_as_inside_record_pattern_implicitly_named.dart.strong.transformed.expect

…

typed_variable_named_as_inside_record_pattern_implicitly_named.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_record_pattern_implicitly_named.dart.textual_outline.expect

…

typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.expect

…

typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.modular.expect

…

typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.outline.expect

…

typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.transformed.expect

…

typed_variable_named_as_inside_record_pattern_named.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_record_pattern_named.dart.strong.expect

…

typed_variable_named_as_inside_record_pattern_named.dart.strong.transformed.expect

…

typed_variable_named_as_inside_record_pattern_named.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_record_pattern_named.dart.textual_outline.expect

…

typed_variable_named_as_inside_record_pattern_named.dart.weak.expect

…

typed_variable_named_as_inside_record_pattern_named.dart.weak.modular.expect

…

typed_variable_named_as_inside_record_pattern_named.dart.weak.outline.expect

…

typed_variable_named_as_inside_record_pattern_named.dart.weak.transformed.expect

…

typed_variable_named_as_inside_record_pattern_unnamed.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

typed_variable_named_as_inside_record_pattern_unnamed.dart.strong.expect

…

typed_variable_named_as_inside_record_pattern_unnamed.dart.strong.transformed.expect

…

typed_variable_named_as_inside_record_pattern_unnamed.dart.textual_outline_modelled.expect

…

typed_variable_named_as_inside_record_pattern_unnamed.dart.textual_outline.expect

…

typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.expect

…

typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.modular.expect

…

typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.outline.expect

…

typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.transformed.expect

…

var_variable_inside_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

var_variable_inside_case.dart.strong.expect

…

var_variable_inside_case.dart.strong.transformed.expect

…

var_variable_inside_case.dart.textual_outline_modelled.expect

…

var_variable_inside_case.dart.textual_outline.expect

…

var_variable_inside_case.dart.weak.expect

…

var_variable_inside_case.dart.weak.modular.expect

…

var_variable_inside_case.dart.weak.outline.expect

…

var_variable_inside_case.dart.weak.transformed.expect

…

var_variable_inside_cast.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

var_variable_inside_cast.dart.strong.expect

…

var_variable_inside_cast.dart.strong.transformed.expect

…

var_variable_inside_cast.dart.textual_outline_modelled.expect

…

var_variable_inside_cast.dart.textual_outline.expect

…

var_variable_inside_cast.dart.weak.expect

…

var_variable_inside_cast.dart.weak.modular.expect

…

var_variable_inside_cast.dart.weak.outline.expect

…

var_variable_inside_cast.dart.weak.transformed.expect

…

var_variable_inside_if_case.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

var_variable_inside_if_case.dart.strong.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

var_variable_inside_if_case.dart.strong.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

var_variable_inside_if_case.dart.textual_outline_modelled.expect

…

var_variable_inside_if_case.dart.textual_outline.expect

…

var_variable_inside_if_case.dart.weak.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

var_variable_inside_if_case.dart.weak.modular.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

var_variable_inside_if_case.dart.weak.outline.expect

…

var_variable_inside_if_case.dart.weak.transformed.expect

[cfe] Implement a desugaring for simple if-case statements

2022-10-28 16:08:42 +00:00

var_variable_inside_null_assert.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

var_variable_inside_null_assert.dart.strong.expect

…

var_variable_inside_null_assert.dart.strong.transformed.expect

…

var_variable_inside_null_assert.dart.textual_outline_modelled.expect

…

var_variable_inside_null_assert.dart.textual_outline.expect

…

var_variable_inside_null_assert.dart.weak.expect

…

var_variable_inside_null_assert.dart.weak.modular.expect

…

var_variable_inside_null_assert.dart.weak.outline.expect

…

var_variable_inside_null_assert.dart.weak.transformed.expect

…

var_variable_inside_null_check.dart

[cfe] Add license headers to the patterns testcaes

2022-11-04 09:20:19 +00:00

var_variable_inside_null_check.dart.strong.expect

…

var_variable_inside_null_check.dart.strong.transformed.expect

…

var_variable_inside_null_check.dart.textual_outline_modelled.expect

…

var_variable_inside_null_check.dart.textual_outline.expect

…

var_variable_inside_null_check.dart.weak.expect

…

var_variable_inside_null_check.dart.weak.modular.expect

…

var_variable_inside_null_check.dart.weak.outline.expect

…

var_variable_inside_null_check.dart.weak.transformed.expect

…