diff --git a/pkg/_fe_analyzer_shared/test/mini_ast.dart b/pkg/_fe_analyzer_shared/test/mini_ast.dart
index a7f5ac3..6ec266d 100644
--- a/pkg/_fe_analyzer_shared/test/mini_ast.dart
+++ b/pkg/_fe_analyzer_shared/test/mini_ast.dart
@@ -383,13 +383,9 @@
 
   final Map<String, Type> _members = {};
 
-  Node? _currentSwitch;
-
   Map<String, Map<String, String>> _promotionExceptions = {};
 
-  Statement? _currentBreakTarget;
-
-  Statement? _currentContinueTarget;
+  late final _typeAnalyzer = _MiniAstTypeAnalyzer(this);
 
   Harness({this.legacy = false, String? thisType})
       : thisType = thisType == null ? null : Type(thisType);
@@ -482,8 +478,8 @@
             this, assignedVariables)
         : FlowAnalysis<Node, Statement, Expression, Var, Type>(
             this, assignedVariables);
-    b._visit(this);
-    _flow.finish();
+    _typeAnalyzer.dispatchStatement(b);
+    _typeAnalyzer.finish();
   }
 
   @override
@@ -537,16 +533,6 @@
           'TODO(paulberry): least upper bound of $type1 and $type2');
     }
   }
-
-  void _visitLoopBody(Statement loop, Statement body) {
-    var previousBreakTarget = _currentBreakTarget;
-    var previousContinueTarget = _currentContinueTarget;
-    _currentBreakTarget = loop;
-    _currentContinueTarget = loop;
-    body._visit(this);
-    _currentBreakTarget = previousBreakTarget;
-    _currentContinueTarget = previousContinueTarget;
-  }
 }
 
 class LabeledStatement extends Statement {
@@ -564,9 +550,7 @@
 
   @override
   void _visit(Harness h) {
-    h._flow.labeledStatement_begin(this);
-    _body._visit(h);
-    h._flow.labeledStatement_end();
+    h._typeAnalyzer.analyzeLabeledStatement(this, _body);
   }
 }
 
@@ -644,11 +628,6 @@
   void _preVisit(AssignedVariables<Node, Var> assignedVariables) {
     _body._preVisit(assignedVariables);
   }
-
-  void _visit(Harness h) {
-    h._flow.switchStatement_beginCase(_hasLabel, h._currentSwitch!);
-    _body._visit(h);
-  }
 }
 
 abstract class TryBuilder {
@@ -701,9 +680,7 @@
 
   @override
   Type _visit(Harness h) {
-    target._visit(h);
-    h._flow.asExpression_end(target, type);
-    return type;
+    return h._typeAnalyzer.analyzeTypeCast(this, target, type);
   }
 }
 
@@ -725,10 +702,7 @@
 
   @override
   void _visit(Harness h) {
-    h._flow.assert_begin();
-    h._flow.assert_afterCondition(condition.._visit(h));
-    message?._visit(h);
-    h._flow.assert_end();
+    h._typeAnalyzer.analyzeAssertStatement(condition, message);
   }
 }
 
@@ -750,9 +724,7 @@
 
   @override
   void _visit(Harness h) {
-    for (var statement in statements) {
-      statement._visit(h);
-    }
+    h._typeAnalyzer.analyzeBlock(statements);
   }
 }
 
@@ -769,8 +741,7 @@
 
   @override
   Type _visit(Harness h) {
-    h._flow.booleanLiteral(this, value);
-    return Type('bool');
+    return h._typeAnalyzer.analyzeBoolLiteral(this, value);
   }
 }
 
@@ -787,7 +758,7 @@
 
   @override
   void _visit(Harness h) {
-    h._flow.handleBreak(target ?? h._currentBreakTarget!);
+    h._typeAnalyzer.analyzeBreakStatement(target);
   }
 }
 
@@ -815,12 +786,6 @@
   void _preVisit(AssignedVariables<Node, Var> assignedVariables) {
     _body._preVisit(assignedVariables);
   }
-
-  void _visit(Harness h) {
-    h._flow.tryCatchStatement_catchBegin(_exception, _stackTrace);
-    _body._visit(h);
-    h._flow.tryCatchStatement_catchEnd();
-  }
 }
 
 class _CheckAssigned extends Statement {
@@ -928,13 +893,8 @@
 
   @override
   Type _visit(Harness h) {
-    h._flow.conditional_conditionBegin();
-    h._flow.conditional_thenBegin(condition.._visit(h), this);
-    var ifTrueType = ifTrue._visit(h);
-    h._flow.conditional_elseBegin(ifTrue);
-    var ifFalseType = ifFalse._visit(h);
-    h._flow.conditional_end(this, ifFalse);
-    return h._lub(ifTrueType, ifFalseType);
+    return h._typeAnalyzer
+        .analyzeConditionalExpression(this, condition, ifTrue, ifFalse);
   }
 }
 
@@ -949,7 +909,7 @@
 
   @override
   void _visit(Harness h) {
-    h._flow.handleContinue(h._currentContinueTarget!);
+    h._typeAnalyzer.analyzeContinueStatement();
   }
 }
 
@@ -977,15 +937,9 @@
 
   @override
   void _visit(Harness h) {
-    var initializer = this.initializer;
-    if (initializer == null) {
-      h._flow.declare(variable, false);
-    } else {
-      var initializerType = initializer._visit(h);
-      h._flow.declare(variable, true);
-      h._flow.initialize(variable, initializerType, initializer,
-          isFinal: isFinal, isLate: isLate);
-    }
+    h._typeAnalyzer.analyzeVariableDeclaration(
+        this, variable.type, variable, initializer,
+        isFinal: isFinal, isLate: isLate);
   }
 }
 
@@ -1008,11 +962,7 @@
 
   @override
   void _visit(Harness h) {
-    h._flow.doStatement_bodyBegin(this);
-    h._visitLoopBody(this, body);
-    h._flow.doStatement_conditionBegin();
-    condition._visit(h);
-    h._flow.doStatement_end(condition);
+    h._typeAnalyzer.analyzeDoLoop(this, body, condition);
   }
 }
 
@@ -1034,11 +984,9 @@
 
   @override
   Type _visit(Harness h) {
-    var lhsType = lhs._visit(h);
-    h._flow.equalityOp_rightBegin(lhs, lhsType);
-    var rhsType = rhs._visit(h);
-    h._flow.equalityOp_end(this, rhs, rhsType, notEqual: isInverted);
-    return Type('bool');
+    var operatorName = isInverted ? '!=' : '==';
+    return h._typeAnalyzer
+        .analyzeBinaryExpression(this, lhs, operatorName, rhs);
   }
 }
 
@@ -1057,7 +1005,7 @@
 
   @override
   void _visit(Harness h) {
-    expr._visit(h);
+    h._typeAnalyzer.analyzeExpressionStatement(expr);
   }
 }
 
@@ -1104,13 +1052,25 @@
 
   @override
   void _visit(Harness h) {
-    initializer?._visit(h);
+    if (initializer != null) {
+      h._typeAnalyzer.dispatchStatement(initializer!);
+    } else {
+      h._typeAnalyzer.handleNoInitializer();
+    }
     h._flow.for_conditionBegin(this);
-    condition?._visit(h);
+    if (condition != null) {
+      h._typeAnalyzer.analyzeExpression(condition!);
+    } else {
+      h._typeAnalyzer.handleNoCondition();
+    }
     h._flow.for_bodyBegin(forCollection ? null : this, condition);
-    h._visitLoopBody(this, body);
+    h._typeAnalyzer._visitLoopBody(this, body);
     h._flow.for_updaterBegin();
-    updater?._visit(h);
+    if (updater != null) {
+      h._typeAnalyzer.analyzeExpression(updater!);
+    } else {
+      h._typeAnalyzer.handleNoStatement();
+    }
     h._flow.for_end();
   }
 }
@@ -1154,13 +1114,14 @@
 
   @override
   void _visit(Harness h) {
-    var iteratedType = h._getIteratedType(iterable._visit(h));
+    var iteratedType =
+        h._getIteratedType(h._typeAnalyzer.analyzeExpression(iterable));
     h._flow.forEach_bodyBegin(this);
     var variable = this.variable;
     if (variable != null && !declaresVariable) {
       h._flow.write(this, variable, iteratedType, null);
     }
-    h._visitLoopBody(this, body);
+    h._typeAnalyzer._visitLoopBody(this, body);
     h._flow.forEach_end();
   }
 }
