anchor.diff:          isEqualTokens(node.ofKeyword, other.ofKeyword) &&
           isEqualNodes(node.libraryName, other.libraryName) &&
           isEqualTokens(node.semicolon, other.semicolon);
  +  }
  +
  +  @override
  +  bool visitPattern(Pattern node) {
  +    Pattern other = _other as Pattern;
  +    return isEqualNodes(node.pattern, other.pattern);
  +  }
  +
  +  @override
  +  bool visitPatternGuard(PatternGuard node) {
  +    PatternGuard other = _other as PatternGuard;
  +    return isEqualTokens(node.ifKeyword, other.ifKeyword) &&
  +        isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
  +        isEqualNodes(node.condition, other.condition) &&
  +        isEqualTokens(node.rightParenthesis, other.rightParenthesis);
     }
   
     @override
  
positive.code:     _patternGuard = _becomeParentOf(patternGuard);
      _armExpression = _becomeParentOf(armExpression);
    }
  }
  
  class Pattern extends AstNode {
  
negative.code: 
    PatternGuard(
        this.ifKeyword,
        this.leftParenthesis,
        Expression condition,
        this.rightParenthesis) {
      _condition = _becomeParentOf(condition);
    }
  
    Expression get condition => _condition;
  
    @override
    Token get beginToken => ifKeyword;
  
    @override
    Iterable get childEntities => new ChildEntities()
      ..add(ifKeyword)
      ..add(leftParenthesis)
      ..add(_condition)
      ..add(rightParenthesis);
  
    @override
    Token get endToken => rightParenthesis;
  
    @override
    accept(AstVisitor visitor) => visitor.visitPatternGuard(this);
  
    @override
    void visitChildren(AstVisitor visitor) {
      _safelyVisitChild(_condition, visitor);
    }
  }
  
  