anchor.diff:      return new MapExpression(pairs, scanner.spanFrom(start));
     }
   
  +  /// Consumes an expression that starts with a `#`.
     Expression _hashExpression() {
       assert(scanner.peekChar() == $hash);
  -    return scanner.peekChar(1) == $lbrace ? _identifierLike() : _hexColorOrID();
  -  }
  -
  +    if (scanner.peekChar(1) == $lbrace) return _identifierLike();
  +
  +    var start = scanner.state;
  +    scanner.expectChar($hash);
  +
  +    var first = scanner.peekChar();
  +    if (first != null && isDigit(first)) {
  +      return new ColorExpression(_hexColorContents(), scanner.spanFrom(start));
  +    }
  +
  +    var afterHash = scanner.state;
  +    var identifier = _interpolatedIdentifier();
  +    if (_isHexColor(identifier)) {
  +      scanner.state = afterHash;
  +      return new ColorExpression(_hexColorContents(), scanner.spanFrom(start));
  +    }
  +
  +    var buffer = new InterpolationBuffer();
  +    buffer.writeCharCode($hash);
  +    buffer.addInterpolation(identifier);
  +    return new StringExpression(buffer.interpolation(scanner.spanFrom(start)));
  +  }
  +
  +  /// Consumes the contents of a hex color, after the `#`.
  +  SassColor _hexColorContents() {
  +    var red = _hexDigit();
  +    var green = _hexDigit();
  +    var blue = _hexDigit();
  +
  +    var next = scanner.peekChar();
  +    if (next != null && isHex(next)) {
  +      red = (red << 4) + green;
  +      green = (blue << 4) + _hexDigit();
  +      blue = (_hexDigit() << 4) + _hexDigit();
  +    } else {
  +      red = (red << 4) + red;
  +      green = (green << 4) + green;
  +      blue = (blue << 4) + blue;
  +    }
  +
  +    return new SassColor.rgb(red, green, blue);
  +  }
  +
  +  /// Returns whether [interpolation] is a plain string that can be parsed as a
  +  /// hex color.
  +  bool _isHexColor(Interpolation interpolation) {
  +    var plain = interpolation.asPlain;
  +    if (plain == null) return false;
  +    if (plain.length != 3 && plain.length != 6) return false;
  +    return plain.codeUnits.every(isHex);
  +  }
  +
  +  // Consumes a single hexadecimal digit.
  +  int _hexDigit() {
  +    var char = scanner.peekChar();
  +    if (char == null || !isHex(char)) scanner.error("Expected hex digit.");
  +    return asHex(scanner.readChar());
  +  }
  +
  +  /// Consumes an expression that starts with a `+`.
     Expression _plusExpression() {
       assert(scanner.peekChar() == $plus);
       var next = scanner.peekChar(1);
       return isDigit(next) || next == $dot ? _number() : _unaryOperation();
     }
   
  +  /// Consumes an expression that starts with a `-`.
     Expression _minusExpression() {
       assert(scanner.peekChar() == $minus);
       var next = scanner.peekChar(1);
  
positive.code:         brackets: true, span: scanner.spanFrom(start));
    }
  
    /// Parse a parenthesized expression.
    Expression _parentheses() {
      var start = scanner.state;
      scanner.expectChar($lparen);
  
negative.code:     return _unaryOperation();
    }
  
    /// Consumes a unary operation expression.
    UnaryOperationExpression _unaryOperation() {
      var start = scanner.state;
      var operator = _unaryOperatorFor(scanner.readChar());
  