@@ -1179,7 +1140,7 @@
 
   @override
   Type _visit(Harness h) {
-    var type = target._visit(h);
+    var type = h._typeAnalyzer.analyzeExpression(target);
     h._flow.forwardExpression(this, target);
     callback(h._flow.expressionInfoForTesting(this));
     return type;
@@ -1222,16 +1183,7 @@
 
   @override
   void _visit(Harness h) {
-    h._flow.ifStatement_conditionBegin();
-    h._flow.ifStatement_thenBegin(condition.._visit(h), this);
-    ifTrue._visit(h);
-    if (ifFalse == null) {
-      h._flow.ifStatement_end(false);
-    } else {
-      h._flow.ifStatement_elseBegin();
-      ifFalse!._visit(h);
-      h._flow.ifStatement_end(true);
-    }
+    h._typeAnalyzer.analyzeIfStatement(this, condition, ifTrue, ifFalse);
   }
 }
 
@@ -1252,11 +1204,7 @@
 
   @override
   Type _visit(Harness h) {
-    var lhsType = lhs._visit(h);
-    h._flow.ifNullExpression_rightBegin(lhs, lhsType);
-    var rhsType = rhs._visit(h);
-    h._flow.ifNullExpression_end();
-    return h._lub(h.promoteToNonNull(lhsType), rhsType);
+    return h._typeAnalyzer.analyzeIfNullExpression(this, lhs, rhs);
   }
 }
 
@@ -1277,8 +1225,8 @@
 
   @override
   Type _visit(Harness h) {
-    h._flow.isExpression_end(this, target.._visit(h), isInverted, type);
-    return Type('bool');
+    return h._typeAnalyzer
+        .analyzeTypeTest(this, target, type, isInverted: isInverted);
   }
 }
 
@@ -1300,7 +1248,7 @@
   @override
   void _visit(Harness h) {
     h._flow.functionExpression_begin(this);
-    body._visit(h);
+    h._typeAnalyzer.dispatchStatement(body);
     h._flow.functionExpression_end();
   }
 }
@@ -1325,10 +1273,9 @@
 
   @override
   Type _visit(Harness h) {
-    h._flow.logicalBinaryOp_begin();
-    h._flow.logicalBinaryOp_rightBegin(lhs.._visit(h), this, isAnd: isAnd);
-    h._flow.logicalBinaryOp_end(this, rhs.._visit(h), isAnd: isAnd);
-    return Type('bool');
+    var operatorName = isAnd ? '&&' : '||';
+    return h._typeAnalyzer
+        .analyzeBinaryExpression(this, lhs, operatorName, rhs);
   }
 }
 
@@ -1348,6 +1295,344 @@
   readWrite,
 }
 
