Some cleanup and comments

Author: jordan-powers

libs/x-content/impl/src/main/java/org/elasticsearch/xcontent/provider/json/ESByteSourceJsonBootstrapper.java

@@ -17,6 +17,10 @@
  * defined in JSON specification (RFC-4627 or newer), except
  * for BOM handling, which is a property of underlying
  * streams.
+ *
+ * This class is copied from {@link com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper},
+ * just modified so that {@code constructParser()} returns an
+ * instance of {@link ESUTF8StreamJsonParser}.
  */
 @SuppressWarnings("all")
 public final class ESByteSourceJsonBootstrapper {

libs/x-content/impl/src/main/java/org/elasticsearch/xcontent/provider/json/ESUTF8StreamJsonParser.java

@@ -36,6 +36,11 @@ public ESUTF8StreamJsonParser(
         super(ctxt, features, in, codec, sym, inputBuffer, start, end, bytesPreProcessed, bufferRecyclable);
     }
 
+    /**
+     * Method that will try to get underlying UTF-8 encoded bytes of the current string token.
+     * This is only a best-effort attempt; if there is some reason the bytes cannot be retrieved, this method will return null.
+     * Currently, this is only implemented for ascii-only strings that do not contain escaped characters.
+     */
     public ESBytesRef getValueAsByteRef() throws IOException {
         if (_currToken == JsonToken.VALUE_STRING && _tokenIncomplete) {
             var value = _finishAndReturnByteRef();

server/src/main/java/org/elasticsearch/index/mapper/KeywordFieldMapper.java

@@ -1104,36 +1104,22 @@ public String getOffsetFieldName() {
         return offsetsFieldName;
     }
 
+    /**
+     * Class that holds either a UTF-16 String or a UTF-8 BytesRef, and lazily converts between the two.
+     */
     private static class RawString {
         private BytesRef bytesValue;
         private String stringValue;
-        private boolean isNull;
 
         RawString(BytesRef bytesValue) {
-            if (bytesValue == null) {
-                throw new IllegalArgumentException();
-            }
-            this.bytesValue = bytesValue;
-            this.isNull = false;
+            this.bytesValue = Objects.requireNonNull(bytesValue);
         }
 
         RawString(String stringValue) {
-            if (stringValue == null) {
-                throw new IllegalArgumentException();
-            }
-            this.stringValue = stringValue;
-            this.isNull = false;
-        }
-
-        RawString() {
-            this.isNull = true;
+            this.stringValue = Objects.requireNonNull(stringValue);
         }
 
         BytesRef bytesValue() {
-            if (isNull) {
-                return null;
-            }
-
             if (bytesValue != null) {
                 return bytesValue;
             }
@@ -1143,10 +1129,6 @@ BytesRef bytesValue() {
         }
 
         String stringValue() {
-            if (isNull) {
-                return null;
-            }
-
             if (stringValue != null) {
                 return stringValue;
             }
@@ -1155,18 +1137,11 @@ String stringValue() {
             return stringValue;
         }
 
-        boolean isNull() {
-            return isNull;
-        }
-
         int length() {
-            if (isNull) {
-                throw new UnsupportedOperationException();
-            }
-
             if (stringValue != null) {
                 return stringValue.length();
             } else {
+                // This works because we currently use raw utf-8 encoding only for ascii-only strings.
                 return bytesValue.length;
             }
         }
@@ -1182,19 +1157,19 @@ protected void parseCreateField(DocumentParserContext context) throws IOExceptio
             if (stringValue != null) {
                 value = new RawString(stringValue);
             } else {
-                value = new RawString();
+                value = null;
             }
         }
 
-        if (value.isNull() && fieldType().nullValue != null) {
+        if (value == null && fieldType().nullValue != null) {
             value = new RawString(fieldType().nullValue);
         }
 
         boolean indexed = indexValue(context, value);
         if (offsetsFieldName != null && context.isImmediateParentAnArray() && context.canAddIgnoredField()) {
             if (indexed) {
                 context.getOffSetContext().recordOffset(offsetsFieldName, value.stringValue());
-            } else if (value.isNull()) {
+            } else if (value == null) {
                 context.getOffSetContext().recordNull(offsetsFieldName);
             }
         }
@@ -1219,7 +1194,7 @@ private boolean indexValue(DocumentParserContext context, String value) {
     }
 
     private boolean indexValue(DocumentParserContext context, RawString value) throws IOException {
-        if (value.isNull()) {
+        if (value == null) {
             return false;
         }