Reverted the removal of fallback synthetic source in block loader

Author: Kubik42

modules/mapper-extras/src/main/java/org/elasticsearch/index/mapper/extras/MatchOnlyTextFieldMapper.java

@@ -585,7 +585,7 @@ protected BytesRef toBytesRef(Object v) {
         public BlockLoader blockLoader(BlockLoaderContext blContext) {
             if (isSyntheticSourceEnabled()) {
                 // if there is no synthetic source delegate, then this match only text field would've created StoredFields for us to use
-                if (textFieldType.syntheticSourceDelegate().isPresent() == false) {
+                if (textFieldType.syntheticSourceDelegate().isEmpty()) {
                     if (storedFieldInBinaryFormat) {
                         return new BlockStoredFieldsReader.BytesFromBytesRefsBlockLoader(syntheticSourceFallbackFieldName());
                     } else {
@@ -701,7 +701,7 @@ protected void parseCreateField(DocumentParserContext context) throws IOExceptio
         context.addToFieldNames(fieldType().name());
 
         // match_only_text isn't stored, so if synthetic source needs to be supported, we must do something about it
-        if (fieldType().textFieldType.shouldStoreFieldForSyntheticSource(indexCreatedVersion)) {
+        if (fieldType().textFieldType.storeFieldForSyntheticSource(indexCreatedVersion)) {
             // check if we can use the delegate
             if (fieldType().canUseSyntheticSourceDelegateForSyntheticSource(value)) {
                 return;

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

@@ -76,6 +76,7 @@
 import org.elasticsearch.search.aggregations.support.CoreValuesSourceType;
 import org.elasticsearch.xcontent.ToXContent;
 import org.elasticsearch.xcontent.XContentBuilder;
+import org.elasticsearch.xcontent.XContentParser;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -1063,7 +1064,7 @@ public boolean canUseSyntheticSourceDelegateForQueryingEquality(String str) {
             return syntheticSourceDelegate.get().ignoreAbove().isIgnored(str) == false;
         }
 
-        public boolean shouldStoreFieldForSyntheticSource(final IndexVersion indexCreatedVersion) {
+        public boolean storeFieldForSyntheticSource(final IndexVersion indexCreatedVersion) {
             if (multiFieldsNotStoredByDefaultIndexVersionCheck(indexCreatedVersion)) {
                 // if we're within a multi field, then supporting synthetic source isn't necessary as that's the responsibility of the
                 // parent
@@ -1106,10 +1107,56 @@ protected String delegatingTo() {
                 return new BlockStoredFieldsReader.BytesFromStringsBlockLoader(name());
             }
 
+            // if there is no field to delegate to and this field isn't stored, then fallback to ignored source
+            if (isSyntheticSourceEnabled() && syntheticSourceDelegate.isEmpty() && parentField == null) {
+                return fallbackSyntheticSourceBlockLoader(blContext);
+            }
+
+            // otherwise, load values from _source (synthetic or not)
             SourceValueFetcher fetcher = SourceValueFetcher.toString(blContext.sourcePaths(name()));
             return new BlockSourceReader.BytesRefsBlockLoader(fetcher, blockReaderDisiLookup(blContext));
         }
 
+        FallbackSyntheticSourceBlockLoader fallbackSyntheticSourceBlockLoader(BlockLoaderContext blContext) {
+            var reader = new FallbackSyntheticSourceBlockLoader.SingleValueReader<BytesRef>(null) {
+                @Override
+                public void convertValue(Object value, List<BytesRef> accumulator) {
+                    if (value != null) {
+                        accumulator.add(new BytesRef(value.toString()));
+                    }
+                }
+
+                @Override
+                protected void parseNonNullValue(XContentParser parser, List<BytesRef> accumulator) throws IOException {
+                    var text = parser.textOrNull();
+
+                    if (text != null) {
+                        accumulator.add(new BytesRef(text));
+                    }
+                }
+
+                @Override
+                public void writeToBlock(List<BytesRef> values, BlockLoader.Builder blockBuilder) {
+                    var bytesRefBuilder = (BlockLoader.BytesRefBuilder) blockBuilder;
+
+                    for (var value : values) {
+                        bytesRefBuilder.appendBytesRef(value);
+                    }
+                }
+            };
+
+            return new FallbackSyntheticSourceBlockLoader(
+                    reader,
+                    name(),
+                    IgnoredSourceFieldMapper.ignoredSourceFormat(blContext.indexSettings().getIndexVersionCreated())
+            ) {
+                @Override
+                public Builder builder(BlockFactory factory, int expectedCount) {
+                    return factory.bytesRefs(expectedCount);
+                }
+            };
+        }
+
         /**
          * Build an iterator of documents that have the field. This mirrors parseCreateField,
          * using whatever
@@ -1420,7 +1467,7 @@ protected void parseCreateField(DocumentParserContext context) throws IOExceptio
         }
 
         // store the field if isn't stored yet, and we need it to be stored for synthetic source
-        if (fieldType.stored() == false && fieldType().shouldStoreFieldForSyntheticSource(indexCreatedVersion)) {
+        if (fieldType.stored() == false && fieldType().storeFieldForSyntheticSource(indexCreatedVersion)) {
             // if we can rely on the synthetic source delegate for synthetic source, then exit as there is nothing to do
             if (fieldType().canUseSyntheticSourceDelegateForSyntheticSource(value)) {
                 return;