+class _MiniAstTypeAnalyzer {
+  final Harness _harness;
+
+  Statement? _currentBreakTarget;
+
+  Statement? _currentContinueTarget;
+
+  late final Type boolType = Type('bool');
+
+  late final Type neverType = Type('Never');
+
+  late final Type nullType = Type('Null');
+
+  _MiniAstTypeAnalyzer(this._harness);
+
+  FlowAnalysis<Node, Statement, Expression, Var, Type> get flow =>
+      _harness._flow;
+
+  Type get thisType => _harness.thisType!;
+
+  void analyzeAssertStatement(Expression condition, Expression? message) {
+    flow.assert_begin();
+    analyzeExpression(condition);
+    flow.assert_afterCondition(condition);
+    if (message != null) {
+      analyzeExpression(message);
+    } else {
+      handleNoMessage();
+    }
+    flow.assert_end();
+  }
+
+  Type analyzeBinaryExpression(
+      Expression node, Expression lhs, String operatorName, Expression rhs) {
+    bool isEquals = false;
+    bool isNot = false;
+    bool isLogical = false;
+    bool isAnd = false;
+    switch (operatorName) {
+      case '==':
+        isEquals = true;
+        break;
+      case '!=':
+        isEquals = true;
+        isNot = true;
+        operatorName = '==';
+        break;
+      case '&&':
+        isLogical = true;
+        isAnd = true;
+        break;
+      case '||':
+        isLogical = true;
+        break;
+    }
+    if (operatorName == '==') {
+      isEquals = true;
+    } else if (operatorName == '!=') {
+      isEquals = true;
+      isNot = true;
+      operatorName = '==';
+    }
+    if (isLogical) {
+      flow.logicalBinaryOp_begin();
+    }
+    var leftType = analyzeExpression(lhs);
+    if (isEquals) {
+      flow.equalityOp_rightBegin(lhs, leftType);
+    } else if (isLogical) {
+      flow.logicalBinaryOp_rightBegin(lhs, node, isAnd: isAnd);
+    }
+    var rightType = analyzeExpression(rhs);
+    if (isEquals) {
+      flow.equalityOp_end(node, rhs, rightType, notEqual: isNot);
+    } else if (isLogical) {
+      flow.logicalBinaryOp_end(node, rhs, isAnd: isAnd);
+    }
+    return boolType;
+  }
+
+  void analyzeBlock(Iterable<Statement> statements) {
+    for (var statement in statements) {
+      dispatchStatement(statement);
+    }
+  }
+
+  Type analyzeBoolLiteral(Expression node, bool value) {
+    flow.booleanLiteral(node, value);
+    return boolType;
+  }
+
+  void analyzeBreakStatement(Statement? target) {
+    flow.handleBreak(target ?? _currentBreakTarget!);
+  }
+
+  Type analyzeConditionalExpression(Expression node, Expression condition,
+      Expression ifTrue, Expression ifFalse) {
+    flow.conditional_conditionBegin();
+    analyzeExpression(condition);
+    flow.conditional_thenBegin(condition, node);
+    var ifTrueType = analyzeExpression(ifTrue);
+    flow.conditional_elseBegin(ifTrue);
+    var ifFalseType = analyzeExpression(ifFalse);
+    flow.conditional_end(node, ifFalse);
+    return leastUpperBound(ifTrueType, ifFalseType);
+  }
+
+  void analyzeContinueStatement() {
+    flow.handleContinue(_currentContinueTarget!);
+  }
+
+  void analyzeDoLoop(Statement node, Statement body, Expression condition) {
+    flow.doStatement_bodyBegin(node);
+    _visitLoopBody(node, body);
+    flow.doStatement_conditionBegin();
+    analyzeExpression(condition);
+    flow.doStatement_end(condition);
+  }
+
+  Type analyzeExpression(Expression expression) {
+    return dispatchExpression(expression);
+  }
+
+  void analyzeExpressionStatement(Expression expression) {
+    analyzeExpression(expression);
+  }
+
+  Type analyzeIfNullExpression(
+      Expression node, Expression lhs, Expression rhs) {
+    var leftType = analyzeExpression(lhs);
+    flow.ifNullExpression_rightBegin(lhs, leftType);
+    var rightType = analyzeExpression(rhs);
+    flow.ifNullExpression_end();
+    return leastUpperBound(
+        flow.typeOperations.promoteToNonNull(leftType), rightType);
+  }
+
+  void analyzeIfStatement(Statement node, Expression condition,
+      Statement ifTrue, Statement? ifFalse) {
+    flow.ifStatement_conditionBegin();
+    analyzeExpression(condition);
+    flow.ifStatement_thenBegin(condition, node);
+    dispatchStatement(ifTrue);
+    if (ifFalse == null) {
+      handleNoStatement();
+      flow.ifStatement_end(false);
+    } else {
+      flow.ifStatement_elseBegin();
+      dispatchStatement(ifFalse);
+      flow.ifStatement_end(true);
+    }
+  }
+
+  void analyzeLabeledStatement(Statement node, Statement body) {
+    flow.labeledStatement_begin(node);
+    dispatchStatement(body);
+    flow.labeledStatement_end();
+  }
+
+  Type analyzeLogicalNot(Expression node, Expression expression) {
+    analyzeExpression(expression);
+    flow.logicalNot_end(node, expression);
+    return boolType;
+  }
+
+  Type analyzeNonNullAssert(Expression node, Expression expression) {
+    var type = analyzeExpression(expression);
+    flow.nonNullAssert_end(expression);
+    return flow.typeOperations.promoteToNonNull(type);
+  }
+
+  Type analyzeNullLiteral(Expression node) {
+    flow.nullLiteral(node);
+    return nullType;
+  }
+
+  Type analyzeParenthesizedExpression(Expression node, Expression expression) {
+    var type = analyzeExpression(expression);
+    flow.parenthesizedExpression(node, expression);
+    return type;
+  }
+
+  Type analyzePropertyGet(
+      Expression node, Expression receiver, String propertyName) {
+    var receiverType = analyzeExpression(receiver);
+    var type = _lookupMember(node, receiverType, propertyName);
+    flow.propertyGet(node, receiver, propertyName, propertyName, type);
+    return type;
+  }
+
+  void analyzeReturnStatement() {
+    flow.handleExit();
+  }
+
+  void analyzeSwitchStatement(
+      _Switch node, Expression expression, List<SwitchCase> cases) {
+    analyzeExpression(expression);
+    flow.switchStatement_expressionEnd(node);
+    var previousBreakTarget = _currentBreakTarget;
+    _currentBreakTarget = node;
+    for (var case_ in cases) {
+      flow.switchStatement_beginCase(case_._hasLabel, node);
+      dispatchStatement(case_._body);
+    }
+    _currentBreakTarget = previousBreakTarget;
+    flow.switchStatement_end(isSwitchExhaustive(node));
+  }
+
+  Type analyzeThis(Expression node) {
+    var thisType = this.thisType;
+    flow.thisOrSuper(node, thisType);
+    return thisType;
+  }
+
+  Type analyzeThisPropertyGet(Expression node, String propertyName) {
+    var type = _lookupMember(node, thisType, propertyName);
+    flow.thisOrSuperPropertyGet(node, propertyName, propertyName, type);
+    return type;
+  }
+
+  Type analyzeThrow(Expression node, Expression expression) {
+    analyzeExpression(expression);
+    flow.handleExit();
+    return neverType;
+  }
+
+  void analyzeTryStatement(Statement node, Statement body,
+      Iterable<_CatchClause> catchClauses, Statement? finallyBlock) {
+    if (finallyBlock != null) {
+      flow.tryFinallyStatement_bodyBegin();
+    }
+    if (catchClauses.isNotEmpty) {
+      flow.tryCatchStatement_bodyBegin();
+    }
+    dispatchStatement(body);
+    if (catchClauses.isNotEmpty) {
+      flow.tryCatchStatement_bodyEnd(body);
+      for (var catch_ in catchClauses) {
+        flow.tryCatchStatement_catchBegin(
+            catch_._exception, catch_._stackTrace);
+        dispatchStatement(catch_._body);
+        flow.tryCatchStatement_catchEnd();
+      }
+      flow.tryCatchStatement_end();
+    }
+    if (finallyBlock != null) {
+      flow.tryFinallyStatement_finallyBegin(
+          catchClauses.isNotEmpty ? node : body);
+      dispatchStatement(finallyBlock);
+      flow.tryFinallyStatement_end();
+    } else {
+      handleNoStatement();
+    }
+  }
+
+  Type analyzeTypeCast(Expression node, Expression expression, Type type) {
+    analyzeExpression(expression);
+    flow.asExpression_end(expression, type);
+    return type;
+  }
+
+  Type analyzeTypeTest(Expression node, Expression expression, Type type,
+      {bool isInverted = false}) {
+    analyzeExpression(expression);
+    flow.isExpression_end(node, expression, isInverted, type);
+    return boolType;
+  }
+
+  void analyzeVariableDeclaration(
+      Statement node, Type type, Var variable, Expression? initializer,
+      {required bool isFinal, required bool isLate}) {
+    if (initializer == null) {
+      handleNoInitializer();
+      flow.declare(variable, false);
+    } else {
+      var initializerType = analyzeExpression(initializer);
+      flow.declare(variable, true);
+      flow.initialize(variable, initializerType, initializer,
+          isFinal: isFinal, isLate: isLate);
+    }
+  }
+
+  Type analyzeVariableGet(
+      Expression node, Var variable, void Function(Type?)? callback) {
+    var promotedType = flow.variableRead(node, variable);
+    callback?.call(promotedType);
+    return promotedType ?? variable.type;
+  }
+
+  void analyzeWhileLoop(Statement node, Expression condition, Statement body) {
+    flow.whileStatement_conditionBegin(node);
+    analyzeExpression(condition);
+    flow.whileStatement_bodyBegin(node, condition);
+    _visitLoopBody(node, body);
+    flow.whileStatement_end();
+  }
+
+  Type dispatchExpression(Expression expression) => expression._visit(_harness);
+
+  void dispatchStatement(Statement statement) => statement._visit(_harness);
+
+  void finish() {
+    flow.finish();
+  }
+
+  void handleNoCondition() {}
+
+  void handleNoInitializer() {}
+
+  void handleNoMessage() {}
+
+  void handleNoStatement() {}
+
+  bool isSwitchExhaustive(_Switch node) {
+    return node.isExhaustive;
+  }
+
+  Type leastUpperBound(Type t1, Type t2) => _harness._lub(t1, t2);
+
+  Type lookupInterfaceMember(Node node, Type receiverType, String memberName) {
+    return _harness.getMember(receiverType, memberName);
+  }
+
+  Type _lookupMember(Expression node, Type receiverType, String memberName) {
+    return lookupInterfaceMember(node, receiverType, memberName);
+  }
+
+  void _visitLoopBody(Statement loop, Statement body) {
+    var previousBreakTarget = _currentBreakTarget;
+    var previousContinueTarget = _currentContinueTarget;
+    _currentBreakTarget = loop;
+    _currentContinueTarget = loop;
+    dispatchStatement(body);
+    _currentBreakTarget = previousBreakTarget;
+    _currentContinueTarget = previousContinueTarget;
+  }
+}
+
 class _NonNullAssert extends Expression {
   final Expression operand;
 
@@ -1363,9 +1648,7 @@
 
   @override
   Type _visit(Harness h) {
-    var type = operand._visit(h);
-    h._flow.nonNullAssert_end(operand);
-    return h.promoteToNonNull(type);
+    return h._typeAnalyzer.analyzeNonNullAssert(this, operand);
   }
 }
 
@@ -1384,8 +1667,7 @@
 
   @override
   Type _visit(Harness h) {
-    h._flow.logicalNot_end(this, operand.._visit(h));
-    return Type('bool');
+    return h._typeAnalyzer.analyzeLogicalNot(this, operand);
   }
 }
 
@@ -1407,9 +1689,9 @@
 
   @override
   Type _visit(Harness h) {
-    var lhsType = lhs._visit(h);
+    var lhsType = h._typeAnalyzer.analyzeExpression(lhs);
     h._flow.nullAwareAccess_rightBegin(isCascaded ? null : lhs, lhsType);
-    var rhsType = rhs._visit(h);
+    var rhsType = h._typeAnalyzer.analyzeExpression(rhs);
     h._flow.nullAwareAccess_end();
     return h._lub(rhsType, Type('Null'));
   }
@@ -1426,8 +1708,7 @@
 
   @override
   Type _visit(Harness h) {
-    h._flow.nullLiteral(this);
-    return Type('Null');
+    return h._typeAnalyzer.analyzeNullLiteral(this);
   }
 }
 
@@ -1446,9 +1727,7 @@
 
   @override
   Type _visit(Harness h) {
-    var type = expr._visit(h);
-    h._flow.parenthesizedExpression(this, expr);
-    return type;
+    return h._typeAnalyzer.analyzeParenthesizedExpression(this, expr);
   }
 }
 
@@ -1482,10 +1761,7 @@
 
   @override
   Type _visit(Harness h) {
-    var targetType = target._visit(h);
-    var propertyType = h.getMember(targetType, propertyName);
-    h._flow.propertyGet(this, target, propertyName, propertyName, propertyType);
-    return propertyType;
+    return h._typeAnalyzer.analyzePropertyGet(this, target, propertyName);
   }
 
   @override
@@ -1506,7 +1782,7 @@
 
   @override
   void _visit(Harness h) {
-    h._flow.handleExit();
+    h._typeAnalyzer.analyzeReturnStatement();
   }
 }
 
