anchor.diff:          : super._(validatorFactory, field);
   
       Iterable<_Rule> _rules() {
  +        var options = field.options;
           var rules = <_Rule>[];
  -        if (field.options.hasExtension(Options.required)) {
  -            var requiredString = _Rule((v) => v.property('isEmpty'),
  -                                       (v) => _requiredMissing(),
  -                                       validatorFactory.violationList);
  +        if (options.hasExtension(Options.required) && options.getExtension(Options.required)) {
  +            var requiredString = _rule((v) => v.property('isEmpty'),
  +                                       (v) => _requiredMissing());
               rules.add(requiredString);
           }
  +        if (options.hasExtension(Options.pattern)) {
  +            PatternOption pattern = options.getExtension(Options.pattern);
  +            var rule = _rule((v) => refer('RegEx').newInstance([literalString(pattern.regex)])
  +                                                  .property('stringMatch')
  +                                                  .call([v])
  +                                                  .equalTo(v),
  +                             (v) => _patternMismatch(pattern.regex));
  +            rules.add(rule);
  +        }
           return rules;
  +    }
  +
  +    Expression _patternMismatch(String pattern) {
  +        var message = 'String must match the regular expression `$pattern`';
  +        return violationRef.call([literalString(message),
  +                                  literalString(validatorFactory.fullTypeName),
  +                                  literalList([field.name])]);
       }
   }
   
  
positive.code:       var check = exclusive
                    ? (Expression v) => v.lessOrEqualTo(literal)
                    : (Expression v) => v.lessThan(literal);
        var requiredString = _Rule((v) => check(v),
                                   _outOfBound,
                                   validatorFactory.violationList);
        return requiredString;
      }
  
  
negative.code:     /// Obtains validation rules to apply to the field..
      Iterable<_Rule> _rules() => null;
  
      _Rule _rule(LazyCondition condition, LazyViolation violation) {
          return _Rule(condition, violation, validatorFactory.violationList);
      }
  
      /// Generates an expression which constructs a `ConstraintViolation` for a missing required
      /// field.
      Expression _requiredMissing() {
  