Fix check for fast format, only %6N is accepted, not %N

Author: eregon

src/main/java/org/truffleruby/core/time/RubyDateFormatter.java

@@ -574,12 +574,12 @@ public static boolean formatCanBeFast(Token[] compiledPattern) {
 
             switch (format) {
                 case FORMAT_ENCODING:
-                    // We only care about UTF8 encoding
+                    // Only handle UTF-8 for fast formats
                     if (token.getData() != UTF8Encoding.INSTANCE) {
                         return false;
                     }
                     break;
-                case FORMAT_OUTPUT:
+                case FORMAT_OUTPUT: // only %6N
                     RubyTimeOutputFormatter formatter = (RubyTimeOutputFormatter) token.getData();
 
                     // Check for the attributes present in the default case
@@ -595,14 +595,19 @@ public static boolean formatCanBeFast(Token[] compiledPattern) {
                         return false;
                     }
                     break;
+                case FORMAT_NANOSEC: // only %6N
+                    if (i - 1 >= 0 && compiledPattern[i - 1].getFormat() == Format.FORMAT_OUTPUT) {
+                        break;
+                    } else {
+                        return false;
+                    }
                 case FORMAT_STRING:
                 case FORMAT_DAY:
                 case FORMAT_HOUR:
                 case FORMAT_MINUTES:
                 case FORMAT_MONTH:
                 case FORMAT_SECONDS:
                 case FORMAT_YEAR_LONG:
-                case FORMAT_NANOSEC:
                     break;
                 default:
                     return false;
@@ -646,22 +651,21 @@ public static Rope formatToRopeFast(Token[] compiledPattern, ZonedDateTime dt,
 
                 case FORMAT_YEAR_LONG: {
                     final int value = dt.getYear();
-
                     assert value >= 1000;
                     assert value <= 9999;
 
                     appendRope = new LazyIntRope(value, UTF8Encoding.INSTANCE, 4);
                 }
                     break;
 
-                case FORMAT_NANOSEC: {
+                case FORMAT_NANOSEC: { // always %6N, checked by formatCanBeFast()
                     final int nano = dt.getNano();
                     final LazyIntRope microSecondRope = new LazyIntRope(nano / 1000);
 
                     // This fast-path only handles the '%6N' format, so output will always be 6 characters long.
                     final int length = 6;
                     final int padding = length - microSecondRope.characterLength();
-                    assert padding >= 0;
+                    assert padding >= 0 : microSecondRope;
 
                     // `padding` is guaranteed to be >= 0 because `nano` can be at most 9 digits long before the
                     // conversion to microseconds. The division further constrains the rope to be at most 6 digits long.