@@ -1542,18 +1818,7 @@
 
   @override
   void _visit(Harness h) {
-    expression._visit(h);
-    h._flow.switchStatement_expressionEnd(this);
-    var oldSwitch = h._currentSwitch;
-    var previousBreakTarget = h._currentBreakTarget;
-    h._currentSwitch = this;
-    h._currentBreakTarget = this;
-    for (var case_ in cases) {
-      case_._visit(h);
-    }
-    h._currentSwitch = oldSwitch;
-    h._currentBreakTarget = previousBreakTarget;
-    h._flow.switchStatement_end(isExhaustive);
+    h._typeAnalyzer.analyzeSwitchStatement(this, expression, cases);
   }
 }
 
@@ -1566,9 +1831,7 @@
 
   @override
   Type _visit(Harness h) {
-    var thisType = h.thisType!;
-    h._flow.thisOrSuper(this, thisType);
-    return thisType;
+    return h._typeAnalyzer.analyzeThis(this);
   }
 }
 
@@ -1582,9 +1845,7 @@
 
   @override
   Type _visit(Harness h) {
-    var type = h.getMember(h.thisType!, propertyName);
-    h._flow.thisOrSuperPropertyGet(this, propertyName, propertyName, type);
-    return type;
+    return h._typeAnalyzer.analyzeThisPropertyGet(this, propertyName);
   }
 }
 
@@ -1603,9 +1864,7 @@
 
   @override
   Type _visit(Harness h) {
-    operand._visit(h);
-    h._flow.handleExit();
-    return Type('Never');
+    return h._typeAnalyzer.analyzeThrow(this, operand);
   }
 }
 
@@ -1653,26 +1912,7 @@
 
   @override
   void _visit(Harness h) {
-    if (_finally != null) {
-      h._flow.tryFinallyStatement_bodyBegin();
-    }
-    if (_catches.isNotEmpty) {
-      h._flow.tryCatchStatement_bodyBegin();
-    }
-    _body._visit(h);
-    if (_catches.isNotEmpty) {
-      h._flow.tryCatchStatement_bodyEnd(_body);
-      for (var catch_ in _catches) {
-        catch_._visit(h);
-      }
-      h._flow.tryCatchStatement_end();
-    }
-    if (_finally != null) {
-      h._flow
-          .tryFinallyStatement_finallyBegin(_catches.isNotEmpty ? this : _body);
-      _finally!._visit(h);
-      h._flow.tryFinallyStatement_end();
-    }
+    h._typeAnalyzer.analyzeTryStatement(this, _body, _catches, _finally);
   }
 }
 
@@ -1699,9 +1939,7 @@
 
   @override
   Type _visit(Harness h) {
-    var readResult = h._flow.variableRead(this, variable);
-    callback?.call(readResult);
-    return readResult ?? variable.type;
+    return h._typeAnalyzer.analyzeVariableGet(this, variable, callback);
   }
 
   @override
@@ -1730,11 +1968,7 @@
 
   @override
   void _visit(Harness h) {
-    h._flow.whileStatement_conditionBegin(this);
-    condition._visit(h);
-    h._flow.whileStatement_bodyBegin(this, condition);
-    h._visitLoopBody(this, body);
-    h._flow.whileStatement_end();
+    h._typeAnalyzer.analyzeWhileLoop(this, condition, body);
   }
 }
 
