From e0d64d786635da895a414a694c73efa6f2f34934 Mon Sep 17 00:00:00 2001 From: Paul Elschot Date: Sun, 15 Jan 2017 13:50:28 +0100 Subject: [PATCH 1/2] Rename Terms to FieldTerms --- .../query/QueryAutoStopWordAnalyzer.java | 4 +-- .../sinks/TestTeeSinkTokenFilter.java | 4 +-- .../apache/lucene/index/FixBrokenOffsets.java | 2 +- .../legacy/LegacyNumericRangeQuery.java | 4 +-- .../lucene/legacy/LegacyNumericUtils.java | 14 ++++----- .../lucene54/TestLucene54DocValuesFormat.java | 6 ++-- .../index/TestBackwardsCompatibility.java | 4 +-- .../apache/lucene/legacy/TestLegacyTerms.java | 14 ++++----- .../quality/utils/QualityQueriesFinder.java | 4 +-- .../benchmark/byTask/TestPerfTasksLogic.java | 4 +-- .../BooleanPerceptronClassifier.java | 6 ++-- .../CachingNaiveBayesClassifier.java | 4 +-- .../SimpleNaiveBayesClassifier.java | 8 ++--- .../SimpleNaiveBayesDocumentClassifier.java | 6 ++-- .../utils/DocToDoubleVectorUtils.java | 6 ++-- .../CachingNaiveBayesClassifierTest.java | 4 +-- .../KNearestNeighborClassifierTest.java | 4 +-- .../SimpleNaiveBayesClassifierTest.java | 4 +-- .../utils/DocToDoubleVectorUtilsTest.java | 8 ++--- .../codecs/blockterms/BlockTermsReader.java | 6 ++-- .../codecs/blockterms/BlockTermsWriter.java | 4 +-- .../OrdsBlockTreeTermsReader.java | 4 +-- .../OrdsBlockTreeTermsWriter.java | 4 +-- .../codecs/blocktreeords/OrdsFieldReader.java | 6 ++-- .../bloom/BloomFilteringPostingsFormat.java | 20 ++++++------- .../codecs/memory/DirectPostingsFormat.java | 12 ++++---- .../codecs/memory/FSTOrdTermsReader.java | 6 ++-- .../codecs/memory/FSTOrdTermsWriter.java | 4 +-- .../lucene/codecs/memory/FSTTermsReader.java | 6 ++-- .../lucene/codecs/memory/FSTTermsWriter.java | 4 +-- .../codecs/memory/MemoryPostingsFormat.java | 8 ++--- .../simpletext/SimpleTextFieldsReader.java | 6 ++-- .../simpletext/SimpleTextFieldsWriter.java | 4 +-- .../SimpleTextTermVectorsReader.java | 6 ++-- .../apache/lucene/codecs/FieldsConsumer.java | 2 +- .../lucene/codecs/TermVectorsWriter.java | 6 ++-- .../blocktree/BlockTreeTermsReader.java | 8 ++--- .../blocktree/BlockTreeTermsWriter.java | 6 ++-- .../lucene/codecs/blocktree/FieldReader.java | 6 ++-- .../codecs/blocktree/IntersectTermsEnum.java | 4 +-- .../CompressingTermVectorsReader.java | 6 ++-- .../codecs/perfield/PerFieldMergeState.java | 4 +-- .../perfield/PerFieldPostingsFormat.java | 4 +-- .../lucene/index/BufferedUpdatesStream.java | 4 +-- .../org/apache/lucene/index/CheckIndex.java | 22 +++++++------- .../lucene/index/ExitableDirectoryReader.java | 8 ++--- .../index/{Terms.java => FieldTerms.java} | 10 +++---- .../java/org/apache/lucene/index/Fields.java | 8 ++--- .../apache/lucene/index/FilterLeafReader.java | 16 +++++----- .../apache/lucene/index/FreqProxFields.java | 4 +-- .../lucene/index/FreqProxTermsWriter.java | 2 +- .../org/apache/lucene/index/IndexReader.java | 8 ++--- .../org/apache/lucene/index/LeafReader.java | 14 ++++----- .../lucene/index/MappedMultiFields.java | 2 +- .../apache/lucene/index/MultiDocValues.java | 2 +- .../org/apache/lucene/index/MultiFields.java | 18 +++++------ .../org/apache/lucene/index/MultiTerms.java | 24 +++++++-------- .../lucene/index/ParallelLeafReader.java | 8 ++--- .../lucene/index/SlowCodecReaderWrapper.java | 2 +- .../lucene/index/SortingLeafReader.java | 6 ++-- .../index/SortingTermVectorsConsumer.java | 4 +-- .../org/apache/lucene/index/TermContext.java | 2 +- .../org/apache/lucene/index/package-info.java | 18 +++++------ .../apache/lucene/search/AutomatonQuery.java | 4 +-- .../apache/lucene/search/BoostAttribute.java | 4 +-- .../lucene/search/CollectionStatistics.java | 8 ++--- .../lucene/search/DocValuesRewriteMethod.java | 4 +-- .../org/apache/lucene/search/FuzzyQuery.java | 4 +-- .../apache/lucene/search/FuzzyTermsEnum.java | 6 ++-- .../apache/lucene/search/IndexSearcher.java | 4 +-- .../MaxNonCompetitiveBoostAttribute.java | 6 ++-- .../lucene/search/MultiPhraseQuery.java | 4 +-- .../apache/lucene/search/MultiTermQuery.java | 14 ++++----- .../MultiTermQueryConstantScoreWrapper.java | 4 +-- .../org/apache/lucene/search/PhraseQuery.java | 4 +-- .../lucene/search/TermCollectingRewrite.java | 4 +-- .../apache/lucene/search/TermInSetQuery.java | 4 +-- .../org/apache/lucene/search/TermQuery.java | 4 +-- .../search/similarities/BasicStats.java | 6 ++-- .../lucene/search/spans/SpanNearQuery.java | 4 +-- .../lucene/search/spans/SpanTermQuery.java | 4 +-- .../apache/lucene/util/DocIdSetBuilder.java | 6 ++-- .../util/automaton/CompiledAutomaton.java | 8 ++--- .../lucene50/TestBlockPostingsFormat3.java | 10 +++---- .../lucene70/TestLucene70DocValuesFormat.java | 6 ++-- .../org/apache/lucene/index/Test2BDocs.java | 2 +- .../lucene/index/TestBagOfPositions.java | 2 +- .../lucene/index/TestBagOfPostings.java | 2 +- .../org/apache/lucene/index/TestCodecs.java | 6 ++-- .../lucene/index/TestDirectoryReader.java | 6 ++-- .../test/org/apache/lucene/index/TestDoc.java | 2 +- .../org/apache/lucene/index/TestDocCount.java | 4 +-- .../lucene/index/TestDocsAndPositions.java | 2 +- .../index/TestExitableDirectoryReader.java | 6 ++-- .../lucene/index/TestFilterLeafReader.java | 4 +-- .../apache/lucene/index/TestIndexWriter.java | 2 +- .../lucene/index/TestIndexableField.java | 2 +- .../lucene/index/TestMultiTermsEnum.java | 14 ++++----- .../lucene/index/TestParallelTermEnum.java | 2 +- .../lucene/index/TestPayloadsOnVectors.java | 4 +-- .../lucene/index/TestPerSegmentDeletes.java | 2 +- .../lucene/index/TestSegmentMerger.java | 2 +- .../lucene/index/TestSegmentReader.java | 4 +-- .../lucene/index/TestStressIndexing2.java | 16 +++++----- .../apache/lucene/index/TestSumDocFreq.java | 4 +-- .../lucene/index/TestTermVectorsReader.java | 10 +++---- .../lucene/index/TestTermVectorsWriter.java | 2 +- .../org/apache/lucene/index/TestTerms.java | 4 +-- .../apache/lucene/index/TestTermsEnum.java | 12 ++++---- .../lucene/search/TermInSetQueryTest.java | 6 ++-- .../lucene/search/TestAutomatonQuery.java | 6 ++-- .../search/TestMultiTermQueryRewrites.java | 4 +-- .../search/TestMultiThreadTermVectors.java | 6 ++-- .../lucene/search/TestPrefixRandom.java | 4 +-- .../lucene/search/TestRegexpRandom2.java | 4 +-- .../search/TestSameScoresWithThreads.java | 4 +-- .../apache/lucene/search/TestTermQuery.java | 4 +-- .../apache/lucene/search/TestWildcard.java | 4 +-- .../lucene/util/TestDocIdSetBuilder.java | 6 ++-- .../org/apache/lucene/util/fst/TestFSTs.java | 4 +-- .../directory/DirectoryTaxonomyWriter.java | 8 ++--- .../highlight/TermVectorLeafReader.java | 8 ++--- .../lucene/search/highlight/TokenSources.java | 28 ++++++++--------- .../highlight/TokenStreamFromTermVector.java | 10 +++---- .../highlight/WeightedSpanTermExtractor.java | 14 ++++----- .../PostingsHighlighter.java | 4 +-- .../uhighlight/FieldOffsetStrategy.java | 6 ++-- .../search/uhighlight/PhraseHelper.java | 8 ++--- ...PostingsWithTermVectorsOffsetStrategy.java | 4 +-- .../TermVectorFilteredLeafReader.java | 16 +++++----- .../uhighlight/TermVectorOffsetStrategy.java | 4 +-- .../vectorhighlight/FieldTermStack.java | 4 +-- .../search/vectorhighlight/package-info.java | 2 +- .../search/join/TermsIncludingScoreQuery.java | 6 ++-- .../apache/lucene/search/join/TermsQuery.java | 4 +-- .../lucene/search/join/TestJoinUtil.java | 4 +-- .../lucene/index/memory/MemoryIndex.java | 8 ++--- .../memory/TestMemoryIndexAgainstRAMDir.java | 10 +++---- .../org/apache/lucene/misc/HighFreqTerms.java | 6 ++-- .../lucene/queries/CommonTermsQuery.java | 4 +-- .../valuesource/JoinDocFreqValueSource.java | 4 +-- .../SumTotalTermFreqValueSource.java | 4 +-- .../function/valuesource/TFValueSource.java | 4 +-- .../valuesource/TermFreqValueSource.java | 4 +-- .../lucene/queries/mlt/MoreLikeThis.java | 6 ++-- .../payloads/SpanPayloadCheckQuery.java | 4 +-- .../lucene/queries/CommonTermsQueryTest.java | 4 +-- .../surround/query/SrndPrefixQuery.java | 4 +-- .../surround/query/SrndTermQuery.java | 4 +-- .../surround/query/SrndTruncQuery.java | 4 +-- .../VersionBlockTreeTermsReader.java | 4 +-- .../VersionBlockTreeTermsWriter.java | 4 +-- .../codecs/idversion/VersionFieldReader.java | 6 ++-- .../sandbox/queries/FuzzyLikeThisQuery.java | 6 ++-- .../lucene/search/DocValuesTermsQuery.java | 6 ++-- .../prefix/AbstractPrefixTreeQuery.java | 4 +-- .../spatial/util/ShapeFieldCacheProvider.java | 2 +- .../search/GeoPointMultiTermQuery.java | 4 +-- ...GeoPointTermQueryConstantScoreWrapper.java | 4 +-- .../search/spell/DirectSpellChecker.java | 4 +-- .../search/spell/HighFrequencyDictionary.java | 6 ++-- .../lucene/search/spell/LuceneDictionary.java | 4 +-- .../lucene/search/spell/SpellChecker.java | 4 +-- .../analyzing/BlendedInfixSuggester.java | 4 +-- .../suggest/analyzing/FreeTextSuggester.java | 4 +-- .../document/CompletionFieldsConsumer.java | 4 +-- .../document/CompletionFieldsProducer.java | 6 ++-- .../suggest/document/CompletionQuery.java | 4 +-- .../suggest/document/CompletionTerms.java | 6 ++-- .../suggest/document/CompletionWeight.java | 4 +-- .../document/TestPrefixCompletionQuery.java | 2 +- .../asserting/AssertingPostingsFormat.java | 8 ++--- .../codecs/ramonly/RAMOnlyPostingsFormat.java | 8 ++--- .../lucene/index/AssertingLeafReader.java | 30 +++++++++---------- .../index/BasePostingsFormatTestCase.java | 14 ++++----- .../index/BaseTermVectorsFormatTestCase.java | 14 ++++----- .../lucene/index/FieldFilterLeafReader.java | 2 +- .../lucene/index/PerThreadPKLookup.java | 2 +- .../lucene/index/RandomPostingsTester.java | 8 ++--- .../ThreadedIndexingAndSearchingTestCase.java | 2 +- .../org/apache/lucene/search/QueryUtils.java | 4 +-- .../apache/lucene/util/LuceneTestCase.java | 10 +++---- .../java/org/apache/lucene/util/TestUtil.java | 4 +-- .../lucene/analysis/TestMockAnalyzer.java | 4 +-- .../TestCompressingTermVectorsFormat.java | 4 +-- 185 files changed, 567 insertions(+), 567 deletions(-) rename lucene/core/src/java/org/apache/lucene/index/{Terms.java => FieldTerms.java} (96%) diff --git a/lucene/analysis/common/src/java/org/apache/lucene/analysis/query/QueryAutoStopWordAnalyzer.java b/lucene/analysis/common/src/java/org/apache/lucene/analysis/query/QueryAutoStopWordAnalyzer.java index 37f044aeb627..f614883e4461 100644 --- a/lucene/analysis/common/src/java/org/apache/lucene/analysis/query/QueryAutoStopWordAnalyzer.java +++ b/lucene/analysis/common/src/java/org/apache/lucene/analysis/query/QueryAutoStopWordAnalyzer.java @@ -26,7 +26,7 @@ import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.Term; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.CharsRefBuilder; @@ -140,7 +140,7 @@ public QueryAutoStopWordAnalyzer( for (String field : fields) { Set stopWords = new HashSet<>(); - Terms terms = MultiFields.getTerms(indexReader, field); + FieldTerms terms = MultiFields.getTerms(indexReader, field); CharsRefBuilder spare = new CharsRefBuilder(); if (terms != null) { TermsEnum te = terms.iterator(); diff --git a/lucene/analysis/common/src/test/org/apache/lucene/analysis/sinks/TestTeeSinkTokenFilter.java b/lucene/analysis/common/src/test/org/apache/lucene/analysis/sinks/TestTeeSinkTokenFilter.java index c0127a330e3b..3d4e5ab483fa 100644 --- a/lucene/analysis/common/src/test/org/apache/lucene/analysis/sinks/TestTeeSinkTokenFilter.java +++ b/lucene/analysis/common/src/test/org/apache/lucene/analysis/sinks/TestTeeSinkTokenFilter.java @@ -41,7 +41,7 @@ import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.index.PostingsEnum; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.DocIdSetIterator; import org.apache.lucene.store.Directory; @@ -95,7 +95,7 @@ public void testEndOffsetPositionWithTeeSinkTokenFilter() throws Exception { w.close(); IndexReader r = DirectoryReader.open(dir); - Terms vector = r.getTermVectors(0).terms("field"); + FieldTerms vector = r.getTermVectors(0).terms("field"); assertEquals(1, vector.size()); TermsEnum termsEnum = vector.iterator(); termsEnum.next(); diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/index/FixBrokenOffsets.java b/lucene/backward-codecs/src/java/org/apache/lucene/index/FixBrokenOffsets.java index d4d6f85430bf..c890255d9716 100644 --- a/lucene/backward-codecs/src/java/org/apache/lucene/index/FixBrokenOffsets.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/index/FixBrokenOffsets.java @@ -70,7 +70,7 @@ public Fields getTermVectors(int docID) throws IOException { } return new FilterFields(termVectors) { @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { return new FilterTerms(super.terms(field)) { @Override public TermsEnum iterator() throws IOException { diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java index f172a2007792..33193f122085 100644 --- a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java @@ -27,7 +27,7 @@ import org.apache.lucene.document.LongPoint; import org.apache.lucene.index.FilteredTermsEnum; import org.apache.lucene.index.PointValues; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.MultiTermQuery; @@ -303,7 +303,7 @@ public static LegacyNumericRangeQuery newFloatRange(final String field, } @Override @SuppressWarnings("unchecked") - protected TermsEnum getTermsEnum(final Terms terms, AttributeSource atts) throws IOException { + protected TermsEnum getTermsEnum(final FieldTerms terms, AttributeSource atts) throws IOException { // very strange: java.lang.Number itself is not Comparable, but all subclasses used here are if (min != null && max != null && ((Comparable) min).compareTo(max) > 0) { return TermsEnum.EMPTY; diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericUtils.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericUtils.java index e6659d7e1025..a4f67d1c1b13 100644 --- a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericUtils.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericUtils.java @@ -21,7 +21,7 @@ import org.apache.lucene.index.FilterLeafReader; import org.apache.lucene.index.FilteredTermsEnum; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.BytesRefBuilder; @@ -447,7 +447,7 @@ public SeekStatus seekCeil(BytesRef term) throws IOException { } } - private static Terms intTerms(Terms terms) { + private static FieldTerms intTerms(FieldTerms terms) { return new FilterLeafReader.FilterTerms(terms) { @Override public TermsEnum iterator() throws IOException { @@ -456,7 +456,7 @@ public TermsEnum iterator() throws IOException { }; } - private static Terms longTerms(Terms terms) { + private static FieldTerms longTerms(FieldTerms terms) { return new FilterLeafReader.FilterTerms(terms) { @Override public TermsEnum iterator() throws IOException { @@ -469,7 +469,7 @@ public TermsEnum iterator() throws IOException { * Returns the minimum int value indexed into this * numeric field or null if no terms exist. */ - public static Integer getMinInt(Terms terms) throws IOException { + public static Integer getMinInt(FieldTerms terms) throws IOException { // All shift=0 terms are sorted first, so we don't need // to filter the incoming terms; we can just get the // min: @@ -481,7 +481,7 @@ public static Integer getMinInt(Terms terms) throws IOException { * Returns the maximum int value indexed into this * numeric field or null if no terms exist. */ - public static Integer getMaxInt(Terms terms) throws IOException { + public static Integer getMaxInt(FieldTerms terms) throws IOException { BytesRef max = intTerms(terms).getMax(); return (max != null) ? LegacyNumericUtils.prefixCodedToInt(max) : null; } @@ -490,7 +490,7 @@ public static Integer getMaxInt(Terms terms) throws IOException { * Returns the minimum long value indexed into this * numeric field or null if no terms exist. */ - public static Long getMinLong(Terms terms) throws IOException { + public static Long getMinLong(FieldTerms terms) throws IOException { // All shift=0 terms are sorted first, so we don't need // to filter the incoming terms; we can just get the // min: @@ -502,7 +502,7 @@ public static Long getMinLong(Terms terms) throws IOException { * Returns the maximum long value indexed into this * numeric field or null if no terms exist. */ - public static Long getMaxLong(Terms terms) throws IOException { + public static Long getMaxLong(FieldTerms terms) throws IOException { BytesRef max = longTerms(terms).getMax(); return (max != null) ? LegacyNumericUtils.prefixCodedToLong(max) : null; } diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene54/TestLucene54DocValuesFormat.java b/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene54/TestLucene54DocValuesFormat.java index a761dfcec15e..0df39eb65b8c 100644 --- a/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene54/TestLucene54DocValuesFormat.java +++ b/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene54/TestLucene54DocValuesFormat.java @@ -59,7 +59,7 @@ import org.apache.lucene.index.SortedNumericDocValues; import org.apache.lucene.index.SortedSetDocValues; import org.apache.lucene.index.Term; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum.SeekStatus; import org.apache.lucene.search.DocIdSetIterator; import org.apache.lucene.index.TermsEnum; @@ -333,7 +333,7 @@ public DocValuesFormat getDocValuesFormatForField(String field) { DirectoryReader ir = writer.getReader(); for (LeafReaderContext context : ir.leaves()) { LeafReader r = context.reader(); - Terms terms = r.terms("indexed"); + FieldTerms terms = r.terms("indexed"); if (terms != null) { SortedSetDocValues ssdv = r.getSortedSetDocValues("dv"); assertEquals(terms.size(), ssdv.getValueCount()); @@ -351,7 +351,7 @@ public DocValuesFormat getDocValuesFormatForField(String field) { // now compare again after the merge ir = writer.getReader(); LeafReader ar = getOnlyLeafReader(ir); - Terms terms = ar.terms("indexed"); + FieldTerms terms = ar.terms("indexed"); if (terms != null) { assertEquals(terms.size(), ar.getSortedSetDocValues("dv").getValueCount()); TermsEnum expected = terms.iterator(); diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java b/lucene/backward-codecs/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java index d924238fd88d..cd8f43faeecd 100644 --- a/lucene/backward-codecs/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java +++ b/lucene/backward-codecs/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java @@ -805,7 +805,7 @@ public void searchIndex(Directory dir, String oldName) throws IOException { Fields tfvFields = reader.getTermVectors(i); assertNotNull("i=" + i, tfvFields); - Terms tfv = tfvFields.terms("utf8"); + FieldTerms tfv = tfvFields.terms("utf8"); assertNotNull("docID=" + i + " index=" + oldName, tfv); } else { // Only ID 7 is deleted @@ -1260,7 +1260,7 @@ public void testNumericFields() throws Exception { assertEquals("wrong number of hits", 34, hits.length); // check decoding of terms - Terms terms = MultiFields.getTerms(searcher.getIndexReader(), "trieInt"); + FieldTerms terms = MultiFields.getTerms(searcher.getIndexReader(), "trieInt"); TermsEnum termsEnum = LegacyNumericUtils.filterPrefixCodedInts(terms.iterator()); while (termsEnum.next() != null) { int val = LegacyNumericUtils.prefixCodedToInt(termsEnum.term()); diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyTerms.java b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyTerms.java index 27fae15e9165..37b87319c013 100644 --- a/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyTerms.java +++ b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyTerms.java @@ -21,7 +21,7 @@ import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.RandomIndexWriter; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.legacy.LegacyDoubleField; import org.apache.lucene.legacy.LegacyFloatField; @@ -55,7 +55,7 @@ public void testIntFieldMinMax() throws Exception { } IndexReader r = w.getReader(); - Terms terms = MultiFields.getTerms(r, "field"); + FieldTerms terms = MultiFields.getTerms(r, "field"); assertEquals(new Integer(minValue), LegacyNumericUtils.getMinInt(terms)); assertEquals(new Integer(maxValue), LegacyNumericUtils.getMaxInt(terms)); @@ -86,7 +86,7 @@ public void testLongFieldMinMax() throws Exception { IndexReader r = w.getReader(); - Terms terms = MultiFields.getTerms(r, "field"); + FieldTerms terms = MultiFields.getTerms(r, "field"); assertEquals(new Long(minValue), LegacyNumericUtils.getMinLong(terms)); assertEquals(new Long(maxValue), LegacyNumericUtils.getMaxLong(terms)); @@ -111,7 +111,7 @@ public void testFloatFieldMinMax() throws Exception { } IndexReader r = w.getReader(); - Terms terms = MultiFields.getTerms(r, "field"); + FieldTerms terms = MultiFields.getTerms(r, "field"); assertEquals(minValue, NumericUtils.sortableIntToFloat(LegacyNumericUtils.getMinInt(terms)), 0.0f); assertEquals(maxValue, NumericUtils.sortableIntToFloat(LegacyNumericUtils.getMaxInt(terms)), 0.0f); @@ -137,7 +137,7 @@ public void testDoubleFieldMinMax() throws Exception { IndexReader r = w.getReader(); - Terms terms = MultiFields.getTerms(r, "field"); + FieldTerms terms = MultiFields.getTerms(r, "field"); assertEquals(minValue, NumericUtils.sortableLongToDouble(LegacyNumericUtils.getMinLong(terms)), 0.0); assertEquals(maxValue, NumericUtils.sortableLongToDouble(LegacyNumericUtils.getMaxLong(terms)), 0.0); @@ -148,9 +148,9 @@ public void testDoubleFieldMinMax() throws Exception { } /** - * A complete empty Terms instance that has no terms in it and supports no optional statistics + * A complete empty FieldTerms instance that has no terms in it and supports no optional statistics */ - private static Terms EMPTY_TERMS = new Terms() { + private static FieldTerms EMPTY_TERMS = new FieldTerms() { public TermsEnum iterator() { return TermsEnum.EMPTY; } public long size() { return -1; } public long getSumTotalTermFreq() { return -1; } diff --git a/lucene/benchmark/src/java/org/apache/lucene/benchmark/quality/utils/QualityQueriesFinder.java b/lucene/benchmark/src/java/org/apache/lucene/benchmark/quality/utils/QualityQueriesFinder.java index 15ba807e3e2e..2266ac606508 100644 --- a/lucene/benchmark/src/java/org/apache/lucene/benchmark/quality/utils/QualityQueriesFinder.java +++ b/lucene/benchmark/src/java/org/apache/lucene/benchmark/quality/utils/QualityQueriesFinder.java @@ -22,7 +22,7 @@ import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.TermsEnum; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.MultiFields; import org.apache.lucene.store.Directory; import org.apache.lucene.store.FSDirectory; @@ -90,7 +90,7 @@ private static String formatQueryAsTrecTopic (int qnum, String title, String des IndexReader ir = DirectoryReader.open(dir); try { int threshold = ir.maxDoc() / 10; // ignore words too common. - Terms terms = MultiFields.getTerms(ir, field); + FieldTerms terms = MultiFields.getTerms(ir, field); if (terms != null) { TermsEnum termsEnum = terms.iterator(); while (termsEnum.next() != null) { diff --git a/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/TestPerfTasksLogic.java b/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/TestPerfTasksLogic.java index 3d483f3954cc..5ab8f4ccf9c7 100644 --- a/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/TestPerfTasksLogic.java +++ b/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/TestPerfTasksLogic.java @@ -48,7 +48,7 @@ import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.SegmentInfos; import org.apache.lucene.index.SerialMergeScheduler; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.DocIdSetIterator; import org.apache.lucene.store.Directory; @@ -379,7 +379,7 @@ public void testReadTokens() throws Exception { if (fieldName.equals(DocMaker.ID_FIELD) || fieldName.equals(DocMaker.DATE_MSEC_FIELD) || fieldName.equals(DocMaker.TIME_SEC_FIELD)) { continue; } - Terms terms = fields.terms(fieldName); + FieldTerms terms = fields.terms(fieldName); if (terms == null) { continue; } diff --git a/lucene/classification/src/java/org/apache/lucene/classification/BooleanPerceptronClassifier.java b/lucene/classification/src/java/org/apache/lucene/classification/BooleanPerceptronClassifier.java index 781a14ff6eec..9aaef75f1c4b 100644 --- a/lucene/classification/src/java/org/apache/lucene/classification/BooleanPerceptronClassifier.java +++ b/lucene/classification/src/java/org/apache/lucene/classification/BooleanPerceptronClassifier.java @@ -30,7 +30,7 @@ import org.apache.lucene.index.IndexableField; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.Term; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; @@ -59,7 +59,7 @@ public class BooleanPerceptronClassifier implements Classifier { private final Double threshold; - private final Terms textTerms; + private final FieldTerms textTerms; private final Analyzer analyzer; private final String textFieldName; private FST fst; @@ -155,7 +155,7 @@ private void updateWeights(IndexReader indexReader, TermsEnum cte = textTerms.iterator(); // get the doc term vectors - Terms terms = indexReader.getTermVector(docId, textFieldName); + FieldTerms terms = indexReader.getTermVector(docId, textFieldName); if (terms == null) { throw new IOException("term vectors must be stored for field " diff --git a/lucene/classification/src/java/org/apache/lucene/classification/CachingNaiveBayesClassifier.java b/lucene/classification/src/java/org/apache/lucene/classification/CachingNaiveBayesClassifier.java index 6fe683546d06..c91e44366cb9 100644 --- a/lucene/classification/src/java/org/apache/lucene/classification/CachingNaiveBayesClassifier.java +++ b/lucene/classification/src/java/org/apache/lucene/classification/CachingNaiveBayesClassifier.java @@ -27,7 +27,7 @@ import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.Term; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; @@ -227,7 +227,7 @@ public void reInitCache(int minTermOccurrenceInCache, boolean justCachedTerms) t } // fill the class list - Terms terms = MultiFields.getTerms(indexReader, classFieldName); + FieldTerms terms = MultiFields.getTerms(indexReader, classFieldName); TermsEnum termsEnum = terms.iterator(); while ((termsEnum.next()) != null) { cclasses.add(BytesRef.deepCopyOf(termsEnum.term())); diff --git a/lucene/classification/src/java/org/apache/lucene/classification/SimpleNaiveBayesClassifier.java b/lucene/classification/src/java/org/apache/lucene/classification/SimpleNaiveBayesClassifier.java index 3509df585111..57207bb3764c 100644 --- a/lucene/classification/src/java/org/apache/lucene/classification/SimpleNaiveBayesClassifier.java +++ b/lucene/classification/src/java/org/apache/lucene/classification/SimpleNaiveBayesClassifier.java @@ -29,7 +29,7 @@ import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.Term; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; @@ -144,7 +144,7 @@ public List> getClasses(String text, int max) thr protected List> assignClassNormalizedList(String inputDocument) throws IOException { List> assignedClasses = new ArrayList<>(); - Terms classes = MultiFields.getTerms(indexReader, classFieldName); + FieldTerms classes = MultiFields.getTerms(indexReader, classFieldName); if (classes != null) { TermsEnum classesEnum = classes.iterator(); BytesRef next; @@ -169,7 +169,7 @@ protected List> assignClassNormalizedList(String * @throws IOException if accessing to term vectors or search fails */ protected int countDocsWithClass() throws IOException { - Terms terms = MultiFields.getTerms(this.indexReader, this.classFieldName); + FieldTerms terms = MultiFields.getTerms(this.indexReader, this.classFieldName); int docCount; if (terms == null || terms.getDocCount() == -1) { // in case codec doesn't support getDocCount TotalHitCountCollector classQueryCountCollector = new TotalHitCountCollector(); @@ -240,7 +240,7 @@ private double calculateLogLikelihood(String[] tokenizedText, Term term, int doc private double getTextTermFreqForClass(Term term) throws IOException { double avgNumberOfUniqueTerms = 0; for (String textFieldName : textFieldNames) { - Terms terms = MultiFields.getTerms(indexReader, textFieldName); + FieldTerms terms = MultiFields.getTerms(indexReader, textFieldName); long numPostings = terms.getSumDocFreq(); // number of term/doc pairs avgNumberOfUniqueTerms += numPostings / (double) terms.getDocCount(); // avg # of unique terms per doc } diff --git a/lucene/classification/src/java/org/apache/lucene/classification/document/SimpleNaiveBayesDocumentClassifier.java b/lucene/classification/src/java/org/apache/lucene/classification/document/SimpleNaiveBayesDocumentClassifier.java index 21ad7d134a47..a8d546ca285d 100644 --- a/lucene/classification/src/java/org/apache/lucene/classification/document/SimpleNaiveBayesDocumentClassifier.java +++ b/lucene/classification/src/java/org/apache/lucene/classification/document/SimpleNaiveBayesDocumentClassifier.java @@ -36,7 +36,7 @@ import org.apache.lucene.index.IndexableField; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.Term; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; @@ -112,7 +112,7 @@ private List> assignNormClasses(Document inputDoc List> assignedClasses = new ArrayList<>(); Map> fieldName2tokensArray = new LinkedHashMap<>(); Map fieldName2boost = new LinkedHashMap<>(); - Terms classes = MultiFields.getTerms(indexReader, classFieldName); + FieldTerms classes = MultiFields.getTerms(indexReader, classFieldName); TermsEnum classesEnum = classes.iterator(); BytesRef c; @@ -225,7 +225,7 @@ private double calculateLogLikelihood(String[] tokenizedText, String fieldName, */ private double getTextTermFreqForClass(Term term, String fieldName) throws IOException { double avgNumberOfUniqueTerms; - Terms terms = MultiFields.getTerms(indexReader, fieldName); + FieldTerms terms = MultiFields.getTerms(indexReader, fieldName); long numPostings = terms.getSumDocFreq(); // number of term/doc pairs avgNumberOfUniqueTerms = numPostings / (double) terms.getDocCount(); // avg # of unique terms per doc int docsWithC = indexReader.docFreq(term); diff --git a/lucene/classification/src/java/org/apache/lucene/classification/utils/DocToDoubleVectorUtils.java b/lucene/classification/src/java/org/apache/lucene/classification/utils/DocToDoubleVectorUtils.java index 288d8c180760..640dacb2418f 100644 --- a/lucene/classification/src/java/org/apache/lucene/classification/utils/DocToDoubleVectorUtils.java +++ b/lucene/classification/src/java/org/apache/lucene/classification/utils/DocToDoubleVectorUtils.java @@ -18,7 +18,7 @@ import java.io.IOException; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.util.BytesRef; @@ -39,7 +39,7 @@ private DocToDoubleVectorUtils() { * @return a sparse vector of Doubles as an array * @throws IOException in case accessing the underlying index fails */ - public static Double[] toSparseLocalFreqDoubleArray(Terms docTerms, Terms fieldTerms) throws IOException { + public static Double[] toSparseLocalFreqDoubleArray(FieldTerms docTerms, FieldTerms fieldTerms) throws IOException { TermsEnum fieldTermsEnum = fieldTerms.iterator(); Double[] freqVector = null; if (docTerms != null && fieldTerms.size() > -1) { @@ -71,7 +71,7 @@ public static Double[] toSparseLocalFreqDoubleArray(Terms docTerms, Terms fieldT * @return a dense vector of Doubles as an array * @throws IOException in case accessing the underlying index fails */ - public static Double[] toDenseLocalFreqDoubleArray(Terms docTerms) throws IOException { + public static Double[] toDenseLocalFreqDoubleArray(FieldTerms docTerms) throws IOException { Double[] freqVector = null; if (docTerms != null) { freqVector = new Double[(int) docTerms.size()]; diff --git a/lucene/classification/src/test/org/apache/lucene/classification/CachingNaiveBayesClassifierTest.java b/lucene/classification/src/test/org/apache/lucene/classification/CachingNaiveBayesClassifierTest.java index acbfe82be9a8..8c52db4288b5 100644 --- a/lucene/classification/src/test/org/apache/lucene/classification/CachingNaiveBayesClassifierTest.java +++ b/lucene/classification/src/test/org/apache/lucene/classification/CachingNaiveBayesClassifierTest.java @@ -27,7 +27,7 @@ import org.apache.lucene.index.LeafReader; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.Term; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.TermQuery; import org.apache.lucene.util.BytesRef; @@ -123,7 +123,7 @@ public void testPerformance() throws Exception { assertTrue(precision >= 0d); assertTrue(precision <= 1d); - Terms terms = MultiFields.getTerms(leafReader, categoryFieldName); + FieldTerms terms = MultiFields.getTerms(leafReader, categoryFieldName); TermsEnum iterator = terms.iterator(); BytesRef term; while ((term = iterator.next()) != null) { diff --git a/lucene/classification/src/test/org/apache/lucene/classification/KNearestNeighborClassifierTest.java b/lucene/classification/src/test/org/apache/lucene/classification/KNearestNeighborClassifierTest.java index 5e3ce7bfff33..dc77c1f443d5 100644 --- a/lucene/classification/src/test/org/apache/lucene/classification/KNearestNeighborClassifierTest.java +++ b/lucene/classification/src/test/org/apache/lucene/classification/KNearestNeighborClassifierTest.java @@ -25,7 +25,7 @@ import org.apache.lucene.index.LeafReader; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.Term; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.TermQuery; import org.apache.lucene.search.similarities.BM25Similarity; @@ -153,7 +153,7 @@ public void testPerformance() throws Exception { assertTrue(precision >= 0d); assertTrue(precision <= 1d); - Terms terms = MultiFields.getTerms(leafReader, categoryFieldName); + FieldTerms terms = MultiFields.getTerms(leafReader, categoryFieldName); TermsEnum iterator = terms.iterator(); BytesRef term; while ((term = iterator.next()) != null) { diff --git a/lucene/classification/src/test/org/apache/lucene/classification/SimpleNaiveBayesClassifierTest.java b/lucene/classification/src/test/org/apache/lucene/classification/SimpleNaiveBayesClassifierTest.java index 830ce2c251b7..08e68ff46428 100644 --- a/lucene/classification/src/test/org/apache/lucene/classification/SimpleNaiveBayesClassifierTest.java +++ b/lucene/classification/src/test/org/apache/lucene/classification/SimpleNaiveBayesClassifierTest.java @@ -26,7 +26,7 @@ import org.apache.lucene.index.LeafReader; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.Term; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.TermQuery; import org.apache.lucene.util.BytesRef; @@ -124,7 +124,7 @@ public void testPerformance() throws Exception { assertTrue(precision >= 0d); assertTrue(precision <= 1d); - Terms terms = MultiFields.getTerms(leafReader, categoryFieldName); + FieldTerms terms = MultiFields.getTerms(leafReader, categoryFieldName); TermsEnum iterator = terms.iterator(); BytesRef term; while ((term = iterator.next()) != null) { diff --git a/lucene/classification/src/test/org/apache/lucene/classification/utils/DocToDoubleVectorUtilsTest.java b/lucene/classification/src/test/org/apache/lucene/classification/utils/DocToDoubleVectorUtilsTest.java index a90d1a50f5e8..ffd0cb6d9c70 100644 --- a/lucene/classification/src/test/org/apache/lucene/classification/utils/DocToDoubleVectorUtilsTest.java +++ b/lucene/classification/src/test/org/apache/lucene/classification/utils/DocToDoubleVectorUtilsTest.java @@ -23,7 +23,7 @@ import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.RandomIndexWriter; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.MatchAllDocsQuery; import org.apache.lucene.search.ScoreDoc; @@ -80,7 +80,7 @@ public void tearDown() throws Exception { public void testDenseFreqDoubleArrayConversion() throws Exception { IndexSearcher indexSearcher = new IndexSearcher(index); for (ScoreDoc scoreDoc : indexSearcher.search(new MatchAllDocsQuery(), Integer.MAX_VALUE).scoreDocs) { - Terms docTerms = index.getTermVector(scoreDoc.doc, "text"); + FieldTerms docTerms = index.getTermVector(scoreDoc.doc, "text"); Double[] vector = DocToDoubleVectorUtils.toDenseLocalFreqDoubleArray(docTerms); assertNotNull(vector); assertTrue(vector.length > 0); @@ -89,11 +89,11 @@ public void testDenseFreqDoubleArrayConversion() throws Exception { @Test public void testSparseFreqDoubleArrayConversion() throws Exception { - Terms fieldTerms = MultiFields.getTerms(index, "text"); + FieldTerms fieldTerms = MultiFields.getTerms(index, "text"); if (fieldTerms != null && fieldTerms.size() != -1) { IndexSearcher indexSearcher = new IndexSearcher(index); for (ScoreDoc scoreDoc : indexSearcher.search(new MatchAllDocsQuery(), Integer.MAX_VALUE).scoreDocs) { - Terms docTerms = index.getTermVector(scoreDoc.doc, "text"); + FieldTerms docTerms = index.getTermVector(scoreDoc.doc, "text"); Double[] vector = DocToDoubleVectorUtils.toSparseLocalFreqDoubleArray(docTerms, fieldTerms); assertNotNull(vector); assertTrue(vector.length > 0); diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blockterms/BlockTermsReader.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blockterms/BlockTermsReader.java index b8d23bdb3d62..2fe60a734103 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/blockterms/BlockTermsReader.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/blockterms/BlockTermsReader.java @@ -36,7 +36,7 @@ import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.SegmentReadState; import org.apache.lucene.index.TermState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.ByteArrayDataInput; import org.apache.lucene.store.IndexInput; @@ -202,7 +202,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { assert field != null; return fields.get(field); } @@ -213,7 +213,7 @@ public int size() { } private static final long FIELD_READER_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(FieldReader.class); - private class FieldReader extends Terms implements Accountable { + private class FieldReader extends FieldTerms implements Accountable { final long numTerms; final FieldInfo fieldInfo; final long termsStartPointer; diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blockterms/BlockTermsWriter.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blockterms/BlockTermsWriter.java index f19cd2c052ae..9fd28cd80793 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/blockterms/BlockTermsWriter.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/blockterms/BlockTermsWriter.java @@ -34,7 +34,7 @@ import org.apache.lucene.index.Fields; import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.SegmentWriteState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.IndexOutput; import org.apache.lucene.store.RAMOutputStream; @@ -131,7 +131,7 @@ public void write(Fields fields) throws IOException { for(String field : fields) { - Terms terms = fields.terms(field); + FieldTerms terms = fields.terms(field); if (terms == null) { continue; } diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsReader.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsReader.java index afdaf5aad17e..6ba45b17186c 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsReader.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsReader.java @@ -34,7 +34,7 @@ import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.SegmentReadState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.store.IndexInput; import org.apache.lucene.util.Accountable; import org.apache.lucene.util.Accountables; @@ -199,7 +199,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { assert field != null; return fields.get(field); } diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsWriter.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsWriter.java index b16bb1566cba..1120f123dd28 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsWriter.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsWriter.java @@ -33,7 +33,7 @@ import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.SegmentWriteState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.IndexOutput; import org.apache.lucene.store.RAMOutputStream; @@ -220,7 +220,7 @@ public void write(Fields fields) throws IOException { assert lastField == null || lastField.compareTo(field) < 0; lastField = field; - Terms terms = fields.terms(field); + FieldTerms terms = fields.terms(field); if (terms == null) { continue; } diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsFieldReader.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsFieldReader.java index 5d02258837d3..cf2ce274def0 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsFieldReader.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsFieldReader.java @@ -24,7 +24,7 @@ import org.apache.lucene.codecs.blocktreeords.FSTOrdsOutputs.Output; import org.apache.lucene.index.FieldInfo; import org.apache.lucene.index.IndexOptions; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.ByteArrayDataInput; import org.apache.lucene.store.IndexInput; @@ -34,8 +34,8 @@ import org.apache.lucene.util.automaton.CompiledAutomaton; import org.apache.lucene.util.fst.FST; -/** BlockTree's implementation of {@link Terms}. */ -final class OrdsFieldReader extends Terms implements Accountable { +/** BlockTree's implementation of {@link FieldTerms}. */ +final class OrdsFieldReader extends FieldTerms implements Accountable { final long numTerms; final FieldInfo fieldInfo; final long sumTotalTermFreq; diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/bloom/BloomFilteringPostingsFormat.java b/lucene/codecs/src/java/org/apache/lucene/codecs/bloom/BloomFilteringPostingsFormat.java index ffe9fa1002af..956d4c087320 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/bloom/BloomFilteringPostingsFormat.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/bloom/BloomFilteringPostingsFormat.java @@ -37,7 +37,7 @@ import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.SegmentReadState; import org.apache.lucene.index.SegmentWriteState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.ChecksumIndexInput; import org.apache.lucene.store.DataOutput; @@ -200,12 +200,12 @@ public void close() throws IOException { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { FuzzySet filter = bloomsByFieldName.get(field); if (filter == null) { return delegateFieldsProducer.terms(field); } else { - Terms result = delegateFieldsProducer.terms(field); + FieldTerms result = delegateFieldsProducer.terms(field); if (result == null) { return null; } @@ -218,11 +218,11 @@ public int size() { return delegateFieldsProducer.size(); } - class BloomFilteredTerms extends Terms { - private Terms delegateTerms; + class BloomFilteredTerms extends FieldTerms { + private FieldTerms delegateTerms; private FuzzySet filter; - public BloomFilteredTerms(Terms terms, FuzzySet filter) { + public BloomFilteredTerms(FieldTerms terms, FuzzySet filter) { this.delegateTerms = terms; this.filter = filter; } @@ -290,16 +290,16 @@ public BytesRef getMax() throws IOException { } final class BloomFilteredTermsEnum extends TermsEnum { - private Terms delegateTerms; + private FieldTerms delegateTerms; private TermsEnum delegateTermsEnum; private final FuzzySet filter; - public BloomFilteredTermsEnum(Terms delegateTerms, FuzzySet filter) throws IOException { + public BloomFilteredTermsEnum(FieldTerms delegateTerms, FuzzySet filter) throws IOException { this.delegateTerms = delegateTerms; this.filter = filter; } - void reset(Terms delegateTerms) throws IOException { + void reset(FieldTerms delegateTerms) throws IOException { this.delegateTerms = delegateTerms; this.delegateTermsEnum = null; } @@ -427,7 +427,7 @@ public void write(Fields fields) throws IOException { delegateFieldsConsumer.write(fields); for(String field : fields) { - Terms terms = fields.terms(field); + FieldTerms terms = fields.terms(field); if (terms == null) { continue; } diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/DirectPostingsFormat.java b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/DirectPostingsFormat.java index 00f25cf189c3..8b7ba2f16624 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/DirectPostingsFormat.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/DirectPostingsFormat.java @@ -35,7 +35,7 @@ import org.apache.lucene.index.SegmentReadState; import org.apache.lucene.index.SegmentWriteState; import org.apache.lucene.index.TermState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.IOContext; import org.apache.lucene.store.RAMOutputStream; @@ -88,7 +88,7 @@ public DirectPostingsFormat() { } /** minSkipCount is how many terms in a row must have the - * same prefix before we put a skip pointer down. Terms + * same prefix before we put a skip pointer down. FieldTerms * with docFreq <= lowFreqCutoff will use a single int[] * to hold all docs, freqs, position and offsets; terms * with higher docFreq will use separate arrays. */ @@ -136,7 +136,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) { + public FieldTerms terms(String field) { return fields.get(field); } @@ -176,7 +176,7 @@ public String toString() { } } - private final static class DirectField extends Terms implements Accountable { + private final static class DirectField extends FieldTerms implements Accountable { private static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(DirectField.class); @@ -299,7 +299,7 @@ public int[] get() { } } - public DirectField(SegmentReadState state, String field, Terms termsIn, int minSkipCount, int lowFreqCutoff) throws IOException { + public DirectField(SegmentReadState state, String field, FieldTerms termsIn, int minSkipCount, int lowFreqCutoff) throws IOException { final FieldInfo fieldInfo = state.fieldInfos.fieldInfo(field); sumTotalTermFreq = termsIn.getSumTotalTermFreq(); @@ -308,7 +308,7 @@ public DirectField(SegmentReadState state, String field, Terms termsIn, int minS final int numTerms = (int) termsIn.size(); if (numTerms == -1) { - throw new IllegalArgumentException("codec does not provide Terms.size()"); + throw new IllegalArgumentException("codec does not provide FieldTerms.size()"); } terms = new TermAndSkip[numTerms]; termOffsets = new int[1+numTerms]; diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTOrdTermsReader.java b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTOrdTermsReader.java index 97bbea3ddef1..b3bfd6855754 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTOrdTermsReader.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTOrdTermsReader.java @@ -40,7 +40,7 @@ import org.apache.lucene.index.SegmentInfo; import org.apache.lucene.index.SegmentReadState; import org.apache.lucene.index.TermState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.ByteArrayDataInput; import org.apache.lucene.store.ChecksumIndexInput; @@ -160,7 +160,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { assert field != null; return fields.get(field); } @@ -179,7 +179,7 @@ public void close() throws IOException { } } - final class TermsReader extends Terms implements Accountable { + final class TermsReader extends FieldTerms implements Accountable { final FieldInfo fieldInfo; final long numTerms; final long sumTotalTermFreq; diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTOrdTermsWriter.java b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTOrdTermsWriter.java index cbe6583e892b..36d0e25db221 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTOrdTermsWriter.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTOrdTermsWriter.java @@ -31,7 +31,7 @@ import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.SegmentWriteState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.DataOutput; import org.apache.lucene.store.IndexOutput; @@ -188,7 +188,7 @@ public FSTOrdTermsWriter(SegmentWriteState state, PostingsWriterBase postingsWri @Override public void write(Fields fields) throws IOException { for(String field : fields) { - Terms terms = fields.terms(field); + FieldTerms terms = fields.terms(field); if (terms == null) { continue; } diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTTermsReader.java b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTTermsReader.java index b120656688cf..392dcfd14346 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTTermsReader.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTTermsReader.java @@ -39,7 +39,7 @@ import org.apache.lucene.index.SegmentInfo; import org.apache.lucene.index.SegmentReadState; import org.apache.lucene.index.TermState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.ByteArrayDataInput; import org.apache.lucene.store.IndexInput; @@ -140,7 +140,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { assert field != null; return fields.get(field); } @@ -160,7 +160,7 @@ public void close() throws IOException { } private static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(TermsReader.class); - final class TermsReader extends Terms implements Accountable { + final class TermsReader extends FieldTerms implements Accountable { final FieldInfo fieldInfo; final long numTerms; diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTTermsWriter.java b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTTermsWriter.java index 8284d7444f26..7213b64d75f3 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTTermsWriter.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/FSTTermsWriter.java @@ -31,7 +31,7 @@ import org.apache.lucene.index.Fields; import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.SegmentWriteState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.DataOutput; import org.apache.lucene.store.IndexOutput; @@ -160,7 +160,7 @@ private void writeTrailer(IndexOutput out, long dirStart) throws IOException { @Override public void write(Fields fields) throws IOException { for(String field : fields) { - Terms terms = fields.terms(field); + FieldTerms terms = fields.terms(field); if (terms == null) { continue; } diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/MemoryPostingsFormat.java b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/MemoryPostingsFormat.java index 2f7176542cd8..4ebc053211e7 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/MemoryPostingsFormat.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/MemoryPostingsFormat.java @@ -38,7 +38,7 @@ import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.SegmentReadState; import org.apache.lucene.index.SegmentWriteState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.ByteArrayDataInput; import org.apache.lucene.store.ChecksumIndexInput; @@ -290,7 +290,7 @@ private MemoryFieldsConsumer(SegmentWriteState state) throws IOException { public void write(Fields fields) throws IOException { for(String field : fields) { - Terms terms = fields.terms(field); + FieldTerms terms = fields.terms(field); if (terms == null) { continue; } @@ -857,7 +857,7 @@ public long ord() { } } - private final static class TermsReader extends Terms implements Accountable { + private final static class TermsReader extends FieldTerms implements Accountable { private final long sumTotalTermFreq; private final long sumDocFreq; @@ -982,7 +982,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) { + public FieldTerms terms(String field) { return fields.get(field); } diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsReader.java b/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsReader.java index faab7885f6c3..bddcc660f059 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsReader.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsReader.java @@ -32,7 +32,7 @@ import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.PostingsEnum; import org.apache.lucene.index.SegmentReadState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.BufferedChecksumIndexInput; import org.apache.lucene.store.ChecksumIndexInput; @@ -521,7 +521,7 @@ public TermData(long docsStart, int docFreq) { RamUsageEstimator.shallowSizeOfInstance(SimpleTextTerms.class) + RamUsageEstimator.shallowSizeOfInstance(BytesRef.class) + RamUsageEstimator.shallowSizeOfInstance(CharsRef.class); - private class SimpleTextTerms extends Terms implements Accountable { + private class SimpleTextTerms extends FieldTerms implements Accountable { private final long termsStart; private final FieldInfo fieldInfo; private final int maxDoc; @@ -679,7 +679,7 @@ public Iterator iterator() { private final Map termsCache = new HashMap<>(); @Override - synchronized public Terms terms(String field) throws IOException { + synchronized public FieldTerms terms(String field) throws IOException { SimpleTextTerms terms = termsCache.get(field); if (terms == null) { Long fp = fields.get(field); diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsWriter.java b/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsWriter.java index 20235528dcad..849d5ac3583f 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsWriter.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsWriter.java @@ -25,7 +25,7 @@ import org.apache.lucene.index.FieldInfos; import org.apache.lucene.index.Fields; import org.apache.lucene.index.SegmentWriteState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.IndexOutput; import org.apache.lucene.util.BytesRef; @@ -64,7 +64,7 @@ public void write(FieldInfos fieldInfos, Fields fields) throws IOException { // for each field for(String field : fields) { - Terms terms = fields.terms(field); + FieldTerms terms = fields.terms(field); if (terms == null) { // Annoyingly, this can happen! continue; diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextTermVectorsReader.java b/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextTermVectorsReader.java index c1808bfb76c9..521cc22d180f 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextTermVectorsReader.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextTermVectorsReader.java @@ -29,7 +29,7 @@ import org.apache.lucene.index.Fields; import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.SegmentInfo; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.AlreadyClosedException; import org.apache.lucene.store.BufferedChecksumIndexInput; @@ -252,7 +252,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { return fields.get(field); } @@ -262,7 +262,7 @@ public int size() { } } - private static class SimpleTVTerms extends Terms { + private static class SimpleTVTerms extends FieldTerms { final SortedMap terms; final boolean hasOffsets; final boolean hasPositions; diff --git a/lucene/core/src/java/org/apache/lucene/codecs/FieldsConsumer.java b/lucene/core/src/java/org/apache/lucene/codecs/FieldsConsumer.java index 28bae1d07c59..1293e91bfd0e 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/FieldsConsumer.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/FieldsConsumer.java @@ -48,7 +48,7 @@ protected FieldsConsumer() { // TODO: maybe we should factor out "limited" (only // iterables, no counts/stats) base classes from - // Fields/Terms/Docs/AndPositions? + // Fields/FieldTerms/Docs/AndPositions? /** Write all fields, terms and postings. This the "pull" * API, allowing you to iterate more than once over the diff --git a/lucene/core/src/java/org/apache/lucene/codecs/TermVectorsWriter.java b/lucene/core/src/java/org/apache/lucene/codecs/TermVectorsWriter.java index b84065af66ad..616170542cdd 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/TermVectorsWriter.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/TermVectorsWriter.java @@ -28,7 +28,7 @@ import org.apache.lucene.index.Fields; import org.apache.lucene.index.MergeState; import org.apache.lucene.index.PostingsEnum; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.DocIdSetIterator; import org.apache.lucene.store.DataInput; @@ -262,7 +262,7 @@ protected final void addAllDocVectors(Fields vectors, MergeState mergeState) thr assert lastFieldName == null || fieldName.compareTo(lastFieldName) > 0: "lastFieldName=" + lastFieldName + " fieldName=" + fieldName; lastFieldName = fieldName; - final Terms terms = vectors.terms(fieldName); + final FieldTerms terms = vectors.terms(fieldName); if (terms == null) { // FieldsEnum shouldn't lie... continue; @@ -275,7 +275,7 @@ protected final void addAllDocVectors(Fields vectors, MergeState mergeState) thr int numTerms = (int) terms.size(); if (numTerms == -1) { - // count manually. It is stupid, but needed, as Terms.size() is not a mandatory statistics function + // count manually. It is stupid, but needed, as FieldTerms.size() is not a mandatory statistics function numTerms = 0; termsEnum = terms.iterator(); while(termsEnum.next() != null) { diff --git a/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java index 6fc9a2490724..0b20468d6f8e 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java @@ -33,7 +33,7 @@ import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.SegmentReadState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.search.PrefixQuery; // javadocs import org.apache.lucene.search.TermRangeQuery; // javadocs import org.apache.lucene.store.IndexInput; @@ -60,12 +60,12 @@ * much memory the terms index uses.

* *

If auto-prefix terms were indexed (see - * {@link BlockTreeTermsWriter}), then the {@link Terms#intersect} + * {@link BlockTreeTermsWriter}), then the {@link FieldTerms#intersect} * implementation here will make use of these terms only if the * automaton has a binary sink state, i.e. an accept state * which has a transition to itself accepting all byte values. * For example, both {@link PrefixQuery} and {@link TermRangeQuery} - * pass such automata to {@link Terms#intersect}.

+ * pass such automata to {@link FieldTerms#intersect}.

* *

The data structure used by this implementation is very * similar to a burst trie @@ -287,7 +287,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { assert field != null; return fields.get(field); } diff --git a/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java b/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java index bdacc22325fa..9ef1bb0faedc 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java @@ -31,7 +31,7 @@ import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.SegmentWriteState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.DataOutput; import org.apache.lucene.store.IndexOutput; @@ -324,7 +324,7 @@ public void write(Fields fields) throws IOException { lastField = field; //if (DEBUG) System.out.println("\nBTTW.write seg=" + segment + " field=" + field); - Terms terms = fields.terms(field); + FieldTerms terms = fields.terms(field); if (terms == null) { continue; } @@ -750,7 +750,7 @@ private PendingBlock writeBlock(int prefixLength, boolean isFloor, int floorLead // For non-leaf block we borrow 1 bit to record // if entry is term or sub-block, and 1 bit to record if - // it's a prefix term. Terms cannot be larger than ~32 KB + // it's a prefix term. FieldTerms cannot be larger than ~32 KB // so we won't run out of bits: suffixWriter.writeVInt(suffix << 1); diff --git a/lucene/core/src/java/org/apache/lucene/codecs/blocktree/FieldReader.java b/lucene/core/src/java/org/apache/lucene/codecs/blocktree/FieldReader.java index 4ee38262403d..8ab3a8f305e8 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/blocktree/FieldReader.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/blocktree/FieldReader.java @@ -23,7 +23,7 @@ import org.apache.lucene.index.FieldInfo; import org.apache.lucene.index.IndexOptions; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.ByteArrayDataInput; import org.apache.lucene.store.IndexInput; @@ -36,10 +36,10 @@ import org.apache.lucene.util.fst.FST; /** - * BlockTree's implementation of {@link Terms}. + * BlockTree's implementation of {@link FieldTerms}. * @lucene.internal */ -public final class FieldReader extends Terms implements Accountable { +public final class FieldReader extends FieldTerms implements Accountable { // private final boolean DEBUG = BlockTreeTermsWriter.DEBUG; diff --git a/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnum.java b/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnum.java index 19e56a40a04d..f420bb258b86 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnum.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnum.java @@ -21,7 +21,7 @@ import org.apache.lucene.index.PostingsEnum; import org.apache.lucene.index.TermState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.IndexInput; import org.apache.lucene.util.ArrayUtil; @@ -35,7 +35,7 @@ import org.apache.lucene.util.fst.FST; import org.apache.lucene.util.fst.Outputs; -/** This is used to implement efficient {@link Terms#intersect} for +/** This is used to implement efficient {@link FieldTerms#intersect} for * block-tree. Note that it cannot seek, except for the initial term on * init. It just "nexts" through the intersection of the automaton and * the terms. It does not use the terms index at all: on init, it diff --git a/lucene/core/src/java/org/apache/lucene/codecs/compressing/CompressingTermVectorsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/compressing/CompressingTermVectorsReader.java index f0d1640d85e7..9dc876b2b89b 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/compressing/CompressingTermVectorsReader.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/compressing/CompressingTermVectorsReader.java @@ -33,7 +33,7 @@ import org.apache.lucene.index.Fields; import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.SegmentInfo; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.AlreadyClosedException; import org.apache.lucene.store.ByteArrayDataInput; @@ -706,7 +706,7 @@ public void remove() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { final FieldInfo fieldInfo = fieldInfos.fieldInfo(field); if (fieldInfo == null) { return null; @@ -747,7 +747,7 @@ public int size() { } - private class TVTerms extends Terms { + private class TVTerms extends FieldTerms { private final int numTerms, flags; private final int[] prefixLengths, suffixLengths, termFreqs, positionIndex, positions, startOffsets, lengths, payloadIndex; diff --git a/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldMergeState.java b/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldMergeState.java index 991eedfe78e2..b0ad5d4ae0fc 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldMergeState.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldMergeState.java @@ -30,7 +30,7 @@ import org.apache.lucene.index.FieldInfos; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.MergeState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; /** * Utility class to update the {@link MergeState} instance to be restricted to a set of fields. @@ -248,7 +248,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { if (!filtered.contains(field)) { throw new IllegalArgumentException("The field named '" + field + "' is not accessible in the current " + "merge context, available ones are: " + filtered); diff --git a/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldPostingsFormat.java b/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldPostingsFormat.java index 281b08fe3748..60314cd04e4d 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldPostingsFormat.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldPostingsFormat.java @@ -43,7 +43,7 @@ import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.SegmentReadState; import org.apache.lucene.index.SegmentWriteState; -import org.apache.lucene.index.Terms; +import org.apache.lucene.index.FieldTerms; import org.apache.lucene.util.Accountable; import org.apache.lucene.util.Accountables; import org.apache.lucene.util.IOUtils; @@ -311,7 +311,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { FieldsProducer fieldsProducer = fields.get(field); return fieldsProducer == null ? null : fieldsProducer.terms(field); } diff --git a/lucene/core/src/java/org/apache/lucene/index/BufferedUpdatesStream.java b/lucene/core/src/java/org/apache/lucene/index/BufferedUpdatesStream.java index 9da1e09530de..d704497c6d60 100644 --- a/lucene/core/src/java/org/apache/lucene/index/BufferedUpdatesStream.java +++ b/lucene/core/src/java/org/apache/lucene/index/BufferedUpdatesStream.java @@ -502,7 +502,7 @@ private synchronized long applyTermDeletes(CoalescedUpdates updates, SegmentStat long segTermCount = 0; for(int i=0;i updates, // if we change the code to process updates in terms order, enable this assert // assert currentField == null || currentField.compareTo(term.field()) < 0; currentField = term.field(); - Terms terms = fields.terms(currentField); + FieldTerms terms = fields.terms(currentField); if (terms != null) { termsEnum = terms.iterator(); } else { diff --git a/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java b/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java index 3bb10d325b5a..44f675b0462b 100644 --- a/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java +++ b/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java @@ -1104,9 +1104,9 @@ private static long getDocsFromTermRange(String field, int maxDoc, TermsEnum ter } } - /** Test Terms.intersect on this range, and validates that it returns the same doc ids as using non-intersect TermsEnum. Returns true if + /** Test FieldTerms.intersect on this range, and validates that it returns the same doc ids as using non-intersect TermsEnum. Returns true if * any fake terms were seen. */ - private static boolean checkSingleTermRange(String field, int maxDoc, Terms terms, BytesRef minTerm, BytesRef maxTerm, FixedBitSet normalDocs, FixedBitSet intersectDocs) throws IOException { + private static boolean checkSingleTermRange(String field, int maxDoc, FieldTerms terms, BytesRef minTerm, BytesRef maxTerm, FixedBitSet normalDocs, FixedBitSet intersectDocs) throws IOException { //System.out.println(" check minTerm=" + minTerm.utf8ToString() + " maxTerm=" + maxTerm.utf8ToString()); assert minTerm.compareTo(maxTerm) <= 0; @@ -1138,7 +1138,7 @@ private static boolean checkSingleTermRange(String field, int maxDoc, Terms term * interval of terms, at different boundaries, and then gradually decrease the interval. This is not guaranteed to hit all non-real * terms (doing that in general is non-trivial), but it should hit many of them, and validate their postings against the postings for the * real terms. */ - private static void checkTermRanges(String field, int maxDoc, Terms terms, long numTerms) throws IOException { + private static void checkTermRanges(String field, int maxDoc, FieldTerms terms, long numTerms) throws IOException { // We'll target this many terms in our interval for the current level: double currentInterval = numTerms; @@ -1239,12 +1239,12 @@ private static Status.TermIndexStatus checkFields(Fields fields, Bits liveDocs, } // TODO: really the codec should not return a field - // from FieldsEnum if it has no Terms... but we do + // from FieldsEnum if it has no FieldTerms... but we do // this today: // assert fields.terms(field) != null; computedFieldCount++; - final Terms terms = fields.terms(field); + final FieldTerms terms = fields.terms(field); if (terms == null) { continue; } @@ -1293,7 +1293,7 @@ private static Status.TermIndexStatus checkFields(Fields fields, Bits liveDocs, if (hasFreqs == false) { if (terms.getSumTotalTermFreq() != -1) { - throw new RuntimeException("field \"" + field + "\" hasFreqs is false, but Terms.getSumTotalTermFreq()=" + terms.getSumTotalTermFreq() + " (should be -1)"); + throw new RuntimeException("field \"" + field + "\" hasFreqs is false, but FieldTerms.getSumTotalTermFreq()=" + terms.getSumTotalTermFreq() + " (should be -1)"); } } @@ -1414,7 +1414,7 @@ private static Status.TermIndexStatus checkFields(Fields fields, Bits liveDocs, // consistently "lie" and pretend that freq was // 1: if (postings.freq() != 1) { - throw new RuntimeException("term " + term + ": doc " + doc + ": freq " + freq + " != 1 when Terms.hasFreqs() is false"); + throw new RuntimeException("term " + term + ": doc " + doc + ": freq " + freq + " != 1 when FieldTerms.hasFreqs() is false"); } } if (liveDocs == null || liveDocs.get(doc)) { @@ -1600,10 +1600,10 @@ private static Status.TermIndexStatus checkFields(Fields fields, Bits liveDocs, throw new RuntimeException("field=\"" + field + "\": minTerm is non-null yet we saw no terms: " + minTerm); } - final Terms fieldTerms = fields.terms(field); + final FieldTerms fieldTerms = fields.terms(field); if (fieldTerms == null) { // Unusual: the FieldsEnum returned a field but - // the Terms for that field is null; this should + // the FieldTerms for that field is null; this should // only happen if it's a ghost field (field with // no terms, eg there used to be terms but all // docs got deleted and then merged away): @@ -2407,13 +2407,13 @@ public static Status.TermVectorStatus testTermVectors(CodecReader reader, PrintS } if (crossCheckTermVectors) { - Terms terms = tfv.terms(field); + FieldTerms terms = tfv.terms(field); TermsEnum termsEnum = terms.iterator(); final boolean postingsHasFreq = fieldInfo.getIndexOptions().compareTo(IndexOptions.DOCS_AND_FREQS) >= 0; final boolean postingsHasPayload = fieldInfo.hasPayloads(); final boolean vectorsHasPayload = terms.hasPayloads(); - Terms postingsTerms = postingsFields.terms(field); + FieldTerms postingsTerms = postingsFields.terms(field); if (postingsTerms == null) { throw new RuntimeException("vector field=" + field + " does not exist in postings; doc=" + j); } diff --git a/lucene/core/src/java/org/apache/lucene/index/ExitableDirectoryReader.java b/lucene/core/src/java/org/apache/lucene/index/ExitableDirectoryReader.java index ee1c0ceda2ec..115f6c57aa8a 100644 --- a/lucene/core/src/java/org/apache/lucene/index/ExitableDirectoryReader.java +++ b/lucene/core/src/java/org/apache/lucene/index/ExitableDirectoryReader.java @@ -115,8 +115,8 @@ public ExitableFields(Fields fields, QueryTimeout queryTimeout) { } @Override - public Terms terms(String field) throws IOException { - Terms terms = in.terms(field); + public FieldTerms terms(String field) throws IOException { + FieldTerms terms = in.terms(field); if (terms == null) { return null; } @@ -125,14 +125,14 @@ public Terms terms(String field) throws IOException { } /** - * Wrapper class for another Terms implementation that is used by ExitableFields. + * Wrapper class for another FieldTerms implementation that is used by ExitableFields. */ public static class ExitableTerms extends FilterTerms { private QueryTimeout queryTimeout; /** Constructor **/ - public ExitableTerms(Terms terms, QueryTimeout queryTimeout) { + public ExitableTerms(FieldTerms terms, QueryTimeout queryTimeout) { super(terms); this.queryTimeout = queryTimeout; } diff --git a/lucene/core/src/java/org/apache/lucene/index/Terms.java b/lucene/core/src/java/org/apache/lucene/index/FieldTerms.java similarity index 96% rename from lucene/core/src/java/org/apache/lucene/index/Terms.java rename to lucene/core/src/java/org/apache/lucene/index/FieldTerms.java index 7197e25e549c..2a02a69d8b76 100644 --- a/lucene/core/src/java/org/apache/lucene/index/Terms.java +++ b/lucene/core/src/java/org/apache/lucene/index/FieldTerms.java @@ -29,11 +29,11 @@ * @lucene.experimental */ -public abstract class Terms { +public abstract class FieldTerms { /** Sole constructor. (For invocation by subclass * constructors, typically implicit.) */ - protected Terms() { + protected FieldTerms() { } /** Returns an iterator that will step through all @@ -135,8 +135,8 @@ protected BytesRef nextSeekTerm(BytesRef term) throws IOException { /** Returns true if documents in this field store payloads. */ public abstract boolean hasPayloads(); - /** Zero-length array of {@link Terms}. */ - public final static Terms[] EMPTY_ARRAY = new Terms[0]; + /** Zero-length array of {@link FieldTerms}. */ + public final static FieldTerms[] EMPTY_ARRAY = new FieldTerms[0]; /** Returns the smallest term (in lexicographic order) in the field. * Note that, just like other term measures, this measure does not @@ -214,7 +214,7 @@ public BytesRef getMax() throws IOException { } /** - * Expert: returns additional information about this Terms instance + * Expert: returns additional information about this FieldTerms instance * for debugging purposes. */ public Object getStats() throws IOException { diff --git a/lucene/core/src/java/org/apache/lucene/index/Fields.java b/lucene/core/src/java/org/apache/lucene/index/Fields.java index c5794b611136..9b4d3e03159f 100644 --- a/lucene/core/src/java/org/apache/lucene/index/Fields.java +++ b/lucene/core/src/java/org/apache/lucene/index/Fields.java @@ -25,7 +25,7 @@ public abstract class Fields implements Iterable { - /** Sole constructor. (For invocation by subclass + /** Sole constructor. (For invocation by subclass * constructors, typically implicit.) */ protected Fields() { } @@ -35,15 +35,15 @@ protected Fields() { @Override public abstract Iterator iterator(); - /** Get the {@link Terms} for this field. This will return + /** Get the {@link FieldTerms} for this field. This will return * null if the field does not exist. */ - public abstract Terms terms(String field) throws IOException; + public abstract FieldTerms terms(String field) throws IOException; /** Returns the number of fields or -1 if the number of * distinct field names is unknown. If >= 0, * {@link #iterator} will return as many field names. */ public abstract int size(); - + /** Zero-length {@code Fields} array. */ public final static Fields[] EMPTY_ARRAY = new Fields[0]; } diff --git a/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java b/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java index 9ed62e70b560..22307244bac4 100644 --- a/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java +++ b/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java @@ -79,7 +79,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { return in.terms(field); } @@ -89,22 +89,22 @@ public int size() { } } - /** Base class for filtering {@link Terms} implementations. + /** Base class for filtering {@link FieldTerms} implementations. *

NOTE: If the order of terms and documents is not changed, and if * these terms are going to be intersected with automata, you could consider * overriding {@link #intersect} for better performance. */ - public abstract static class FilterTerms extends Terms { - /** The underlying Terms instance. */ - protected final Terms in; + public abstract static class FilterTerms extends FieldTerms { + /** The underlying FieldTerms instance. */ + protected final FieldTerms in; /** * Creates a new FilterTerms - * @param in the underlying Terms instance. + * @param in the underlying FieldTerms instance. */ - public FilterTerms(Terms in) { + public FilterTerms(FieldTerms in) { if (in == null) { - throw new NullPointerException("incoming Terms must not be null"); + throw new NullPointerException("incoming FieldTerms must not be null"); } this.in = in; } diff --git a/lucene/core/src/java/org/apache/lucene/index/FreqProxFields.java b/lucene/core/src/java/org/apache/lucene/index/FreqProxFields.java index fb78a928279b..d4e6f31eb806 100644 --- a/lucene/core/src/java/org/apache/lucene/index/FreqProxFields.java +++ b/lucene/core/src/java/org/apache/lucene/index/FreqProxFields.java @@ -48,7 +48,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { FreqProxTermsWriterPerField perField = fields.get(field); return perField == null ? null : new FreqProxTerms(perField); } @@ -59,7 +59,7 @@ public int size() { throw new UnsupportedOperationException(); } - private static class FreqProxTerms extends Terms { + private static class FreqProxTerms extends FieldTerms { final FreqProxTermsWriterPerField terms; public FreqProxTerms(FreqProxTermsWriterPerField terms) { diff --git a/lucene/core/src/java/org/apache/lucene/index/FreqProxTermsWriter.java b/lucene/core/src/java/org/apache/lucene/index/FreqProxTermsWriter.java index 1ca2830edcc7..35fd34b45e28 100644 --- a/lucene/core/src/java/org/apache/lucene/index/FreqProxTermsWriter.java +++ b/lucene/core/src/java/org/apache/lucene/index/FreqProxTermsWriter.java @@ -47,7 +47,7 @@ private void applyDeletes(SegmentWriteState state, Fields fields) throws IOExcep for(Term deleteTerm : deleteTerms) { if (deleteTerm.field().equals(lastField) == false) { lastField = deleteTerm.field(); - Terms terms = fields.terms(lastField); + FieldTerms terms = fields.terms(lastField); if (terms != null) { termsEnum = terms.iterator(); } else { diff --git a/lucene/core/src/java/org/apache/lucene/index/IndexReader.java b/lucene/core/src/java/org/apache/lucene/index/IndexReader.java index 976f548317bd..7831953d176f 100644 --- a/lucene/core/src/java/org/apache/lucene/index/IndexReader.java +++ b/lucene/core/src/java/org/apache/lucene/index/IndexReader.java @@ -311,7 +311,7 @@ public abstract Fields getTermVectors(int docID) * null if term vectors were not indexed. The returned * Fields instance acts like a single-document inverted * index (the docID will be 0). */ - public final Terms getTermVector(int docID, String field) + public final FieldTerms getTermVector(int docID, String field) throws IOException { Fields vectors = getTermVectors(docID); if (vectors == null) { @@ -476,7 +476,7 @@ public Object getCombinedCoreAndDeletesKey() { * or -1 if this measure isn't stored by the codec. Note that, just like other * term measures, this measure does not take deleted documents into account. * - * @see Terms#getSumDocFreq() + * @see FieldTerms#getSumDocFreq() */ public abstract long getSumDocFreq(String field) throws IOException; @@ -485,7 +485,7 @@ public Object getCombinedCoreAndDeletesKey() { * or -1 if this measure isn't stored by the codec. Note that, just like other * term measures, this measure does not take deleted documents into account. * - * @see Terms#getDocCount() + * @see FieldTerms#getDocCount() */ public abstract int getDocCount(String field) throws IOException; @@ -495,7 +495,7 @@ public Object getCombinedCoreAndDeletesKey() { * omits term freq and positions). Note that, just like other term measures, * this measure does not take deleted documents into account. * - * @see Terms#getSumTotalTermFreq() + * @see FieldTerms#getSumTotalTermFreq() */ public abstract long getSumTotalTermFreq(String field) throws IOException; diff --git a/lucene/core/src/java/org/apache/lucene/index/LeafReader.java b/lucene/core/src/java/org/apache/lucene/index/LeafReader.java index 73394f23670e..a555c12c7a49 100644 --- a/lucene/core/src/java/org/apache/lucene/index/LeafReader.java +++ b/lucene/core/src/java/org/apache/lucene/index/LeafReader.java @@ -144,7 +144,7 @@ protected static void removeCoreClosedListenerAsReaderClosedListener(IndexReader @Override public final int docFreq(Term term) throws IOException { - final Terms terms = terms(term.field()); + final FieldTerms terms = terms(term.field()); if (terms == null) { return 0; } @@ -163,7 +163,7 @@ public final int docFreq(Term term) throws IOException { * away. */ @Override public final long totalTermFreq(Term term) throws IOException { - final Terms terms = terms(term.field()); + final FieldTerms terms = terms(term.field()); if (terms == null) { return 0; } @@ -177,7 +177,7 @@ public final long totalTermFreq(Term term) throws IOException { @Override public final long getSumDocFreq(String field) throws IOException { - final Terms terms = terms(field); + final FieldTerms terms = terms(field); if (terms == null) { return 0; } @@ -186,7 +186,7 @@ public final long getSumDocFreq(String field) throws IOException { @Override public final int getDocCount(String field) throws IOException { - final Terms terms = terms(field); + final FieldTerms terms = terms(field); if (terms == null) { return 0; } @@ -195,7 +195,7 @@ public final int getDocCount(String field) throws IOException { @Override public final long getSumTotalTermFreq(String field) throws IOException { - final Terms terms = terms(field); + final FieldTerms terms = terms(field); if (terms == null) { return 0; } @@ -203,7 +203,7 @@ public final long getSumTotalTermFreq(String field) throws IOException { } /** This may return null if the field does not exist.*/ - public final Terms terms(String field) throws IOException { + public final FieldTerms terms(String field) throws IOException { return fields().terms(field); } @@ -215,7 +215,7 @@ public final Terms terms(String field) throws IOException { public final PostingsEnum postings(Term term, int flags) throws IOException { assert term.field() != null; assert term.bytes() != null; - final Terms terms = terms(term.field()); + final FieldTerms terms = terms(term.field()); if (terms != null) { final TermsEnum termsEnum = terms.iterator(); if (termsEnum.seekExact(term.bytes())) { diff --git a/lucene/core/src/java/org/apache/lucene/index/MappedMultiFields.java b/lucene/core/src/java/org/apache/lucene/index/MappedMultiFields.java index 280b52b1c95d..45345d690120 100644 --- a/lucene/core/src/java/org/apache/lucene/index/MappedMultiFields.java +++ b/lucene/core/src/java/org/apache/lucene/index/MappedMultiFields.java @@ -39,7 +39,7 @@ public MappedMultiFields(MergeState mergeState, MultiFields multiFields) { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { MultiTerms terms = (MultiTerms) in.terms(field); if (terms == null) { return null; diff --git a/lucene/core/src/java/org/apache/lucene/index/MultiDocValues.java b/lucene/core/src/java/org/apache/lucene/index/MultiDocValues.java index 3970e0a6524e..11b5b8771092 100644 --- a/lucene/core/src/java/org/apache/lucene/index/MultiDocValues.java +++ b/lucene/core/src/java/org/apache/lucene/index/MultiDocValues.java @@ -646,7 +646,7 @@ public static SortedSetDocValues getSortedSetValues(final IndexReader r, final S } /** maps per-segment ordinals to/from global ordinal space */ - // TODO: we could also have a utility method to merge Terms[] and use size() as a weight when we need it + // TODO: we could also have a utility method to merge FieldTerms[] and use size() as a weight when we need it // TODO: use more efficient packed ints structures? // TODO: pull this out? it's pretty generic (maps between N ord()-enabled TermsEnums) public static class OrdinalMap implements Accountable { diff --git a/lucene/core/src/java/org/apache/lucene/index/MultiFields.java b/lucene/core/src/java/org/apache/lucene/index/MultiFields.java index 1736bace115e..b43f667b37d5 100644 --- a/lucene/core/src/java/org/apache/lucene/index/MultiFields.java +++ b/lucene/core/src/java/org/apache/lucene/index/MultiFields.java @@ -49,7 +49,7 @@ public final class MultiFields extends Fields { private final Fields[] subs; private final ReaderSlice[] subSlices; - private final Map terms = new ConcurrentHashMap<>(); + private final Map terms = new ConcurrentHashMap<>(); /** Returns a single {@link Fields} instance for this * reader, merging fields/terms/docs/positions on the @@ -116,7 +116,7 @@ public static Bits getLiveDocs(IndexReader reader) { } /** This method may return null if the field does not exist.*/ - public static Terms getTerms(IndexReader r, String field) throws IOException { + public static FieldTerms getTerms(IndexReader r, String field) throws IOException { return getFields(r).terms(field); } @@ -136,7 +136,7 @@ public static PostingsEnum getTermDocsEnum(IndexReader r, String field, BytesRef public static PostingsEnum getTermDocsEnum(IndexReader r, String field, BytesRef term, int flags) throws IOException { assert field != null; assert term != null; - final Terms terms = getTerms(r, field); + final FieldTerms terms = getTerms(r, field); if (terms != null) { final TermsEnum termsEnum = terms.iterator(); if (termsEnum.seekExact(term)) { @@ -163,7 +163,7 @@ public static PostingsEnum getTermPositionsEnum(IndexReader r, String field, Byt public static PostingsEnum getTermPositionsEnum(IndexReader r, String field, BytesRef term, int flags) throws IOException { assert field != null; assert term != null; - final Terms terms = getTerms(r, field); + final FieldTerms terms = getTerms(r, field); if (terms != null) { final TermsEnum termsEnum = terms.iterator(); if (termsEnum.seekExact(term)) { @@ -194,20 +194,20 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { - Terms result = terms.get(field); + public FieldTerms terms(String field) throws IOException { + FieldTerms result = terms.get(field); if (result != null) return result; // Lazy init: first time this field is requested, we // create & add to terms: - final List subs2 = new ArrayList<>(); + final List subs2 = new ArrayList<>(); final List slices2 = new ArrayList<>(); // Gather all sub-readers that share this field for(int i=0;i 0) { maxTerm = term; @@ -147,7 +147,7 @@ public long size() { @Override public long getSumTotalTermFreq() throws IOException { long sum = 0; - for(Terms terms : subs) { + for(FieldTerms terms : subs) { final long v = terms.getSumTotalTermFreq(); if (v == -1) { return -1; @@ -160,7 +160,7 @@ public long getSumTotalTermFreq() throws IOException { @Override public long getSumDocFreq() throws IOException { long sum = 0; - for(Terms terms : subs) { + for(FieldTerms terms : subs) { final long v = terms.getSumDocFreq(); if (v == -1) { return -1; @@ -173,7 +173,7 @@ public long getSumDocFreq() throws IOException { @Override public int getDocCount() throws IOException { int sum = 0; - for(Terms terms : subs) { + for(FieldTerms terms : subs) { final int v = terms.getDocCount(); if (v == -1) { return -1; diff --git a/lucene/core/src/java/org/apache/lucene/index/ParallelLeafReader.java b/lucene/core/src/java/org/apache/lucene/index/ParallelLeafReader.java index 60886ea20d01..a8af8c0e0969 100644 --- a/lucene/core/src/java/org/apache/lucene/index/ParallelLeafReader.java +++ b/lucene/core/src/java/org/apache/lucene/index/ParallelLeafReader.java @@ -171,12 +171,12 @@ public void removeCoreClosedListener(CoreClosedListener listener) { // Single instance of this, per ParallelReader instance private final class ParallelFields extends Fields { - final Map fields = new TreeMap<>(); + final Map fields = new TreeMap<>(); ParallelFields() { } - void addField(String fieldName, Terms terms) { + void addField(String fieldName, FieldTerms terms) { fields.put(fieldName, terms); } @@ -186,7 +186,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) { + public FieldTerms terms(String field) { return fields.get(field); } @@ -247,7 +247,7 @@ public Fields getTermVectors(int docID) throws IOException { ParallelFields fields = null; for (Map.Entry ent : tvFieldToReader.entrySet()) { String fieldName = ent.getKey(); - Terms vector = ent.getValue().getTermVector(docID, fieldName); + FieldTerms vector = ent.getValue().getTermVector(docID, fieldName); if (vector != null) { if (fields == null) { fields = new ParallelFields(); diff --git a/lucene/core/src/java/org/apache/lucene/index/SlowCodecReaderWrapper.java b/lucene/core/src/java/org/apache/lucene/index/SlowCodecReaderWrapper.java index d5b5c3358850..862b17d4d759 100644 --- a/lucene/core/src/java/org/apache/lucene/index/SlowCodecReaderWrapper.java +++ b/lucene/core/src/java/org/apache/lucene/index/SlowCodecReaderWrapper.java @@ -293,7 +293,7 @@ public Iterator iterator() { } @Override - public Terms terms(String field) throws IOException { + public FieldTerms terms(String field) throws IOException { return fields.terms(field); } diff --git a/lucene/core/src/java/org/apache/lucene/index/SortingLeafReader.java b/lucene/core/src/java/org/apache/lucene/index/SortingLeafReader.java index a6748b853257..e3fb84f48aa5 100644 --- a/lucene/core/src/java/org/apache/lucene/index/SortingLeafReader.java +++ b/lucene/core/src/java/org/apache/lucene/index/SortingLeafReader.java @@ -61,8 +61,8 @@ public SortingFields(final Fields in, FieldInfos infos, Sorter.DocMap docMap) { } @Override - public Terms terms(final String field) throws IOException { - Terms terms = in.terms(field); + public FieldTerms terms(final String field) throws IOException { + FieldTerms terms = in.terms(field); if (terms == null) { return null; } else { @@ -77,7 +77,7 @@ private static class SortingTerms extends FilterTerms { private final Sorter.DocMap docMap; private final IndexOptions indexOptions; - public SortingTerms(final Terms in, IndexOptions indexOptions, final Sorter.DocMap docMap) { + public SortingTerms(final FieldTerms in, IndexOptions indexOptions, final Sorter.DocMap docMap) { super(in); this.docMap = docMap; this.indexOptions = indexOptions; diff --git a/lucene/core/src/java/org/apache/lucene/index/SortingTermVectorsConsumer.java b/lucene/core/src/java/org/apache/lucene/index/SortingTermVectorsConsumer.java index dff808ee9657..63ef1f1cb2e7 100644 --- a/lucene/core/src/java/org/apache/lucene/index/SortingTermVectorsConsumer.java +++ b/lucene/core/src/java/org/apache/lucene/index/SortingTermVectorsConsumer.java @@ -119,7 +119,7 @@ private static void writeTermVectors(TermVectorsWriter writer, Fields vectors, F assert lastFieldName == null || fieldName.compareTo(lastFieldName) > 0: "lastFieldName=" + lastFieldName + " fieldName=" + fieldName; lastFieldName = fieldName; - final Terms terms = vectors.terms(fieldName); + final FieldTerms terms = vectors.terms(fieldName); if (terms == null) { // FieldsEnum shouldn't lie... continue; @@ -132,7 +132,7 @@ private static void writeTermVectors(TermVectorsWriter writer, Fields vectors, F int numTerms = (int) terms.size(); if (numTerms == -1) { - // count manually. It is stupid, but needed, as Terms.size() is not a mandatory statistics function + // count manually. It is stupid, but needed, as FieldTerms.size() is not a mandatory statistics function numTerms = 0; termsEnum = terms.iterator(); while(termsEnum.next() != null) { diff --git a/lucene/core/src/java/org/apache/lucene/index/TermContext.java b/lucene/core/src/java/org/apache/lucene/index/TermContext.java index e55aeba7c75c..0e130ffd1b78 100644 --- a/lucene/core/src/java/org/apache/lucene/index/TermContext.java +++ b/lucene/core/src/java/org/apache/lucene/index/TermContext.java @@ -88,7 +88,7 @@ public static TermContext build(IndexReaderContext context, Term term) //if (DEBUG) System.out.println("prts.build term=" + term); for (final LeafReaderContext ctx : context.leaves()) { //if (DEBUG) System.out.println(" r=" + leaves[i].reader); - final Terms terms = ctx.reader().terms(field); + final FieldTerms terms = ctx.reader().terms(field); if (terms != null) { final TermsEnum termsEnum = terms.iterator(); if (termsEnum.seekExact(bytes)) { diff --git a/lucene/core/src/java/org/apache/lucene/index/package-info.java b/lucene/core/src/java/org/apache/lucene/index/package-info.java index f5a86d1cb37d..239f295e249e 100644 --- a/lucene/core/src/java/org/apache/lucene/index/package-info.java +++ b/lucene/core/src/java/org/apache/lucene/index/package-info.java @@ -23,7 +23,7 @@ *

  • Postings APIs * @@ -58,15 +58,15 @@ * // enumerate list of fields * for (String field : fields) { * // access the terms for this field - * Terms terms = fields.terms(field); + * FieldTerms terms = fields.terms(field); * } * * *

    - * Terms + * FieldTerms *

    *

    - * {@link org.apache.lucene.index.Terms} represents the collection of terms + * {@link org.apache.lucene.index.FieldTerms} represents the collection of terms * within a field, exposes some metadata and statistics, * and an API for enumeration. * 

    @@ -160,23 +160,23 @@
  *     Field statistics
  * 
  *     
      
- *        
    • {@link org.apache.lucene.index.Terms#size}: Returns the number of 
+ *        
    • {@link org.apache.lucene.index.FieldTerms#size}: Returns the number of 
  *            unique terms in the field. This statistic may be unavailable 
- *            (returns -1) for some Terms implementations such as
+ *            (returns -1) for some FieldTerms implementations such as
  *            {@link org.apache.lucene.index.MultiTerms}, where it cannot be efficiently
  *            computed.  Note that this count also includes terms that appear only
  *            in deleted documents: when segments are merged such terms are also merged
  *            away and the statistic is then updated.
- *        
    • {@link org.apache.lucene.index.Terms#getDocCount}: Returns the number of
+ *        
    • {@link org.apache.lucene.index.FieldTerms#getDocCount}: Returns the number of
  *            documents that contain at least one occurrence of any term for this field.
  *            This can be thought of as a Field-level docFreq(). Like docFreq() it will
  *            also count deleted documents.
- *        
    • {@link org.apache.lucene.index.Terms#getSumDocFreq}: Returns the number of
+ *        
    • {@link org.apache.lucene.index.FieldTerms#getSumDocFreq}: Returns the number of
  *            postings (term-document mappings in the inverted index) for the field. This
  *            can be thought of as the sum of {@link org.apache.lucene.index.TermsEnum#docFreq}
  *            across all terms in the field, and like docFreq() it will also count postings
  *            that appear in deleted documents.
- *        
    • {@link org.apache.lucene.index.Terms#getSumTotalTermFreq}: Returns the number
+ *        
    • {@link org.apache.lucene.index.FieldTerms#getSumTotalTermFreq}: Returns the number
  *            of tokens for the field. This can be thought of as the sum of 
  *            {@link org.apache.lucene.index.TermsEnum#totalTermFreq} across all terms in the
  *            field, and like totalTermFreq() it will also count occurrences that appear in
diff --git a/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java b/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
index 3b113a28a313..ad1bf1c26610 100644
--- a/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
@@ -20,7 +20,7 @@
 import java.io.IOException;
 
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.AttributeSource;
 import org.apache.lucene.util.automaton.Automaton;
@@ -103,7 +103,7 @@ public AutomatonQuery(final Term term, Automaton automaton, int maxDeterminizedS
   }
 
   @Override
-  protected TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException {
+  protected TermsEnum getTermsEnum(FieldTerms terms, AttributeSource atts) throws IOException {
     return compiled.getTermsEnum(terms);
   }
 
diff --git a/lucene/core/src/java/org/apache/lucene/search/BoostAttribute.java b/lucene/core/src/java/org/apache/lucene/search/BoostAttribute.java
index 2a99a0828ad7..a206e409babc 100644
--- a/lucene/core/src/java/org/apache/lucene/search/BoostAttribute.java
+++ b/lucene/core/src/java/org/apache/lucene/search/BoostAttribute.java
@@ -20,9 +20,9 @@
 import org.apache.lucene.util.Attribute;
 import org.apache.lucene.util.AttributeSource; // javadocs only
 import org.apache.lucene.index.TermsEnum; // javadocs only
-import org.apache.lucene.index.Terms; // javadocs only
+import org.apache.lucene.index.FieldTerms; // javadocs only
 
-/** Add this {@link Attribute} to a {@link TermsEnum} returned by {@link MultiTermQuery#getTermsEnum(Terms,AttributeSource)}
+/** Add this {@link Attribute} to a {@link TermsEnum} returned by {@link MultiTermQuery#getTermsEnum(FieldTerms,AttributeSource)}
  * and update the boost on each returned term. This enables to control the boost factor
  * for each matching term in {@link MultiTermQuery#SCORING_BOOLEAN_REWRITE} or
  * {@link TopTermsRewrite} mode.
diff --git a/lucene/core/src/java/org/apache/lucene/search/CollectionStatistics.java b/lucene/core/src/java/org/apache/lucene/search/CollectionStatistics.java
index e0aafa84ab2a..30b4a0c677c0 100644
--- a/lucene/core/src/java/org/apache/lucene/search/CollectionStatistics.java
+++ b/lucene/core/src/java/org/apache/lucene/search/CollectionStatistics.java
@@ -17,7 +17,7 @@
 package org.apache.lucene.search;
 
 import org.apache.lucene.index.IndexReader; // javadocs
-import org.apache.lucene.index.Terms;       // javadocs
+import org.apache.lucene.index.FieldTerms;       // javadocs
 
 
 /**
@@ -57,19 +57,19 @@ public final long maxDoc() {
   
   /** returns the total number of documents that
    * have at least one term for this field. 
-   * @see Terms#getDocCount() */
+   * @see FieldTerms#getDocCount() */
   public final long docCount() {
     return docCount;
   }
   
   /** returns the total number of tokens for this field
-   * @see Terms#getSumTotalTermFreq() */
+   * @see FieldTerms#getSumTotalTermFreq() */
   public final long sumTotalTermFreq() {
     return sumTotalTermFreq;
   }
   
   /** returns the total number of postings for this field 
-   * @see Terms#getSumDocFreq() */
+   * @see FieldTerms#getSumDocFreq() */
   public final long sumDocFreq() {
     return sumDocFreq;
   }
diff --git a/lucene/core/src/java/org/apache/lucene/search/DocValuesRewriteMethod.java b/lucene/core/src/java/org/apache/lucene/search/DocValuesRewriteMethod.java
index 20266781d035..d800f86be339 100644
--- a/lucene/core/src/java/org/apache/lucene/search/DocValuesRewriteMethod.java
+++ b/lucene/core/src/java/org/apache/lucene/search/DocValuesRewriteMethod.java
@@ -23,7 +23,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedSetDocValues;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.LongBitSet;
 
@@ -77,7 +77,7 @@ public Weight createWeight(IndexSearcher searcher, boolean needsScores, float bo
         @Override
         public Scorer scorer(LeafReaderContext context) throws IOException {
           final SortedSetDocValues fcsi = DocValues.getSortedSet(context.reader(), query.field);
-          TermsEnum termsEnum = query.getTermsEnum(new Terms() {
+          TermsEnum termsEnum = query.getTermsEnum(new FieldTerms() {
             
             @Override
             public TermsEnum iterator() throws IOException {
diff --git a/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java b/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java
index 3c1eacd80ee9..a087b2d5d740 100644
--- a/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java
@@ -21,7 +21,7 @@
 
 import org.apache.lucene.index.SingleTermsEnum;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.AttributeSource;
 import org.apache.lucene.util.automaton.LevenshteinAutomata;
@@ -147,7 +147,7 @@ public boolean getTranspositions() {
   }
 
   @Override
-  protected TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException {
+  protected TermsEnum getTermsEnum(FieldTerms terms, AttributeSource atts) throws IOException {
     if (maxEdits == 0 || prefixLength >= term.text().length()) {  // can only match if it's exact
       return new SingleTermsEnum(terms.iterator(), term.bytes());
     }
diff --git a/lucene/core/src/java/org/apache/lucene/search/FuzzyTermsEnum.java b/lucene/core/src/java/org/apache/lucene/search/FuzzyTermsEnum.java
index 881c5dd62b1c..72e4d84c8f2b 100644
--- a/lucene/core/src/java/org/apache/lucene/search/FuzzyTermsEnum.java
+++ b/lucene/core/src/java/org/apache/lucene/search/FuzzyTermsEnum.java
@@ -20,7 +20,7 @@
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.Attribute;
 import org.apache.lucene.util.AttributeImpl;
@@ -72,7 +72,7 @@ public final class FuzzyTermsEnum extends TermsEnum {
   // collected terms are ed=1:
   private int maxEdits;
 
-  final Terms terms;
+  final FieldTerms terms;
   final Term term;
   final int termText[];
   final int realPrefixLength;
@@ -96,7 +96,7 @@ public final class FuzzyTermsEnum extends TermsEnum {
    * @param prefixLength Length of required common prefix. Default value is 0.
    * @throws IOException if there is a low-level IO error
    */
-  public FuzzyTermsEnum(Terms terms, AttributeSource atts, Term term, 
+  public FuzzyTermsEnum(FieldTerms terms, AttributeSource atts, Term term, 
       final int maxEdits, final int prefixLength, boolean transpositions) throws IOException {
     if (maxEdits < 0 || maxEdits > LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE) {
       throw new IllegalArgumentException("max edits must be 0.." + LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE + ", inclusive; got: " + maxEdits);
diff --git a/lucene/core/src/java/org/apache/lucene/search/IndexSearcher.java b/lucene/core/src/java/org/apache/lucene/search/IndexSearcher.java
index 5cae1222cc05..2e7dcdf449db 100644
--- a/lucene/core/src/java/org/apache/lucene/search/IndexSearcher.java
+++ b/lucene/core/src/java/org/apache/lucene/search/IndexSearcher.java
@@ -42,7 +42,7 @@
 import org.apache.lucene.index.StoredFieldVisitor;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.similarities.BM25Similarity;
 import org.apache.lucene.search.similarities.Similarity;
 import org.apache.lucene.store.NIOFSDirectory;    // javadoc
@@ -792,7 +792,7 @@ public CollectionStatistics collectionStatistics(String field) throws IOExceptio
 
     assert field != null;
     
-    Terms terms = MultiFields.getTerms(reader, field);
+    FieldTerms terms = MultiFields.getTerms(reader, field);
     if (terms == null) {
       docCount = 0;
       sumTotalTermFreq = 0;
diff --git a/lucene/core/src/java/org/apache/lucene/search/MaxNonCompetitiveBoostAttribute.java b/lucene/core/src/java/org/apache/lucene/search/MaxNonCompetitiveBoostAttribute.java
index 59670b4885e4..74e12b768a76 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MaxNonCompetitiveBoostAttribute.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MaxNonCompetitiveBoostAttribute.java
@@ -20,16 +20,16 @@
 import org.apache.lucene.util.Attribute;
 import org.apache.lucene.util.AttributeSource; // javadocs only
 import org.apache.lucene.util.BytesRef;
-import org.apache.lucene.index.Terms; // javadocs only
+import org.apache.lucene.index.FieldTerms; // javadocs only
 
 /** Add this {@link Attribute} to a fresh {@link AttributeSource} before calling
- * {@link MultiTermQuery#getTermsEnum(Terms,AttributeSource)}.
+ * {@link MultiTermQuery#getTermsEnum(FieldTerms,AttributeSource)}.
  * {@link FuzzyQuery} is using this to control its internal behaviour
  * to only return competitive terms.
  * 
      Please note: This attribute is intended to be added by the {@link MultiTermQuery.RewriteMethod}
  * to an empty {@link AttributeSource} that is shared for all segments
  * during query rewrite. This attribute source is passed to all segment enums
- * on {@link MultiTermQuery#getTermsEnum(Terms,AttributeSource)}.
+ * on {@link MultiTermQuery#getTermsEnum(FieldTerms,AttributeSource)}.
  * {@link TopTermsRewrite} uses this attribute to
  * inform all enums about the current boost, that is not competitive.
  * @lucene.internal
diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiPhraseQuery.java b/lucene/core/src/java/org/apache/lucene/search/MultiPhraseQuery.java
index afb6fc754cb6..81aa0e6a92b6 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MultiPhraseQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MultiPhraseQuery.java
@@ -28,7 +28,7 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
 import org.apache.lucene.index.TermState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.similarities.Similarity.SimScorer;
 import org.apache.lucene.search.similarities.Similarity;
@@ -226,7 +226,7 @@ public Scorer scorer(LeafReaderContext context) throws IOException {
 
       PhraseQuery.PostingsAndFreq[] postingsFreqs = new PhraseQuery.PostingsAndFreq[termArrays.length];
 
-      final Terms fieldTerms = reader.terms(field);
+      final FieldTerms fieldTerms = reader.terms(field);
       if (fieldTerms == null) {
         return null;
       }
diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java b/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java
index d0869d61b7da..b2e0317060a0 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java
@@ -25,7 +25,7 @@
 import org.apache.lucene.index.SingleTermsEnum;   // javadocs
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanQuery.Builder;
 import org.apache.lucene.util.AttributeSource;
@@ -36,7 +36,7 @@
  * FilteredTermsEnum} enumeration.
  *
  * 
      This query cannot be used directly; you must subclass
- * it and define {@link #getTermsEnum(Terms,AttributeSource)} to provide a {@link
+ * it and define {@link #getTermsEnum(FieldTerms,AttributeSource)} to provide a {@link
  * FilteredTermsEnum} that iterates through the terms to be
  * matched.
  *
@@ -72,9 +72,9 @@ public static abstract class RewriteMethod {
     public abstract Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException;
     /**
      * Returns the {@link MultiTermQuery}s {@link TermsEnum}
-     * @see MultiTermQuery#getTermsEnum(Terms, AttributeSource)
+     * @see MultiTermQuery#getTermsEnum(FieldTerms, AttributeSource)
      */
-    protected TermsEnum getTermsEnum(MultiTermQuery query, Terms terms, AttributeSource atts) throws IOException {
+    protected TermsEnum getTermsEnum(MultiTermQuery query, FieldTerms terms, AttributeSource atts) throws IOException {
       return query.getTermsEnum(terms, atts); // allow RewriteMethod subclasses to pull a TermsEnum from the MTQ 
     }
   }
@@ -290,19 +290,19 @@ public MultiTermQuery(final String field) {
    * provide attributes, the rewrite method uses to inform about e.g. maximum competitive boosts.
    * This is currently only used by {@link TopTermsRewrite}
    */
-  protected abstract TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException;
+  protected abstract TermsEnum getTermsEnum(FieldTerms terms, AttributeSource atts) throws IOException;
 
   /** Convenience method, if no attributes are needed:
    * This simply passes empty attributes and is equal to:
    * getTermsEnum(terms, new AttributeSource())
    */
-  protected final TermsEnum getTermsEnum(Terms terms) throws IOException {
+  protected final TermsEnum getTermsEnum(FieldTerms terms) throws IOException {
     return getTermsEnum(terms, new AttributeSource());
   }
 
   /**
    * To rewrite to a simpler form, instead return a simpler
-   * enum from {@link #getTermsEnum(Terms, AttributeSource)}.  For example,
+   * enum from {@link #getTermsEnum(FieldTerms, AttributeSource)}.  For example,
    * to rewrite to a single term, return a {@link SingleTermsEnum}
    */
   @Override
diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreWrapper.java b/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreWrapper.java
index 54c6d484a0ff..3a741b63f593 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreWrapper.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreWrapper.java
@@ -27,7 +27,7 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
 import org.apache.lucene.index.TermState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause.Occur;
 import org.apache.lucene.util.BytesRef;
@@ -132,7 +132,7 @@ private boolean collectTerms(LeafReaderContext context, TermsEnum termsEnum, Lis
        * there are few terms, or build a bitset containing matching docs.
        */
       private WeightOrDocIdSet rewrite(LeafReaderContext context) throws IOException {
-        final Terms terms = context.reader().terms(query.field);
+        final FieldTerms terms = context.reader().terms(query.field);
         if (terms == null) {
           // field does not exist
           return new WeightOrDocIdSet((DocIdSet) null);
diff --git a/lucene/core/src/java/org/apache/lucene/search/PhraseQuery.java b/lucene/core/src/java/org/apache/lucene/search/PhraseQuery.java
index d0bf8285cc9f..3f26110f1b55 100644
--- a/lucene/core/src/java/org/apache/lucene/search/PhraseQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/PhraseQuery.java
@@ -34,7 +34,7 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
 import org.apache.lucene.index.TermState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.similarities.Similarity;
 import org.apache.lucene.search.similarities.Similarity.SimScorer;
@@ -392,7 +392,7 @@ public Scorer scorer(LeafReaderContext context) throws IOException {
       final LeafReader reader = context.reader();
       PostingsAndFreq[] postingsFreqs = new PostingsAndFreq[terms.length];
 
-      final Terms fieldTerms = reader.terms(field);
+      final FieldTerms fieldTerms = reader.terms(field);
       if (fieldTerms == null) {
         return null;
       }
diff --git a/lucene/core/src/java/org/apache/lucene/search/TermCollectingRewrite.java b/lucene/core/src/java/org/apache/lucene/search/TermCollectingRewrite.java
index fffa5a84fca3..bb516925da9e 100644
--- a/lucene/core/src/java/org/apache/lucene/search/TermCollectingRewrite.java
+++ b/lucene/core/src/java/org/apache/lucene/search/TermCollectingRewrite.java
@@ -24,7 +24,7 @@
 import org.apache.lucene.index.IndexReaderContext;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.AttributeSource;
 import org.apache.lucene.util.BytesRef;
@@ -49,7 +49,7 @@ protected final void addClause(B topLevel, Term term, int docCount, float boost)
   final void collectTerms(IndexReader reader, MultiTermQuery query, TermCollector collector) throws IOException {
     IndexReaderContext topReaderContext = reader.getContext();
     for (LeafReaderContext context : topReaderContext.leaves()) {
-      final Terms terms = context.reader().terms(query.field);
+      final FieldTerms terms = context.reader().terms(query.field);
       if (terms == null) {
         // field does not exist
         continue;
diff --git a/lucene/core/src/java/org/apache/lucene/search/TermInSetQuery.java b/lucene/core/src/java/org/apache/lucene/search/TermInSetQuery.java
index e1a1575d4045..6ce70b8f4de6 100644
--- a/lucene/core/src/java/org/apache/lucene/search/TermInSetQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/TermInSetQuery.java
@@ -37,7 +37,7 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
 import org.apache.lucene.index.TermState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause.Occur;
 import org.apache.lucene.util.Accountable;
@@ -269,7 +269,7 @@ private WeightOrDocIdSet rewrite(LeafReaderContext context) throws IOException {
 
         final Fields fields = reader.fields();
         String lastField = null;
-        Terms terms = null;
+        FieldTerms terms = null;
         TermsEnum termsEnum = null;
         PostingsEnum docs = null;
         TermIterator iterator = termData.iterator();
diff --git a/lucene/core/src/java/org/apache/lucene/search/TermQuery.java b/lucene/core/src/java/org/apache/lucene/search/TermQuery.java
index 73170b915607..d107a6e61235 100644
--- a/lucene/core/src/java/org/apache/lucene/search/TermQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/TermQuery.java
@@ -29,7 +29,7 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
 import org.apache.lucene.index.TermState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.similarities.Similarity;
 import org.apache.lucene.search.similarities.Similarity.SimScorer;
@@ -114,7 +114,7 @@ private TermsEnum getTermsEnum(LeafReaderContext context) throws IOException {
         return termsEnum;
       } else {
         // TermQuery used as a filter, so the term states have not been built up front
-        Terms terms = context.reader().terms(term.field());
+        FieldTerms terms = context.reader().terms(term.field());
         if (terms == null) {
           return null;
         }
diff --git a/lucene/core/src/java/org/apache/lucene/search/similarities/BasicStats.java b/lucene/core/src/java/org/apache/lucene/search/similarities/BasicStats.java
index a08fe2fdbc15..3f7bb6911134 100644
--- a/lucene/core/src/java/org/apache/lucene/search/similarities/BasicStats.java
+++ b/lucene/core/src/java/org/apache/lucene/search/similarities/BasicStats.java
@@ -17,7 +17,7 @@
 package org.apache.lucene.search.similarities;
 
 
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 
 /**
  * Stores all statistics commonly used ranking methods.
@@ -61,7 +61,7 @@ public void setNumberOfDocuments(long numberOfDocuments) {
   
   /**
    * Returns the total number of tokens in the field.
-   * @see Terms#getSumTotalTermFreq()
+   * @see FieldTerms#getSumTotalTermFreq()
    */
   public long getNumberOfFieldTokens() {
     return numberOfFieldTokens;
@@ -69,7 +69,7 @@ public long getNumberOfFieldTokens() {
   
   /**
    * Sets the total number of tokens in the field.
-   * @see Terms#getSumTotalTermFreq()
+   * @see FieldTerms#getSumTotalTermFreq()
    */
   public void setNumberOfFieldTokens(long numberOfFieldTokens) {
     this.numberOfFieldTokens = numberOfFieldTokens;
diff --git a/lucene/core/src/java/org/apache/lucene/search/spans/SpanNearQuery.java b/lucene/core/src/java/org/apache/lucene/search/spans/SpanNearQuery.java
index 7958f4758b0b..138cca99ba49 100644
--- a/lucene/core/src/java/org/apache/lucene/search/spans/SpanNearQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/spans/SpanNearQuery.java
@@ -30,7 +30,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
 
@@ -203,7 +203,7 @@ public void extractTermContexts(Map contexts) {
     @Override
     public Spans getSpans(final LeafReaderContext context, Postings requiredPostings) throws IOException {
 
-      Terms terms = context.reader().terms(field);
+      FieldTerms terms = context.reader().terms(field);
       if (terms == null) {
         return null; // field does not exist
       }
diff --git a/lucene/core/src/java/org/apache/lucene/search/spans/SpanTermQuery.java b/lucene/core/src/java/org/apache/lucene/search/spans/SpanTermQuery.java
index 2746a0c15451..0c5ef7c8bb50 100644
--- a/lucene/core/src/java/org/apache/lucene/search/spans/SpanTermQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/spans/SpanTermQuery.java
@@ -30,7 +30,7 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
 import org.apache.lucene.index.TermState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.IndexSearcher;
 
@@ -107,7 +107,7 @@ public Spans getSpans(final LeafReaderContext context, Postings requiredPostings
         return null;
       }
 
-      final Terms terms = context.reader().terms(term.field());
+      final FieldTerms terms = context.reader().terms(term.field());
       if (terms == null)
         return null;
       if (terms.hasPositions() == false)
diff --git a/lucene/core/src/java/org/apache/lucene/util/DocIdSetBuilder.java b/lucene/core/src/java/org/apache/lucene/util/DocIdSetBuilder.java
index 954614b3ad59..4a7544c58209 100644
--- a/lucene/core/src/java/org/apache/lucene/util/DocIdSetBuilder.java
+++ b/lucene/core/src/java/org/apache/lucene/util/DocIdSetBuilder.java
@@ -22,7 +22,7 @@
 import java.util.List;
 
 import org.apache.lucene.index.PointValues;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.DocIdSet;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.util.packed.PackedInts;
@@ -108,8 +108,8 @@ public DocIdSetBuilder(int maxDoc) {
   }
 
   /** Create a {@link DocIdSetBuilder} instance that is optimized for
-   *  accumulating docs that match the given {@link Terms}. */
-  public DocIdSetBuilder(int maxDoc, Terms terms) throws IOException {
+   *  accumulating docs that match the given {@link FieldTerms}. */
+  public DocIdSetBuilder(int maxDoc, FieldTerms terms) throws IOException {
     this(maxDoc, terms.getDocCount(), terms.getSumDocFreq());
   }
 
diff --git a/lucene/core/src/java/org/apache/lucene/util/automaton/CompiledAutomaton.java b/lucene/core/src/java/org/apache/lucene/util/automaton/CompiledAutomaton.java
index bd00a709afb1..e8738091f80c 100644
--- a/lucene/core/src/java/org/apache/lucene/util/automaton/CompiledAutomaton.java
+++ b/lucene/core/src/java/org/apache/lucene/util/automaton/CompiledAutomaton.java
@@ -22,7 +22,7 @@
 import java.util.List;
 
 import org.apache.lucene.index.SingleTermsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.BytesRefBuilder;
@@ -320,11 +320,11 @@ private BytesRef addTail(int state, BytesRefBuilder term, int idx, int leadLabel
   }
 
   // TODO: should this take startTerm too?  This way
-  // Terms.intersect could forward to this method if type !=
+  // FieldTerms.intersect could forward to this method if type !=
   // NORMAL:
-  /** Return a {@link TermsEnum} intersecting the provided {@link Terms}
+  /** Return a {@link TermsEnum} intersecting the provided {@link FieldTerms}
    *  with the terms accepted by this automaton. */
-  public TermsEnum getTermsEnum(Terms terms) throws IOException {
+  public TermsEnum getTermsEnum(FieldTerms terms) throws IOException {
     switch(type) {
     case NONE:
       return TermsEnum.EMPTY;
diff --git a/lucene/core/src/test/org/apache/lucene/codecs/lucene50/TestBlockPostingsFormat3.java b/lucene/core/src/test/org/apache/lucene/codecs/lucene50/TestBlockPostingsFormat3.java
index 1b3b9affdf3b..5f81fb3a6828 100644
--- a/lucene/core/src/test/org/apache/lucene/codecs/lucene50/TestBlockPostingsFormat3.java
+++ b/lucene/core/src/test/org/apache/lucene/codecs/lucene50/TestBlockPostingsFormat3.java
@@ -41,7 +41,7 @@
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.RandomIndexWriter;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum.SeekStatus;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
@@ -162,7 +162,7 @@ private void verify(Directory dir) throws Exception {
   
   // following code is almost an exact dup of code from TestDuelingCodecs: sorry!
   
-  public void assertTerms(Terms leftTerms, Terms rightTerms, boolean deep) throws Exception {
+  public void assertTerms(FieldTerms leftTerms, FieldTerms rightTerms, boolean deep) throws Exception {
     if (leftTerms == null || rightTerms == null) {
       assertNull(leftTerms);
       assertNull(rightTerms);
@@ -194,7 +194,7 @@ public void assertTerms(Terms leftTerms, Terms rightTerms, boolean deep) throws
     }
   }
   
-  private void assertTermsSeeking(Terms leftTerms, Terms rightTerms) throws Exception {
+  private void assertTermsSeeking(FieldTerms leftTerms, FieldTerms rightTerms) throws Exception {
     TermsEnum leftEnum = null;
     TermsEnum rightEnum = null;
     
@@ -260,9 +260,9 @@ private void assertTermsSeeking(Terms leftTerms, Terms rightTerms) throws Except
   }
   
   /** 
-   * checks collection-level statistics on Terms 
+   * checks collection-level statistics on FieldTerms 
    */
-  public void assertTermsStatistics(Terms leftTerms, Terms rightTerms) throws Exception {
+  public void assertTermsStatistics(FieldTerms leftTerms, FieldTerms rightTerms) throws Exception {
     if (leftTerms.getDocCount() != -1 && rightTerms.getDocCount() != -1) {
       assertEquals(leftTerms.getDocCount(), rightTerms.getDocCount());
     }
diff --git a/lucene/core/src/test/org/apache/lucene/codecs/lucene70/TestLucene70DocValuesFormat.java b/lucene/core/src/test/org/apache/lucene/codecs/lucene70/TestLucene70DocValuesFormat.java
index 6cca55e3a48a..600ad85d44fc 100644
--- a/lucene/core/src/test/org/apache/lucene/codecs/lucene70/TestLucene70DocValuesFormat.java
+++ b/lucene/core/src/test/org/apache/lucene/codecs/lucene70/TestLucene70DocValuesFormat.java
@@ -60,7 +60,7 @@
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.index.SortedSetDocValues;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum.SeekStatus;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.index.TermsEnum;
@@ -345,7 +345,7 @@ public DocValuesFormat getDocValuesFormatForField(String field) {
     DirectoryReader ir = writer.getReader();
     for (LeafReaderContext context : ir.leaves()) {
       LeafReader r = context.reader();
-      Terms terms = r.terms("indexed");
+      FieldTerms terms = r.terms("indexed");
       if (terms != null) {
         SortedSetDocValues ssdv = r.getSortedSetDocValues("dv");
         assertEquals(terms.size(), ssdv.getValueCount());
@@ -363,7 +363,7 @@ public DocValuesFormat getDocValuesFormatForField(String field) {
     // now compare again after the merge
     ir = writer.getReader();
     LeafReader ar = getOnlyLeafReader(ir);
-    Terms terms = ar.terms("indexed");
+    FieldTerms terms = ar.terms("indexed");
     if (terms != null) {
       assertEquals(terms.size(), ar.getSortedSetDocValues("dv").getValueCount());
       TermsEnum expected = terms.iterator();
diff --git a/lucene/core/src/test/org/apache/lucene/index/Test2BDocs.java b/lucene/core/src/test/org/apache/lucene/index/Test2BDocs.java
index 4fab45a1a472..21baa082dc49 100644
--- a/lucene/core/src/test/org/apache/lucene/index/Test2BDocs.java
+++ b/lucene/core/src/test/org/apache/lucene/index/Test2BDocs.java
@@ -91,7 +91,7 @@ public void test2BDocs() throws Exception {
       LeafReader reader = context.reader();
       int lim = context.reader().maxDoc();
 
-      Terms terms = reader.fields().terms("f1");
+      FieldTerms terms = reader.fields().terms("f1");
       for (int i=0; i<10000; i++) {
         TermsEnum te = terms.iterator();
         assertTrue( te.seekExact(term) );
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestBagOfPositions.java b/lucene/core/src/test/org/apache/lucene/index/TestBagOfPositions.java
index 6214e4cde1da..48d9eabeff94 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestBagOfPositions.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestBagOfPositions.java
@@ -134,7 +134,7 @@ public void run() {
     DirectoryReader ir = iw.getReader();
     assertEquals(1, ir.leaves().size());
     LeafReader air = ir.leaves().get(0).reader();
-    Terms terms = air.terms("field");
+    FieldTerms terms = air.terms("field");
     // numTerms-1 because there cannot be a term 0 with 0 postings:
     assertEquals(numTerms-1, terms.size());
     TermsEnum termsEnum = terms.iterator();
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestBagOfPostings.java b/lucene/core/src/test/org/apache/lucene/index/TestBagOfPostings.java
index 8cd255195670..9a4ac70f324a 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestBagOfPostings.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestBagOfPostings.java
@@ -126,7 +126,7 @@ public void run() {
     DirectoryReader ir = iw.getReader();
     assertEquals(1, ir.leaves().size());
     LeafReader air = ir.leaves().get(0).reader();
-    Terms terms = air.terms("field");
+    FieldTerms terms = air.terms("field");
     // numTerms-1 because there cannot be a term 0 with 0 postings:
     assertEquals(numTerms-1, terms.size());
     TermsEnum termsEnum = terms.iterator();
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestCodecs.java b/lucene/core/src/test/org/apache/lucene/index/TestCodecs.java
index 79783b500ca7..a9d087f3c9b0 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestCodecs.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestCodecs.java
@@ -225,7 +225,7 @@ public void testFixedPostings() throws Throwable {
     final Iterator fieldsEnum = reader.iterator();
     String fieldName = fieldsEnum.next();
     assertNotNull(fieldName);
-    final Terms terms2 = reader.terms(fieldName);
+    final FieldTerms terms2 = reader.terms(fieldName);
     assertNotNull(terms2);
 
     final TermsEnum termsEnum = terms2.iterator();
@@ -542,7 +542,7 @@ public void remove() {
     }
 
     @Override
-    public Terms terms(String field) {
+    public FieldTerms terms(String field) {
       // Slow linear search:
       for(FieldData fieldData : fields) {
         if (fieldData.fieldInfo.name.equals(field)) {
@@ -558,7 +558,7 @@ public int size() {
     }
   }
 
-  private static class DataTerms extends Terms {
+  private static class DataTerms extends FieldTerms {
     final FieldData fieldData;
 
     public DataTerms(FieldData fieldData) {
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestDirectoryReader.java b/lucene/core/src/test/org/apache/lucene/index/TestDirectoryReader.java
index 9ac719e50a52..65484357bd4c 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestDirectoryReader.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestDirectoryReader.java
@@ -69,7 +69,7 @@ public void testDocument() throws IOException {
     Document newDoc2 = reader.document(1);
     assertTrue(newDoc2 != null);
     assertTrue(DocHelper.numFields(newDoc2) == DocHelper.numFields(doc2) - DocHelper.unstored.size());
-    Terms vector = reader.getTermVectors(0).terms(DocHelper.TEXT_FIELD_2_KEY);
+    FieldTerms vector = reader.getTermVectors(0).terms(DocHelper.TEXT_FIELD_2_KEY);
     assertNotNull(vector);
 
     reader.close();
@@ -623,14 +623,14 @@ public static void assertIndexEquals(DirectoryReader index1, DirectoryReader ind
     Iterator fenum2 = fields2.iterator();
     for (String field1 : fields1) {
       assertEquals("Different fields", field1, fenum2.next());
-      Terms terms1 = fields1.terms(field1);
+      FieldTerms terms1 = fields1.terms(field1);
       if (terms1 == null) {
         assertNull(fields2.terms(field1));
         continue;
       }
       TermsEnum enum1 = terms1.iterator();
 
-      Terms terms2 = fields2.terms(field1);
+      FieldTerms terms2 = fields2.terms(field1);
       assertNotNull(terms2);
       TermsEnum enum2 = terms2.iterator();
 
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestDoc.java b/lucene/core/src/test/org/apache/lucene/index/TestDoc.java
index 8b24b4d7bc51..89f5b198b898 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestDoc.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestDoc.java
@@ -251,7 +251,7 @@ private void printSegment(PrintWriter out, SegmentCommitInfo si)
 
     Fields fields = reader.fields();
     for (String field : fields)  {
-      Terms terms = fields.terms(field);
+      FieldTerms terms = fields.terms(field);
       assertNotNull(terms);
       TermsEnum tis = terms.iterator();
       while(tis.next() != null) {
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestDocCount.java b/lucene/core/src/test/org/apache/lucene/index/TestDocCount.java
index 0f221e32d279..af12ba5b81db 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestDocCount.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestDocCount.java
@@ -26,7 +26,7 @@
 import org.apache.lucene.util.TestUtil;
 
 /**
- * Tests the Terms.docCount statistic
+ * Tests the FieldTerms.docCount statistic
  */
 public class TestDocCount extends LuceneTestCase {
   public void testSimple() throws Exception {
@@ -59,7 +59,7 @@ private Document doc() {
   private void verifyCount(IndexReader ir) throws Exception {
     Fields fields = MultiFields.getFields(ir);
     for (String field : fields) {
-      Terms terms = fields.terms(field);
+      FieldTerms terms = fields.terms(field);
       if (terms == null) {
         continue;
       }
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestDocsAndPositions.java b/lucene/core/src/test/org/apache/lucene/index/TestDocsAndPositions.java
index cc1f2be04b9c..df968218614a 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestDocsAndPositions.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestDocsAndPositions.java
@@ -91,7 +91,7 @@ public void testPositionsSimple() throws IOException {
 
   public PostingsEnum getDocsAndPositions(LeafReader reader,
       BytesRef bytes) throws IOException {
-    Terms terms = reader.terms(fieldName);
+    FieldTerms terms = reader.terms(fieldName);
     if (terms != null) {
       TermsEnum te = terms.iterator();
       if (te.seekExact(bytes)) {
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestExitableDirectoryReader.java b/lucene/core/src/test/org/apache/lucene/index/TestExitableDirectoryReader.java
index 71406c8759f9..f38e1acd22e9 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestExitableDirectoryReader.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestExitableDirectoryReader.java
@@ -32,7 +32,7 @@
 
 /**
  * Test that uses a default/lucene Implementation of {@link QueryTimeout}
- * to exit out long running queries that take too long to iterate over Terms.
+ * to exit out long running queries that take too long to iterate over FieldTerms.
  */
 public class TestExitableDirectoryReader extends LuceneTestCase {
   private static class TestReader extends FilterLeafReader {
@@ -43,13 +43,13 @@ private static class TestFields extends FilterFields {
       }
 
       @Override
-      public Terms terms(String field) throws IOException {
+      public FieldTerms terms(String field) throws IOException {
         return new TestTerms(super.terms(field));
       }
     }
 
     private static class TestTerms extends FilterTerms {
-      TestTerms(Terms in) {
+      TestTerms(FieldTerms in) {
         super(in);
       }
 
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestFilterLeafReader.java b/lucene/core/src/test/org/apache/lucene/index/TestFilterLeafReader.java
index e9f6fe28854e..2b64ee248a27 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestFilterLeafReader.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestFilterLeafReader.java
@@ -42,13 +42,13 @@ private static class TestFields extends FilterFields {
       }
 
       @Override
-      public Terms terms(String field) throws IOException {
+      public FieldTerms terms(String field) throws IOException {
         return new TestTerms(super.terms(field));
       }
     }
 
     private static class TestTerms extends FilterTerms {
-      TestTerms(Terms in) {
+      TestTerms(FieldTerms in) {
         super(in);
       }
 
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestIndexWriter.java b/lucene/core/src/test/org/apache/lucene/index/TestIndexWriter.java
index e4f0ab0d55d1..e96188d6bf03 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestIndexWriter.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestIndexWriter.java
@@ -823,7 +823,7 @@ public void testPositionIncrementGapEmptyField() throws Exception {
     w.close();
 
     IndexReader r = DirectoryReader.open(dir);
-    Terms tpv = r.getTermVectors(0).terms("field");
+    FieldTerms tpv = r.getTermVectors(0).terms("field");
     TermsEnum termsEnum = tpv.iterator();
     assertNotNull(termsEnum.next());
     PostingsEnum dpEnum = termsEnum.postings(null, PostingsEnum.ALL);
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestIndexableField.java b/lucene/core/src/test/org/apache/lucene/index/TestIndexableField.java
index 67edab90437c..cab942ca4816 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestIndexableField.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestIndexableField.java
@@ -273,7 +273,7 @@ public void remove() {
         if (indexed) {
           final boolean tv = counter % 2 == 1 && fieldID != 9;
           if (tv) {
-            final Terms tfv = r.getTermVectors(docID).terms(name);
+            final FieldTerms tfv = r.getTermVectors(docID).terms(name);
             assertNotNull(tfv);
             TermsEnum termsEnum = tfv.iterator();
             assertEquals(new BytesRef(""+counter), termsEnum.next());
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestMultiTermsEnum.java b/lucene/core/src/test/org/apache/lucene/index/TestMultiTermsEnum.java
index ac352c1318c7..8c83d8a14305 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestMultiTermsEnum.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestMultiTermsEnum.java
@@ -36,7 +36,7 @@
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.index.LeafReaderContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
@@ -89,9 +89,9 @@ private static class MigratingFieldsProducer extends BaseMigratingFieldsProducer
       }
 
       @Override
-      public Terms terms(String field) throws IOException {
+      public FieldTerms terms(String field) throws IOException {
         if ("deleted".equals(field)) {
-          Terms deletedTerms = super.terms("deleted");
+          FieldTerms deletedTerms = super.terms("deleted");
           if (deletedTerms != null) {
             return new ValueFilteredTerms(deletedTerms, new BytesRef("1"));
           }
@@ -106,12 +106,12 @@ protected FieldsProducer create(FieldsProducer delegate, FieldInfos newFieldInfo
         return new MigratingFieldsProducer(delegate, newFieldInfo);
       }
 
-      private static class ValueFilteredTerms extends Terms {
+      private static class ValueFilteredTerms extends FieldTerms {
 
-        private final Terms delegate;
+        private final FieldTerms delegate;
         private final BytesRef value;
 
-        public ValueFilteredTerms(Terms delegate, BytesRef value) {
+        public ValueFilteredTerms(FieldTerms delegate, BytesRef value) {
           this.delegate = delegate;
           this.value = value;
         }
@@ -232,7 +232,7 @@ public int size() {
       }
 
       @Override
-      public Terms terms(String field) throws IOException {
+      public FieldTerms terms(String field) throws IOException {
         return delegate.terms(field);
       }
 
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestParallelTermEnum.java b/lucene/core/src/test/org/apache/lucene/index/TestParallelTermEnum.java
index 25d05ca155be..146d13e876d0 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestParallelTermEnum.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestParallelTermEnum.java
@@ -71,7 +71,7 @@ public void tearDown() throws Exception {
     super.tearDown();
   }
   
-  private void checkTerms(Terms terms, String... termsList) throws IOException {
+  private void checkTerms(FieldTerms terms, String... termsList) throws IOException {
     assertNotNull(terms);
     final TermsEnum te = terms.iterator();
     
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestPayloadsOnVectors.java b/lucene/core/src/test/org/apache/lucene/index/TestPayloadsOnVectors.java
index a90a5d25bbc2..5f26d59a83de 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestPayloadsOnVectors.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestPayloadsOnVectors.java
@@ -68,7 +68,7 @@ public void testMixupDocs() throws Exception {
     writer.addDocument(doc);
     
     DirectoryReader reader = writer.getReader();
-    Terms terms = reader.getTermVector(1, "field");
+    FieldTerms terms = reader.getTermVector(1, "field");
     assert terms != null;
     TermsEnum termsEnum = terms.iterator();
     assertTrue(termsEnum.seekExact(new BytesRef("withPayload")));
@@ -110,7 +110,7 @@ public void testMixupMultiValued() throws Exception {
     doc.add(field3);
     writer.addDocument(doc);
     DirectoryReader reader = writer.getReader();
-    Terms terms = reader.getTermVector(0, "field");
+    FieldTerms terms = reader.getTermVector(0, "field");
     assert terms != null;
     TermsEnum termsEnum = terms.iterator();
     assertTrue(termsEnum.seekExact(new BytesRef("withPayload")));
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestPerSegmentDeletes.java b/lucene/core/src/test/org/apache/lucene/index/TestPerSegmentDeletes.java
index 34d8afbd19c8..f6d517232438 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestPerSegmentDeletes.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestPerSegmentDeletes.java
@@ -222,7 +222,7 @@ public static void printDelDocs(Bits bits) {
   public int[] toDocsArray(Term term, Bits bits, IndexReader reader)
       throws IOException {
     Fields fields = MultiFields.getFields(reader);
-    Terms cterms = fields.terms(term.field);
+    FieldTerms cterms = fields.terms(term.field);
     TermsEnum ctermsEnum = cterms.iterator();
     if (ctermsEnum.seekExact(new BytesRef(term.text()))) {
       PostingsEnum postingsEnum = TestUtil.docs(random(), ctermsEnum, null, PostingsEnum.NONE);
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestSegmentMerger.java b/lucene/core/src/test/org/apache/lucene/index/TestSegmentMerger.java
index 1ef37c0892f1..11911c02c1ac 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestSegmentMerger.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestSegmentMerger.java
@@ -126,7 +126,7 @@ public void testMerge() throws IOException {
     //System.out.println("stored size: " + stored.size());
     assertEquals("We do not have 3 fields that were indexed with term vector", 3, tvCount);
 
-    Terms vector = mergedReader.getTermVectors(0).terms(DocHelper.TEXT_FIELD_2_KEY);
+    FieldTerms vector = mergedReader.getTermVectors(0).terms(DocHelper.TEXT_FIELD_2_KEY);
     assertNotNull(vector);
     assertEquals(3, vector.size());
     TermsEnum termsEnum = vector.iterator();
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestSegmentReader.java b/lucene/core/src/test/org/apache/lucene/index/TestSegmentReader.java
index f008afe7a798..4cc6f09d3afd 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestSegmentReader.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestSegmentReader.java
@@ -116,7 +116,7 @@ public void testGetFieldNameVariations() {
   public void testTerms() throws IOException {
     Fields fields = MultiFields.getFields(reader);
     for (String field : fields) {
-      Terms terms = fields.terms(field);
+      FieldTerms terms = fields.terms(field);
       assertNotNull(terms);
       TermsEnum termsEnum = terms.iterator();
       while(termsEnum.next() != null) {
@@ -186,7 +186,7 @@ public static void checkNorms(LeafReader reader) throws IOException {
   }
   
   public void testTermVectors() throws IOException {
-    Terms result = reader.getTermVectors(0).terms(DocHelper.TEXT_FIELD_2_KEY);
+    FieldTerms result = reader.getTermVectors(0).terms(DocHelper.TEXT_FIELD_2_KEY);
     assertNotNull(result);
     assertEquals(3, result.size());
     TermsEnum termsEnum = result.iterator();
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestStressIndexing2.java b/lucene/core/src/test/org/apache/lucene/index/TestStressIndexing2.java
index 3cd9a6a6c0a6..c88fd4d518c0 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestStressIndexing2.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestStressIndexing2.java
@@ -316,7 +316,7 @@ public void verifyEquals(DirectoryReader r1, DirectoryReader r2, String idField)
       assertNull(MultiFields.getFields(r2));
       return;
     }
-    final Terms terms1 = f1.terms(idField);
+    final FieldTerms terms1 = f1.terms(idField);
     if (terms1 == null) {
       assertTrue(MultiFields.getFields(r2) == null ||
                  MultiFields.getFields(r2).terms(idField) == null);
@@ -328,7 +328,7 @@ public void verifyEquals(DirectoryReader r1, DirectoryReader r2, String idField)
     final Bits liveDocs2 = MultiFields.getLiveDocs(r2);
     
     Fields fields = MultiFields.getFields(r2);
-    Terms terms2 = fields.terms(idField);
+    FieldTerms terms2 = fields.terms(idField);
     if (fields.size() == 0 || terms2 == null) {
       // make sure r1 is in fact empty (eg has only all
       // deleted docs):
@@ -398,7 +398,7 @@ public void verifyEquals(DirectoryReader r1, DirectoryReader r2, String idField)
           PostingsEnum dEnum = null;
           for (String field : tv1) {
             System.out.println("    " + field + ":");
-            Terms terms3 = tv1.terms(field);
+            FieldTerms terms3 = tv1.terms(field);
             assertNotNull(terms3);
             TermsEnum termsEnum3 = terms3.iterator();
             BytesRef term2;
@@ -430,7 +430,7 @@ public void verifyEquals(DirectoryReader r1, DirectoryReader r2, String idField)
           PostingsEnum dEnum = null;
           for (String field : tv2) {
             System.out.println("    " + field + ":");
-            Terms terms3 = tv2.terms(field);
+            FieldTerms terms3 = tv2.terms(field);
             assertNotNull(terms3);
             TermsEnum termsEnum3 = terms3.iterator();
             BytesRef term2;
@@ -490,7 +490,7 @@ public void verifyEquals(DirectoryReader r1, DirectoryReader r2, String idField)
             break;
           }
           field1 = fields1Enum.next();
-          Terms terms = fields1.terms(field1);
+          FieldTerms terms = fields1.terms(field1);
           if (terms == null) {
             continue;
           }
@@ -526,7 +526,7 @@ public void verifyEquals(DirectoryReader r1, DirectoryReader r2, String idField)
             break;
           }
           field2 = fields2Enum.next();
-          Terms terms = fields2.terms(field2);
+          FieldTerms terms = fields2.terms(field2);
           if (terms == null) {
             continue;
           }
@@ -612,11 +612,11 @@ public static void verifyEquals(Fields d1, Fields d2) throws IOException {
       String field2 = fieldsEnum2.next();
       assertEquals(field1, field2);
 
-      Terms terms1 = d1.terms(field1);
+      FieldTerms terms1 = d1.terms(field1);
       assertNotNull(terms1);
       TermsEnum termsEnum1 = terms1.iterator();
 
-      Terms terms2 = d2.terms(field2);
+      FieldTerms terms2 = d2.terms(field2);
       assertNotNull(terms2);
       TermsEnum termsEnum2 = terms2.iterator();
 
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestSumDocFreq.java b/lucene/core/src/test/org/apache/lucene/index/TestSumDocFreq.java
index 67063f661de3..1bc46a2db13d 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestSumDocFreq.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestSumDocFreq.java
@@ -24,7 +24,7 @@
 import org.apache.lucene.util.TestUtil;
 
 /**
- * Tests {@link Terms#getSumDocFreq()}
+ * Tests {@link FieldTerms#getSumDocFreq()}
  * @lucene.experimental
  */
 public class TestSumDocFreq extends LuceneTestCase {
@@ -76,7 +76,7 @@ private void assertSumDocFreq(IndexReader ir) throws Exception {
     Fields fields = MultiFields.getFields(ir);
 
     for (String f : fields) {
-      Terms terms = fields.terms(f);
+      FieldTerms terms = fields.terms(f);
       long sumDocFreq = terms.getSumDocFreq();
       if (sumDocFreq == -1) {
         if (VERBOSE) {
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsReader.java b/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsReader.java
index 4b2a06095a65..5b041df19a2a 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsReader.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsReader.java
@@ -199,7 +199,7 @@ public void test() throws IOException {
   public void testReader() throws IOException {
     TermVectorsReader reader = Codec.getDefault().termVectorsFormat().vectorsReader(dir, seg.info, fieldInfos, newIOContext(random()));
     for (int j = 0; j < 5; j++) {
-      Terms vector = reader.get(j).terms(testFields[0]);
+      FieldTerms vector = reader.get(j).terms(testFields[0]);
       assertNotNull(vector);
       assertEquals(testTerms.length, vector.size());
       TermsEnum termsEnum = vector.iterator();
@@ -218,7 +218,7 @@ public void testReader() throws IOException {
   public void testDocsEnum() throws IOException {
     TermVectorsReader reader = Codec.getDefault().termVectorsFormat().vectorsReader(dir, seg.info, fieldInfos, newIOContext(random()));
     for (int j = 0; j < 5; j++) {
-      Terms vector = reader.get(j).terms(testFields[0]);
+      FieldTerms vector = reader.get(j).terms(testFields[0]);
       assertNotNull(vector);
       assertEquals(testTerms.length, vector.size());
       TermsEnum termsEnum = vector.iterator();
@@ -245,7 +245,7 @@ public void testDocsEnum() throws IOException {
   public void testPositionReader() throws IOException {
     TermVectorsReader reader = Codec.getDefault().termVectorsFormat().vectorsReader(dir, seg.info, fieldInfos, newIOContext(random()));
     BytesRef[] terms;
-    Terms vector = reader.get(0).terms(testFields[0]);
+    FieldTerms vector = reader.get(0).terms(testFields[0]);
     assertNotNull(vector);
     assertEquals(testTerms.length, vector.size());
     TermsEnum termsEnum = vector.iterator();
@@ -282,7 +282,7 @@ public void testPositionReader() throws IOException {
       assertEquals(DocIdSetIterator.NO_MORE_DOCS, dpEnum.nextDoc());
     }
 
-    Terms freqVector = reader.get(0).terms(testFields[1]); //no pos, no offset
+    FieldTerms freqVector = reader.get(0).terms(testFields[1]); //no pos, no offset
     assertNotNull(freqVector);
     assertEquals(testTerms.length, freqVector.size());
     termsEnum = freqVector.iterator();
@@ -301,7 +301,7 @@ public void testPositionReader() throws IOException {
 
   public void testOffsetReader() throws IOException {
     TermVectorsReader reader = Codec.getDefault().termVectorsFormat().vectorsReader(dir, seg.info, fieldInfos, newIOContext(random()));
-    Terms vector = reader.get(0).terms(testFields[0]);
+    FieldTerms vector = reader.get(0).terms(testFields[0]);
     assertNotNull(vector);
     TermsEnum termsEnum = vector.iterator();
     assertNotNull(termsEnum);
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsWriter.java b/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsWriter.java
index 11f1503405b7..6e8adaad7821 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsWriter.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsWriter.java
@@ -59,7 +59,7 @@ public void testDoubleOffsetCounting() throws Exception {
     w.close();
 
     IndexReader r = DirectoryReader.open(dir);
-    Terms vector = r.getTermVectors(0).terms("field");
+    FieldTerms vector = r.getTermVectors(0).terms("field");
     assertNotNull(vector);
     TermsEnum termsEnum = vector.iterator();
     assertNotNull(termsEnum.next());
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestTerms.java b/lucene/core/src/test/org/apache/lucene/index/TestTerms.java
index e8871dcb7699..5d7827587db7 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestTerms.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestTerms.java
@@ -34,7 +34,7 @@ public void testTermMinMaxBasic() throws Exception {
     doc.add(newTextField("field", "a b c cc ddd", Field.Store.NO));
     w.addDocument(doc);
     IndexReader r = w.getReader();
-    Terms terms = MultiFields.getTerms(r, "field");
+    FieldTerms terms = MultiFields.getTerms(r, "field");
     assertEquals(new BytesRef("a"), terms.getMin());
     assertEquals(new BytesRef("ddd"), terms.getMax());
     r.close();
@@ -74,7 +74,7 @@ public void testTermMinMaxRandom() throws Exception {
     }
 
     IndexReader r = w.getReader();
-    Terms terms = MultiFields.getTerms(r, "field");
+    FieldTerms terms = MultiFields.getTerms(r, "field");
     assertEquals(minTerm, terms.getMin());
     assertEquals(maxTerm, terms.getMax());
     
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestTermsEnum.java b/lucene/core/src/test/org/apache/lucene/index/TestTermsEnum.java
index d2df59ff4fd8..0c36e4058554 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestTermsEnum.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestTermsEnum.java
@@ -178,7 +178,7 @@ private boolean accepts(CompiledAutomaton c, BytesRef b) {
     return c.runAutomaton.isAccept(state);
   }
 
-  // Tests Terms.intersect
+  // Tests FieldTerms.intersect
   public void testIntersectRandom() throws IOException {
     final Directory dir = newDirectory();
     final RandomIndexWriter w = new RandomIndexWriter(random(), dir);
@@ -511,7 +511,7 @@ public void testZeroTerms() throws Exception {
     w.close();
     assertEquals(1, r.numDocs());
     assertEquals(1, r.maxDoc());
-    Terms terms = MultiFields.getTerms(r, "field");
+    FieldTerms terms = MultiFields.getTerms(r, "field");
     if (terms != null) {
       assertNull(terms.iterator().next());
     }
@@ -738,7 +738,7 @@ public void testIntersectBasic() throws Exception {
     DirectoryReader r = w.getReader();
     w.close();
     LeafReader sub = getOnlyLeafReader(r);
-    Terms terms = sub.fields().terms("field");
+    FieldTerms terms = sub.fields().terms("field");
     Automaton automaton = new RegExp(".*", RegExp.NONE).toAutomaton();
     CompiledAutomaton ca = new CompiledAutomaton(automaton, false, false);    
     TermsEnum te = terms.intersect(ca, null);
@@ -792,7 +792,7 @@ public void testIntersectStartTerm() throws Exception {
     DirectoryReader r = w.getReader();
     w.close();
     LeafReader sub = getOnlyLeafReader(r);
-    Terms terms = sub.fields().terms("field");
+    FieldTerms terms = sub.fields().terms("field");
 
     Automaton automaton = new RegExp(".*d", RegExp.NONE).toAutomaton();
     CompiledAutomaton ca = new CompiledAutomaton(automaton, false, false);    
@@ -846,7 +846,7 @@ public void testIntersectEmptyString() throws Exception {
     DirectoryReader r = w.getReader();
     w.close();
     LeafReader sub = getOnlyLeafReader(r);
-    Terms terms = sub.fields().terms("field");
+    FieldTerms terms = sub.fields().terms("field");
 
     Automaton automaton = new RegExp(".*", RegExp.NONE).toAutomaton();  // accept ALL
     CompiledAutomaton ca = new CompiledAutomaton(automaton, false, false);    
@@ -1009,7 +1009,7 @@ public void testIntersectRegexp() throws Exception {
     IndexReader r = w.getReader();
     Fields fields = MultiFields.getFields(r);
     CompiledAutomaton automaton = new CompiledAutomaton(new RegExp("do_not_match_anything").toAutomaton());
-    Terms terms = fields.terms("field");
+    FieldTerms terms = fields.terms("field");
     String message = expectThrows(IllegalArgumentException.class, () -> {terms.intersect(automaton, null);}).getMessage();
     assertEquals("please use CompiledAutomaton.getTermsEnum instead", message);
     r.close();
diff --git a/lucene/core/src/test/org/apache/lucene/search/TermInSetQueryTest.java b/lucene/core/src/test/org/apache/lucene/search/TermInSetQueryTest.java
index e694d979539d..f0f6bf023000 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TermInSetQueryTest.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TermInSetQueryTest.java
@@ -39,7 +39,7 @@
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause.Occur;
 import org.apache.lucene.store.Directory;
@@ -256,8 +256,8 @@ public TermsCountingLeafReaderWrapper(LeafReader in, AtomicInteger counter) {
       public Fields fields() throws IOException {
         return new FilterFields(in.fields()) {
           @Override
-          public Terms terms(String field) throws IOException {
-            final Terms in = this.in.terms(field);
+          public FieldTerms terms(String field) throws IOException {
+            final FieldTerms in = this.in.terms(field);
             if (in == null) {
               return null;
             }
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java
index d4c865fac010..52160e887fe0 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java
@@ -30,7 +30,7 @@
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.SingleTermsEnum;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.util.BytesRef;
@@ -181,7 +181,7 @@ public void testEquals() {
    */
   public void testRewriteSingleTerm() throws IOException {
     AutomatonQuery aq = new AutomatonQuery(newTerm("bogus"), Automata.makeString("piece"));
-    Terms terms = MultiFields.getTerms(searcher.getIndexReader(), FN);
+    FieldTerms terms = MultiFields.getTerms(searcher.getIndexReader(), FN);
     assertTrue(aq.getTermsEnum(terms) instanceof SingleTermsEnum);
     assertEquals(1, automatonQueryNrHits(aq));
   }
@@ -204,7 +204,7 @@ public void testEmptyOptimization() throws IOException {
     AutomatonQuery aq = new AutomatonQuery(newTerm("bogus"), Automata.makeEmpty());
     // not yet available: assertTrue(aq.getEnum(searcher.getIndexReader())
     // instanceof EmptyTermEnum);
-    Terms terms = MultiFields.getTerms(searcher.getIndexReader(), FN);
+    FieldTerms terms = MultiFields.getTerms(searcher.getIndexReader(), FN);
     assertSame(TermsEnum.EMPTY, aq.getTermsEnum(terms));
     assertEquals(0, automatonQueryNrHits(aq));
   }
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
index 44f8d8bd2c75..62019a0e12f2 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
@@ -28,7 +28,7 @@
 import org.apache.lucene.index.MultiReader;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.util.AttributeSource;
@@ -153,7 +153,7 @@ private void checkBooleanQueryBoosts(BooleanQuery bq) {
   private void checkBoosts(MultiTermQuery.RewriteMethod method) throws Exception {
     final MultiTermQuery mtq = new MultiTermQuery("data") {
       @Override
-      protected TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException {
+      protected TermsEnum getTermsEnum(FieldTerms terms, AttributeSource atts) throws IOException {
         return new FilteredTermsEnum(terms.iterator()) {
 
           final BoostAttribute boostAtt =
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiThreadTermVectors.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiThreadTermVectors.java
index d143bf74baae..f656c9a84ff8 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiThreadTermVectors.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiThreadTermVectors.java
@@ -25,7 +25,7 @@
 import org.apache.lucene.index.Fields;
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexWriter;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.util.English;
@@ -171,7 +171,7 @@ private void testTermVectors() throws Exception {
       verifyVectors(vectors, docId);
       
       start = System.currentTimeMillis();
-      Terms vector = reader.getTermVectors(docId).terms("field");
+      FieldTerms vector = reader.getTermVectors(docId).terms("field");
       timeElapsed += System.currentTimeMillis()-start;
       
       verifyVector(vector.iterator(), docId);
@@ -180,7 +180,7 @@ private void testTermVectors() throws Exception {
   
   private void verifyVectors(Fields vectors, int num) throws IOException {
     for (String field : vectors) {
-      Terms terms = vectors.terms(field);
+      FieldTerms terms = vectors.terms(field);
       assert terms != null;
       verifyVector(terms.iterator(), num);
     }
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java b/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java
index 72fdc7aa689b..040d9a21f20e 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java
@@ -27,7 +27,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.util.AttributeSource;
@@ -84,7 +84,7 @@ private class DumbPrefixQuery extends MultiTermQuery {
     }
     
     @Override
-    protected TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException {
+    protected TermsEnum getTermsEnum(FieldTerms terms, AttributeSource atts) throws IOException {
       return new SimplePrefixTermsEnum(terms.iterator(), prefix);
     }
 
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java b/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java
index a704d5479e1b..cbaa836ca6c6 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java
@@ -31,7 +31,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.util.AttributeSource;
@@ -112,7 +112,7 @@ private class DumbRegexpQuery extends MultiTermQuery {
     }
     
     @Override
-    protected TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException {
+    protected TermsEnum getTermsEnum(FieldTerms terms, AttributeSource atts) throws IOException {
       return new SimpleAutomatonTermsEnum(terms.iterator());
     }
 
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSameScoresWithThreads.java b/lucene/core/src/test/org/apache/lucene/search/TestSameScoresWithThreads.java
index 83a11be8b7a1..756d6a8f7ae3 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestSameScoresWithThreads.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestSameScoresWithThreads.java
@@ -31,7 +31,7 @@
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.util.BytesRef;
@@ -61,7 +61,7 @@ public void test() throws Exception {
     w.close();
 
     final IndexSearcher s = newSearcher(r);
-    Terms terms = MultiFields.getFields(r).terms("body");
+    FieldTerms terms = MultiFields.getFields(r).terms("body");
     int termCount = 0;
     TermsEnum termsEnum = terms.iterator();
     while(termsEnum.next() != null) {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTermQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestTermQuery.java
index a99411898fad..30af3c4589eb 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTermQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTermQuery.java
@@ -32,7 +32,7 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
 import org.apache.lucene.index.TermState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.util.BytesRef;
@@ -121,7 +121,7 @@ public NoSeekLeafReader(LeafReader in) {
     public Fields fields() throws IOException {
       return new FilterFields(super.fields()) {
         @Override
-        public Terms terms(String field) throws IOException {
+        public FieldTerms terms(String field) throws IOException {
           return new FilterTerms(super.terms(field)) {
             @Override
             public TermsEnum iterator() throws IOException {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java b/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
index 4255d7c64812..2efba54a38a0 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
@@ -27,7 +27,7 @@
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 
 import java.io.IOException;
 
@@ -116,7 +116,7 @@ public void testPrefixTerm() throws IOException {
     
     wq = new WildcardQuery(new Term("field", "*"));
     assertMatches(searcher, wq, 2);
-    Terms terms = MultiFields.getTerms(searcher.getIndexReader(), "field");
+    FieldTerms terms = MultiFields.getTerms(searcher.getIndexReader(), "field");
     assertFalse(wq.getTermsEnum(terms).getClass().getSimpleName().contains("AutomatonTermsEnum"));
     reader.close();
     indexStore.close();
diff --git a/lucene/core/src/test/org/apache/lucene/util/TestDocIdSetBuilder.java b/lucene/core/src/test/org/apache/lucene/util/TestDocIdSetBuilder.java
index 625b8c24604a..5cc8552a7c05 100644
--- a/lucene/core/src/test/org/apache/lucene/util/TestDocIdSetBuilder.java
+++ b/lucene/core/src/test/org/apache/lucene/util/TestDocIdSetBuilder.java
@@ -20,7 +20,7 @@
 import java.io.IOException;
 
 import org.apache.lucene.index.PointValues;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSet;
 import org.apache.lucene.search.DocIdSetIterator;
@@ -204,7 +204,7 @@ public void testLeverageStats() throws IOException {
     assertTrue(builder.multivalued);
 
     // single-valued terms
-    Terms terms = new DummyTerms(42, 42);
+    FieldTerms terms = new DummyTerms(42, 42);
     builder = new DocIdSetBuilder(100, terms);
     assertEquals(1d, builder.numValuesPerDoc, 0d);
     assertFalse(builder.multivalued);
@@ -239,7 +239,7 @@ public void testLeverageStats() throws IOException {
     assertTrue(builder.multivalued);
   }
 
-  private static class DummyTerms extends Terms {
+  private static class DummyTerms extends FieldTerms {
 
     private final int docCount;
     private final long numValues;
diff --git a/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java b/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java
index dcce285383b4..0a6a4fa69751 100644
--- a/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java
+++ b/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java
@@ -49,7 +49,7 @@
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.TermQuery;
@@ -337,7 +337,7 @@ public void testRealTerms() throws Exception {
         System.out.println("FST stores docFreq");
       }
     }
-    Terms terms = MultiFields.getTerms(r, "body");
+    FieldTerms terms = MultiFields.getTerms(r, "body");
     if (terms != null) {
       final IntsRefBuilder scratchIntsRef = new IntsRefBuilder();
       final TermsEnum termsEnum = terms.iterator();
diff --git a/lucene/facet/src/java/org/apache/lucene/facet/taxonomy/directory/DirectoryTaxonomyWriter.java b/lucene/facet/src/java/org/apache/lucene/facet/taxonomy/directory/DirectoryTaxonomyWriter.java
index 632d74bff8f1..d6a5e1d19292 100644
--- a/lucene/facet/src/java/org/apache/lucene/facet/taxonomy/directory/DirectoryTaxonomyWriter.java
+++ b/lucene/facet/src/java/org/apache/lucene/facet/taxonomy/directory/DirectoryTaxonomyWriter.java
@@ -54,7 +54,7 @@
 import org.apache.lucene.index.LogByteSizeMergePolicy;
 import org.apache.lucene.index.ReaderManager;
 import org.apache.lucene.index.SegmentInfos;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.index.TieredMergePolicy;
 import org.apache.lucene.store.AlreadyClosedException;
@@ -382,7 +382,7 @@ protected synchronized int findCategory(FacetLabel categoryPath) throws IOExcept
       final BytesRef catTerm = new BytesRef(FacetsConfig.pathToString(categoryPath.components, categoryPath.length));
       PostingsEnum docs = null; // reuse
       for (LeafReaderContext ctx : reader.leaves()) {
-        Terms terms = ctx.reader().terms(Consts.FULL);
+        FieldTerms terms = ctx.reader().terms(Consts.FULL);
         if (terms != null) {
           // TODO: share per-segment TermsEnum here!
           TermsEnum termsEnum = terms.iterator();
@@ -693,7 +693,7 @@ private synchronized void perhapsFillCache() throws IOException {
     try {
       PostingsEnum postingsEnum = null;
       for (LeafReaderContext ctx : reader.leaves()) {
-        Terms terms = ctx.reader().terms(Consts.FULL);
+        FieldTerms terms = ctx.reader().terms(Consts.FULL);
         if (terms != null) { // cannot really happen, but be on the safe side
           // TODO: share per-segment TermsEnum here!
           TermsEnum termsEnum = terms.iterator();
@@ -790,7 +790,7 @@ public void addTaxonomy(Directory taxoDir, OrdinalMap map) throws IOException {
       PostingsEnum docs = null;
       for (final LeafReaderContext ctx : r.leaves()) {
         final LeafReader ar = ctx.reader();
-        final Terms terms = ar.terms(Consts.FULL);
+        final FieldTerms terms = ar.terms(Consts.FULL);
         // TODO: share per-segment TermsEnum here!
         TermsEnum te = terms.iterator();
         while (te.next() != null) {
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TermVectorLeafReader.java b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TermVectorLeafReader.java
index 608e3d47128e..9bb8fc98240b 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TermVectorLeafReader.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TermVectorLeafReader.java
@@ -33,12 +33,12 @@
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.index.SortedSetDocValues;
 import org.apache.lucene.index.StoredFieldVisitor;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.Sort;
 import org.apache.lucene.util.Bits;
 
 /**
- * Wraps a Terms with a {@link org.apache.lucene.index.LeafReader}, typically from term vectors.
+ * Wraps a FieldTerms with a {@link org.apache.lucene.index.LeafReader}, typically from term vectors.
  *
  * @lucene.experimental
  */
@@ -47,7 +47,7 @@ public class TermVectorLeafReader extends LeafReader {
   private final Fields fields;
   private final FieldInfos fieldInfos;
 
-  public TermVectorLeafReader(String field, Terms terms) {
+  public TermVectorLeafReader(String field, FieldTerms terms) {
     fields = new Fields() {
       @Override
       public Iterator iterator() {
@@ -55,7 +55,7 @@ public Iterator iterator() {
       }
 
       @Override
-      public Terms terms(String fld) throws IOException {
+      public FieldTerms terms(String fld) throws IOException {
         if (!field.equals(fld)) {
           return null;
         }
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TokenSources.java b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TokenSources.java
index 2730f40409a8..a0188db4301e 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TokenSources.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TokenSources.java
@@ -27,7 +27,7 @@
 import org.apache.lucene.document.Document;
 import org.apache.lucene.index.Fields;
 import org.apache.lucene.index.IndexReader;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 
 /**
  * Convenience methods for obtaining a {@link TokenStream} for use with the {@link Highlighter} - can obtain from
@@ -50,7 +50,7 @@ private TokenSources() {}
    *                 be re-used for the same document (e.g. when highlighting multiple fields).
    * @param text the text to analyze, failing term vector un-inversion
    * @param analyzer the analyzer to analyze {@code text} with, failing term vector un-inversion
-   * @param maxStartOffset Terms with a startOffset greater than this aren't returned.  Use -1 for no limit.
+   * @param maxStartOffset FieldTerms with a startOffset greater than this aren't returned.  Use -1 for no limit.
    *                       Suggest using {@link Highlighter#getMaxDocCharsToAnalyze()} - 1.
    *
    * @return a token stream from either term vectors, or from analyzing the text. Never null.
@@ -76,7 +76,7 @@ public static TokenStream getTokenStream(String field, Fields tvFields, String t
    * @param field The field to get term vectors from.
    * @param tvFields from {@link IndexReader#getTermVectors(int)}. Possibly null. For performance, this instance should
    *                 be re-used for the same document (e.g. when highlighting multiple fields).
-   * @param maxStartOffset Terms with a startOffset greater than this aren't returned.  Use -1 for no limit.
+   * @param maxStartOffset FieldTerms with a startOffset greater than this aren't returned.  Use -1 for no limit.
    *                       Suggest using {@link Highlighter#getMaxDocCharsToAnalyze()} - 1
    * @return a token stream from term vectors. Null if no term vectors with the right options.
    */
@@ -85,7 +85,7 @@ public static TokenStream getTermVectorTokenStreamOrNull(String field, Fields tv
     if (tvFields == null) {
       return null;
     }
-    final Terms tvTerms = tvFields.terms(field);
+    final FieldTerms tvTerms = tvFields.terms(field);
     if (tvTerms == null || !tvTerms.hasOffsets()) {
       return null;
     }
@@ -118,7 +118,7 @@ public static TokenStream getAnyTokenStream(IndexReader reader, int docId,
 
     Fields vectors = reader.getTermVectors(docId);
     if (vectors != null) {
-      Terms vector = vectors.terms(field);
+      FieldTerms vector = vectors.terms(field);
       if (vector != null) {
         ts = getTokenStream(vector);
       }
@@ -147,7 +147,7 @@ public static TokenStream getAnyTokenStream(IndexReader reader, int docId,
 
     Fields vectors = reader.getTermVectors(docId);
     if (vectors != null) {
-      Terms vector = vectors.terms(field);
+      FieldTerms vector = vectors.terms(field);
       if (vector != null) {
         ts = getTokenStream(vector);
       }
@@ -160,17 +160,17 @@ public static TokenStream getAnyTokenStream(IndexReader reader, int docId,
     return ts;
   }
 
-  /** Simply calls {@link #getTokenStream(org.apache.lucene.index.Terms)} now. */
+  /** Simply calls {@link #getTokenStream(org.apache.lucene.index.FieldTerms)} now. */
   @Deprecated // maintenance reasons LUCENE-6445
-  public static TokenStream getTokenStream(Terms vector,
+  public static TokenStream getTokenStream(FieldTerms vector,
                                            boolean tokenPositionsGuaranteedContiguous) throws IOException {
     return getTokenStream(vector);
   }
 
   /**
-   * Returns a token stream generated from a {@link Terms}. This
+   * Returns a token stream generated from a {@link FieldTerms}. This
    * can be used to feed the highlighter with a pre-parsed token
-   * stream.  The {@link Terms} must have offsets available. If there are no positions available,
+   * stream.  The {@link FieldTerms} must have offsets available. If there are no positions available,
    * all tokens will have position increments reflecting adjacent tokens, or coincident when terms
    * share a start offset. If there are stopwords filtered from the index, you probably want to ensure
    * term vectors have positions so that phrase queries won't match across stopwords.
@@ -178,7 +178,7 @@ public static TokenStream getTokenStream(Terms vector,
    * @throws IllegalArgumentException if no offsets are available
    */
   @Deprecated // maintenance reasons LUCENE-6445
-  public static TokenStream getTokenStream(final Terms tpv) throws IOException {
+  public static TokenStream getTokenStream(final FieldTerms tpv) throws IOException {
 
     if (!tpv.hasOffsets()) {
       throw new IllegalArgumentException("Highlighting requires offsets from the TokenStream.");
@@ -192,7 +192,7 @@ public static TokenStream getTokenStream(final Terms tpv) throws IOException {
   /**
    * Returns a {@link TokenStream} with positions and offsets constructed from
    * field termvectors.  If the field has no termvectors or offsets
-   * are not included in the termvector, return null.  See {@link #getTokenStream(org.apache.lucene.index.Terms)}
+   * are not included in the termvector, return null.  See {@link #getTokenStream(org.apache.lucene.index.FieldTerms)}
    * for an explanation of what happens when positions aren't present.
    *
    * @param reader the {@link IndexReader} to retrieve term vectors from
@@ -201,7 +201,7 @@ public static TokenStream getTokenStream(final Terms tpv) throws IOException {
    * @return a {@link TokenStream}, or null if offsets are not available
    * @throws IOException If there is a low-level I/O error
    *
-   * @see #getTokenStream(org.apache.lucene.index.Terms)
+   * @see #getTokenStream(org.apache.lucene.index.FieldTerms)
    */
   @Deprecated // maintenance reasons LUCENE-6445
   public static TokenStream getTokenStreamWithOffsets(IndexReader reader, int docId,
@@ -212,7 +212,7 @@ public static TokenStream getTokenStreamWithOffsets(IndexReader reader, int docI
       return null;
     }
 
-    Terms vector = vectors.terms(field);
+    FieldTerms vector = vectors.terms(field);
     if (vector == null) {
       return null;
     }
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TokenStreamFromTermVector.java b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TokenStreamFromTermVector.java
index 346ecba013d7..d6862fadcd32 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TokenStreamFromTermVector.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/TokenStreamFromTermVector.java
@@ -25,7 +25,7 @@
 import org.apache.lucene.analysis.tokenattributes.PayloadAttribute;
 import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
 import org.apache.lucene.index.PostingsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.AttributeFactory;
 import org.apache.lucene.util.BytesRef;
@@ -57,7 +57,7 @@ public final class TokenStreamFromTermVector extends TokenStream {
       AttributeFactory.getStaticImplementation(
           AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY, PackedTokenAttributeImpl.class);
 
-  private final Terms vector;
+  private final FieldTerms vector;
 
   private final CharTermAttribute termAttribute;
 
@@ -84,11 +84,11 @@ public final class TokenStreamFromTermVector extends TokenStream {
    * Constructor. The uninversion doesn't happen here; it's delayed till the first call to
    * {@link #incrementToken}.
    *
-   * @param vector Terms that contains the data for
+   * @param vector FieldTerms that contains the data for
    *        creating the TokenStream. Must have positions and/or offsets.
    * @param maxStartOffset if a token's start offset exceeds this then the token is not added. -1 disables the limit.
    */
-  public TokenStreamFromTermVector(Terms vector, int maxStartOffset) throws IOException {
+  public TokenStreamFromTermVector(FieldTerms vector, int maxStartOffset) throws IOException {
     super(ATTRIBUTE_FACTORY);
     this.maxStartOffset = maxStartOffset < 0 ? Integer.MAX_VALUE : maxStartOffset;
     assert !hasAttribute(PayloadAttribute.class) : "AttributeFactory shouldn't have payloads *yet*";
@@ -101,7 +101,7 @@ public TokenStreamFromTermVector(Terms vector, int maxStartOffset) throws IOExce
     positionIncrementAttribute = addAttribute(PositionIncrementAttribute.class);
   }
 
-  public Terms getTermVectorTerms() { return vector; }
+  public FieldTerms getTermVectorTerms() { return vector; }
 
   @Override
   public void reset() throws IOException {
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java
index 0e0093b02e3b..ce9273a0f4b7 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java
@@ -38,7 +38,7 @@
 import org.apache.lucene.index.NumericDocValues;
 import org.apache.lucene.index.SortedDocValues;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.memory.MemoryIndex;
 import org.apache.lucene.queries.CommonTermsQuery;
 import org.apache.lucene.queries.CustomScoreQuery;
@@ -98,7 +98,7 @@ public WeightedSpanTermExtractor(String defaultField) {
    * Fills a Map with {@link WeightedSpanTerm}s using the terms from the supplied Query.
    * 
    * @param query
-   *          Query to extract Terms from
+   *          Query to extract FieldTerms from
    * @param terms
    *          Map to place created WeightedSpanTerms in
    * @throws IOException If there is a low-level I/O error
@@ -263,7 +263,7 @@ protected void extractUnknownQuery(Query query,
    * @param terms
    *          Map to place created WeightedSpanTerms in
    * @param spanQuery
-   *          SpanQuery to extract Terms from
+   *          SpanQuery to extract FieldTerms from
    * @throws IOException If there is a low-level I/O error
    */
   protected void extractWeightedSpanTerms(Map terms, SpanQuery spanQuery, float boost) throws IOException {
@@ -355,7 +355,7 @@ protected void extractWeightedSpanTerms(Map terms, Span
    * @param terms
    *          Map to place created WeightedSpanTerms in
    * @param query
-   *          Query to extract Terms from
+   *          Query to extract FieldTerms from
    * @throws IOException If there is a low-level I/O error
    */
   protected void extractWeightedTerms(Map terms, Query query, float boost) throws IOException {
@@ -385,10 +385,10 @@ protected LeafReaderContext getLeafContext() throws IOException {
     if (internalReader == null) {
       boolean cacheIt = wrapToCaching && !(tokenStream instanceof CachingTokenFilter);
 
-      // If it's from term vectors, simply wrap the underlying Terms in a reader
+      // If it's from term vectors, simply wrap the underlying FieldTerms in a reader
       if (tokenStream instanceof TokenStreamFromTermVector) {
         cacheIt = false;
-        Terms termVectorTerms = ((TokenStreamFromTermVector) tokenStream).getTermVectorTerms();
+        FieldTerms termVectorTerms = ((TokenStreamFromTermVector) tokenStream).getTermVectorTerms();
         if (termVectorTerms.hasPositions() && termVectorTerms.hasOffsets()) {
           internalReader = new TermVectorLeafReader(DelegatingLeafReader.FIELD_NAME, termVectorTerms);
         }
@@ -439,7 +439,7 @@ public FieldInfos getFieldInfos() {
     public Fields fields() throws IOException {
       return new FilterFields(super.fields()) {
         @Override
-        public Terms terms(String field) throws IOException {
+        public FieldTerms terms(String field) throws IOException {
           return super.terms(DelegatingLeafReader.FIELD_NAME);
         }
 
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/postingshighlight/PostingsHighlighter.java b/lucene/highlighter/src/java/org/apache/lucene/search/postingshighlight/PostingsHighlighter.java
index e4d366793aa3..8729f27d2817 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/postingshighlight/PostingsHighlighter.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/postingshighlight/PostingsHighlighter.java
@@ -42,7 +42,7 @@
 import org.apache.lucene.index.ReaderUtil;
 import org.apache.lucene.index.StoredFieldVisitor;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
@@ -503,7 +503,7 @@ private Map highlightField(String field, String contents[], Brea
       
       // if the segment has changed, we must initialize new enums.
       if (leaf != lastLeaf) {
-        Terms t = r.terms(field);
+        FieldTerms t = r.terms(field);
         if (t != null) {
           if (!t.hasOffsets()) {
             // no offsets available
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/FieldOffsetStrategy.java b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/FieldOffsetStrategy.java
index 155f0a76fb97..9870d37fdbab 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/FieldOffsetStrategy.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/FieldOffsetStrategy.java
@@ -25,7 +25,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.PostingsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.spans.Spans;
 import org.apache.lucene.util.BytesRef;
@@ -65,7 +65,7 @@ public String getField() {
   public abstract List getOffsetsEnums(IndexReader reader, int docId, String content) throws IOException;
 
   protected List createOffsetsEnumsFromReader(LeafReader leafReader, int doc) throws IOException {
-    final Terms termsIndex = leafReader.terms(field);
+    final FieldTerms termsIndex = leafReader.terms(field);
     if (termsIndex == null) {
       return Collections.emptyList();
     }
@@ -110,7 +110,7 @@ protected List createOffsetsEnumsFromReader(LeafReader leafReader,
     return offsetsEnums;
   }
 
-  protected List createAutomataOffsetsFromTerms(Terms termsIndex, int doc) throws IOException {
+  protected List createAutomataOffsetsFromTerms(FieldTerms termsIndex, int doc) throws IOException {
     List> automataPostings = new ArrayList<>(automata.length);
     for (int i = 0; i < automata.length; i++) {
       automataPostings.add(new ArrayList<>());
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/PhraseHelper.java b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/PhraseHelper.java
index d7e8671c4c2e..77adc8b92e8b 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/PhraseHelper.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/PhraseHelper.java
@@ -44,7 +44,7 @@
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.SortedDocValues;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.MatchAllDocsQuery;
@@ -122,7 +122,7 @@ public PhraseHelper(Query query, String field, Predicate fieldMatcher, F
 
     boolean[] mustRewriteHolder = {false}; // boolean wrapped in 1-ary array so it's mutable from inner class
 
-    // For TermQueries or other position insensitive queries, collect the Terms.
+    // For TermQueries or other position insensitive queries, collect the FieldTerms.
     // For other Query types, WSTE will convert to an equivalent SpanQuery.  NOT extracting position spans here.
     new WeightedSpanTermExtractor(field) {
       //anonymous constructor
@@ -407,7 +407,7 @@ public int endOffset() throws IOException {
   }
 
   /**
-   * Simple TreeSet that filters out Terms not matching the provided predicate on {@code add()}.
+   * Simple TreeSet that filters out FieldTerms not matching the provided predicate on {@code add()}.
    */
   private class FieldFilteringTermSet extends TreeSet {
     @Override
@@ -549,7 +549,7 @@ public FieldInfos getFieldInfos() {
     public Fields fields() throws IOException {
       return new FilterFields(super.fields()) {
         @Override
-        public Terms terms(String field) throws IOException {
+        public FieldTerms terms(String field) throws IOException {
           return super.terms(fieldName);
         }
 
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/PostingsWithTermVectorsOffsetStrategy.java b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/PostingsWithTermVectorsOffsetStrategy.java
index b9086a7400ab..b27e63c6a5f4 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/PostingsWithTermVectorsOffsetStrategy.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/PostingsWithTermVectorsOffsetStrategy.java
@@ -24,7 +24,7 @@
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.ReaderUtil;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.automaton.CharacterRunAutomaton;
 
@@ -51,7 +51,7 @@ public List getOffsetsEnums(IndexReader reader, int docId, String c
       docId -= LeafReaderContext.docBase; // adjust 'doc' to be within this atomic reader
     }
 
-    Terms docTerms = leafReader.getTermVector(docId, field);
+    FieldTerms docTerms = leafReader.getTermVector(docId, field);
     if (docTerms == null) {
       return Collections.emptyList();
     }
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/TermVectorFilteredLeafReader.java b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/TermVectorFilteredLeafReader.java
index 954024cbe066..84561331a8f6 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/TermVectorFilteredLeafReader.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/TermVectorFilteredLeafReader.java
@@ -22,7 +22,7 @@
 import org.apache.lucene.index.FilterLeafReader;
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.PostingsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.automaton.CompiledAutomaton;
@@ -37,7 +37,7 @@
 final class TermVectorFilteredLeafReader extends FilterLeafReader {
   // NOTE: super ("in") is baseLeafReader
 
-  private final Terms filterTerms;
+  private final FieldTerms filterTerms;
 
   /**
    * 
      Construct a FilterLeafReader based on the specified base reader.
@@ -46,7 +46,7 @@ final class TermVectorFilteredLeafReader extends FilterLeafReader {
    * @param baseLeafReader full/original reader.
    * @param filterTerms set of terms to filter by -- probably from a TermVector or MemoryIndex.
    */
-  TermVectorFilteredLeafReader(LeafReader baseLeafReader, Terms filterTerms) {
+  TermVectorFilteredLeafReader(LeafReader baseLeafReader, FieldTerms filterTerms) {
     super(baseLeafReader);
     this.filterTerms = filterTerms;
   }
@@ -59,15 +59,15 @@ public Fields fields() throws IOException {
   private static final class TermVectorFilteredFields extends FilterLeafReader.FilterFields {
     // NOTE: super ("in") is baseFields
 
-    private final Terms filterTerms;
+    private final FieldTerms filterTerms;
 
-    TermVectorFilteredFields(Fields baseFields, Terms filterTerms) {
+    TermVectorFilteredFields(Fields baseFields, FieldTerms filterTerms) {
       super(baseFields);
       this.filterTerms = filterTerms;
     }
 
     @Override
-    public Terms terms(String field) throws IOException {
+    public FieldTerms terms(String field) throws IOException {
       return new TermsFilteredTerms(in.terms(field), filterTerms);
     }
   }
@@ -75,9 +75,9 @@ public Terms terms(String field) throws IOException {
   private static final class TermsFilteredTerms extends FilterLeafReader.FilterTerms {
     // NOTE: super ("in") is the baseTerms
 
-    private final Terms filterTerms;
+    private final FieldTerms filterTerms;
 
-    TermsFilteredTerms(Terms baseTerms, Terms filterTerms) {
+    TermsFilteredTerms(FieldTerms baseTerms, FieldTerms filterTerms) {
       super(baseTerms);
       this.filterTerms = filterTerms;
     }
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/TermVectorOffsetStrategy.java b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/TermVectorOffsetStrategy.java
index f6eedc417661..763afe5a0a37 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/TermVectorOffsetStrategy.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/TermVectorOffsetStrategy.java
@@ -22,7 +22,7 @@
 
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.LeafReader;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.highlight.TermVectorLeafReader;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.automaton.CharacterRunAutomaton;
@@ -45,7 +45,7 @@ public UnifiedHighlighter.OffsetSource getOffsetSource() {
 
   @Override
   public List getOffsetsEnums(IndexReader reader, int docId, String content) throws IOException {
-    Terms tvTerms = reader.getTermVector(docId, field);
+    FieldTerms tvTerms = reader.getTermVector(docId, field);
     if (tvTerms == null) {
       return Collections.emptyList();
     }
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldTermStack.java b/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldTermStack.java
index f67ba8044344..d000b258241d 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldTermStack.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldTermStack.java
@@ -25,7 +25,7 @@
 import org.apache.lucene.index.Fields;
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.CharsRefBuilder;
@@ -84,7 +84,7 @@ public FieldTermStack( IndexReader reader, int docId, String fieldName, final Fi
       return;
     }
 
-    final Terms vector = vectors.terms(fieldName);
+    final FieldTerms vector = vectors.terms(fieldName);
     if (vector == null || vector.hasPositions() == false) {
       // null snippet
       return;
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/package-info.java b/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/package-info.java
index 39d0f5d5441d..e69bf895d851 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/package-info.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/package-info.java
@@ -168,7 +168,7 @@
  * 
  *   query = das alte testament (The Old Testament)
  * 
- * Terms in fragmentsum-of-distinct-weightssum-of-boosts
+ * FieldTerms in fragmentsum-of-distinct-weightssum-of-boosts
  * das alte testament5.3396213.0
  * das alte testament5.3396213.0
  * das testament alte5.3396213.0
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java b/lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java
index 28d3044788cd..48916b6eeb92 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java
@@ -25,7 +25,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.Explanation;
@@ -113,7 +113,7 @@ public void extractTerms(Set terms) {}
 
       @Override
       public Explanation explain(LeafReaderContext context, int doc) throws IOException {
-        Terms terms = context.reader().terms(field);
+        FieldTerms terms = context.reader().terms(field);
         if (terms != null) {
           TermsEnum segmentTermsEnum = terms.iterator();
           BytesRef spare = new BytesRef();
@@ -133,7 +133,7 @@ public Explanation explain(LeafReaderContext context, int doc) throws IOExceptio
 
       @Override
       public Scorer scorer(LeafReaderContext context) throws IOException {
-        Terms terms = context.reader().terms(field);
+        FieldTerms terms = context.reader().terms(field);
         if (terms == null) {
           return null;
         }
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java b/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java
index 63561c39e3ba..ee3a2953cb80 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java
@@ -17,7 +17,7 @@
 package org.apache.lucene.search.join;
 
 import org.apache.lucene.index.FilteredTermsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.Query;
@@ -51,7 +51,7 @@ class TermsQuery extends MultiTermQuery {
   }
 
   @Override
-  protected TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException {
+  protected TermsEnum getTermsEnum(FieldTerms terms, AttributeSource atts) throws IOException {
     if (this.terms.size() == 0) {
       return TermsEnum.EMPTY;
     }
diff --git a/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java b/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java
index 6e20f232a2bd..b155b1cf3936 100644
--- a/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java
+++ b/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java
@@ -64,7 +64,7 @@
 import org.apache.lucene.index.SortedDocValues;
 import org.apache.lucene.index.SortedSetDocValues;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
@@ -1261,7 +1261,7 @@ public boolean needsScores() {
 
       final Map docToJoinScore = new HashMap<>();
       if (multipleValuesPerDocument) {
-        Terms terms = MultiFields.getTerms(topLevelReader, toField);
+        FieldTerms terms = MultiFields.getTerms(topLevelReader, toField);
         if (terms != null) {
           PostingsEnum postingsEnum = null;
           SortedSet joinValues = new TreeSet<>();
diff --git a/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java b/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
index 218d26c87c12..f4323acddba9 100644
--- a/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
+++ b/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
@@ -835,11 +835,11 @@ private final class Info {
      * Term strings and their positions for this field: Map <String
      * termText, ArrayIntList positions>
      */
-    private BytesRefHash terms; // note unfortunate variable name class with Terms type
+    private BytesRefHash terms; // note unfortunate variable name class with FieldTerms type
     
     private SliceByteStartArray sliceArray;
 
-    /** Terms sorted ascending by term text; computed on demand */
+    /** FieldTerms sorted ascending by term text; computed on demand */
     private transient int[] sortedTerms;
     
     /** Number of added tokens for this field */
@@ -1230,13 +1230,13 @@ public Iterator iterator() {
       }
 
       @Override
-      public Terms terms(final String field) {
+      public FieldTerms terms(final String field) {
         final Info info = fields.get(field);
         if (info == null || info.numTokens <= 0) {
           return null;
         }
 
-        return new Terms() {
+        return new FieldTerms() {
           @Override
           public TermsEnum iterator() {
             return new MemoryTermsEnum(info);
diff --git a/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstRAMDir.java b/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstRAMDir.java
index 03c17a502139..7d197e189053 100644
--- a/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstRAMDir.java
+++ b/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstRAMDir.java
@@ -173,8 +173,8 @@ private void duellReaders(CompositeReader other, LeafReader memIndexReader)
       throws IOException {
     Fields memFields = memIndexReader.fields();
     for (String field : MultiFields.getFields(other)) {
-      Terms memTerms = memFields.terms(field);
-      Terms iwTerms = memIndexReader.terms(field);
+      FieldTerms memTerms = memFields.terms(field);
+      FieldTerms iwTerms = memIndexReader.terms(field);
       if (iwTerms == null) {
         assertNull(memTerms);
       } else {
@@ -690,10 +690,10 @@ public void testDuelMemoryIndexCoreDirectoryWithArrayField() throws Exception {
     memIndex.addField(field_name, "foo bar foo bar foo", mockAnalyzer);
 
     //compare term vectors
-    Terms ramTv = reader.getTermVector(0, field_name);
+    FieldTerms ramTv = reader.getTermVector(0, field_name);
     IndexReader memIndexReader = memIndex.createSearcher().getIndexReader();
     TestUtil.checkReader(memIndexReader);
-    Terms memTv = memIndexReader.getTermVector(0, field_name);
+    FieldTerms memTv = memIndexReader.getTermVector(0, field_name);
 
     compareTermVectors(ramTv, memTv, field_name);
     memIndexReader.close();
@@ -702,7 +702,7 @@ public void testDuelMemoryIndexCoreDirectoryWithArrayField() throws Exception {
 
   }
 
-  protected void compareTermVectors(Terms terms, Terms memTerms, String field_name) throws IOException {
+  protected void compareTermVectors(FieldTerms terms, FieldTerms memTerms, String field_name) throws IOException {
 
     TermsEnum termEnum = terms.iterator();
     TermsEnum memTermEnum = memTerms.iterator();
diff --git a/lucene/misc/src/java/org/apache/lucene/misc/HighFreqTerms.java b/lucene/misc/src/java/org/apache/lucene/misc/HighFreqTerms.java
index 01a2d9dcef36..7d422f8ccb44 100644
--- a/lucene/misc/src/java/org/apache/lucene/misc/HighFreqTerms.java
+++ b/lucene/misc/src/java/org/apache/lucene/misc/HighFreqTerms.java
@@ -21,7 +21,7 @@
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.Fields;
 import org.apache.lucene.index.TermsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.FSDirectory;
 import org.apache.lucene.util.PriorityQueue;
@@ -98,7 +98,7 @@ public static TermStats[] getHighFreqTerms(IndexReader reader, int numTerms, Str
     TermStatsQueue tiq = null;
     
     if (field != null) {
-      Terms terms = MultiFields.getTerms(reader, field);
+      FieldTerms terms = MultiFields.getTerms(reader, field);
       if (terms == null) {
         throw new RuntimeException("field " + field + " not found");
       }
@@ -113,7 +113,7 @@ public static TermStats[] getHighFreqTerms(IndexReader reader, int numTerms, Str
       }
       tiq = new TermStatsQueue(numTerms, comparator);
       for (String fieldName : fields) {
-        Terms terms = fields.terms(fieldName);
+        FieldTerms terms = fields.terms(fieldName);
         if (terms != null) {
           tiq.fill(fieldName, terms.iterator());
         }
diff --git a/lucene/queries/src/java/org/apache/lucene/queries/CommonTermsQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/CommonTermsQuery.java
index 857f4d3fdbcc..7ce8575a294c 100644
--- a/lucene/queries/src/java/org/apache/lucene/queries/CommonTermsQuery.java
+++ b/lucene/queries/src/java/org/apache/lucene/queries/CommonTermsQuery.java
@@ -27,7 +27,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause.Occur;
 import org.apache.lucene.search.BooleanQuery;
@@ -218,7 +218,7 @@ public void collectTermContext(IndexReader reader,
       for (int i = 0; i < queryTerms.length; i++) {
         Term term = queryTerms[i];
         TermContext termContext = contextArray[i];
-        final Terms terms = fields.terms(term.field());
+        final FieldTerms terms = fields.terms(term.field());
         if (terms == null) {
           // field does not exist
           continue;
diff --git a/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/JoinDocFreqValueSource.java b/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/JoinDocFreqValueSource.java
index db936ba655c6..6391d3432265 100644
--- a/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/JoinDocFreqValueSource.java
+++ b/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/JoinDocFreqValueSource.java
@@ -25,7 +25,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.ReaderUtil;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.queries.function.FunctionValues;
 import org.apache.lucene.queries.function.docvalues.IntDocValues;
@@ -57,7 +57,7 @@ public FunctionValues getValues(Map context, LeafReaderContext readerContext) th
   {
     final BinaryDocValues terms = DocValues.getBinary(readerContext.reader(), field);
     final IndexReader top = ReaderUtil.getTopLevelContext(readerContext).reader();
-    Terms t = MultiFields.getTerms(top, qfield);
+    FieldTerms t = MultiFields.getTerms(top, qfield);
     final TermsEnum termsEnum = t == null ? TermsEnum.EMPTY : t.iterator();
     
     return new IntDocValues(this) {
diff --git a/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/SumTotalTermFreqValueSource.java b/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/SumTotalTermFreqValueSource.java
index 746ad8e9d186..542a554c0854 100644
--- a/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/SumTotalTermFreqValueSource.java
+++ b/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/SumTotalTermFreqValueSource.java
@@ -17,7 +17,7 @@
 package org.apache.lucene.queries.function.valuesource;
 
 import org.apache.lucene.index.LeafReaderContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.queries.function.FunctionValues;
 import org.apache.lucene.queries.function.ValueSource;
 import org.apache.lucene.queries.function.docvalues.LongDocValues;
@@ -58,7 +58,7 @@ public FunctionValues getValues(Map context, LeafReaderContext readerContext) th
   public void createWeight(Map context, IndexSearcher searcher) throws IOException {
     long sumTotalTermFreq = 0;
     for (LeafReaderContext readerContext : searcher.getTopReaderContext().leaves()) {
-      Terms terms = readerContext.reader().terms(indexedField);
+      FieldTerms terms = readerContext.reader().terms(indexedField);
       if (terms == null) continue;
       long v = terms.getSumTotalTermFreq();
       if (v == -1) {
diff --git a/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/TFValueSource.java b/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/TFValueSource.java
index f0e252c6980b..3ac05d811dc2 100644
--- a/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/TFValueSource.java
+++ b/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/TFValueSource.java
@@ -22,7 +22,7 @@
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.Fields;
 import org.apache.lucene.index.LeafReaderContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.queries.function.FunctionValues;
 import org.apache.lucene.queries.function.docvalues.FloatDocValues;
@@ -51,7 +51,7 @@ public String name() {
   @Override
   public FunctionValues getValues(Map context, LeafReaderContext readerContext) throws IOException {
     Fields fields = readerContext.reader().fields();
-    final Terms terms = fields.terms(indexedField);
+    final FieldTerms terms = fields.terms(indexedField);
     IndexSearcher searcher = (IndexSearcher)context.get("searcher");
     final TFIDFSimilarity similarity = IDFValueSource.asTFIDF(searcher.getSimilarity(true), indexedField);
     if (similarity == null) {
diff --git a/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/TermFreqValueSource.java b/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/TermFreqValueSource.java
index 789e3e9e6e3a..2081c73173c1 100644
--- a/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/TermFreqValueSource.java
+++ b/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/TermFreqValueSource.java
@@ -22,7 +22,7 @@
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.Fields;
 import org.apache.lucene.index.LeafReaderContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.queries.function.FunctionValues;
 import org.apache.lucene.queries.function.docvalues.IntDocValues;
@@ -49,7 +49,7 @@ public String name() {
   @Override
   public FunctionValues getValues(Map context, LeafReaderContext readerContext) throws IOException {
     Fields fields = readerContext.reader().fields();
-    final Terms terms = fields.terms(indexedField);
+    final FieldTerms terms = fields.terms(indexedField);
 
     return new IntDocValues(this) {
       PostingsEnum docs ;
diff --git a/lucene/queries/src/java/org/apache/lucene/queries/mlt/MoreLikeThis.java b/lucene/queries/src/java/org/apache/lucene/queries/mlt/MoreLikeThis.java
index ea02af3f8f43..fd5d20e85e8c 100644
--- a/lucene/queries/src/java/org/apache/lucene/queries/mlt/MoreLikeThis.java
+++ b/lucene/queries/src/java/org/apache/lucene/queries/mlt/MoreLikeThis.java
@@ -34,7 +34,7 @@
 import org.apache.lucene.index.IndexableField;
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
@@ -731,7 +731,7 @@ private PriorityQueue retrieveTerms(int docNum) throws IOException {
     Map> field2termFreqMap = new HashMap<>();
     for (String fieldName : fieldNames) {
       final Fields vectors = ir.getTermVectors(docNum);
-      final Terms vector;
+      final FieldTerms vector;
       if (vectors != null) {
         vector = vectors.terms(fieldName);
       } else {
@@ -781,7 +781,7 @@ private PriorityQueue retrieveTerms(Map> f
    * @param field2termFreqMap a Map of terms and their frequencies per field
    * @param vector List of terms and their frequencies for a doc/field
    */
-  private void addTermFrequencies(Map> field2termFreqMap, Terms vector, String fieldName) throws IOException {
+  private void addTermFrequencies(Map> field2termFreqMap, FieldTerms vector, String fieldName) throws IOException {
     Map termFreqMap = field2termFreqMap.get(fieldName);
     if (termFreqMap == null) {
       termFreqMap = new HashMap<>();
diff --git a/lucene/queries/src/java/org/apache/lucene/queries/payloads/SpanPayloadCheckQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/payloads/SpanPayloadCheckQuery.java
index 57ba678e34d9..db69bbe96d60 100644
--- a/lucene/queries/src/java/org/apache/lucene/queries/payloads/SpanPayloadCheckQuery.java
+++ b/lucene/queries/src/java/org/apache/lucene/queries/payloads/SpanPayloadCheckQuery.java
@@ -24,7 +24,7 @@
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.similarities.Similarity;
 import org.apache.lucene.search.spans.FilterSpans;
@@ -105,7 +105,7 @@ public SpanScorer scorer(LeafReaderContext context) throws IOException {
       if (field == null)
         return null;
 
-      Terms terms = context.reader().terms(field);
+      FieldTerms terms = context.reader().terms(field);
       if (terms != null && terms.hasPositions() == false) {
         throw new IllegalStateException("field \"" + field + "\" was indexed without position data; cannot run SpanQuery (query=" + parentQuery + ")");
       }
diff --git a/lucene/queries/src/test/org/apache/lucene/queries/CommonTermsQueryTest.java b/lucene/queries/src/test/org/apache/lucene/queries/CommonTermsQueryTest.java
index 716e2fb19aa7..49351d6b8c97 100644
--- a/lucene/queries/src/test/org/apache/lucene/queries/CommonTermsQueryTest.java
+++ b/lucene/queries/src/test/org/apache/lucene/queries/CommonTermsQueryTest.java
@@ -34,7 +34,7 @@
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause.Occur;
 import org.apache.lucene.search.BooleanClause;
@@ -402,7 +402,7 @@ public void testRandomIndex() throws IOException {
     DirectoryReader reader = w.getReader();
     LeafReader wrapper = getOnlyLeafReader(reader);
     String field = "body";
-    Terms terms = wrapper.terms(field);
+    FieldTerms terms = wrapper.terms(field);
     PriorityQueue lowFreqQueue = new PriorityQueue(
         5) {
       
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndPrefixQuery.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndPrefixQuery.java
index 587c4fbe1cf7..eedf0f1d0fd8 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndPrefixQuery.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndPrefixQuery.java
@@ -16,7 +16,7 @@
  */
 package org.apache.lucene.queryparser.surround.query;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.StringHelper;
 import org.apache.lucene.index.TermsEnum;
@@ -61,7 +61,7 @@ public void visitMatchingTerms(
     MatchingTermVisitor mtv) throws IOException
   {
     /* inspired by PrefixQuery.rewrite(): */
-    Terms terms = MultiFields.getTerms(reader, fieldName);
+    FieldTerms terms = MultiFields.getTerms(reader, fieldName);
     if (terms != null) {
       TermsEnum termsEnum = terms.iterator();
 
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndTermQuery.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndTermQuery.java
index ffa8c783890e..1edf5f3df29d 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndTermQuery.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndTermQuery.java
@@ -20,7 +20,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.util.BytesRef;
 
@@ -51,7 +51,7 @@ public void visitMatchingTerms(
     MatchingTermVisitor mtv) throws IOException
   {
     /* check term presence in index here for symmetry with other SimpleTerm's */
-    Terms terms = MultiFields.getTerms(reader, fieldName);
+    FieldTerms terms = MultiFields.getTerms(reader, fieldName);
     if (terms != null) {
       TermsEnum termsEnum = terms.iterator();
 
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndTruncQuery.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndTruncQuery.java
index b98792156736..fe7abb94276e 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndTruncQuery.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SrndTruncQuery.java
@@ -17,7 +17,7 @@
 package org.apache.lucene.queryparser.surround.query;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.StringHelper;
 import org.apache.lucene.index.IndexReader;
@@ -91,7 +91,7 @@ public void visitMatchingTerms(
     MatchingTermVisitor mtv) throws IOException
   {
     int prefixLength = prefix.length();
-    Terms terms = MultiFields.getTerms(reader, fieldName);
+    FieldTerms terms = MultiFields.getTerms(reader, fieldName);
     if (terms != null) {
       Matcher matcher = pattern.matcher("");
       try {
diff --git a/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionBlockTreeTermsReader.java b/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionBlockTreeTermsReader.java
index 167bb4808e4b..a4b15d4b2a28 100644
--- a/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionBlockTreeTermsReader.java
+++ b/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionBlockTreeTermsReader.java
@@ -31,7 +31,7 @@
 import org.apache.lucene.index.FieldInfo;
 import org.apache.lucene.index.IndexFileNames;
 import org.apache.lucene.index.SegmentReadState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.store.IndexInput;
 import org.apache.lucene.util.Accountable;
 import org.apache.lucene.util.Accountables;
@@ -196,7 +196,7 @@ public Iterator iterator() {
   }
 
   @Override
-  public Terms terms(String field) throws IOException {
+  public FieldTerms terms(String field) throws IOException {
     assert field != null;
     return fields.get(field);
   }
diff --git a/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionBlockTreeTermsWriter.java b/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionBlockTreeTermsWriter.java
index d83b9155e5b8..67986e99abbf 100644
--- a/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionBlockTreeTermsWriter.java
+++ b/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionBlockTreeTermsWriter.java
@@ -31,7 +31,7 @@
 import org.apache.lucene.index.IndexFileNames;
 import org.apache.lucene.index.IndexOptions;
 import org.apache.lucene.index.SegmentWriteState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.IndexOutput;
 import org.apache.lucene.store.RAMOutputStream;
@@ -227,7 +227,7 @@ public void write(Fields fields) throws IOException {
       assert lastField == null || lastField.compareTo(field) < 0;
       lastField = field;
 
-      Terms terms = fields.terms(field);
+      FieldTerms terms = fields.terms(field);
       if (terms == null) {
         continue;
       }
diff --git a/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionFieldReader.java b/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionFieldReader.java
index 581201f9ea4c..44068bf96974 100644
--- a/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionFieldReader.java
+++ b/lucene/sandbox/src/java/org/apache/lucene/codecs/idversion/VersionFieldReader.java
@@ -22,7 +22,7 @@
 
 import org.apache.lucene.index.FieldInfo;
 import org.apache.lucene.index.IndexOptions;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.ByteArrayDataInput;
 import org.apache.lucene.store.IndexInput;
@@ -32,9 +32,9 @@
 import org.apache.lucene.util.fst.FST;
 import org.apache.lucene.util.fst.PairOutputs.Pair;
 
-/** BlockTree's implementation of {@link Terms}. */
+/** BlockTree's implementation of {@link FieldTerms}. */
 // public for CheckIndex:
-final class VersionFieldReader extends Terms implements Accountable {
+final class VersionFieldReader extends FieldTerms implements Accountable {
   final long numTerms;
   final FieldInfo fieldInfo;
   final long sumTotalTermFreq;
diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/queries/FuzzyLikeThisQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/queries/FuzzyLikeThisQuery.java
index 8bd7b894afa3..c8ff994fa56a 100644
--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/queries/FuzzyLikeThisQuery.java
+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/queries/FuzzyLikeThisQuery.java
@@ -31,7 +31,7 @@
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
@@ -188,7 +188,7 @@ public void addTerms(String queryString, String fieldName,float minSimilarity, i
 
   private void addTerms(IndexReader reader, FieldVals f, ScoreTermQueue q) throws IOException {
     if (f.queryString == null) return;
-    final Terms terms = MultiFields.getTerms(reader, f.fieldName);
+    final FieldTerms terms = MultiFields.getTerms(reader, f.fieldName);
     if (terms == null) {
       return;
     }
@@ -259,7 +259,7 @@ private Query newTermQuery(IndexReader reader, Term term) throws IOException {
       // equal to 1
       TermContext context = new TermContext(reader.getContext());
       for (LeafReaderContext leafContext : reader.leaves()) {
-        Terms terms = leafContext.reader().terms(term.field());
+        FieldTerms terms = leafContext.reader().terms(term.field());
         if (terms != null) {
           TermsEnum termsEnum = terms.iterator();
           if (termsEnum.seekExact(term.bytes())) {
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/DocValuesTermsQuery.java b/lucene/sandbox/src/java/org/apache/lucene/search/DocValuesTermsQuery.java
index 6e30baed9cd4..c1ccf553d2a4 100644
--- a/lucene/sandbox/src/java/org/apache/lucene/search/DocValuesTermsQuery.java
+++ b/lucene/sandbox/src/java/org/apache/lucene/search/DocValuesTermsQuery.java
@@ -52,7 +52,7 @@
  *
  * 
      
  * With each search, this query translates the specified
- * set of Terms into a private {@link LongBitSet} keyed by
+ * set of FieldTerms into a private {@link LongBitSet} keyed by
  * term number per unique {@link IndexReader} (normally one
  * reader per segment).  Then, during matching, the term
  * number for each docID is retrieved from the cache and
@@ -79,9 +79,9 @@
  * 
      
  * Generally, this filter will be slower on the first
  * invocation for a given field, but subsequent invocations,
- * even if you change the allowed set of Terms, should be
+ * even if you change the allowed set of FieldTerms, should be
  * faster than TermsQuery, especially as the number of
- * Terms being matched increases.  If you are matching only
+ * FieldTerms being matched increases.  If you are matching only
  * a very small number of terms, and those terms in turn
  * match a very small number of documents, TermsQuery may
  * perform faster.
diff --git a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/prefix/AbstractPrefixTreeQuery.java b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/prefix/AbstractPrefixTreeQuery.java
index dbe643e4b995..4ef87d61f79e 100644
--- a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/prefix/AbstractPrefixTreeQuery.java
+++ b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/prefix/AbstractPrefixTreeQuery.java
@@ -21,7 +21,7 @@
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.PostingsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.ConstantScoreScorer;
 import org.apache.lucene.search.ConstantScoreWeight;
@@ -103,7 +103,7 @@ public abstract class BaseTermsEnumTraverser {//TODO rename to LeafTermsEnumTrav
     protected final LeafReaderContext context;
     protected final int maxDoc;
 
-    protected final Terms terms; // maybe null
+    protected final FieldTerms terms; // maybe null
     protected final TermsEnum termsEnum;//remember to check for null!
     protected PostingsEnum postingsEnum;
 
diff --git a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/util/ShapeFieldCacheProvider.java b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/util/ShapeFieldCacheProvider.java
index bca73ccf4dc1..afe9336818aa 100644
--- a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/util/ShapeFieldCacheProvider.java
+++ b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/util/ShapeFieldCacheProvider.java
@@ -61,7 +61,7 @@ public synchronized ShapeFieldCache getCache(LeafReader reader) throws IOExce
     idx = new ShapeFieldCache<>(reader.maxDoc(),defaultSize);
     int count = 0;
     PostingsEnum docs = null;
-    Terms terms = reader.terms(shapeField);
+    FieldTerms terms = reader.terms(shapeField);
     if (terms != null) {
       TermsEnum te = terms.iterator();
       BytesRef term = te.next();
diff --git a/lucene/spatial/src/java/org/apache/lucene/spatial/geopoint/search/GeoPointMultiTermQuery.java b/lucene/spatial/src/java/org/apache/lucene/spatial/geopoint/search/GeoPointMultiTermQuery.java
index 511720606838..4ab328629691 100644
--- a/lucene/spatial/src/java/org/apache/lucene/spatial/geopoint/search/GeoPointMultiTermQuery.java
+++ b/lucene/spatial/src/java/org/apache/lucene/spatial/geopoint/search/GeoPointMultiTermQuery.java
@@ -20,7 +20,7 @@
 
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.PointValues.Relation;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.Query;
@@ -85,7 +85,7 @@ public Query rewrite(IndexReader reader, MultiTermQuery query) {
   };
 
   @Override @SuppressWarnings("unchecked")
-  protected TermsEnum getTermsEnum(final Terms terms, AttributeSource atts) throws IOException {
+  protected TermsEnum getTermsEnum(final FieldTerms terms, AttributeSource atts) throws IOException {
     return new GeoPointTermsEnum(terms.iterator(), this);
   }
 
diff --git a/lucene/spatial/src/java/org/apache/lucene/spatial/geopoint/search/GeoPointTermQueryConstantScoreWrapper.java b/lucene/spatial/src/java/org/apache/lucene/spatial/geopoint/search/GeoPointTermQueryConstantScoreWrapper.java
index a5344b7fbebd..32371b4aa8e3 100644
--- a/lucene/spatial/src/java/org/apache/lucene/spatial/geopoint/search/GeoPointTermQueryConstantScoreWrapper.java
+++ b/lucene/spatial/src/java/org/apache/lucene/spatial/geopoint/search/GeoPointTermQueryConstantScoreWrapper.java
@@ -22,7 +22,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.SortedNumericDocValues;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.ConstantScoreScorer;
 import org.apache.lucene.search.ConstantScoreWeight;
 import org.apache.lucene.search.DocIdSet;
@@ -80,7 +80,7 @@ public Weight createWeight(IndexSearcher searcher, boolean needsScores, float bo
 
       @Override
       public Scorer scorer(LeafReaderContext context) throws IOException {
-        final Terms terms = context.reader().terms(query.getField());
+        final FieldTerms terms = context.reader().terms(query.getField());
         if (terms == null) {
           return null;
         }
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/spell/DirectSpellChecker.java b/lucene/suggest/src/java/org/apache/lucene/search/spell/DirectSpellChecker.java
index 0774718f4dbc..1f29bebf2fe8 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/spell/DirectSpellChecker.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/spell/DirectSpellChecker.java
@@ -19,7 +19,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.BoostAttribute;
 import org.apache.lucene.search.FuzzyTermsEnum;
 import org.apache.lucene.search.MaxNonCompetitiveBoostAttribute;
@@ -402,7 +402,7 @@ protected Collection suggestSimilar(Term term, int numSug, IndexReade
     AttributeSource atts = new AttributeSource();
     MaxNonCompetitiveBoostAttribute maxBoostAtt =
       atts.addAttribute(MaxNonCompetitiveBoostAttribute.class);
-    Terms terms = MultiFields.getTerms(ir, term.field());
+    FieldTerms terms = MultiFields.getTerms(ir, term.field());
     if (terms == null) {
       return Collections.emptyList();
     }
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/spell/HighFrequencyDictionary.java b/lucene/suggest/src/java/org/apache/lucene/search/spell/HighFrequencyDictionary.java
index 657684c587ae..8f325a066af9 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/spell/HighFrequencyDictionary.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/spell/HighFrequencyDictionary.java
@@ -21,7 +21,7 @@
 
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.TermsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.search.suggest.InputIterator;
 import org.apache.lucene.util.BytesRef;
@@ -46,7 +46,7 @@ public class HighFrequencyDictionary implements Dictionary {
    * Creates a new Dictionary, pulling source terms from
    * the specified field in the provided reader.
    * 
      
-   * Terms appearing in less than thresh percentage of documents
+   * FieldTerms appearing in less than thresh percentage of documents
    * will be excluded.
    */
   public HighFrequencyDictionary(IndexReader reader, String field, float thresh) {
@@ -67,7 +67,7 @@ final class HighFrequencyIterator implements InputIterator {
     private long freq;
 
     HighFrequencyIterator() throws IOException {
-      Terms terms = MultiFields.getTerms(reader, field);
+      FieldTerms terms = MultiFields.getTerms(reader, field);
       if (terms != null) {
         termsEnum = terms.iterator();
       } else {
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/spell/LuceneDictionary.java b/lucene/suggest/src/java/org/apache/lucene/search/spell/LuceneDictionary.java
index b96af9bbd580..6d7b8511d13c 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/spell/LuceneDictionary.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/spell/LuceneDictionary.java
@@ -18,7 +18,7 @@
 
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.search.suggest.InputIterator;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.MultiFields;
 
 import java.io.*;
@@ -42,7 +42,7 @@ public LuceneDictionary(IndexReader reader, String field) {
 
   @Override
   public final InputIterator getEntryIterator() throws IOException {
-    final Terms terms = MultiFields.getTerms(reader, field);
+    final FieldTerms terms = MultiFields.getTerms(reader, field);
     if (terms != null) {
       return new InputIterator.InputIteratorWrapper(terms.iterator());
     } else {
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/spell/SpellChecker.java b/lucene/suggest/src/java/org/apache/lucene/search/spell/SpellChecker.java
index 1f11e27507cc..245c608d814a 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/spell/SpellChecker.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/spell/SpellChecker.java
@@ -33,7 +33,7 @@
 import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
@@ -496,7 +496,7 @@ public final void indexDictionary(Dictionary dict, IndexWriterConfig config, boo
       final IndexReader reader = searcher.getIndexReader();
       if (reader.maxDoc() > 0) {
         for (final LeafReaderContext ctx : reader.leaves()) {
-          Terms terms = ctx.reader().terms(F_WORD);
+          FieldTerms terms = ctx.reader().terms(F_WORD);
           if (terms != null)
             termsEnums.add(terms.iterator());
         }
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/BlendedInfixSuggester.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/BlendedInfixSuggester.java
index 413d401b6a5b..a3c5eec3b139 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/BlendedInfixSuggester.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/BlendedInfixSuggester.java
@@ -31,7 +31,7 @@
 import org.apache.lucene.index.IndexOptions;
 import org.apache.lucene.index.MultiDocValues;
 import org.apache.lucene.index.PostingsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
@@ -271,7 +271,7 @@ private static void boundedTreeAdd(TreeSet results, Lookup.
    */
   private double createCoefficient(IndexSearcher searcher, int doc, Set matchedTokens, String prefixToken) throws IOException {
 
-    Terms tv = searcher.getIndexReader().getTermVector(doc, TEXT_FIELD_NAME);
+    FieldTerms tv = searcher.getIndexReader().getTermVector(doc, TEXT_FIELD_NAME);
     TermsEnum it = tv.iterator();
 
     Integer position = Integer.MAX_VALUE;
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/FreeTextSuggester.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/FreeTextSuggester.java
index 3e4845bf16b2..7fbc0608a7bc 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/FreeTextSuggester.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/FreeTextSuggester.java
@@ -50,7 +50,7 @@
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.index.MultiFields;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.suggest.InputIterator;
 import org.apache.lucene.search.suggest.Lookup;
@@ -295,7 +295,7 @@ public void build(InputIterator iterator, double ramBufferSizeMB) throws IOExcep
       }
       reader = DirectoryReader.open(writer);
 
-      Terms terms = MultiFields.getTerms(reader, "body");
+      FieldTerms terms = MultiFields.getTerms(reader, "body");
       if (terms == null) {
         throw new IllegalArgumentException("need at least one suggestion");
       }
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsConsumer.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsConsumer.java
index 9df9d605197d..8644a2a8651d 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsConsumer.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsConsumer.java
@@ -28,7 +28,7 @@
 import org.apache.lucene.index.IndexFileNames;
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.SegmentWriteState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.store.ByteArrayDataInput;
@@ -85,7 +85,7 @@ public void write(Fields fields) throws IOException {
 
     for (String field : fields) {
       CompletionTermWriter termWriter = new CompletionTermWriter();
-      Terms terms = fields.terms(field);
+      FieldTerms terms = fields.terms(field);
       if (terms == null) {
         // this can happen from ghost fields, where the incoming Fields iterator claims a field exists but it does not
         continue;
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsProducer.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsProducer.java
index 7a29b616ce73..999606531c0f 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsProducer.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsProducer.java
@@ -31,7 +31,7 @@
 import org.apache.lucene.index.FieldInfo;
 import org.apache.lucene.index.IndexFileNames;
 import org.apache.lucene.index.SegmentReadState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.store.ChecksumIndexInput;
 import org.apache.lucene.store.IndexInput;
 import org.apache.lucene.util.Accountable;
@@ -161,8 +161,8 @@ public Iterator iterator() {
   }
 
   @Override
-  public Terms terms(String field) throws IOException {
-    Terms terms = delegateFieldsProducer.terms(field) ;
+  public FieldTerms terms(String field) throws IOException {
+    FieldTerms terms = delegateFieldsProducer.terms(field) ;
     if (terms == null) {
       return null;
     }
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionQuery.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionQuery.java
index 71ba15ae1205..d4aeb9aceb2d 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionQuery.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionQuery.java
@@ -22,7 +22,7 @@
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.suggest.BitsProducer;
 
@@ -96,7 +96,7 @@ public Term getTerm() {
   public Query rewrite(IndexReader reader) throws IOException {
     byte type = 0;
     boolean first = true;
-    Terms terms;
+    FieldTerms terms;
     for (LeafReaderContext context : reader.leaves()) {
       LeafReader leafReader = context.reader();
       try {
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionTerms.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionTerms.java
index 0f86739515f7..5b0a948bad9a 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionTerms.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionTerms.java
@@ -19,10 +19,10 @@
 import java.io.IOException;
 
 import org.apache.lucene.index.FilterLeafReader;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 
 /**
- * Wrapped {@link org.apache.lucene.index.Terms}
+ * Wrapped {@link org.apache.lucene.index.FieldTerms}
  * used by {@link SuggestField} and {@link ContextSuggestField}
  * to access corresponding suggester and their attributes
  *
@@ -35,7 +35,7 @@ public final class CompletionTerms extends FilterLeafReader.FilterTerms {
   /**
    * Creates a completionTerms based on {@link CompletionsTermsReader}
    */
-  CompletionTerms(Terms in, CompletionsTermsReader reader) {
+  CompletionTerms(FieldTerms in, CompletionsTermsReader reader) {
     super(in);
     this.reader = reader;
   }
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionWeight.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionWeight.java
index d74e56f2ecfc..4c80969b1732 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionWeight.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionWeight.java
@@ -22,7 +22,7 @@
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.BulkScorer;
 import org.apache.lucene.search.Explanation;
 import org.apache.lucene.search.Scorer;
@@ -70,7 +70,7 @@ public Automaton getAutomaton() {
   @Override
   public BulkScorer bulkScorer(final LeafReaderContext context) throws IOException {
     final LeafReader reader = context.reader();
-    final Terms terms;
+    final FieldTerms terms;
     final NRTSuggester suggester;
     if ((terms = reader.terms(completionQuery.getField())) == null) {
       return null;
diff --git a/lucene/suggest/src/test/org/apache/lucene/search/suggest/document/TestPrefixCompletionQuery.java b/lucene/suggest/src/test/org/apache/lucene/search/suggest/document/TestPrefixCompletionQuery.java
index f5bacefc6384..e9c082babc41 100644
--- a/lucene/suggest/src/test/org/apache/lucene/search/suggest/document/TestPrefixCompletionQuery.java
+++ b/lucene/suggest/src/test/org/apache/lucene/search/suggest/document/TestPrefixCompletionQuery.java
@@ -320,7 +320,7 @@ public void testGhostField() throws Exception {
     // first force merge is OK
     iw.forceMerge(1);
     
-    // second force merge causes MultiFields to include "suggest_field" in its iteration, yet a null Terms is returned (no documents have
+    // second force merge causes MultiFields to include "suggest_field" in its iteration, yet a null FieldTerms is returned (no documents have
     // this field anymore)
     iw.addDocument(new Document());
     iw.forceMerge(1);
diff --git a/lucene/test-framework/src/java/org/apache/lucene/codecs/asserting/AssertingPostingsFormat.java b/lucene/test-framework/src/java/org/apache/lucene/codecs/asserting/AssertingPostingsFormat.java
index a89b5081ded3..51a653b7a8a7 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/codecs/asserting/AssertingPostingsFormat.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/codecs/asserting/AssertingPostingsFormat.java
@@ -31,7 +31,7 @@
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.SegmentReadState;
 import org.apache.lucene.index.SegmentWriteState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.Accountable;
 import org.apache.lucene.util.BytesRef;
@@ -83,8 +83,8 @@ public Iterator iterator() {
     }
 
     @Override
-    public Terms terms(String field) throws IOException {
-      Terms terms = in.terms(field);
+    public FieldTerms terms(String field) throws IOException {
+      FieldTerms terms = in.terms(field);
       return terms == null ? null : new AssertingLeafReader.AssertingTerms(terms);
     }
 
@@ -150,7 +150,7 @@ public void write(Fields fields) throws IOException {
         assert lastField == null || lastField.compareTo(field) < 0;
         lastField = field;
 
-        Terms terms = fields.terms(field);
+        FieldTerms terms = fields.terms(field);
         if (terms == null) {
           continue;
         }
diff --git a/lucene/test-framework/src/java/org/apache/lucene/codecs/ramonly/RAMOnlyPostingsFormat.java b/lucene/test-framework/src/java/org/apache/lucene/codecs/ramonly/RAMOnlyPostingsFormat.java
index 4b85f130c4af..ed61217aca14 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/codecs/ramonly/RAMOnlyPostingsFormat.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/codecs/ramonly/RAMOnlyPostingsFormat.java
@@ -40,7 +40,7 @@
 import org.apache.lucene.index.IndexOptions;
 import org.apache.lucene.index.SegmentReadState;
 import org.apache.lucene.index.SegmentWriteState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.IndexInput;
 import org.apache.lucene.store.IndexOutput;
@@ -68,7 +68,7 @@ static class RAMPostings extends FieldsProducer {
     final Map fieldToTerms = new TreeMap<>();
 
     @Override
-    public Terms terms(String field) {
+    public FieldTerms terms(String field) {
       return fieldToTerms.get(field);
     }
 
@@ -104,7 +104,7 @@ public Collection getChildResources() {
     public void checkIntegrity() throws IOException {}
   } 
 
-  static class RAMField extends Terms implements Accountable {
+  static class RAMField extends FieldTerms implements Accountable {
     final String field;
     final SortedMap termToDocs = new TreeMap<>();
     long sumTotalTermFreq;
@@ -230,7 +230,7 @@ public RAMFieldsConsumer(SegmentWriteState writeState, RAMPostings postings) {
     public void write(Fields fields) throws IOException {
       for(String field : fields) {
 
-        Terms terms = fields.terms(field);
+        FieldTerms terms = fields.terms(field);
         if (terms == null) {
           continue;
         }
diff --git a/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java b/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java
index 37c549ec723f..1cbf0b23cacc 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java
@@ -85,17 +85,17 @@ public Iterator iterator() {
     }
 
     @Override
-    public Terms terms(String field) throws IOException {
-      Terms terms = super.terms(field);
+    public FieldTerms terms(String field) throws IOException {
+      FieldTerms terms = super.terms(field);
       return terms == null ? null : new AssertingTerms(terms);
     }
   }
   
   /**
-   * Wraps a Terms but with additional asserts
+   * Wraps a FieldTerms but with additional asserts
    */
   public static class AssertingTerms extends FilterTerms {
-    public AssertingTerms(Terms in) {
+    public AssertingTerms(FieldTerms in) {
       super(in);
     }
 
@@ -149,7 +149,7 @@ public AssertingTermsEnum(TermsEnum in) {
 
     @Override
     public PostingsEnum postings(PostingsEnum reuse, int flags) throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       assert state == State.POSITIONED: "docs(...) called on unpositioned TermsEnum";
 
       // reuse if the codec reused
@@ -174,7 +174,7 @@ public PostingsEnum postings(PostingsEnum reuse, int flags) throws IOException {
     // someone should not call next() after it returns null!!!!
     @Override
     public BytesRef next() throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       assert state == State.INITIAL || state == State.POSITIONED: "next() called on unpositioned TermsEnum";
       BytesRef result = super.next();
       if (result == null) {
@@ -188,28 +188,28 @@ public BytesRef next() throws IOException {
 
     @Override
     public long ord() throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       assert state == State.POSITIONED : "ord() called on unpositioned TermsEnum";
       return super.ord();
     }
 
     @Override
     public int docFreq() throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       assert state == State.POSITIONED : "docFreq() called on unpositioned TermsEnum";
       return super.docFreq();
     }
 
     @Override
     public long totalTermFreq() throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       assert state == State.POSITIONED : "totalTermFreq() called on unpositioned TermsEnum";
       return super.totalTermFreq();
     }
 
     @Override
     public BytesRef term() throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       assert state == State.POSITIONED : "term() called on unpositioned TermsEnum";
       BytesRef ret = super.term();
       assert ret == null || ret.isValid();
@@ -218,14 +218,14 @@ public BytesRef term() throws IOException {
 
     @Override
     public void seekExact(long ord) throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       super.seekExact(ord);
       state = State.POSITIONED;
     }
 
     @Override
     public SeekStatus seekCeil(BytesRef term) throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       assert term.isValid();
       SeekStatus result = super.seekCeil(term);
       if (result == SeekStatus.END) {
@@ -238,7 +238,7 @@ public SeekStatus seekCeil(BytesRef term) throws IOException {
 
     @Override
     public boolean seekExact(BytesRef text) throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       assert text.isValid();
       boolean result;
       if (delegateOverridesSeekExact) {
@@ -256,14 +256,14 @@ public boolean seekExact(BytesRef text) throws IOException {
 
     @Override
     public TermState termState() throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       assert state == State.POSITIONED : "termState() called on unpositioned TermsEnum";
       return in.termState();
     }
 
     @Override
     public void seekExact(BytesRef term, TermState state) throws IOException {
-      assertThread("Terms enums", creationThread);
+      assertThread("FieldTerms enums", creationThread);
       assert term.isValid();
       in.seekExact(term, state);
       this.state = State.POSITIONED;
diff --git a/lucene/test-framework/src/java/org/apache/lucene/index/BasePostingsFormatTestCase.java b/lucene/test-framework/src/java/org/apache/lucene/index/BasePostingsFormatTestCase.java
index 1155a7365c3e..c4d151950352 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/index/BasePostingsFormatTestCase.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/index/BasePostingsFormatTestCase.java
@@ -160,7 +160,7 @@ public void testPostingsEnumReuse() throws Exception {
     Collections.shuffle(postingsTester.allTerms, random());
     RandomPostingsTester.FieldAndTerm fieldAndTerm = postingsTester.allTerms.get(0);
 
-    Terms terms = fieldsProducer.terms(fieldAndTerm.field);
+    FieldTerms terms = fieldsProducer.terms(fieldAndTerm.field);
     TermsEnum te = terms.iterator();
 
     te.seekExact(fieldAndTerm.term);
@@ -197,7 +197,7 @@ public void testJustEmptyField() throws Exception {
     int fieldCount = fields.size();
     // -1 is allowed, if the codec doesn't implement fields.size():
     assertTrue(fieldCount == 1 || fieldCount == -1);
-    Terms terms = ar.terms("");
+    FieldTerms terms = ar.terms("");
     assertNotNull(terms);
     TermsEnum termsEnum = terms.iterator();
     assertNotNull(termsEnum.next());
@@ -222,7 +222,7 @@ public void testEmptyFieldAndEmptyTerm() throws Exception {
     int fieldCount = fields.size();
     // -1 is allowed, if the codec doesn't implement fields.size():
     assertTrue(fieldCount == 1 || fieldCount == -1);
-    Terms terms = ar.terms("");
+    FieldTerms terms = ar.terms("");
     assertNotNull(terms);
     TermsEnum termsEnum = terms.iterator();
     assertNotNull(termsEnum.next());
@@ -300,7 +300,7 @@ public void testGhosts() throws Exception {
     // Ghost busting terms dict impls will have
     // fields.size() == 0; all others must be == 1:
     assertTrue(fields.size() <= 1);
-    Terms terms = fields.terms("ghostField");
+    FieldTerms terms = fields.terms("ghostField");
     if (terms != null) {
       TermsEnum termsEnum = terms.iterator();
       BytesRef term = termsEnum.next();
@@ -342,7 +342,7 @@ public void testLevel2Ghosts() throws Exception {
     // first force merge creates a level 1 ghost field
     iw.forceMerge(1);
     
-    // second force merge creates a level 2 ghost field, causing MultiFields to include "suggest_field" in its iteration, yet a null Terms is returned (no documents have
+    // second force merge creates a level 2 ghost field, causing MultiFields to include "suggest_field" in its iteration, yet a null FieldTerms is returned (no documents have
     // this field anymore)
     iw.addDocument(new Document());
     iw.forceMerge(1);
@@ -424,7 +424,7 @@ public void write(Fields fields) throws IOException {
                   //System.out.println("write isMerge=" + isMerge + " 2ndPass=" + addOnSecondPass);
 
                   // Gather our own stats:
-                  Terms terms = fields.terms("body");
+                  FieldTerms terms = fields.terms("body");
                   assert terms != null;
 
                   TermsEnum termsEnum = terms.iterator();
@@ -557,7 +557,7 @@ public FieldsProducer fieldsProducer(SegmentReadState state) throws IOException
     IndexReader r = w.getReader();
     w.close();
 
-    Terms terms = MultiFields.getTerms(r, "body");
+    FieldTerms terms = MultiFields.getTerms(r, "body");
     assertEquals(sumDocFreq.get(), terms.getSumDocFreq());
     assertEquals(sumTotalTermFreq.get(), terms.getSumTotalTermFreq());
 
diff --git a/lucene/test-framework/src/java/org/apache/lucene/index/BaseTermVectorsFormatTestCase.java b/lucene/test-framework/src/java/org/apache/lucene/index/BaseTermVectorsFormatTestCase.java
index 7acee871f59d..ab3d5464f353 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/index/BaseTermVectorsFormatTestCase.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/index/BaseTermVectorsFormatTestCase.java
@@ -424,7 +424,7 @@ protected static boolean equals(Object o1, Object o2) {
   private final ThreadLocal docsEnum = new ThreadLocal<>();
   private final ThreadLocal docsAndPositionsEnum = new ThreadLocal<>();
 
-  protected void assertEquals(RandomTokenStream tk, FieldType ft, Terms terms) throws IOException {
+  protected void assertEquals(RandomTokenStream tk, FieldType ft, FieldTerms terms) throws IOException {
     assertEquals(1, terms.getDocCount());
     final int termCount = new HashSet<>(Arrays.asList(tk.terms)).size();
     assertEquals(termCount, terms.size());
@@ -757,7 +757,7 @@ protected TokenStreamComponents createComponents(String fieldName) {
     iw.addDocument(doc);
     DirectoryReader reader = DirectoryReader.open(iw);
     
-    Terms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
+    FieldTerms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
     TermsEnum termsEnum = terms.iterator();
     assertNotNull(termsEnum);
     assertEquals(new BytesRef("bar"), termsEnum.next());
@@ -838,7 +838,7 @@ protected TokenStreamComponents createComponents(String fieldName) {
     iw.addDocument(doc);
     DirectoryReader reader = DirectoryReader.open(iw);
     
-    Terms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
+    FieldTerms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
     TermsEnum termsEnum = terms.iterator();
     assertNotNull(termsEnum);
     assertEquals(new BytesRef("bar"), termsEnum.next());
@@ -1017,7 +1017,7 @@ protected TokenStreamComponents createComponents(String fieldName) {
     iw.addDocument(doc);
     DirectoryReader reader = DirectoryReader.open(iw);
     
-    Terms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
+    FieldTerms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
     TermsEnum termsEnum = terms.iterator();
     assertNotNull(termsEnum);
     assertEquals(new BytesRef("bar"), termsEnum.next());
@@ -1203,7 +1203,7 @@ protected TokenStreamComponents createComponents(String fieldName) {
     iw.addDocument(doc);
     DirectoryReader reader = DirectoryReader.open(iw);
     
-    Terms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
+    FieldTerms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
     TermsEnum termsEnum = terms.iterator();
     assertNotNull(termsEnum);
     assertEquals(new BytesRef("bar"), termsEnum.next());
@@ -1389,7 +1389,7 @@ public void testPostingsEnumPayloads() throws Exception {
     iw.addDocument(doc);
     DirectoryReader reader = DirectoryReader.open(iw);
     
-    Terms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
+    FieldTerms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
     TermsEnum termsEnum = terms.iterator();
     assertNotNull(termsEnum);
     assertEquals(new BytesRef("bar"), termsEnum.next());
@@ -1575,7 +1575,7 @@ public void testPostingsEnumAll() throws Exception {
     iw.addDocument(doc);
     DirectoryReader reader = DirectoryReader.open(iw);
     
-    Terms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
+    FieldTerms terms = getOnlyLeafReader(reader).getTermVector(0, "foo");
     TermsEnum termsEnum = terms.iterator();
     assertNotNull(termsEnum);
     assertEquals(new BytesRef("bar"), termsEnum.next());
diff --git a/lucene/test-framework/src/java/org/apache/lucene/index/FieldFilterLeafReader.java b/lucene/test-framework/src/java/org/apache/lucene/index/FieldFilterLeafReader.java
index a75af543d92a..02f035bf8ba6 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/index/FieldFilterLeafReader.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/index/FieldFilterLeafReader.java
@@ -169,7 +169,7 @@ protected boolean predicateFunction(String field) {
     }
 
     @Override
-    public Terms terms(String field) throws IOException {
+    public FieldTerms terms(String field) throws IOException {
       return hasField(field) ? super.terms(field) : null;
     }
     
diff --git a/lucene/test-framework/src/java/org/apache/lucene/index/PerThreadPKLookup.java b/lucene/test-framework/src/java/org/apache/lucene/index/PerThreadPKLookup.java
index c417a8864507..a28062736567 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/index/PerThreadPKLookup.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/index/PerThreadPKLookup.java
@@ -59,7 +59,7 @@ public int compare(LeafReaderContext c1, LeafReaderContext c2) {
     int numSegs = 0;
     boolean hasDeletions = false;
     for(int i=0;i iterator() {
     }
 
     @Override
-    public Terms terms(String field) {
+    public FieldTerms terms(String field) {
       SortedMap terms = fields.get(field);
       if (terms == null) {
         return null;
@@ -449,7 +449,7 @@ public int size() {
     }
   }
 
-  private static class SeedTerms extends Terms {
+  private static class SeedTerms extends FieldTerms {
     final SortedMap terms;
     final FieldInfo fieldInfo;
     final IndexOptions maxAllowed;
@@ -1076,7 +1076,7 @@ private void testTermsOneThread(Random random, Fields fieldsSource, EnumSet 0) {
                     smokeTestSearcher(s);
                     Fields fields = MultiFields.getFields(s.getIndexReader());
-                    Terms terms = fields.terms("body");
+                    FieldTerms terms = fields.terms("body");
                     if (terms == null) {
                       continue;
                     }
diff --git a/lucene/test-framework/src/java/org/apache/lucene/search/QueryUtils.java b/lucene/test-framework/src/java/org/apache/lucene/search/QueryUtils.java
index ae4c89023d40..4cb985fcf455 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/search/QueryUtils.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/search/QueryUtils.java
@@ -36,7 +36,7 @@
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.index.SortedSetDocValues;
 import org.apache.lucene.index.StoredFieldVisitor;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.util.Bits;
 import org.apache.lucene.util.LuceneTestCase;
 
@@ -205,7 +205,7 @@ public Iterator iterator() {
           }
 
           @Override
-          public Terms terms(String field) throws IOException {
+          public FieldTerms terms(String field) throws IOException {
             return null;
           }
 
diff --git a/lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java b/lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java
index 50139a099deb..5b6674a25f6d 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java
@@ -2018,9 +2018,9 @@ public void assertFieldStatisticsEquals(String info, Fields leftFields, Fields r
   }
 
   /** 
-   * Terms api equivalency 
+   * FieldTerms api equivalency 
    */
-  public void assertTermsEquals(String info, IndexReader leftReader, Terms leftTerms, Terms rightTerms, boolean deep) throws IOException {
+  public void assertTermsEquals(String info, IndexReader leftReader, FieldTerms leftTerms, FieldTerms rightTerms, boolean deep) throws IOException {
     if (leftTerms == null || rightTerms == null) {
       assertNull(info, leftTerms);
       assertNull(info, rightTerms);
@@ -2053,9 +2053,9 @@ public void assertTermsEquals(String info, IndexReader leftReader, Terms leftTer
   }
 
   /** 
-   * checks collection-level statistics on Terms 
+   * checks collection-level statistics on FieldTerms 
    */
-  public void assertTermsStatisticsEquals(String info, Terms leftTerms, Terms rightTerms) throws IOException {
+  public void assertTermsStatisticsEquals(String info, FieldTerms leftTerms, FieldTerms rightTerms) throws IOException {
     if (leftTerms.getDocCount() != -1 && rightTerms.getDocCount() != -1) {
       assertEquals(info, leftTerms.getDocCount(), rightTerms.getDocCount());
     }
@@ -2260,7 +2260,7 @@ public void assertPositionsSkippingEquals(String info, IndexReader leftReader, i
   }
 
   
-  private void assertTermsSeekingEquals(String info, Terms leftTerms, Terms rightTerms) throws IOException {
+  private void assertTermsSeekingEquals(String info, FieldTerms leftTerms, FieldTerms rightTerms) throws IOException {
 
     // just an upper bound
     int numTests = atLeast(20);
diff --git a/lucene/test-framework/src/java/org/apache/lucene/util/TestUtil.java b/lucene/test-framework/src/java/org/apache/lucene/util/TestUtil.java
index 0ea90fc04eb9..fe5232dd0729 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/util/TestUtil.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/util/TestUtil.java
@@ -83,7 +83,7 @@
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.SegmentReader;
 import org.apache.lucene.index.SlowCodecReaderWrapper;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.index.TieredMergePolicy;
 import org.apache.lucene.mockfile.FilterFileSystem;
@@ -1103,7 +1103,7 @@ public static Document cloneDocument(Document doc1) {
   // DocsAndFreqsEnum, DocsAndPositionsEnum.  Returns null
   // if field/term doesn't exist:
   public static PostingsEnum docs(Random random, IndexReader r, String field, BytesRef term, PostingsEnum reuse, int flags) throws IOException {
-    final Terms terms = MultiFields.getTerms(r, field);
+    final FieldTerms terms = MultiFields.getTerms(r, field);
     if (terms == null) {
       return null;
     }
diff --git a/lucene/test-framework/src/test/org/apache/lucene/analysis/TestMockAnalyzer.java b/lucene/test-framework/src/test/org/apache/lucene/analysis/TestMockAnalyzer.java
index 52953490190d..13c499aa79c8 100644
--- a/lucene/test-framework/src/test/org/apache/lucene/analysis/TestMockAnalyzer.java
+++ b/lucene/test-framework/src/test/org/apache/lucene/analysis/TestMockAnalyzer.java
@@ -29,7 +29,7 @@
 import org.apache.lucene.index.IndexOptions;
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.RandomIndexWriter;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.TestUtil;
@@ -317,7 +317,7 @@ public int getOffsetGap(String fieldName) {
     writer.addDocument(doc);
     final LeafReader reader = getOnlyLeafReader(writer.getReader());
     final Fields fields = reader.getTermVectors(0);
-    final Terms terms = fields.terms("f");
+    final FieldTerms terms = fields.terms("f");
     final TermsEnum te = terms.iterator();
     assertEquals(new BytesRef("a"), te.next());
     final PostingsEnum dpe = te.postings(null, PostingsEnum.ALL);
diff --git a/lucene/test-framework/src/test/org/apache/lucene/codecs/compressing/TestCompressingTermVectorsFormat.java b/lucene/test-framework/src/test/org/apache/lucene/codecs/compressing/TestCompressingTermVectorsFormat.java
index cf1c6a30a393..45706c04d9e0 100644
--- a/lucene/test-framework/src/test/org/apache/lucene/codecs/compressing/TestCompressingTermVectorsFormat.java
+++ b/lucene/test-framework/src/test/org/apache/lucene/codecs/compressing/TestCompressingTermVectorsFormat.java
@@ -33,7 +33,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.NoMergePolicy;
 import org.apache.lucene.index.RandomIndexWriter;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum.SeekStatus;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.store.Directory;
@@ -56,7 +56,7 @@ public void testNoOrds() throws Exception {
     doc.add(new Field("foo", "this is a test", ft));
     iw.addDocument(doc);
     LeafReader ir = getOnlyLeafReader(iw.getReader());
-    Terms terms = ir.getTermVector(0, "foo");
+    FieldTerms terms = ir.getTermVector(0, "foo");
     assertNotNull(terms);
     TermsEnum termsEnum = terms.iterator();
     assertEquals(SeekStatus.FOUND, termsEnum.seekCeil(new BytesRef("this")));

From f9716a7350187330cc326cec450f88d6eaa3a267 Mon Sep 17 00:00:00 2001
From: Paul Elschot 
Date: Sun, 15 Jan 2017 14:07:23 +0100
Subject: [PATCH 2/2] Make solr ant compile-test pass for renaming Terms to
 FieldTerms

---
 .../solr/handler/admin/LukeRequestHandler.java | 10 +++++-----
 .../component/QueryElevationComponent.java     |  6 +++---
 .../handler/component/TermVectorComponent.java |  6 +++---
 .../solr/handler/component/TermsComponent.java |  4 ++--
 .../solr/highlight/DefaultSolrHighlighter.java |  4 ++--
 .../org/apache/solr/query/SolrRangeQuery.java  |  6 +++---
 .../org/apache/solr/request/NumericFacets.java |  6 +++---
 .../org/apache/solr/request/SimpleFacets.java  |  6 +++---
 .../org/apache/solr/search/DocSetUtil.java     |  4 ++--
 .../solr/search/GraphTermsQParserPlugin.java   |  6 +++---
 .../solr/search/IGainTermsQParserPlugin.java   |  4 ++--
 .../apache/solr/search/JoinQParserPlugin.java  |  6 +++---
 .../apache/solr/search/SolrIndexSearcher.java  |  4 ++--
 .../TextLogisticRegressionQParserPlugin.java   |  4 ++--
 .../FacetFieldProcessorByEnumTermsStream.java  |  4 ++--
 .../apache/solr/uninverting/DocTermOrds.java   |  4 ++--
 .../apache/solr/uninverting/FieldCache.java    | 18 +++++++++---------
 .../solr/uninverting/FieldCacheImpl.java       | 18 +++++++++---------
 .../apache/solr/update/SolrIndexSplitter.java  |  4 ++--
 .../org/apache/solr/update/VersionInfo.java    |  6 +++---
 .../org/apache/solr/search/TestRTGBase.java    |  4 ++--
 .../solr/uninverting/TestDocTermOrds.java      |  4 ++--
 .../solr/uninverting/TestLegacyFieldCache.java |  4 ++--
 23 files changed, 71 insertions(+), 71 deletions(-)

diff --git a/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java b/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java
index 50f46ef8d02d..5b4265524598 100644
--- a/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java
+++ b/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java
@@ -54,7 +54,7 @@
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.SegmentReader;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.similarities.Similarity;
@@ -306,7 +306,7 @@ private static SimpleOrderedMap getDocumentFieldsInfo( Document doc, int
       // If we have a term vector, return that
       if( field.fieldType().storeTermVectors() ) {
         try {
-          Terms v = reader.getTermVector( docId, field.name() );
+          FieldTerms v = reader.getTermVector( docId, field.name() );
           if( v != null ) {
             SimpleOrderedMap tfv = new SimpleOrderedMap<>();
             final TermsEnum termsEnum = v.iterator();
@@ -368,7 +368,7 @@ private static SimpleOrderedMap getIndexedFieldsInfo(SolrQueryRequest re
       if (sfield != null && schema.isDynamicField(sfield.getName()) && schema.getDynamicPattern(sfield.getName()) != null) {
         fieldMap.add("dynamicBase", schema.getDynamicPattern(sfield.getName()));
       }
-      Terms terms = reader.fields().terms(fieldName);
+      FieldTerms terms = reader.fields().terms(fieldName);
       if (terms == null) { // Not indexed, so we need to report what we can (it made it through the fl param if specified)
         finfo.add( fieldName, fieldMap );
         continue;
@@ -407,7 +407,7 @@ private static SimpleOrderedMap getIndexedFieldsInfo(SolrQueryRequest re
   // Just get a document with the term in it, the first one will do!
   // Is there a better way to do this? Shouldn't actually be very costly
   // to do it this way.
-  private static Document getFirstLiveDoc(Terms terms, LeafReader reader) throws IOException {
+  private static Document getFirstLiveDoc(FieldTerms terms, LeafReader reader) throws IOException {
     PostingsEnum postingsEnum = null;
     TermsEnum termsEnum = terms.iterator();
     BytesRef text;
@@ -647,7 +647,7 @@ private static void getDetailedFieldInfo(SolrQueryRequest req, String field, Sim
 
     final CharsRefBuilder spare = new CharsRefBuilder();
 
-    Terms terms = MultiFields.getTerms(req.getSearcher().getIndexReader(), field);
+    FieldTerms terms = MultiFields.getTerms(req.getSearcher().getIndexReader(), field);
     if (terms == null) {  // field does not exist
       return;
     }
diff --git a/solr/core/src/java/org/apache/solr/handler/component/QueryElevationComponent.java b/solr/core/src/java/org/apache/solr/handler/component/QueryElevationComponent.java
index 25157cfb7baf..e70dd5029d29 100644
--- a/solr/core/src/java/org/apache/solr/handler/component/QueryElevationComponent.java
+++ b/solr/core/src/java/org/apache/solr/handler/component/QueryElevationComponent.java
@@ -25,7 +25,7 @@
 import org.apache.lucene.index.Fields;
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
@@ -562,7 +562,7 @@ public static IntIntHashMap getBoostDocs(SolrIndexSearcher indexSearcher, Map it = localBoosts.iterator();
         while(it.hasNext()) {
@@ -679,7 +679,7 @@ protected void doSetNextReader(LeafReaderContext context) throws IOException {
         ordSet.clear();
         Fields fields = context.reader().fields();
         if (fields == null) return;
-        Terms terms = fields.terms(idField);
+        FieldTerms terms = fields.terms(idField);
         if (terms == null) return;
         TermsEnum termsEnum = terms.iterator();
         BytesRefBuilder term = new BytesRefBuilder();
diff --git a/solr/core/src/java/org/apache/solr/handler/component/TermVectorComponent.java b/solr/core/src/java/org/apache/solr/handler/component/TermVectorComponent.java
index c8872778f217..d30f61393d1f 100644
--- a/solr/core/src/java/org/apache/solr/handler/component/TermVectorComponent.java
+++ b/solr/core/src/java/org/apache/solr/handler/component/TermVectorComponent.java
@@ -34,7 +34,7 @@
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.StoredFieldVisitor;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.BytesRef;
 import org.apache.solr.common.SolrException;
@@ -312,7 +312,7 @@ public Status needsField(FieldInfo fieldInfo) {
       if ( null != fields ) {
         for (Map.Entry entry : fieldOptions.entrySet()) {
           final String field = entry.getKey();
-          final Terms vector = reader.getTermVector(docId, field);
+          final FieldTerms vector = reader.getTermVector(docId, field);
           if (vector != null) {
             TermsEnum termsEnum = vector.iterator();
             mapOneVector(docNL, entry.getValue(), reader, docId, termsEnum, field);
@@ -322,7 +322,7 @@ public Status needsField(FieldInfo fieldInfo) {
         // extract all fields
         final Fields vectors = reader.getTermVectors(docId);
         for (String field : vectors) {
-          Terms terms = vectors.terms(field);
+          FieldTerms terms = vectors.terms(field);
           if (terms != null) {
             TermsEnum termsEnum = terms.iterator();
             mapOneVector(docNL, allFields, reader, docId, termsEnum, field);
diff --git a/solr/core/src/java/org/apache/solr/handler/component/TermsComponent.java b/solr/core/src/java/org/apache/solr/handler/component/TermsComponent.java
index b76537a05a42..5ca09ebca14e 100644
--- a/solr/core/src/java/org/apache/solr/handler/component/TermsComponent.java
+++ b/solr/core/src/java/org/apache/solr/handler/component/TermsComponent.java
@@ -143,7 +143,7 @@ public void process(ResponseBuilder rb) throws IOException {
       NamedList fieldTerms = new NamedList<>();
       termsResult.add(field, fieldTerms);
 
-      Terms terms = lfields.terms(field);
+      FieldTerms terms = lfields.terms(field);
       if (terms == null) {
         // field does not exist
         continue;
@@ -550,7 +550,7 @@ private void collectTermContext(IndexReader reader,
       for (int i = 0; i < queryTerms.length; i++) {
         Term term = queryTerms[i];
         TermContext termContext = contextArray[i];
-        final Terms terms = fields.terms(term.field());
+        final FieldTerms terms = fields.terms(term.field());
         if (terms == null) {
           // field does not exist
           continue;
diff --git a/solr/core/src/java/org/apache/solr/highlight/DefaultSolrHighlighter.java b/solr/core/src/java/org/apache/solr/highlight/DefaultSolrHighlighter.java
index e035a759bc35..0aff40f0d346 100644
--- a/solr/core/src/java/org/apache/solr/highlight/DefaultSolrHighlighter.java
+++ b/solr/core/src/java/org/apache/solr/highlight/DefaultSolrHighlighter.java
@@ -39,7 +39,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexableField;
 import org.apache.lucene.index.LeafReader;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.highlight.Encoder;
 import org.apache.lucene.search.highlight.Formatter;
@@ -221,7 +221,7 @@ protected QueryScorer getSpanQueryScorer(Query query, String fieldName, TokenStr
     try {
       // It'd be nice to know if payloads are on the tokenStream but the presence of the attribute isn't a good
       // indicator.
-      final Terms terms = request.getSearcher().getSlowAtomicReader().fields().terms(fieldName);
+      final FieldTerms terms = request.getSearcher().getSlowAtomicReader().fields().terms(fieldName);
       if (terms != null) {
         defaultPayloads = terms.hasPayloads();
       }
diff --git a/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java b/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java
index bed0ad58bd13..66a174c74ae9 100644
--- a/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java
+++ b/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java
@@ -26,7 +26,7 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
 import org.apache.lucene.index.TermState;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
@@ -178,7 +178,7 @@ private class RangeTermsEnum extends TermsEnum {
     BytesRef curr;
     boolean positioned;
 
-    public RangeTermsEnum(Terms terms) throws IOException {
+    public RangeTermsEnum(FieldTerms terms) throws IOException {
       if (terms == null) {
         positioned = true;
       } else {
@@ -379,7 +379,7 @@ private SegState getSegState(LeafReaderContext context) throws IOException {
         return segStates[context.ord] = new SegState(filter.getDocIdSet(context, null));
       }
 
-      final Terms terms = context.reader().terms(SolrRangeQuery.this.getField());
+      final FieldTerms terms = context.reader().terms(SolrRangeQuery.this.getField());
       if (terms == null) {
         return segStates[context.ord] = new SegState((DocIdSet) null);
       }
diff --git a/solr/core/src/java/org/apache/solr/request/NumericFacets.java b/solr/core/src/java/org/apache/solr/request/NumericFacets.java
index d292a88fb136..a7dde319e7b2 100644
--- a/solr/core/src/java/org/apache/solr/request/NumericFacets.java
+++ b/solr/core/src/java/org/apache/solr/request/NumericFacets.java
@@ -32,7 +32,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.NumericDocValues;
 import org.apache.lucene.index.ReaderUtil;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.legacy.LegacyNumericType;
 import org.apache.lucene.queries.function.FunctionValues;
@@ -266,7 +266,7 @@ protected boolean lessThan(Entry a, Entry b) {
         for (int i = 0; i < result.size(); ++i) {
           alreadySeen.add(result.getName(i));
         }
-        final Terms terms = searcher.getSlowAtomicReader().terms(fieldName);
+        final FieldTerms terms = searcher.getSlowAtomicReader().terms(fieldName);
         if (terms != null) {
           final String prefixStr = TrieField.getMainValuePrefix(ft);
           final BytesRef prefix;
@@ -319,7 +319,7 @@ protected boolean lessThan(Entry a, Entry b) {
         final FunctionValues values = vs.getValues(Collections.emptyMap(), leaves.get(readerIdx));
         counts.put(values.strVal(entry.docID - leaves.get(readerIdx).docBase), entry.count);
       }
-      final Terms terms = searcher.getSlowAtomicReader().terms(fieldName);
+      final FieldTerms terms = searcher.getSlowAtomicReader().terms(fieldName);
       if (terms != null) {
         final String prefixStr = TrieField.getMainValuePrefix(ft);
         final BytesRef prefix;
diff --git a/solr/core/src/java/org/apache/solr/request/SimpleFacets.java b/solr/core/src/java/org/apache/solr/request/SimpleFacets.java
index 641b1f394020..7da15937a20d 100644
--- a/solr/core/src/java/org/apache/solr/request/SimpleFacets.java
+++ b/solr/core/src/java/org/apache/solr/request/SimpleFacets.java
@@ -41,7 +41,7 @@
 import org.apache.lucene.index.MultiPostingsEnum;
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause.Occur;
 import org.apache.lucene.search.BooleanQuery;
@@ -850,7 +850,7 @@ public NamedList getFacetTermEnumCounts(SolrIndexSearcher searcher, Doc
     throws IOException {
 
     /* :TODO: potential optimization...
-    * cache the Terms with the highest docFreq and try them first
+    * cache the FieldTerms with the highest docFreq and try them first
     * don't enum if we get our max from them
     */
 
@@ -885,7 +885,7 @@ public NamedList getFacetTermEnumCounts(SolrIndexSearcher searcher, Doc
     }
 
     Fields fields = r.fields();
-    Terms terms = fields==null ? null : fields.terms(field);
+    FieldTerms terms = fields==null ? null : fields.terms(field);
     TermsEnum termsEnum = null;
     SolrIndexSearcher.DocsEnumState deState = null;
     BytesRef term = null;
diff --git a/solr/core/src/java/org/apache/solr/search/DocSetUtil.java b/solr/core/src/java/org/apache/solr/search/DocSetUtil.java
index b7545e6f12a3..67c29eca73c8 100644
--- a/solr/core/src/java/org/apache/solr/search/DocSetUtil.java
+++ b/solr/core/src/java/org/apache/solr/search/DocSetUtil.java
@@ -27,7 +27,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
@@ -125,7 +125,7 @@ public static DocSet createDocSet(SolrIndexSearcher searcher, Term term) throws
       assert leaves.get(ctx.ord) == ctx;
       LeafReader r = ctx.reader();
       Fields f = r.fields();
-      Terms t = f.terms(field);
+      FieldTerms t = f.terms(field);
       if (t == null) continue;  // field is missing
       TermsEnum te = t.iterator();
       if (te.seekExact(termVal)) {
diff --git a/solr/core/src/java/org/apache/solr/search/GraphTermsQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/GraphTermsQParserPlugin.java
index a8a86cb8783f..79b5ee53d59f 100644
--- a/solr/core/src/java/org/apache/solr/search/GraphTermsQParserPlugin.java
+++ b/solr/core/src/java/org/apache/solr/search/GraphTermsQParserPlugin.java
@@ -25,7 +25,7 @@
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.TermContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermState;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.BulkScorer;
@@ -221,7 +221,7 @@ public void extractTerms(Set terms) {
         private WeightOrDocIdSet rewrite(LeafReaderContext context) throws IOException {
           final LeafReader reader = context.reader();
           final Fields fields = reader.fields();
-          Terms terms = fields.terms(field);
+          FieldTerms terms = fields.terms(field);
           if(terms == null) {
             return new WeightOrDocIdSet(new BitDocIdSet(new FixedBitSet(reader.maxDoc()), 0));
           }
@@ -285,7 +285,7 @@ private void collectTermContext(IndexReader reader,
       TermsEnum termsEnum = null;
       for (LeafReaderContext context : leaves) {
 
-        Terms terms = context.reader().terms(this.field);
+        FieldTerms terms = context.reader().terms(this.field);
         if (terms == null) {
           // field does not exist
           continue;
diff --git a/solr/core/src/java/org/apache/solr/search/IGainTermsQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/IGainTermsQParserPlugin.java
index bccbe0655898..34ecd9f59ba6 100644
--- a/solr/core/src/java/org/apache/solr/search/IGainTermsQParserPlugin.java
+++ b/solr/core/src/java/org/apache/solr/search/IGainTermsQParserPlugin.java
@@ -26,7 +26,7 @@
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.NumericDocValues;
 import org.apache.lucene.index.PostingsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.IndexSearcher;
@@ -162,7 +162,7 @@ public void finish() throws IOException {
       double pc = numPositiveDocs / numDocs;
       double entropyC = binaryEntropy(pc);
 
-      Terms terms = MultiFields.getFields(searcher.getIndexReader()).terms(field);
+      FieldTerms terms = MultiFields.getFields(searcher.getIndexReader()).terms(field);
       TermsEnum termsEnum = terms.iterator();
       BytesRef term;
       PostingsEnum postingsEnum = null;
diff --git a/solr/core/src/java/org/apache/solr/search/JoinQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/JoinQParserPlugin.java
index bf64060aea1e..ca54f8717dd6 100644
--- a/solr/core/src/java/org/apache/solr/search/JoinQParserPlugin.java
+++ b/solr/core/src/java/org/apache/solr/search/JoinQParserPlugin.java
@@ -28,7 +28,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.MultiPostingsEnum;
 import org.apache.lucene.index.PostingsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.ConstantScoreScorer;
 import org.apache.lucene.search.ConstantScoreWeight;
@@ -303,8 +303,8 @@ public DocSet getDocSet() throws IOException {
       Fields fromFields = fromSearcher.getSlowAtomicReader().fields();
       Fields toFields = fromSearcher==toSearcher ? fromFields : toSearcher.getSlowAtomicReader().fields();
       if (fromFields == null) return DocSet.EMPTY;
-      Terms terms = fromFields.terms(fromField);
-      Terms toTerms = toFields.terms(toField);
+      FieldTerms terms = fromFields.terms(fromField);
+      FieldTerms toTerms = toFields.terms(toField);
       if (terms == null || toTerms==null) return DocSet.EMPTY;
       String prefixStr = TrieField.getMainValuePrefix(fromSearcher.getSchema().getFieldType(fromField));
       BytesRef prefix = prefixStr == null ? null : new BytesRef(prefixStr);
diff --git a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
index 6d13b5150768..9727d444b68e 100644
--- a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
+++ b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
@@ -957,7 +957,7 @@ private SortSpec implWeightSortSpec(Sort originalSort, int num, int offset, Sort
    * @return the first document number containing the term
    */
   public int getFirstMatch(Term t) throws IOException {
-    Terms terms = leafReader.terms(t.field());
+    FieldTerms terms = leafReader.terms(t.field());
     if (terms == null) return -1;
     BytesRef termBytes = t.bytes();
     final TermsEnum termsEnum = terms.iterator();
@@ -983,7 +983,7 @@ public long lookupId(BytesRef idBytes) throws IOException {
       final LeafReaderContext leaf = leafContexts.get(i);
       final LeafReader reader = leaf.reader();
 
-      final Terms terms = reader.terms(field);
+      final FieldTerms terms = reader.terms(field);
       if (terms == null) continue;
 
       TermsEnum te = terms.iterator();
diff --git a/solr/core/src/java/org/apache/solr/search/TextLogisticRegressionQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/TextLogisticRegressionQParserPlugin.java
index c1b89061b22e..4493f5ef7dea 100644
--- a/solr/core/src/java/org/apache/solr/search/TextLogisticRegressionQParserPlugin.java
+++ b/solr/core/src/java/org/apache/solr/search/TextLogisticRegressionQParserPlugin.java
@@ -29,7 +29,7 @@
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.NumericDocValues;
 import org.apache.lucene.index.PostingsEnum;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.IndexSearcher;
@@ -173,7 +173,7 @@ public void collect(int doc) throws IOException{
     public void finish() throws IOException {
 
       Map docVectors = new HashMap<>();
-      Terms terms = MultiFields.getFields(searcher.getIndexReader()).terms(trainingParams.feature);
+      FieldTerms terms = MultiFields.getFields(searcher.getIndexReader()).terms(trainingParams.feature);
       TermsEnum termsEnum = terms.iterator();
       PostingsEnum postingsEnum = null;
       int termIndex = 0;
diff --git a/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByEnumTermsStream.java b/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByEnumTermsStream.java
index 2ab47132331f..bedd27d75050 100644
--- a/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByEnumTermsStream.java
+++ b/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByEnumTermsStream.java
@@ -27,7 +27,7 @@
 import org.apache.lucene.index.MultiPostingsEnum;
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.TermQuery;
@@ -157,7 +157,7 @@ private void setup() throws IOException {
     }
 
     Fields fields = fcontext.searcher.getSlowAtomicReader().fields();
-    Terms terms = fields == null ? null : fields.terms(sf.getName());
+    FieldTerms terms = fields == null ? null : fields.terms(sf.getName());
 
     termsEnum = null;
     deState = null;
diff --git a/solr/core/src/java/org/apache/solr/uninverting/DocTermOrds.java b/solr/core/src/java/org/apache/solr/uninverting/DocTermOrds.java
index fcc6974f480b..6ef475c27843 100644
--- a/solr/core/src/java/org/apache/solr/uninverting/DocTermOrds.java
+++ b/solr/core/src/java/org/apache/solr/uninverting/DocTermOrds.java
@@ -31,7 +31,7 @@
 import org.apache.lucene.index.LegacySortedSetDocValuesWrapper;
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.SortedSetDocValues;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.util.Accountable;
@@ -287,7 +287,7 @@ protected void uninvert(final LeafReader reader, Bits liveDocs, final BytesRef t
     final int[] lastTerm = new int[maxDoc];    // last term we saw for this document
     final byte[][] bytes = new byte[maxDoc][]; // list of term numbers for the doc (delta encoded vInts)
 
-    final Terms terms = reader.terms(field);
+    final FieldTerms terms = reader.terms(field);
     if (terms == null) {
       // No terms
       return;
diff --git a/solr/core/src/java/org/apache/solr/uninverting/FieldCache.java b/solr/core/src/java/org/apache/solr/uninverting/FieldCache.java
index 544800e3d3be..6b4bc3a749ae 100644
--- a/solr/core/src/java/org/apache/solr/uninverting/FieldCache.java
+++ b/solr/core/src/java/org/apache/solr/uninverting/FieldCache.java
@@ -26,7 +26,7 @@
 import org.apache.lucene.index.NumericDocValues;
 import org.apache.lucene.index.SortedDocValues;
 import org.apache.lucene.index.SortedSetDocValues;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.legacy.LegacyNumericUtils;
 import org.apache.lucene.util.Accountable;
@@ -66,16 +66,16 @@ public long ramBytesUsed() {
   public interface Parser {
     
     /**
-     * Pulls a {@link TermsEnum} from the given {@link Terms}. This method allows certain parsers
+     * Pulls a {@link TermsEnum} from the given {@link FieldTerms}. This method allows certain parsers
      * to filter the actual TermsEnum before the field cache is filled.
      * 
-     * @param terms the {@link Terms} instance to create the {@link TermsEnum} from.
+     * @param terms the {@link FieldTerms} instance to create the {@link TermsEnum} from.
      * @return a possibly filtered {@link TermsEnum} instance, this method must not return null.
      * @throws IOException if an {@link IOException} occurs
      * @deprecated index with Points instead
      */
     @Deprecated
-    public TermsEnum termsEnum(Terms terms) throws IOException;
+    public TermsEnum termsEnum(FieldTerms terms) throws IOException;
     
     /** Parse's this field's value */
     public long parseValue(BytesRef term);
@@ -88,7 +88,7 @@ public interface Parser {
    * This abstraction can be cleaned up when Parser.termsEnum is removed.
    */
   public abstract class PointParser implements Parser {
-    public final TermsEnum termsEnum(Terms terms) throws IOException {
+    public final TermsEnum termsEnum(FieldTerms terms) throws IOException {
       throw new UnsupportedOperationException("makes no sense for parsing points");
     }
   }
@@ -173,7 +173,7 @@ public long parseValue(BytesRef term) {
     }
     
     @Override
-    public TermsEnum termsEnum(Terms terms) throws IOException {
+    public TermsEnum termsEnum(FieldTerms terms) throws IOException {
       return LegacyNumericUtils.filterPrefixCodedInts(terms.iterator());
     }
     
@@ -203,7 +203,7 @@ public String toString() {
     }
     
     @Override
-    public TermsEnum termsEnum(Terms terms) throws IOException {
+    public TermsEnum termsEnum(FieldTerms terms) throws IOException {
       return LegacyNumericUtils.filterPrefixCodedInts(terms.iterator());
     }
   };
@@ -225,7 +225,7 @@ public String toString() {
     }
     
     @Override
-    public TermsEnum termsEnum(Terms terms) throws IOException {
+    public TermsEnum termsEnum(FieldTerms terms) throws IOException {
       return LegacyNumericUtils.filterPrefixCodedLongs(terms.iterator());
     }
   };
@@ -249,7 +249,7 @@ public String toString() {
     }
     
     @Override
-    public TermsEnum termsEnum(Terms terms) throws IOException {
+    public TermsEnum termsEnum(FieldTerms terms) throws IOException {
       return LegacyNumericUtils.filterPrefixCodedLongs(terms.iterator());
     }
   };
diff --git a/solr/core/src/java/org/apache/solr/uninverting/FieldCacheImpl.java b/solr/core/src/java/org/apache/solr/uninverting/FieldCacheImpl.java
index 90be40070ba3..8e9a995a05d3 100644
--- a/solr/core/src/java/org/apache/solr/uninverting/FieldCacheImpl.java
+++ b/solr/core/src/java/org/apache/solr/uninverting/FieldCacheImpl.java
@@ -40,7 +40,7 @@
 import org.apache.lucene.index.SegmentReader;
 import org.apache.lucene.index.SortedDocValues;
 import org.apache.lucene.index.SortedSetDocValues;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.util.Accountable;
@@ -323,7 +323,7 @@ public Relation compare(byte[] minPackedValue, byte[] maxPackedValue) {
     
     final void uninvertPostings(LeafReader reader, String field) throws IOException {
       final int maxDoc = reader.maxDoc();
-      Terms terms = reader.terms(field);
+      FieldTerms terms = reader.terms(field);
       if (terms != null) {
         final boolean setDocsWithField;
         final int termsDocCount = terms.getDocCount();
@@ -365,7 +365,7 @@ final void uninvertPostings(LeafReader reader, String field) throws IOException
       }
     }
 
-    protected abstract TermsEnum termsEnum(Terms terms) throws IOException;
+    protected abstract TermsEnum termsEnum(FieldTerms terms) throws IOException;
     protected abstract void visitTerm(BytesRef term);
     protected abstract void visitDoc(int docID);
   }
@@ -524,7 +524,7 @@ private BitsEntry createValuePoints(LeafReader reader, String field) throws IOEx
       // otherwise a no-op uninvert!
       Uninvert u = new Uninvert(true) {
         @Override
-        protected TermsEnum termsEnum(Terms terms) throws IOException {
+        protected TermsEnum termsEnum(FieldTerms terms) throws IOException {
           throw new AssertionError();
         }
 
@@ -544,7 +544,7 @@ private BitsEntry createValuePostings(LeafReader reader, String field) throws IO
 
       // Visit all docs that have terms for this field
       FixedBitSet res = null;
-      Terms terms = reader.terms(field);
+      FieldTerms terms = reader.terms(field);
       if (terms != null) {
         final int termsDocCount = terms.getDocCount();
         assert termsDocCount <= maxDoc;
@@ -758,7 +758,7 @@ public void visitDoc(int docID) {
           }
           
           @Override
-          protected TermsEnum termsEnum(Terms terms) throws IOException {
+          protected TermsEnum termsEnum(FieldTerms terms) throws IOException {
             return parser.termsEnum(terms);
           }
         };
@@ -927,7 +927,7 @@ protected Accountable createValue(LeafReader reader, CacheKey key)
 
       final int maxDoc = reader.maxDoc();
 
-      Terms terms = reader.terms(key.field);
+      FieldTerms terms = reader.terms(key.field);
 
       final float acceptableOverheadRatio = ((Float) key.custom).floatValue();
 
@@ -1128,7 +1128,7 @@ protected Accountable createValue(LeafReader reader, CacheKey key)
       // that instead, to avoid insanity
 
       final int maxDoc = reader.maxDoc();
-      Terms terms = reader.terms(key.field);
+      FieldTerms terms = reader.terms(key.field);
 
       final float acceptableOverheadRatio = ((Float) key.custom).floatValue();
 
@@ -1235,7 +1235,7 @@ public SortedSetDocValues getDocTermOrds(LeafReader reader, String field, BytesR
     
     // ok we need to uninvert. check if we can optimize a bit.
     
-    Terms terms = reader.terms(field);
+    FieldTerms terms = reader.terms(field);
     if (terms == null) {
       return DocValues.emptySortedSet();
     } else {
diff --git a/solr/core/src/java/org/apache/solr/update/SolrIndexSplitter.java b/solr/core/src/java/org/apache/solr/update/SolrIndexSplitter.java
index bd4612e5cc47..2286aee56234 100644
--- a/solr/core/src/java/org/apache/solr/update/SolrIndexSplitter.java
+++ b/solr/core/src/java/org/apache/solr/update/SolrIndexSplitter.java
@@ -29,7 +29,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.SlowCodecReaderWrapper;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.util.Bits;
@@ -165,7 +165,7 @@ FixedBitSet[] split(LeafReaderContext readerContext) throws IOException {
     Bits liveDocs = reader.getLiveDocs();
 
     Fields fields = reader.fields();
-    Terms terms = fields==null ? null : fields.terms(field.getName());
+    FieldTerms terms = fields==null ? null : fields.terms(field.getName());
     TermsEnum termsEnum = terms==null ? null : terms.iterator();
     if (termsEnum == null) return docSets;
 
diff --git a/solr/core/src/java/org/apache/solr/update/VersionInfo.java b/solr/core/src/java/org/apache/solr/update/VersionInfo.java
index 3c55172258fd..07a0486817ee 100644
--- a/solr/core/src/java/org/apache/solr/update/VersionInfo.java
+++ b/solr/core/src/java/org/apache/solr/update/VersionInfo.java
@@ -24,7 +24,7 @@
 
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.LeafReaderContext;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.legacy.LegacyNumericUtils;
 import org.apache.lucene.queries.function.FunctionValues;
 import org.apache.lucene.queries.function.ValueSource;
@@ -229,11 +229,11 @@ public Long getMaxVersionFromIndex(IndexSearcher searcher) throws IOException {
     // if indexed, then we have terms to get the max from
     if (versionField.indexed()) {
       LeafReader leafReader = SlowCompositeReaderWrapper.wrap(searcher.getIndexReader());
-      Terms versionTerms = leafReader.terms(versionFieldName);
+      FieldTerms versionTerms = leafReader.terms(versionFieldName);
       Long max = (versionTerms != null) ? LegacyNumericUtils.getMaxLong(versionTerms) : null;
       if (max != null) {
         maxVersionInIndex = max.longValue();
-        log.debug("Found MAX value {} from Terms for {} in index", maxVersionInIndex, versionFieldName);
+        log.debug("Found MAX value {} from FieldTerms for {} in index", maxVersionInIndex, versionFieldName);
       } else {
         log.debug("No terms found for {}, cannot seed version bucket highest value from index", versionFieldName);
       }
diff --git a/solr/core/src/test/org/apache/solr/search/TestRTGBase.java b/solr/core/src/test/org/apache/solr/search/TestRTGBase.java
index bb1b08a04a53..c565cdece2ff 100644
--- a/solr/core/src/test/org/apache/solr/search/TestRTGBase.java
+++ b/solr/core/src/test/org/apache/solr/search/TestRTGBase.java
@@ -28,7 +28,7 @@
 import org.apache.lucene.index.MultiFields;
 import org.apache.lucene.index.PostingsEnum;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.util.BytesRef;
@@ -108,7 +108,7 @@ protected List getLatestVersions() {
 
 
   protected int getFirstMatch(IndexReader r, Term t) throws IOException {
-    Terms terms = MultiFields.getTerms(r, t.field());
+    FieldTerms terms = MultiFields.getTerms(r, t.field());
     if (terms == null) return -1;
     BytesRef termBytes = t.bytes();
     final TermsEnum termsEnum = terms.iterator();
diff --git a/solr/core/src/test/org/apache/solr/uninverting/TestDocTermOrds.java b/solr/core/src/test/org/apache/solr/uninverting/TestDocTermOrds.java
index 67b62cfe75ff..5f47c2468c22 100644
--- a/solr/core/src/test/org/apache/solr/uninverting/TestDocTermOrds.java
+++ b/solr/core/src/test/org/apache/solr/uninverting/TestDocTermOrds.java
@@ -41,7 +41,7 @@
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.SortedSetDocValues;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum.SeekStatus;
 import org.apache.lucene.legacy.LegacyIntField;
 import org.apache.lucene.legacy.LegacyLongField;
@@ -376,7 +376,7 @@ private void verify(LeafReader r, int[][] idToOrds, BytesRef[] termsArray, Bytes
       if (prefixRef == null) {
         assertNull(MultiFields.getTerms(r, "field"));
       } else {
-        Terms terms = MultiFields.getTerms(r, "field");
+        FieldTerms terms = MultiFields.getTerms(r, "field");
         if (terms != null) {
           TermsEnum termsEnum = terms.iterator();
           TermsEnum.SeekStatus result = termsEnum.seekCeil(prefixRef);
diff --git a/solr/core/src/test/org/apache/solr/uninverting/TestLegacyFieldCache.java b/solr/core/src/test/org/apache/solr/uninverting/TestLegacyFieldCache.java
index 9dc047bcb3a1..fece44bb4595 100644
--- a/solr/core/src/test/org/apache/solr/uninverting/TestLegacyFieldCache.java
+++ b/solr/core/src/test/org/apache/solr/uninverting/TestLegacyFieldCache.java
@@ -32,7 +32,7 @@
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.NumericDocValues;
 import org.apache.lucene.index.RandomIndexWriter;
-import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.FieldTerms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.legacy.LegacyDoubleField;
 import org.apache.lucene.legacy.LegacyFloatField;
@@ -115,7 +115,7 @@ public void testInfoStream() throws Exception {
       cache.getNumerics(reader, "theDouble", FieldCache.LEGACY_DOUBLE_PARSER);
       cache.getNumerics(reader, "theDouble", new FieldCache.Parser() {
         @Override
-        public TermsEnum termsEnum(Terms terms) throws IOException {
+        public TermsEnum termsEnum(FieldTerms terms) throws IOException {
           return LegacyNumericUtils.filterPrefixCodedLongs(terms.iterator());
         }
         @Override