anchor.diff:      expect(forStatement.body, isNotNull);
     }
   
  +  void test_parseForStatement_each_finalExternal() {
  +    ForStatement forStatement = parseStatement(
  +      'for (final external in list) {}',
  +      featureSet: controlFlow,
  +    );
  +    assertNoErrors();
  +    expect(forStatement.awaitKeyword, isNull);
  +    expect(forStatement.forKeyword, isNotNull);
  +    expect(forStatement.leftParenthesis, isNotNull);
  +    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
  +    expect(forLoopParts.loopVariable.identifier.name, 'external');
  +    expect(forLoopParts.inKeyword, isNotNull);
  +    expect(forLoopParts.iterable, isNotNull);
  +    expect(forStatement.rightParenthesis, isNotNull);
  +    expect(forStatement.body, isNotNull);
  +  }
  +
  +  void test_parseForStatement_each_finalRequired() {
  +    ForStatement forStatement = parseStatement(
  +      'for (final required in list) {}',
  +      featureSet: controlFlow,
  +    );
  +    assertNoErrors();
  +    expect(forStatement.awaitKeyword, isNull);
  +    expect(forStatement.forKeyword, isNotNull);
  +    expect(forStatement.leftParenthesis, isNotNull);
  +    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
  +    expect(forLoopParts.loopVariable.identifier.name, 'required');
  +    expect(forLoopParts.inKeyword, isNotNull);
  +    expect(forLoopParts.iterable, isNotNull);
  +    expect(forStatement.rightParenthesis, isNotNull);
  +    expect(forStatement.body, isNotNull);
  +  }
  +
     void test_parseForStatement_each_genericFunctionType2() {
       ForStatement forStatement = parseStatement(
         'for (void Function<T>(T) element in list) {}',
  
positive.code:     VariableDeclaration variable = variables[0];
      expect(variable.name, isNotNull);
    }
  
    void test_parseClassMember_operator_gtgtgt() {
      CompilationUnitImpl unit = parseCompilationUnit(
          'class C { bool operator >>>(other) => false; }',
          featureSet: tripleShift);
      ClassDeclaration declaration = unit.declarations[0];
      MethodDeclaration method = declaration.members[0];
  
      expect(method.documentationComment, isNull);
      expect(method.externalKeyword, isNull);
      expect(method.modifierKeyword, isNull);
      expect(method.propertyKeyword, isNull);
      expect(method.returnType, isNotNull);
      expect(method.name.name, '>>>');
      expect(method.operatorKeyword, isNotNull);
      expect(method.typeParameters, isNull);
      expect(method.parameters, isNotNull);
      expect(method.body, isNotNull);
    }
  
    void test_parseClassMember_operator_gtgtgteq() {
      CompilationUnitImpl unit = parseCompilationUnit(
          'class C { foo(int value) { x >>>= value; } }',
          featureSet: tripleShift);
      ClassDeclaration declaration = unit.declarations[0];
      MethodDeclaration method = declaration.members[0];
      BlockFunctionBody blockFunctionBody = method.body;
      NodeList<Statement> statements = blockFunctionBody.block.statements;
      expect(statements, hasLength(1));
      ExpressionStatement statement = statements[0];
      AssignmentExpression assignment = statement.expression;
      SimpleIdentifier leftHandSide = assignment.leftHandSide;
      expect(leftHandSide.name, 'x');
      expect(assignment.operator.lexeme, '>>>=');
      SimpleIdentifier rightHandSide = assignment.rightHandSide;
      expect(rightHandSide.name, 'value');
    }
  }
  
  /**
  
negative.code:     expect(elseExpression, isSimpleIdentifier);
    }
  
    void test_is_nullable_parenthesis() {
      CompilationUnit unit =
          parseNNBDCompilationUnit('main() { (x is String?) ? (x + y) : z; }');
  