anchor.diff:    @override
     bool visitMatchExpression(MatchExpression node) {
       MatchExpression toNode = this._toNode as MatchExpression;
  -    return _and(
  +    if (_and(
           _isEqualTokens(node.matchKeyword, toNode.matchKeyword),
           _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis),
           _isEqualNodes(node.expression, toNode.expression),
           _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis),
           _isEqualTokens(node.leftBracket, toNode.leftBracket),
           _isEqualNodeLists(node.clauses, toNode.clauses),
  -        _isEqualTokens(node.rightBracket, toNode.rightBracket));
  +        _isEqualTokens(node.rightBracket, toNode.rightBracket))) {
  +      toNode.propagatedType = node.propagatedType;
  +      toNode.staticType = node.staticType;
  +      return true;
  +    }
  +    return false;
     }
   
     @override
  
positive.code:    *         assignableExpression assignmentOperator expressionWithoutCascade
     *       | conditionalExpression
     *       | throwExpressionWithoutCascade
     */
    Expression parseExpressionWithoutCascade() {
      if (_matchesKeyword(Keyword.THROW)) {
        return _parseThrowExpressionWithoutCascade();
      } else if (_matchesKeyword(Keyword.RETHROW)) {
        return _parseRethrowExpression();
      }
      //
      // assignableExpression is a subset of conditionalExpression, so we can
  
negative.code:   }
  
    /**
     * Parse a pattern. Return the pattern that was parsed.
     *
     *     pattern ::=
     *         literal
     */
    Pattern _parsePattern() {
    }
  
    /**
     * Parse a postfix expression. Return the postfix expression that was parsed.
     *
     *     postfixExpression ::=
  