@@ -1755,7 +1989,7 @@
 
   @override
   Type _visit(Harness h) {
-    var type = target._visit(h);
+    var type = h._typeAnalyzer.analyzeExpression(target);
     h._flow.forwardExpression(this, target);
     Type.withComparisonsAllowed(() {
       callback(h._flow.whyNotPromoted(this)());
@@ -1815,9 +2049,13 @@
 
   @override
   Type _visit(Harness h) {
-    before?._visit(h);
-    var type = expr._visit(h);
-    after?._visit(h);
+    if (before != null) {
+      h._typeAnalyzer.dispatchStatement(before!);
+    }
+    var type = h._typeAnalyzer.analyzeExpression(expr);
+    if (after != null) {
+      h._typeAnalyzer.dispatchStatement(after!);
+    }
     h._flow.forwardExpression(this, expr);
     return type;
   }
@@ -1848,9 +2086,9 @@
     if (rhs == null) {
       // We are simulating an increment/decrement operation.
       // TODO(paulberry): Make a separate node type for this.
-      type = lhs._visit(h);
+      type = h._typeAnalyzer.analyzeExpression(lhs);
     } else {
-      type = rhs._visit(h);
+      type = h._typeAnalyzer.analyzeExpression(rhs);
     }
     lhs._visitWrite(h, this, type, rhs);
     return type;
diff --git a/pkg/analysis_server/lib/src/services/completion/statement/statement_completion.dart b/pkg/analysis_server/lib/src/services/completion/statement/statement_completion.dart
index 679b457..9bd0039 100644
--- a/pkg/analysis_server/lib/src/services/completion/statement/statement_completion.dart
+++ b/pkg/analysis_server/lib/src/services/completion/statement/statement_completion.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart = 2.9
-
 import 'dart:math';
 
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
@@ -21,6 +19,7 @@
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer_plugin/utilities/range_factory.dart';
+import 'package:collection/collection.dart';
 
 /// An enumeration of possible statement completion kinds.
 class DartStatementCompletion {
@@ -105,20 +104,23 @@
 
   final StatementCompletionContext statementContext;
   final CorrectionUtils utils;
-  AstNode node;
-  StatementCompletion completion;
+
+  /// TODO(brianwilkerson) Refactor the code so that the completion is returned
+  ///  from the methods in which it's computed rather than being a field that we
+  ///  have to test.
+  StatementCompletion? completion;
   SourceChange change = SourceChange('statement-completion');
   List<engine.AnalysisError> errors = [];
   final Map<String, LinkedEditGroup> linkedPositionGroups =
       <String, LinkedEditGroup>{};
-  Position exitPosition;
+  Position? exitPosition;
 
   StatementCompletionProcessor(this.statementContext)
       : utils = CorrectionUtils(statementContext.resolveResult);
 
   String get eol => utils.endOfLine;
 
-  String get file => statementContext.resolveResult.path;
+  String get file => statementContext.resolveResult.path!;
 
   LineInfo get lineInfo => statementContext.resolveResult.lineInfo;
 
@@ -126,29 +128,27 @@
 
   Source get source => unitElement.source;
 
-  CompilationUnit get unit => statementContext.resolveResult.unit;
+  CompilationUnit get unit => statementContext.resolveResult.unit!;
 
-  CompilationUnitElement get unitElement =>
-      statementContext.resolveResult.unit.declaredElement;
+  CompilationUnitElement get unitElement => unit.declaredElement!;
 
   Future<StatementCompletion> compute() async {
-    node = _selectedNode();
+    var node = _selectedNode();
     if (node == null) {
       return NO_COMPLETION;
     }
     node = node.thisOrAncestorMatching(
         (n) => n is Statement || _isNonStatementDeclaration(n));
     if (node == null) {
-      return _complete_simpleEnter() ? completion : NO_COMPLETION;
+      return _complete_simpleEnter() ? completion! : NO_COMPLETION;
     }
     if (node is Block) {
-      Block blockNode = node;
-      if (blockNode.statements.isNotEmpty) {
-        node = blockNode.statements.last;
+      if (node.statements.isNotEmpty) {
+        node = node.statements.last;
       }
     }
     if (_isEmptyStatementOrEmptyBlock(node)) {
-      node = node.parent;
+      node = node.parent!;
     }
     for (var error in statementContext.resolveResult.errors) {
       if (error.offset >= node.offset && error.offset <= node.end) {
@@ -158,41 +158,41 @@
       }
     }
 
-    _checkExpressions();
+    _checkExpressions(node);
     if (node is Statement) {
       if (errors.isEmpty) {
-        if (_complete_ifStatement() ||
-            _complete_forStatement2() ||
-            _complete_whileStatement() ||
-            _complete_controlFlowBlock()) {
-          return completion;
+        if (_complete_ifStatement(node) ||
+            _complete_forStatement2(node) ||
+            _complete_whileStatement(node) ||
+            _complete_controlFlowBlock(node)) {
+          return completion!;
         }
       } else {
-        if (_complete_ifStatement() ||
-            _complete_doStatement() ||
-            _complete_forStatement2() ||
-            _complete_functionDeclarationStatement() ||
-            _complete_switchStatement() ||
-            _complete_tryStatement() ||
-            _complete_whileStatement() ||
-            _complete_controlFlowBlock() ||
-            _complete_simpleSemicolon() ||
-            _complete_methodCall()) {
-          return completion;
+        if (_complete_ifStatement(node) ||
+            _complete_doStatement(node) ||
+            _complete_forStatement2(node) ||
+            _complete_functionDeclarationStatement(node) ||
+            _complete_switchStatement(node) ||
+            _complete_tryStatement(node) ||
+            _complete_whileStatement(node) ||
+            _complete_controlFlowBlock(node) ||
+            _complete_simpleSemicolon(node) ||
+            _complete_methodCall(node)) {
+          return completion!;
         }
       }
     } else if (node is Declaration) {
       if (errors.isNotEmpty) {
-        if (_complete_classDeclaration() ||
-            _complete_variableDeclaration() ||
-            _complete_simpleSemicolon() ||
-            _complete_functionDeclaration()) {
-          return completion;
+        if (_complete_classDeclaration(node) ||
+            _complete_variableDeclaration(node) ||
+            _complete_simpleSemicolon(node) ||
+            _complete_functionDeclaration(node)) {
+          return completion!;
         }
       }
     }
     if (_complete_simpleEnter()) {
-      return completion;
+      return completion!;
     }
     return NO_COMPLETION;
   }
@@ -259,16 +259,16 @@
     return text;
   }
 
-  void _checkExpressions() {
+  void _checkExpressions(AstNode node) {
     // Note: This may queue edits that have to be accounted for later.
     // See _lengthOfInsertions().
-    AstNode errorMatching(errorCode, {partialMatch}) {
+    AstNode? errorMatching(errorCode, {partialMatch}) {
       var error = _findError(errorCode, partialMatch: partialMatch);
       if (error == null) {
         return null;
       }
       var expr = _selectedNode();
-      return (expr.thisOrAncestorOfType<StringInterpolation>() == null)
+      return (expr?.thisOrAncestorOfType<StringInterpolation>() == null)
           ? expr
           : null;
     }
@@ -306,9 +306,8 @@
         errorMatching(ScannerErrorCode.EXPECTED_TOKEN, partialMatch: "']'");
     if (expr != null) {
       expr = expr.thisOrAncestorOfType<ListLiteral>();
-      if (expr != null) {
-        ListLiteral lit = expr;
-        if (lit.rightBracket.isSynthetic) {
+      if (expr is ListLiteral) {
+        if (expr.rightBracket.isSynthetic) {
           var src = utils.getNodeText(expr).trim();
           var loc = expr.offset + src.length;
           if (src.contains(eol)) {
@@ -351,14 +350,13 @@
     */
   }
 
-  bool _complete_classDeclaration() {
+  bool _complete_classDeclaration(AstNode node) {
     if (node is! ClassDeclaration) {
       return false;
     }
-    ClassDeclaration decl = node;
-    if (decl.leftBracket.isSynthetic && errors.length == 1) {
+    if (node.leftBracket.isSynthetic && errors.length == 1) {
       // The space before the left brace is assumed to exist, even if it does not.
-      var sb = SourceBuilder(file, decl.end - 1);
+      var sb = SourceBuilder(file, node.end - 1);
       sb.append(' ');
       _appendEmptyBraces(sb, true);
       _insertBuilder(sb);
@@ -368,19 +366,18 @@
     return false;
   }
 
-  bool _complete_controlFlowBlock() {
+  bool _complete_controlFlowBlock(AstNode node) {
     var expr = (node is ExpressionStatement)
-        ? (node as ExpressionStatement).expression
-        : (node is ReturnStatement
-            ? (node as ReturnStatement).expression
-            : null);
+        ? node.expression
+        : (node is ReturnStatement ? node.expression : null);
     if (!(node is ReturnStatement || expr is ThrowExpression)) {
       return false;
     }
-    if (node.parent is! Block) {
+    var parent = node.parent;
+    if (parent is! Block) {
       return false;
     }
-    var outer = node.parent.parent;
+    var outer = parent.parent;
     if (!(outer is DoStatement ||
         outer is ForStatement ||
         outer is IfStatement ||
@@ -399,12 +396,10 @@
         // Because of this, check for length == 0 rather than isSynthetic.
         if (expr == null || expr.length == 0) {
           if (node is ReturnStatement) {
-            insertOffset = (node as ReturnStatement).returnKeyword.end;
+            insertOffset = node.returnKeyword.end;
           } else if (node is ExpressionStatement) {
             insertOffset =
-                ((node as ExpressionStatement).expression as ThrowExpression)
-                    .throwKeyword
-                    .end;
+                (node.expression as ThrowExpression).throwKeyword.end;
           } else {
             insertOffset = node.end; // Not reached.
           }
@@ -417,71 +412,65 @@
         delta = 1;
       }
     }
-    var offset = _appendNewlinePlusIndentAt(node.parent.end);
+    var offset = _appendNewlinePlusIndentAt(parent.end);
     exitPosition = Position(file, offset + delta + previousInsertions);
     _setCompletion(DartStatementCompletion.COMPLETE_CONTROL_FLOW_BLOCK);
     return true;
   }
 
-  bool _complete_doStatement() {
+  bool _complete_doStatement(AstNode node) {
     if (node is! DoStatement) {
       return false;
     }
-    DoStatement statement = node;
-    var sb = _sourceBuilderAfterKeyword(statement.doKeyword);
-    var hasWhileKeyword =
-        statement.whileKeyword != null && !statement.whileKeyword.isSynthetic;
+    var sb = _sourceBuilderAfterKeyword(node, node.doKeyword);
+    var hasWhileKeyword = !node.whileKeyword.isSynthetic;
     var exitDelta = 0;
-    if (!_statementHasValidBody(statement.doKeyword, statement.body)) {
-      var text = utils.getNodeText(statement.body);
+    if (!_statementHasValidBody(node.doKeyword, node.body)) {
+      var text = utils.getNodeText(node.body);
       var delta = 0;
       if (text.startsWith(';')) {
         delta = 1;
-        _addReplaceEdit(range.startLength(statement.body, delta), '');
+        _addReplaceEdit(range.startLength(node.body, delta), '');
         if (hasWhileKeyword) {
-          text = utils.getNodeText(statement);
+          text = utils.getNodeText(node);
           if (text.indexOf(RegExp(r'do\s*;\s*while')) == 0) {
             var end = text.indexOf('while');
             var start = text.indexOf(';') + 1;
             delta += end - start - 1;
-            _addReplaceEdit(
-                SourceRange(start + statement.offset, end - start), ' ');
+            _addReplaceEdit(SourceRange(start + node.offset, end - start), ' ');
           }
         }
         sb = SourceBuilder(file, sb.offset + delta);
         sb.append(' ');
       }
-      _appendEmptyBraces(sb,
-          !(hasWhileKeyword && _isSyntheticExpression(statement.condition)));
+      _appendEmptyBraces(
+          sb, !(hasWhileKeyword && _isSyntheticExpression(node.condition)));
       if (delta != 0) {
         exitDelta = sb.length - delta;
       }
-    } else if (_isEmptyBlock(statement.body)) {
-      sb = SourceBuilder(sb.file, statement.body.end);
+    } else if (_isEmptyBlock(node.body)) {
+      sb = SourceBuilder(sb.file, node.body.end);
     }
-    SourceBuilder sb2;
+    SourceBuilder? sb2;
     if (hasWhileKeyword) {
-      var stmt = _KeywordConditionBlockStructure(
-          statement.whileKeyword,
-          statement.leftParenthesis,
-          statement.condition,
-          statement.rightParenthesis,
-          null);
-      sb2 = _complete_keywordCondition(stmt);
+      var stmt = _KeywordConditionBlockStructure(node.whileKeyword,
+          node.leftParenthesis, node.condition, node.rightParenthesis, null);
+      sb2 = _complete_keywordCondition(node, stmt);
       if (sb2 == null) {
         return false;
       }
       if (sb2.length == 0) {
         // true if condition is '()'
+        final exitPosition = this.exitPosition;
         if (exitPosition != null) {
-          if (statement.semicolon.isSynthetic) {
+          if (node.semicolon.isSynthetic) {
             _insertBuilder(sb);
             sb = SourceBuilder(file, exitPosition.offset + 1);
             sb.append(';');
           }
         }
       } else {
-        if (sb.exitOffset == null && sb2?.exitOffset != null) {
+        if (sb.exitOffset == null && sb2.exitOffset != null) {
           _insertBuilder(sb);
           sb = sb2;
           sb.append(';');
@@ -497,7 +486,7 @@
     _insertBuilder(sb);
     if (exitDelta != 0) {
       exitPosition =
-          Position(exitPosition.file, exitPosition.offset + exitDelta);
+          Position(exitPosition!.file, exitPosition!.offset + exitDelta);
     }
     _setCompletion(DartStatementCompletion.COMPLETE_DO_STMT);
     return true;
@@ -514,6 +503,7 @@
       throw StateError('Unrecognized for loop parts');
     }
     return _complete_forEachStatementRest(
+        forNode,
         forNode.forKeyword,
         forNode.leftParenthesis,
         name,
@@ -524,11 +514,12 @@
   }
 
   bool _complete_forEachStatementRest(
+      AstNode node,
       Token forKeyword,
       Token leftParenthesis,
-      AstNode name,
+      AstNode? name,
       Token inKeyword,
-      Expression iterable,
+      Expression? iterable,
       Token rightParenthesis,
       Statement body) {
     if (inKeyword.isSynthetic) {
@@ -577,7 +568,7 @@
         return false;
       }
       // keywordOnly (unit test name suffix that exercises this branch)
-      sb = _sourceBuilderAfterKeyword(forNode.forKeyword);
+      sb = _sourceBuilderAfterKeyword(forNode, forNode.forKeyword);
       sb.append('(');
       sb.setExitOffset();
       sb.append(')');
@@ -625,18 +616,19 @@
         sb = SourceBuilder(file, forNode.rightParenthesis.offset);
       } else if (forParts is ForPartsWithExpression &&
           forParts.initialization is SimpleIdentifier &&
-          forParts.initialization.beginToken.lexeme == 'in') {
+          forParts.initialization!.beginToken.lexeme == 'in') {
         // looks like a for/each statement missing the loop variable
         return _complete_forEachStatementRest(
+            forNode,
             forNode.forKeyword,
             forNode.leftParenthesis,
             null,
-            forParts.initialization.beginToken,
+            forParts.initialization!.beginToken,
             null,
             forNode.rightParenthesis,
             forNode.body);
       } else {
-        var start = forParts.condition.offset + forParts.condition.length;
+        var start = forParts.condition!.offset + forParts.condition!.length;
         var text = utils.getNodeText(forNode).substring(start - forNode.offset);
         if (text.startsWith(RegExp(r'\s*\)'))) {
           // missingLeftSeparator
@@ -651,12 +643,12 @@
         }
       }
     }
-    if (!_statementHasValidBody(forNode.forKeyword, forNode.body)) {
+    var body = forNode.body;
+    if (!_statementHasValidBody(forNode.forKeyword, body)) {
       // keywordOnly, noError
       sb.append(' ');
       _appendEmptyBraces(sb, true /*exitPosition == null*/);
-    } else if (forNode.body is Block) {
-      Block body = forNode.body;
+    } else if (body is Block) {
       if (body.rightBracket.end <= selectionOffset) {
         // emptyInitializersAfterBody
         errors = []; // Ignore errors; they are for previous statement.
@@ -668,8 +660,7 @@
     return true;
   }
 
-  bool _complete_forStatement2() {
-    var node = this.node;
+  bool _complete_forStatement2(AstNode node) {
     if (node is ForStatement) {
       var forLoopParts = node.forLoopParts;
       if (forLoopParts is ForParts) {
@@ -681,7 +672,7 @@
     return false;
   }
 
-  bool _complete_functionDeclaration() {
+  bool _complete_functionDeclaration(AstNode node) {
     if (node is! MethodDeclaration && node is! FunctionDeclaration) {
       return false;
     }
@@ -698,11 +689,19 @@
 
     int paramListEnd;
     if (node is FunctionDeclaration) {
-      FunctionDeclaration func = node;
-      paramListEnd = computeExitPos(func.functionExpression.parameters);
+      var parameters = node.functionExpression.parameters;
+      if (parameters == null) {
+        return false;
+      }
+      paramListEnd = computeExitPos(parameters);
+    } else if (node is MethodDeclaration) {
+      var parameters = node.parameters;
+      if (parameters == null) {
+        return false;
+      }
+      paramListEnd = computeExitPos(parameters);
     } else {
-      MethodDeclaration meth = node;
-      paramListEnd = computeExitPos(meth.parameters);
+      return false;
     }
     var sb = SourceBuilder(file, paramListEnd);
     if (needsParen) {
@@ -715,26 +714,23 @@
     return true;
   }
 
-  bool _complete_functionDeclarationStatement() {
+  bool _complete_functionDeclarationStatement(AstNode node) {
     if (node is! FunctionDeclarationStatement) {
       return false;
     }
     var error = _findError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "';'");
     if (error != null) {
-      FunctionDeclarationStatement stmt = node;
-      var src = utils.getNodeText(stmt);
-      var insertOffset = stmt.functionDeclaration.end - 1;
-      if (stmt.functionDeclaration.functionExpression.body
-          is ExpressionFunctionBody) {
-        ExpressionFunctionBody fnb =
-            stmt.functionDeclaration.functionExpression.body;
-        var fnbOffset = fnb.functionDefinition.offset;
-        var fnSrc = src.substring(fnbOffset - stmt.offset);
+      var src = utils.getNodeText(node);
+      var insertOffset = node.functionDeclaration.end - 1;
+      var body = node.functionDeclaration.functionExpression.body;
+      if (body is ExpressionFunctionBody) {
+        var fnbOffset = body.functionDefinition.offset;
+        var fnSrc = src.substring(fnbOffset - node.offset);
         if (!fnSrc.startsWith('=>')) {
           return false;
         }
         var delta = 0;
-        if (fnb.expression.isSynthetic) {
+        if (body.expression.isSynthetic) {
           if (!fnSrc.startsWith('=> ')) {
             _addInsertEdit(insertOffset, ' ');
             delta = 1;
@@ -754,12 +750,12 @@
     return false;
   }
 
-  bool _complete_ifOrWhileStatement(
+  bool _complete_ifOrWhileStatement(AstNode node,
       _KeywordConditionBlockStructure statement, StatementCompletionKind kind) {
-    if (_statementHasValidBody(statement.keyword, statement.block)) {
+    if (_statementHasValidBody(statement.keyword, statement.block!)) {
       return false;
     }
-    var sb = _complete_keywordCondition(statement);
+    var sb = _complete_keywordCondition(node, statement);
     if (sb == null) {
       return false;
     }
@@ -768,24 +764,24 @@
     _appendEmptyBraces(sb, exitPosition == null);
     _insertBuilder(sb);
     if (overshoot != 0) {
-      exitPosition = _newPosition(exitPosition.offset - overshoot);
+      exitPosition = _newPosition(exitPosition!.offset - overshoot);
     }
     _setCompletion(kind);
     return true;
   }
 
-  bool _complete_ifStatement() {
+  bool _complete_ifStatement(AstNode node) {
     if (node is! IfStatement) {
       return false;
     }
-    IfStatement ifNode = node;
-    if (ifNode.elseKeyword != null) {
-      if (selectionOffset >= ifNode.elseKeyword.end &&
-          _isEmptyStatement(ifNode.elseStatement)) {
+    var elseKeyword = node.elseKeyword;
+    if (elseKeyword != null) {
+      if (selectionOffset >= elseKeyword.end &&
+          _isEmptyStatement(node.elseStatement)) {
         var sb = SourceBuilder(file, selectionOffset);
-        var src = utils.getNodeText(ifNode);
+        var src = utils.getNodeText(node);
         if (!src
-            .substring(ifNode.elseKeyword.end - node.offset)
+            .substring(elseKeyword.end - node.offset)
             .startsWith(RegExp(r'[ \t]'))) {
           sb.append(' ');
         }
@@ -797,24 +793,24 @@
       return false;
     }
     var stmt = _KeywordConditionBlockStructure(
-        ifNode.ifKeyword,
-        ifNode.leftParenthesis,
-        ifNode.condition,
-        ifNode.rightParenthesis,
-        ifNode.thenStatement);
+        node.ifKeyword,
+        node.leftParenthesis,
+        node.condition,
+        node.rightParenthesis,
+        node.thenStatement);
     return _complete_ifOrWhileStatement(
-        stmt, DartStatementCompletion.COMPLETE_IF_STMT);
+        node, stmt, DartStatementCompletion.COMPLETE_IF_STMT);
   }
 
-  SourceBuilder _complete_keywordCondition(
-      _KeywordConditionBlockStructure statement) {
+  SourceBuilder? _complete_keywordCondition(
+      AstNode node, _KeywordConditionBlockStructure statement) {
     SourceBuilder sb;
     if (statement.leftParenthesis.isSynthetic) {
       if (!statement.rightParenthesis.isSynthetic) {
         // Quite unlikely to see this so don't try to fix it.
         return null;
       }
-      sb = _sourceBuilderAfterKeyword(statement.keyword);
+      sb = _sourceBuilderAfterKeyword(node, statement.keyword);
       sb.append('(');
       sb.setExitOffset();
       sb.append(')');
@@ -841,18 +837,19 @@
     return sb;
   }
 
-  bool _complete_methodCall() {
+  bool _complete_methodCall(AstNode node) {
     var parenError =
         _findError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "')'") ??
             _findError(ScannerErrorCode.EXPECTED_TOKEN, partialMatch: "')'");
     if (parenError == null) {
       return false;
     }
-    AstNode argList =
-        _selectedNode(at: selectionOffset).thisOrAncestorOfType<ArgumentList>();
+    var argList = _selectedNode(at: selectionOffset)
+        ?.thisOrAncestorOfType<ArgumentList>();
     argList ??= _selectedNode(at: parenError.offset)
-        .thisOrAncestorOfType<ArgumentList>();
-    if (argList?.thisOrAncestorMatching((n) => n == node) == null) {
+        ?.thisOrAncestorOfType<ArgumentList>();
+    if (argList == null ||
+        argList.thisOrAncestorMatching((n) => n == node) == null) {
       return false;
     }
     var previousInsertions = _lengthOfInsertions();
@@ -891,7 +888,7 @@
     return true;
   }
 
-  bool _complete_simpleSemicolon() {
+  bool _complete_simpleSemicolon(AstNode node) {
     if (errors.length != 1) {
       return false;
     }
@@ -908,41 +905,39 @@
     return false;
   }
 
-  bool _complete_switchStatement() {
+  bool _complete_switchStatement(AstNode node) {
     if (node is! SwitchStatement) {
       return false;
     }
     SourceBuilder sb;
-    SwitchStatement switchNode = node;
-    if (switchNode.leftParenthesis.isSynthetic &&
-        switchNode.rightParenthesis.isSynthetic) {
-      exitPosition = Position(file, switchNode.switchKeyword.end + 2);
-      var src = utils.getNodeText(switchNode);
+    if (node.leftParenthesis.isSynthetic && node.rightParenthesis.isSynthetic) {
+      exitPosition = Position(file, node.switchKeyword.end + 2);
+      var src = utils.getNodeText(node);
       if (src
-          .substring(switchNode.switchKeyword.end - switchNode.offset)
+          .substring(node.switchKeyword.end - node.offset)
           .startsWith(RegExp(r'[ \t]+'))) {
-        sb = SourceBuilder(file, switchNode.switchKeyword.end + 1);
+        sb = SourceBuilder(file, node.switchKeyword.end + 1);
       } else {
-        sb = SourceBuilder(file, switchNode.switchKeyword.end);
+        sb = SourceBuilder(file, node.switchKeyword.end);
         sb.append(' ');
       }
       sb.append('()');
-    } else if (switchNode.leftParenthesis.isSynthetic ||
-        switchNode.rightParenthesis.isSynthetic) {
+    } else if (node.leftParenthesis.isSynthetic ||
+        node.rightParenthesis.isSynthetic) {
       return false;
     } else {
-      sb = SourceBuilder(file, switchNode.rightParenthesis.offset + 1);
-      if (_isSyntheticExpression(switchNode.expression)) {
-        exitPosition = Position(file, switchNode.leftParenthesis.offset + 1);
+      sb = SourceBuilder(file, node.rightParenthesis.offset + 1);
+      if (_isSyntheticExpression(node.expression)) {
+        exitPosition = Position(file, node.leftParenthesis.offset + 1);
       }
     }
-    if (switchNode
+    if (node
         .leftBracket.isSynthetic /*&& switchNode.rightBracket.isSynthetic*/) {
       // See https://github.com/dart-lang/sdk/issues/29391
       sb.append(' ');
       _appendEmptyBraces(sb, exitPosition == null);
     } else {
-      var member = _findInvalidElement(switchNode.members);
+      var member = _findInvalidElement(node.members);
       if (member != null) {
         if (member.colon.isSynthetic) {
           var loc =
@@ -958,98 +953,103 @@
     return true;
   }
 
-  bool _complete_tryStatement() {
+  bool _complete_tryStatement(AstNode node) {
     if (node is! TryStatement) {
       return false;
     }
-    TryStatement tryNode = node;
-    SourceBuilder sb;
-    CatchClause catchNode;
     var addSpace = true;
-    if (tryNode.body.leftBracket.isSynthetic) {
-      var src = utils.getNodeText(tryNode);
+    if (node.body.leftBracket.isSynthetic) {
+      var src = utils.getNodeText(node);
+      SourceBuilder sb;
       if (src
-          .substring(tryNode.tryKeyword.end - tryNode.offset)
+          .substring(node.tryKeyword.end - node.offset)
           .startsWith(RegExp(r'[ \t]+'))) {
         // keywordSpace
-        sb = SourceBuilder(file, tryNode.tryKeyword.end + 1);
+        sb = SourceBuilder(file, node.tryKeyword.end + 1);
       } else {
         // keywordOnly
-        sb = SourceBuilder(file, tryNode.tryKeyword.end);
+        sb = SourceBuilder(file, node.tryKeyword.end);
         sb.append(' ');
       }
       _appendEmptyBraces(sb, true);
       _insertBuilder(sb);
-      sb = null;
-    } else if ((catchNode = _findInvalidElement(tryNode.catchClauses)) !=
-        null) {
-      if (catchNode.onKeyword != null) {
-        if (catchNode.exceptionType.length == 0 ||
-            null !=
-                _findError(CompileTimeErrorCode.NON_TYPE_IN_CATCH_CLAUSE,
-                    partialMatch: "name 'catch")) {
-          var src = utils.getNodeText(catchNode);
-          if (src.startsWith(RegExp(r'on[ \t]+'))) {
-            if (src.startsWith(RegExp(r'on[ \t][ \t]+'))) {
-              // onSpaces
-              exitPosition = Position(file, catchNode.onKeyword.end + 1);
-              sb = SourceBuilder(file, catchNode.onKeyword.end + 2);
-              addSpace = false;
+    } else {
+      SourceBuilder? sb;
+      var catchNode = _findInvalidElement(node.catchClauses);
+      if (catchNode != null) {
+        var onKeyword = catchNode.onKeyword;
+        var exceptionType = catchNode.exceptionType;
+        if (onKeyword != null && exceptionType != null) {
+          if (exceptionType.length == 0 ||
+              _findError(CompileTimeErrorCode.NON_TYPE_IN_CATCH_CLAUSE,
+                      partialMatch: "name 'catch") !=
+                  null) {
+            var src = utils.getNodeText(catchNode);
+            if (src.startsWith(RegExp(r'on[ \t]+'))) {
+              if (src.startsWith(RegExp(r'on[ \t][ \t]+'))) {
+                // onSpaces
+                exitPosition = Position(file, onKeyword.end + 1);
+                sb = SourceBuilder(file, onKeyword.end + 2);
+                addSpace = false;
+              } else {
+                // onSpace
+                sb = SourceBuilder(file, onKeyword.end + 1);
+                sb.setExitOffset();
+              }
             } else {
-              // onSpace
-              sb = SourceBuilder(file, catchNode.onKeyword.end + 1);
+              // onOnly
+              sb = SourceBuilder(file, onKeyword.end);
+              sb.append(' ');
               sb.setExitOffset();
             }
           } else {
-            // onOnly
-            sb = SourceBuilder(file, catchNode.onKeyword.end);
-            sb.append(' ');
-            sb.setExitOffset();
+            // onType
+            sb = SourceBuilder(file, exceptionType.end);
           }
-        } else {
-          // onType
-          sb = SourceBuilder(file, catchNode.exceptionType.end);
         }
-      }
-      if (catchNode.catchKeyword != null) {
-        // catchOnly
-        var struct = _KeywordConditionBlockStructure(
-            catchNode.catchKeyword,
-            catchNode.leftParenthesis,
-            catchNode.exceptionParameter,
-            catchNode.rightParenthesis,
-            catchNode.body);
+        var catchKeyword = catchNode.catchKeyword;
+        if (catchKeyword != null) {
+          // catchOnly
+          var struct = _KeywordConditionBlockStructure(
+              catchKeyword,
+              catchNode.leftParenthesis!,
+              catchNode.exceptionParameter!,
+              catchNode.rightParenthesis!,
+              catchNode.body);
+          if (sb != null) {
+            // onCatch
+            _insertBuilder(sb);
+          }
+          sb = _complete_keywordCondition(node, struct);
+          if (sb == null) {
+            return false;
+          }
+        }
         if (sb != null) {
-          // onCatch
+          if (catchNode.body.leftBracket.isSynthetic) {
+            // onOnly and others
+            if (addSpace) {
+              sb.append(' ');
+            }
+            _appendEmptyBraces(sb, exitPosition == null);
+          }
           _insertBuilder(sb);
         }
-        sb = _complete_keywordCondition(struct);
-        if (sb == null) {
-          return false;
-        }
-      }
-      if (catchNode.body.leftBracket.isSynthetic) {
-        // onOnly and others
-        if (addSpace) {
+      } else if (node.finallyKeyword != null) {
+        if (node.finallyBlock!.leftBracket.isSynthetic) {
+          // finallyOnly
+          sb = SourceBuilder(file, node.finallyKeyword!.end);
           sb.append(' ');
+          _appendEmptyBraces(sb, true);
+          _insertBuilder(sb);
         }
-        _appendEmptyBraces(sb, exitPosition == null);
-      }
-      _insertBuilder(sb);
-    } else if (tryNode.finallyKeyword != null) {
-      if (tryNode.finallyBlock.leftBracket.isSynthetic) {
-        // finallyOnly
-        sb = SourceBuilder(file, tryNode.finallyKeyword.end);
-        sb.append(' ');
-        _appendEmptyBraces(sb, true);
-        _insertBuilder(sb);
       }
     }
     _setCompletion(DartStatementCompletion.COMPLETE_TRY_STMT);
     return true;
   }
 
-  bool _complete_variableDeclaration() {
+  bool _complete_variableDeclaration(AstNode node) {
     if (node is! VariableDeclaration) {
       return false;
     }
@@ -1059,36 +1059,25 @@
     return true;
   }
 
-  bool _complete_whileStatement() {
+  bool _complete_whileStatement(AstNode node) {
     if (node is! WhileStatement) {
       return false;
     }
-    WhileStatement whileNode = node;
-    if (whileNode != null) {
-      var stmt = _KeywordConditionBlockStructure(
-          whileNode.whileKeyword,
-          whileNode.leftParenthesis,
-          whileNode.condition,
-          whileNode.rightParenthesis,
-          whileNode.body);
-      return _complete_ifOrWhileStatement(
-          stmt, DartStatementCompletion.COMPLETE_WHILE_STMT);
-    }
-    return false;
+    var stmt = _KeywordConditionBlockStructure(node.whileKeyword,
+        node.leftParenthesis, node.condition, node.rightParenthesis, node.body);
+    return _complete_ifOrWhileStatement(
+        node, stmt, DartStatementCompletion.COMPLETE_WHILE_STMT);
   }
 
-  engine.AnalysisError _findError(ErrorCode code, {partialMatch}) {
-    return errors.firstWhere(
-        (err) =>
-            err.errorCode == code &&
-            (partialMatch == null ? true : err.message.contains(partialMatch)),
-        orElse: () => null);
+  engine.AnalysisError? _findError(ErrorCode code, {partialMatch}) {
+    return errors.firstWhereOrNull((err) =>
+        err.errorCode == code &&
+        (partialMatch == null ? true : err.message.contains(partialMatch)));
   }
 
-  T _findInvalidElement<T extends AstNode>(NodeList<T> list) {
-    return list.firstWhere(
-        (item) => selectionOffset >= item.offset && selectionOffset <= item.end,
-        orElse: () => null);
+  T? _findInvalidElement<T extends AstNode>(NodeList<T> list) {
+    return list.firstWhereOrNull((item) =>
+        selectionOffset >= item.offset && selectionOffset <= item.end);
   }
 
   void _insertBuilder(SourceBuilder builder, [int length = 0]) {
@@ -1110,7 +1099,7 @@
     return stmt is Block && stmt.statements.isEmpty;
   }
 
-  bool _isEmptyStatement(AstNode stmt) {
+  bool _isEmptyStatement(AstNode? stmt) {
     if (stmt is ExpressionStatement) {
       var expression = stmt.expression;
       if (expression is SimpleIdentifier) {
@@ -1137,7 +1126,7 @@
         p?.parent?.parent is! Statement;
   }
 
-  bool _isSyntheticExpression(Expression expr) {
+  bool _isSyntheticExpression(Expression? expr) {
     return expr is SimpleIdentifier && expr.isSynthetic;
   }
 
@@ -1187,10 +1176,10 @@
     }
   }
 
-  AstNode _selectedNode({int at}) =>
+  AstNode? _selectedNode({int? at}) =>
       NodeLocator(at ?? selectionOffset).searchWithin(unit);
 
-  void _setCompletion(StatementCompletionKind kind, [List args]) {
+  void _setCompletion(StatementCompletionKind kind, [List? args]) {
     assert(exitPosition != null);
     change.selection = exitPosition;
     change.message = formatList(kind.message, args);
@@ -1199,12 +1188,13 @@
     completion = StatementCompletion(kind, change);
   }
 
-  void _setCompletionAt(StatementCompletionKind kind, int offset, [List args]) {
+  void _setCompletionAt(StatementCompletionKind kind, int offset,
+      [List? args]) {
     exitPosition = _newPosition(offset);
     _setCompletion(kind, args);
   }
 
-  SourceBuilder _sourceBuilderAfterKeyword(Token keyword) {
+  SourceBuilder _sourceBuilderAfterKeyword(AstNode node, Token keyword) {
     SourceBuilder sb;
     var text = _baseNodeText(node);
     text = text.substring(keyword.offset - node.offset);
@@ -1239,7 +1229,7 @@
   final Token keyword;
   final Token leftParenthesis, rightParenthesis;
   final Expression condition;
-  final Statement block;
+  final Statement? block;
 
   _KeywordConditionBlockStructure(this.keyword, this.leftParenthesis,
       this.condition, this.rightParenthesis, this.block);
diff --git a/pkg/analysis_server/test/services/completion/statement/statement_completion_test.dart b/pkg/analysis_server/test/services/completion/statement/statement_completion_test.dart
index 6d787d6..741715f 100644
--- a/pkg/analysis_server/test/services/completion/statement/statement_completion_test.dart
+++ b/pkg/analysis_server/test/services/completion/statement/statement_completion_test.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart = 2.9
-
 import 'package:analysis_server/src/protocol_server.dart';
 import 'package:analysis_server/src/services/completion/statement/statement_completion.dart';
 import 'package:test/test.dart';
@@ -28,7 +26,7 @@
 }
 
 class StatementCompletionTest extends AbstractSingleUnitTest {
-  SourceChange change;
+  late SourceChange change;
 
   int _after(String source, String match) =>
       source.indexOf(match) + match.length;
@@ -39,7 +37,7 @@
   void _assertHasChange(
     String message,
     String expectedCode, [
-    int Function(String) cmp,
+    int Function(String)? cmp,
   ]) {
     if (change.message == message) {
       if (change.edits.isNotEmpty) {
@@ -48,13 +46,13 @@
         expect(resultCode, expectedCode.replaceAll('////', ''));
         if (cmp != null) {
           var offset = cmp(resultCode);
-          expect(change.selection.offset, offset);
+          expect(change.selection!.offset, offset);
         }
       } else {
         expect(testCode, expectedCode.replaceAll('////', ''));
         if (cmp != null) {
           var offset = cmp(testCode);
-          expect(change.selection.offset, offset);
+          expect(change.selection!.offset, offset);
         }
       }
       return;
diff --git a/tools/VERSION b/tools/VERSION
index d75cb56..646d39a 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 13
 PATCH 0
-PRERELEASE 227
+PRERELEASE 228
 PRERELEASE_PATCH 0
\ No newline at end of file