Test refactoring to use the patterns syntax suggested in:

dart-lang/language#2137 (comment)

In particular:

- Instead of if-var statements, use `is <pattern>` as the condition.
- Require "var" before variables in cases.

Author: munificent

lib/src/argument_list_visitor.dart

@@ -65,7 +65,7 @@ class ArgumentListVisitor {
       Token leftParenthesis,
       Token rightParenthesis,
       List<Expression> arguments) {
-    if (var (start, end)? = _contiguousFunctions(arguments)) {
+    if (_contiguousFunctions(arguments) is (var start, var end)?) {
       // Split the arguments into two independent argument lists with the
       // functions in the middle.
       var argumentsBefore = arguments.take(start).toList();
@@ -228,30 +228,30 @@ class ArgumentListVisitor {
   static bool _isBlockFunction(Expression expression) {
     // This is pretty nice:
     switch (expression) {
-      case NamedExpression(expression):
+      case NamedExpression(var expression):
         return _isBlockFunction(expression);
 
       // Allow functions wrapped in dotted method calls like "a.b.c(() { ... })".
-      case MethodInvocation(target, argumentList):
+      case MethodInvocation(var target, var argumentList):
         if (!_isValidWrappingTarget(target)) return false;
         if (argumentList.arguments.length != 1) return false;
         return _isBlockFunction(argumentList.arguments.single);
 
-      case InstanceCreationExpression(argumentList):
+      case InstanceCreationExpression(var argumentList):
         if (argumentList.arguments.length != 1) return false;
         return _isBlockFunction(argumentList.arguments.single);
 
       // Allow immediately-invoked functions like "() { ... }()".
-      case FunctionExpressionInvocation(function, argumentList):
+      case FunctionExpressionInvocation(var function, var argumentList):
         if (argumentList.arguments.isNotEmpty) return false;
         return _isBlockFunction(function);
 
       // Unwrap parenthesized expressions.
-      case ParenthesizedExpression(expression):
+      case ParenthesizedExpression(var expression):
         return _isBlockFunction(expression);
 
       // Must be a function with a non-empty curly body.
-      case FunctionExpression(body: BlockFunctionBody(block))
+      case FunctionExpression(body: BlockFunctionBody(var block))
           when block.statements.isNotEmpty ||
               block.rightBracket.precedingComments != null:
         return true;
@@ -269,7 +269,7 @@ class ArgumentListVisitor {
       case null => true;
 
       // Allow property accesses.
-      case PropertyAccess(target) => _isValidWrappingTarget(target);
+      case PropertyAccess(var target) => _isValidWrappingTarget(target);
 
       case PrefixedIdentifier() | SimpleIdentifier() => true;
 
@@ -328,7 +328,7 @@ class ArgumentSublist {
     var blocks = <Expression, Token>{};
     for (var argument in arguments) {
       // Not sure if this is really better:
-      if (var bracket? = _blockToken(argument)) blocks[argument] = bracket;
+      if (_blockToken(argument) is var bracket?) blocks[argument] = bracket;
     }
 
     // Count the leading arguments that are blocks.
@@ -437,7 +437,7 @@ class ArgumentSublist {
     var argumentBlock = _blocks[argument];
     // Not really an improvement.
     switch (argumentBlock) {
-      case block?:
+      case var block?:
         rule.disableSplitOnInnerRules();
 
         // Tell it to use the rule we've already created.
@@ -518,12 +518,12 @@ class ArgumentSublist {
   static Token? _blockToken(Expression expression) {
     // Beautiful!
     return switch (expression) {
-      case NamedExpression(expression) => _blockToken(expression);
+      case NamedExpression(var expression) => _blockToken(expression);
 
       // TODO(rnystrom): Should we step into parenthesized expressions?
-      case ListLiteral(leftBracket: token)
-         | SetOrMapLiteral(leftBracket: token)
-         | SingleStringLiteral(isMultiline: true, beginToken: token) => token;
+      case ListLiteral(leftBracket: var token)
+         | SetOrMapLiteral(leftBracket: var token)
+         | SingleStringLiteral(isMultiline: true, beginToken: var token) => token;
 
       // Not a collection literal.
       default => null;

lib/src/ast_extensions.dart

@@ -95,8 +95,8 @@ extension ExpressionExtensions on Expression {
 
       // If the target is a call with a trailing comma in the argument list,
       // treat it like a collection literal.
-      case InvocationExpression(argumentList)
-         | InstanceCreationExpression(argumentList) =>
+      case InvocationExpression(var argumentList)
+         | InstanceCreationExpression(var argumentList) =>
 
         // TODO(rnystrom): Do we want to allow an invocation where the last
         // argument is a collection literal? Like:
@@ -114,7 +114,7 @@ extension ExpressionExtensions on Expression {
   bool get isTrailingCommaArgument {
     return switch (this) {
       case NamedExpression named => named.isTrailingCommaArgument;
-      case ArgumentList(arguments) => arguments.hasCommaAfter;
+      case ArgumentList(var arguments) => arguments.hasCommaAfter;
       default => false;
     }
   }
@@ -147,7 +147,7 @@ extension ExpressionExtensions on Expression {
       // A prefixed unnamed constructor call:
       //
       //     prefix.Foo();
-      case MethodInvocation(SimpleIdentifier target, methodName)
+      case MethodInvocation(SimpleIdentifier target, var methodName)
           when _looksLikeClassName(methodName.name) => true;
 
       // A prefixed or unprefixed named constructor call:
@@ -157,7 +157,7 @@ extension ExpressionExtensions on Expression {
       case MethodInvocation(PrefixedIdentifier target) =>
           target.looksLikeStaticCall;
 
-      case SimpleIdentifier(name) when _looksLikeClassName(name) => true;
+      case SimpleIdentifier(var name) when _looksLikeClassName(name) => true;
 
       default => false;
     }

lib/src/call_chain_visitor.dart

@@ -236,7 +236,7 @@ class CallChainVisitor {
 
     // If there are block calls, end the chain and write those without any
     // extra indentation.
-    if (var blockCalls? _blockCalls) {
+    if (_blockCalls is var blockCalls?) {
       _enableRule();
       _visitor.zeroSplit();
       _disableRule();
@@ -278,7 +278,7 @@ class CallChainVisitor {
     // * The body of a `=>` function.
     switch (expression) {
       // Unwrap parentheses.
-      case ParenthesizedExpression(expression):
+      case ParenthesizedExpression(var expression):
         return _forcesSplit(expression);
 
       // Don't split right after a collection literal.
@@ -294,9 +294,9 @@ class CallChainVisitor {
 
       // If the expression ends in an argument list, base the splitting on the
       // last argument.
-      case MethodInvocation(argumentList):
-      case InstanceCreationExpression(argumentList):
-      case FunctionExpressionInvocation(argumentList):
+      case MethodInvocation(var argumentList):
+      case InstanceCreationExpression(var argumentList):
+      case FunctionExpressionInvocation(var argumentList):
         if (argumentList.arguments.isEmpty) return true;
 
         var argument = argumentList.arguments.last;
@@ -426,8 +426,8 @@ switch class _Selector {
   /// Whether this selector is a method call whose arguments are block
   /// formatted.
   bool isBlockCall(SourceVisitor visitor) => switch (this) {
-    case _MethodSelector(_node) =>
-      ArgumentListVisitor(visitor, _node.argumentList).hasBlockArguments;
+    case _MethodSelector(var node) =>
+      ArgumentListVisitor(visitor, node.argumentList).hasBlockArguments;
 
     default => false;
   }
@@ -449,7 +449,7 @@ switch class _Selector {
           visitor._visitor.visitArgumentList(invocation.argumentList);
         case IndexExpression index:
           visitor._visitor.finishIndexExpression(index);
-        case PostfixExpression(operator):
+        case PostfixExpression(var operator):
           assert(operator.type == TokenType.BANG);
           visitor._visitor.token(operator);
         default:
@@ -463,25 +463,25 @@ switch class _Selector {
   /// Subclasses implement this to write their selector.
   void writeSelector(CallChainVisitor visitor) {
     switch (this) {
-      case _MethodSelector(_node):
-        visitor._visitor.token(_node.operator);
-        visitor._visitor.token(_node.methodName.token);
+      case _MethodSelector(var node):
+        visitor._visitor.token(node.operator);
+        visitor._visitor.token(node.methodName.token);
 
         visitor._beforeMethodArguments(this);
 
         visitor._visitor.builder.nestExpression();
-        visitor._visitor.visit(_node.typeArguments);
+        visitor._visitor.visit(node.typeArguments);
         visitor._visitor
-            .visitArgumentList(_node.argumentList, nestExpression: false);
+            .visitArgumentList(node.argumentList, nestExpression: false);
         visitor._visitor.builder.unnest();
 
-      case _PrefixedSelector(_node):
-        visitor._visitor.token(_node.period);
-        visitor._visitor.visit(_node.identifier);
+      case _PrefixedSelector(var node):
+        visitor._visitor.token(node.period);
+        visitor._visitor.visit(node.identifier);
 
-      case _PropertySelector(_node):
-        visitor._visitor.token(_node.operator);
-        visitor._visitor.visit(_node.propertyName);
+      case _PropertySelector(var node):
+        visitor._visitor.token(node.operator);
+        visitor._visitor.visit(node.propertyName);
     }
   }
 }
@@ -506,8 +506,7 @@ class _PropertySelector extends _Selector {
 
 /// If [expression] is a null-assertion operator, returns its operand.
 Expression _unwrapNullAssertion(Expression expression) {
-  if (expression is PostfixExpression &&
-      expression.operator.type == TokenType.BANG) {
+  if (expression is PostfixExpression(operator: Token(type: TokenType.BANG))) {
     return expression.operand;
   }
 
@@ -542,19 +541,19 @@ Expression _unwrapTarget(Expression node, List<_Selector> calls) {
     case _ when node.looksLikeStaticCall => node;
 
     // Selectors.
-    case MethodInvocation(target?) =>
+    case MethodInvocation(var target?) =>
         _unwrapSelector(target, _MethodSelector(node), calls);
 
-    case PropertyAccess(target?) =>
+    case PropertyAccess(var target?) =>
         _unwrapSelector(target, _PropertySelector(node), calls);
 
-    case PrefixedIdentifier(prefix) =>
+    case PrefixedIdentifier(var prefix) =>
         _unwrapSelector(prefix, _PrefixedSelector(node), calls);
 
     // Postfix expressions.
-    case IndexExpression(target?) => _unwrapPostfix(node, target, calls);
+    case IndexExpression(var target?) => _unwrapPostfix(node, target, calls);
 
-    case FunctionExpressionInvocation(function) =>
+    case FunctionExpressionInvocation(var function) =>
         _unwrapPostfix(node, function, calls);
 
     case PostfixExpression(operator: Token(type: TokenType.BANG)) =>

lib/src/chunk.dart

@@ -201,7 +201,7 @@ class Chunk extends Selection {
     if (!isBlock) return false;
 
     // Something like guard-let would be nice here.
-    if (var argument? = block.argument) {
+    if (block.argument is var argument?) {
       var rule = argument.rule;
 
       // There may be no rule if the block occurs inside a string interpolation.

lib/src/chunk_builder.dart

@@ -383,7 +383,7 @@ class ChunkBuilder {
 
       // Remove any leading "*" from the middle lines.
       if (i > 0 && i < lines.length - 1) {
-        if (_javaDocLine.firstMatch(line) case var match?) {
+        if (_javaDocLine.firstMatch(line) is var match?) {
           line = match[1]!;
         }
       }

lib/src/cli/format_command.dart

@@ -66,7 +66,7 @@ class FormatCommand extends Command<int> {
     // If the user wants to print the code and didn't indicate how the files
     // should be printed, default to only showing the code.
     if (!argResults.wasParsed('show') &&
-        (output == Output.show || output == Output.json)) {
+        (output is Output.show | Output.json)) {
       show = Show.none;
     }
 

lib/src/debug.dart

@@ -189,7 +189,7 @@ void dumpConstraints(List<Chunk> chunks) {
       for (var other in rules) {
         if (rule == other) continue;
 
-        if (var constraint? = rule.constrain(value, other)) {
+        if (rule.constrain(value, other) is var constraint?) {
           constraints.add('$other->$constraint');
         }
       }

lib/src/line_splitting/rule_set.dart

@@ -89,7 +89,7 @@ class RuleSet {
           } else {
             onSplitRule(other);
           }
-        case (null, constraint?):
+        case (null, var constraint?):
           // Bind the other rule to its value and recursively propagate its
           // constraints.
           if (!tryBind(rules, other, constraint, onSplitRule)) return false;
@@ -98,13 +98,13 @@ class RuleSet {
           // that value.
         case (!= null, Rule.mustSplit): // Instead of `!= null`, could do `_?`.
           if (otherValue == Rule.unsplit) return false;
-        case (!= null, constraint?):
+        case (!= null, var constraint?):
           if (otherValue != constraint) return false;
         case (!= null, _):
           // See if the other rule's constraint allows us to use this value.
           switch (other.constrain(otherValue, rule)) {
             case Rule.mustSplit when value == Rule.unsplit:
-            case constraint? when value != constraint:
+            case var constraint? when value != constraint:
               return false;
             default:
           }

lib/src/line_writer.dart

@@ -192,8 +192,8 @@ class LineWriter {
   /// Writes [chunk] to the output and updates the selection if the chunk
   /// contains a selection marker.
   void _writeChunk(Chunk chunk) {
-    if (var start? = chunk.selectionStart) _selectionStart = length + start;
-    if (var end? = chunk.selectionEnd) _selectionEnd = length + end;
+    if (chunk.selectionStart is var start?) _selectionStart = length + start;
+    if (chunk.selectionEnd is var end?) _selectionEnd = length + end;
 
     _buffer.write(chunk.text);
   }

lib/src/nesting_builder.dart

@@ -99,15 +99,15 @@ class NestingBuilder {
     indent ??= Indent.expression;
 
     _pendingNesting = switch (_pendingNesting) {
-      case nesting? => nesting.nest(indent);
+      case var nesting? => nesting.nest(indent);
       default => _nesting.nest(indent);
     }
   }
 
   /// Discards the most recent level of expression nesting.
   void unnest() {
     _pendingNesting = switch (_pendingNesting) {
-      case nesting? => nesting.parent;
+      case var nesting? => nesting.parent;
       default => _nesting.parent;
     }
 

lib/src/nesting_level.dart

@@ -65,7 +65,7 @@ class NestingLevel extends FastHash {
 
     totalIndent = 0;
 
-    if (var parent? = parent) {
+    if (parent is var parent?) {
       parent.refreshTotalUsedIndent(usedNesting);
       totalIndent += parent.totalUsedIndent;
     }

lib/src/source_code.dart

@@ -63,16 +63,16 @@ class SourceCode {
         throw ArgumentError(
             'If selectionStart is provided, selectionLength must be too.');
 
-      case (start?, _) when start < 0:
+      case (var start?, _) when start < 0:
         throw ArgumentError('selectionStart must be non-negative.');
 
-      case (start?, _) when start > text.length:
+      case (var start?, _) when start > text.length:
         throw ArgumentError('selectionStart must be within text.');
 
-      case (_, length?) when length < 0:
+      case (_, var length?) when length < 0:
         throw ArgumentError('selectionLength must be non-negative.');
 
-      case (start?, length?) when start + length > text.length:
+      case (var start?, var length?) when start + length > text.length:
         throw ArgumentError('selectionLength must end within text.');
     }
   }