From 3d404c5d3c6079621d2b179d6c0c16dc4845b534 Mon Sep 17 00:00:00 2001
From: unknown <laimis@gmail.com>
Date: Fri, 14 Apr 2023 09:43:32 -0700
Subject: [PATCH 01/11] introduce protected constructor that allows to avoid
 virtual calls

---
 src/Lucene.Net/Search/IndexSearcher.cs | 35 +++++++++++++++-----------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index abdee3c172..d1a1108705 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -135,13 +135,30 @@ public IndexSearcher(IndexReader r, TaskScheduler executor)
         /// <seealso cref="IndexReaderContext"/>
         /// <seealso cref="IndexReader.Context"/>
         public IndexSearcher(IndexReaderContext context, TaskScheduler executor)
+            : this(context, executor, allocateLeafSlices: executor is not null)
+        {
+        }
+
+        /// <summary>
+        /// LUCENENET specific constructor that can be used by the subclasses to
+        /// control whether or not the leaf slices are allocated.
+        /// If you choose to skip allocating the leaf slices here, you must 
+        /// call <see cref="Slices"/> in your subclass's constructor.
+        /// </summary>
+        [SuppressMessage("CodeQuality", "IDE0079:Remove unnecessary suppression", Justification = "This is a SonarCloud issue")]
+        [SuppressMessage("CodeQuality", "S1699:Constructors should only call non-overridable methods", Justification = "Required for continuity with Lucene's design")]
+        protected IndexSearcher(IndexReaderContext context, TaskScheduler executor, bool allocateLeafSlices)
         {
             if (Debugging.AssertsEnabled) Debugging.Assert(context.IsTopLevel,"IndexSearcher's ReaderContext must be topLevel for reader {0}", context.Reader);
             reader = context.Reader;
             this.executor = executor;
             this.m_readerContext = context;
             m_leafContexts = context.Leaves;
-            this.m_leafSlices = executor is null ? null : GetSlicesInternal(m_leafContexts);
+
+            if (allocateLeafSlices)
+            {
+                this.m_leafSlices = Slices(m_leafContexts);
+            }
         }
 
         /// <summary>
@@ -160,18 +177,8 @@ public IndexSearcher(IndexReaderContext context)
         /// Expert: Creates an array of leaf slices each holding a subset of the given leaves.
         /// Each <see cref="LeafSlice"/> is executed in a single thread. By default there
         /// will be one <see cref="LeafSlice"/> per leaf (<see cref="AtomicReaderContext"/>).
-        /// 
-        /// NOTE: When overriding this method, be aware that the constructor of this class calls 
-        /// a private method and not this virtual method. So if you need to override
-        /// the behavior during the initialization, call your own private method from the constructor
-        /// with whatever custom behavior you need.
         /// </summary>
-        // LUCENENET specific - renamed to GetSlices to better indicate the purpose of this method
-        protected virtual LeafSlice[] GetSlices(IList<AtomicReaderContext> leaves)
-            => GetSlicesInternal(leaves);
-
-        // LUCENENET specific - creating this so that we can call it from the constructor
-        protected LeafSlice[] GetSlicesInternal(IList<AtomicReaderContext> leaves)
+        protected virtual LeafSlice[] Slices(IList<AtomicReaderContext> leaves)
         {
             LeafSlice[] slices = new LeafSlice[leaves.Count];
             for (int i = 0; i < slices.Length; i++)
@@ -460,7 +467,7 @@ protected virtual TopDocs Search(Weight weight, ScoreDoc after, int nDocs)
             }
             else
             {
-                HitQueue hq = new HitQueue(nDocs, prePopulate: false);
+                HitQueue hq = new HitQueue(nDocs, false);
                 ReentrantLock @lock = new ReentrantLock();
                 ExecutionHelper<TopDocs> runner = new ExecutionHelper<TopDocs>(executor);
 
@@ -538,7 +545,7 @@ protected virtual TopFieldDocs Search(Weight weight, FieldDoc after, int nDocs,
         {
             if (sort is null)
             {
-                throw new ArgumentNullException(nameof(sort), "Sort must not be null"); // LUCENENET specific - changed from IllegalArgumentException to ArgumentNullException (.NET convention)
+                throw new ArgumentNullException("Sort must not be null"); // LUCENENET specific - changed from IllegalArgumentException to ArgumentNullException (.NET convention)
             }
 
             int limit = reader.MaxDoc;

From 6a15e75fccc2d5fc04fb96d9e766b6138f208a0d Mon Sep 17 00:00:00 2001
From: unknown <laimis@gmail.com>
Date: Fri, 14 Apr 2023 09:43:48 -0700
Subject: [PATCH 02/11] introduce protected constructor that allows to avoid
 virtual calls

---
 src/Lucene.Net/Search/IndexSearcher.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index d1a1108705..c9e8d27cb3 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;

From cf309715964a8e32715c8c4644aff6610fb94540 Mon Sep 17 00:00:00 2001
From: unknown <laimis@gmail.com>
Date: Fri, 14 Apr 2023 09:52:08 -0700
Subject: [PATCH 03/11] introduce protected constructor that allows to avoid
 virtual calls

---
 src/Lucene.Net/Search/IndexSearcher.cs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index c9e8d27cb3..7e4ae33289 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -472,6 +472,10 @@ protected virtual TopDocs Search(Weight weight, ScoreDoc after, int nDocs)
                 ReentrantLock @lock = new ReentrantLock();
                 ExecutionHelper<TopDocs> runner = new ExecutionHelper<TopDocs>(executor);
 
+                if (m_leafSlices == null)
+                    throw new InvalidOperationException("m_leafSlices must not be null and initialized in the constructor");
+            
+
                 for (int i = 0; i < m_leafSlices.Length; i++) // search each sub
                 {
                     runner.Submit(new SearcherCallableNoSort(@lock, this, m_leafSlices[i], weight, after, nDocs, hq).Call);

From 71ff3a8812c1af47921fd978653116ef21fb1268 Mon Sep 17 00:00:00 2001
From: unknown <laimis@gmail.com>
Date: Fri, 14 Apr 2023 09:55:50 -0700
Subject: [PATCH 04/11] introduce protected constructor that allows to avoid
 virtual calls

---
 src/Lucene.Net/Search/IndexSearcher.cs | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index 7e4ae33289..2696c7b7a3 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -1,5 +1,4 @@
 using Lucene.Net.Diagnostics;
-using Lucene.Net.Support;
 using Lucene.Net.Support.Threading;
 using Lucene.Net.Util;
 using System;
@@ -7,7 +6,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Lucene.Net.Search
@@ -144,7 +142,7 @@ public IndexSearcher(IndexReaderContext context, TaskScheduler executor)
         /// LUCENENET specific constructor that can be used by the subclasses to
         /// control whether or not the leaf slices are allocated.
         /// If you choose to skip allocating the leaf slices here, you must 
-        /// call <see cref="Slices"/> in your subclass's constructor.
+        /// call <see cref="GetSlices"/> in your subclass's constructor.
         /// </summary>
         [SuppressMessage("CodeQuality", "IDE0079:Remove unnecessary suppression", Justification = "This is a SonarCloud issue")]
         [SuppressMessage("CodeQuality", "S1699:Constructors should only call non-overridable methods", Justification = "Required for continuity with Lucene's design")]
@@ -158,7 +156,7 @@ protected IndexSearcher(IndexReaderContext context, TaskScheduler executor, bool
 
             if (allocateLeafSlices)
             {
-                this.m_leafSlices = Slices(m_leafContexts);
+                this.m_leafSlices = GetSlices(m_leafContexts);
             }
         }
 
@@ -179,7 +177,7 @@ public IndexSearcher(IndexReaderContext context)
         /// Each <see cref="LeafSlice"/> is executed in a single thread. By default there
         /// will be one <see cref="LeafSlice"/> per leaf (<see cref="AtomicReaderContext"/>).
         /// </summary>
-        protected virtual LeafSlice[] Slices(IList<AtomicReaderContext> leaves)
+        protected virtual LeafSlice[] GetSlices(IList<AtomicReaderContext> leaves)
         {
             LeafSlice[] slices = new LeafSlice[leaves.Count];
             for (int i = 0; i < slices.Length; i++)
@@ -468,7 +466,7 @@ protected virtual TopDocs Search(Weight weight, ScoreDoc after, int nDocs)
             }
             else
             {
-                HitQueue hq = new HitQueue(nDocs, false);
+                HitQueue hq = new HitQueue(nDocs, prePopulate: false);
                 ReentrantLock @lock = new ReentrantLock();
                 ExecutionHelper<TopDocs> runner = new ExecutionHelper<TopDocs>(executor);
 
@@ -550,7 +548,7 @@ protected virtual TopFieldDocs Search(Weight weight, FieldDoc after, int nDocs,
         {
             if (sort is null)
             {
-                throw new ArgumentNullException("Sort must not be null"); // LUCENENET specific - changed from IllegalArgumentException to ArgumentNullException (.NET convention)
+                throw new ArgumentNullException(nameof(sort), "Sort must not be null"); // LUCENENET specific - changed from IllegalArgumentException to ArgumentNullException (.NET convention)
             }
 
             int limit = reader.MaxDoc;

From e92da0586478a932b40fffa388740eab0e020266 Mon Sep 17 00:00:00 2001
From: unknown <laimis@gmail.com>
Date: Fri, 14 Apr 2023 10:03:35 -0700
Subject: [PATCH 05/11] adjust comments

---
 src/Lucene.Net/Search/IndexSearcher.cs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index 2696c7b7a3..1a87e8986c 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -142,7 +142,8 @@ public IndexSearcher(IndexReaderContext context, TaskScheduler executor)
         /// LUCENENET specific constructor that can be used by the subclasses to
         /// control whether or not the leaf slices are allocated.
         /// If you choose to skip allocating the leaf slices here, you must 
-        /// call <see cref="GetSlices"/> in your subclass's constructor.
+        /// initialize <see cref="m_leafSlices" /> in your subclass's constructor, either
+        /// by calling <see cref="GetSlices"/> or using your own logic
         /// </summary>
         [SuppressMessage("CodeQuality", "IDE0079:Remove unnecessary suppression", Justification = "This is a SonarCloud issue")]
         [SuppressMessage("CodeQuality", "S1699:Constructors should only call non-overridable methods", Justification = "Required for continuity with Lucene's design")]
@@ -472,7 +473,6 @@ protected virtual TopDocs Search(Weight weight, ScoreDoc after, int nDocs)
 
                 if (m_leafSlices == null)
                     throw new InvalidOperationException("m_leafSlices must not be null and initialized in the constructor");
-            
 
                 for (int i = 0; i < m_leafSlices.Length; i++) // search each sub
                 {
@@ -570,6 +570,9 @@ protected virtual TopFieldDocs Search(Weight weight, FieldDoc after, int nDocs,
                 ReentrantLock @lock = new ReentrantLock();
                 ExecutionHelper<TopFieldDocs> runner = new ExecutionHelper<TopFieldDocs>(executor);
 
+                if (m_leafSlices == null)
+                    throw new InvalidOperationException("m_leafSlices must not be null and initialized in the constructor");
+
                 for (int i = 0; i < m_leafSlices.Length; i++) // search each leaf slice
                 {
                     runner.Submit(new SearcherCallableWithSort(@lock, this, m_leafSlices[i], weight, after, nDocs, topCollector, sort, doDocScores, doMaxScore).Call);

From daf510ed612de3d8bd63f9dfef1c5f74c5c22b4d Mon Sep 17 00:00:00 2001
From: unknown <laimis@gmail.com>
Date: Fri, 14 Apr 2023 10:55:43 -0700
Subject: [PATCH 06/11] feedback

---
 src/Lucene.Net/Search/IndexSearcher.cs | 33 ++++++++++++++++++--------
 1 file changed, 23 insertions(+), 10 deletions(-)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index 1a87e8986c..665e4f711a 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -117,7 +117,7 @@ public IndexSearcher(IndexReader r)
         /// @lucene.experimental
         /// </summary>
         public IndexSearcher(IndexReader r, TaskScheduler executor)
-            : this(r.Context, executor)
+            : this(r?.Context, executor)
         {
         }
 
@@ -140,16 +140,29 @@ public IndexSearcher(IndexReaderContext context, TaskScheduler executor)
 
         /// <summary>
         /// LUCENENET specific constructor that can be used by the subclasses to
-        /// control whether or not the leaf slices are allocated.
-        /// If you choose to skip allocating the leaf slices here, you must 
-        /// initialize <see cref="m_leafSlices" /> in your subclass's constructor, either
-        /// by calling <see cref="GetSlices"/> or using your own logic
+        /// control whether the leaf slices are allocated in the base class or subclass.
         /// </summary>
+        /// <remarks>
+        /// If executor is non-<c>null</c> and you choose to skip allocating the leaf slices
+        /// (i.e. <paramref name="allocateLeafSlices"/> == <c>false</c>), you must
+        /// set the <see cref="m_leafSlices"/> field in your subclass constructor.
+        /// This is commonly done by calling <see cref="GetSlices(IList{AtomicReaderContext})"/>
+        /// and using the result to set <see cref="m_leafSlices"/>. You may wish to do this if you
+        /// have state to pass into your constructor and need to set it prior to the call to
+        /// <see cref="GetSlices(IList{AtomicReaderContext})"/> so it is available for use
+        /// as a member field or property inside a custom override of
+        /// <see cref="GetSlices(IList{AtomicReaderContext})"/>.
+        /// </remarks>
         [SuppressMessage("CodeQuality", "IDE0079:Remove unnecessary suppression", Justification = "This is a SonarCloud issue")]
         [SuppressMessage("CodeQuality", "S1699:Constructors should only call non-overridable methods", Justification = "Required for continuity with Lucene's design")]
         protected IndexSearcher(IndexReaderContext context, TaskScheduler executor, bool allocateLeafSlices)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(context.IsTopLevel,"IndexSearcher's ReaderContext must be topLevel for reader {0}", context.Reader);
+            if (context is null)
+                throw new ArgumentNullException(nameof(context));
+
+            if (Debugging.AssertsEnabled)
+                Debugging.Assert(context.IsTopLevel,"IndexSearcher's ReaderContext must be topLevel for reader {0}", context.Reader);
+
             reader = context.Reader;
             this.executor = executor;
             this.m_readerContext = context;
@@ -471,8 +484,8 @@ protected virtual TopDocs Search(Weight weight, ScoreDoc after, int nDocs)
                 ReentrantLock @lock = new ReentrantLock();
                 ExecutionHelper<TopDocs> runner = new ExecutionHelper<TopDocs>(executor);
 
-                if (m_leafSlices == null)
-                    throw new InvalidOperationException("m_leafSlices must not be null and initialized in the constructor");
+                if (m_leafSlices is null)
+                    throw new InvalidOperationException($"When the constructor is passed a non-null {nameof(TaskScheduler)}, {nameof(m_leafSlices)} must also be set to a non-null value in the constructor.");
 
                 for (int i = 0; i < m_leafSlices.Length; i++) // search each sub
                 {
@@ -570,8 +583,8 @@ protected virtual TopFieldDocs Search(Weight weight, FieldDoc after, int nDocs,
                 ReentrantLock @lock = new ReentrantLock();
                 ExecutionHelper<TopFieldDocs> runner = new ExecutionHelper<TopFieldDocs>(executor);
 
-                if (m_leafSlices == null)
-                    throw new InvalidOperationException("m_leafSlices must not be null and initialized in the constructor");
+                if (m_leafSlices is null)
+                    throw new InvalidOperationException($"When the constructor is passed a non-null {nameof(TaskScheduler)}, {nameof(m_leafSlices)} must also be set to a non-null value in the constructor.");
 
                 for (int i = 0; i < m_leafSlices.Length; i++) // search each leaf slice
                 {

From 00843c3e2454eedc6ff237908379bece26ae28e2 Mon Sep 17 00:00:00 2001
From: unknown <laimis@gmail.com>
Date: Fri, 14 Apr 2023 11:20:43 -0700
Subject: [PATCH 07/11] nullable enable

---
 src/Lucene.Net/Search/IndexSearcher.cs | 82 ++++++++++++++------------
 1 file changed, 45 insertions(+), 37 deletions(-)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index 665e4f711a..974aee4f48 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+#nullable enable
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support.Threading;
 using Lucene.Net.Util;
 using System;
@@ -79,10 +80,10 @@ public class IndexSearcher
 
         /// <summary>
         /// Used with executor - each slice holds a set of leafs executed within one thread </summary>
-        protected readonly LeafSlice[] m_leafSlices;
+        protected readonly LeafSlice[]? m_leafSlices;
 
         // These are only used for multi-threaded search
-        private readonly TaskScheduler executor;
+        private readonly TaskScheduler? executor;
 
         // the default Similarity
         private static readonly Similarity defaultSimilarity = new DefaultSimilarity();
@@ -104,7 +105,7 @@ public class IndexSearcher
         /// <summary>
         /// Creates a searcher searching the provided index. </summary>
         public IndexSearcher(IndexReader r)
-            : this(r, null)
+            : this(r, executor: null)
         {
         }
 
@@ -116,8 +117,8 @@ public IndexSearcher(IndexReader r)
         /// <para/>
         /// @lucene.experimental
         /// </summary>
-        public IndexSearcher(IndexReader r, TaskScheduler executor)
-            : this(r?.Context, executor)
+        public IndexSearcher(IndexReader r, TaskScheduler? executor)
+            : this(r.Context, executor)
         {
         }
 
@@ -133,7 +134,7 @@ public IndexSearcher(IndexReader r, TaskScheduler executor)
         /// </summary>
         /// <seealso cref="IndexReaderContext"/>
         /// <seealso cref="IndexReader.Context"/>
-        public IndexSearcher(IndexReaderContext context, TaskScheduler executor)
+        public IndexSearcher(IndexReaderContext context, TaskScheduler? executor)
             : this(context, executor, allocateLeafSlices: executor is not null)
         {
         }
@@ -155,7 +156,7 @@ public IndexSearcher(IndexReaderContext context, TaskScheduler executor)
         /// </remarks>
         [SuppressMessage("CodeQuality", "IDE0079:Remove unnecessary suppression", Justification = "This is a SonarCloud issue")]
         [SuppressMessage("CodeQuality", "S1699:Constructors should only call non-overridable methods", Justification = "Required for continuity with Lucene's design")]
-        protected IndexSearcher(IndexReaderContext context, TaskScheduler executor, bool allocateLeafSlices)
+        protected IndexSearcher(IndexReaderContext context, TaskScheduler? executor, bool allocateLeafSlices)
         {
             if (context is null)
                 throw new ArgumentNullException(nameof(context));
@@ -247,7 +248,7 @@ public virtual Similarity Similarity
 
         /// <summary>
         /// @lucene.internal </summary>
-        protected virtual Query WrapFilter(Query query, Filter filter)
+        protected virtual Query WrapFilter(Query query, Filter? filter)
         {
             return (filter is null) ? query : new FilteredQuery(query, filter);
         }
@@ -292,7 +293,7 @@ public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, i
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
         public virtual TopDocs Search(Query query, int n)
         {
-            return Search(query, null, n);
+            return Search(query, filter: null, n);
         }
 
         /// <summary>
@@ -301,9 +302,9 @@ public virtual TopDocs Search(Query query, int n)
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        public virtual TopDocs Search(Query query, Filter filter, int n)
+        public virtual TopDocs Search(Query query, Filter? filter, int n)
         {
-            return Search(CreateNormalizedWeight(WrapFilter(query, filter)), null, n);
+            return Search(CreateNormalizedWeight(WrapFilter(query, filter)), after: null, n);
         }
 
         /// <summary>
@@ -383,13 +384,27 @@ public virtual TopFieldDocs Search(Query query, Filter filter, int n, Sort sort,
         ///         <seealso cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
         public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n, Sort sort)
         {
+            FieldDoc? fieldDoc = GetScoreDocAsFieldDocIfNotNull(after);
+
+            return Search(CreateNormalizedWeight(WrapFilter(query, filter)), fieldDoc, n, sort, true, false, false);
+        }
+
+        private static FieldDoc? GetScoreDocAsFieldDocIfNotNull(ScoreDoc after)
+        {
+            FieldDoc? fieldDoc = null;
             if (after != null && !(after is FieldDoc))
             {
                 // TODO: if we fix type safety of TopFieldDocs we can
                 // remove this
                 throw new ArgumentException("after must be a FieldDoc; got " + after);
             }
-            return Search(CreateNormalizedWeight(WrapFilter(query, filter)), (FieldDoc)after, n, sort, true, false, false);
+
+            if (after != null && after is FieldDoc)
+            {
+                fieldDoc = (FieldDoc)after;
+            }
+
+            return fieldDoc;
         }
 
         /// <summary>
@@ -417,13 +432,9 @@ public virtual TopFieldDocs Search(Query query, int n, Sort sort)
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
         public virtual TopDocs SearchAfter(ScoreDoc after, Query query, int n, Sort sort)
         {
-            if (after != null && !(after is FieldDoc))
-            {
-                // TODO: if we fix type safety of TopFieldDocs we can
-                // remove this
-                throw new ArgumentException("after must be a FieldDoc; got " + after);
-            }
-            return Search(CreateNormalizedWeight(query), (FieldDoc)after, n, sort, true, false, false);
+            var fieldDoc = GetScoreDocAsFieldDocIfNotNull(after);
+
+            return Search(CreateNormalizedWeight(query), fieldDoc, n, sort, true, false, false);
         }
 
         /// <summary>
@@ -444,13 +455,9 @@ public virtual TopDocs SearchAfter(ScoreDoc after, Query query, int n, Sort sort
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
         public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n, Sort sort, bool doDocScores, bool doMaxScore)
         {
-            if (after != null && !(after is FieldDoc))
-            {
-                // TODO: if we fix type safety of TopFieldDocs we can
-                // remove this
-                throw new ArgumentException("after must be a FieldDoc; got " + after);
-            }
-            return Search(CreateNormalizedWeight(WrapFilter(query, filter)), (FieldDoc)after, n, sort, true, doDocScores, doMaxScore);
+            var fieldDoc = GetScoreDocAsFieldDocIfNotNull(after);
+
+            return Search(CreateNormalizedWeight(WrapFilter(query, filter)), fieldDoc, n, sort, true, doDocScores, doMaxScore);
         }
 
         /// <summary>
@@ -461,7 +468,7 @@ public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, i
         /// <see cref="IndexSearcher.Search(Query,Filter,int)"/> instead. </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        protected virtual TopDocs Search(Weight weight, ScoreDoc after, int nDocs)
+        protected virtual TopDocs Search(Weight weight, ScoreDoc? after, int nDocs)
         {
             int limit = reader.MaxDoc;
             if (limit == 0)
@@ -521,7 +528,7 @@ protected virtual TopDocs Search(Weight weight, ScoreDoc after, int nDocs)
         /// <see cref="IndexSearcher.Search(Query,Filter,int)"/> instead. </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        protected virtual TopDocs Search(IList<AtomicReaderContext> leaves, Weight weight, ScoreDoc after, int nDocs)
+        protected virtual TopDocs Search(IList<AtomicReaderContext> leaves, Weight weight, ScoreDoc? after, int nDocs)
         {
             // single thread
             int limit = reader.MaxDoc;
@@ -549,7 +556,7 @@ protected virtual TopDocs Search(IList<AtomicReaderContext> leaves, Weight weigh
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
         protected virtual TopFieldDocs Search(Weight weight, int nDocs, Sort sort, bool doDocScores, bool doMaxScore)
         {
-            return Search(weight, null, nDocs, sort, true, doDocScores, doMaxScore);
+            return Search(weight, after: null, nDocs, sort, true, doDocScores, doMaxScore);
         }
 
         /// <summary>
@@ -557,7 +564,7 @@ protected virtual TopFieldDocs Search(Weight weight, int nDocs, Sort sort, bool
         /// whether or not the fields in the returned <see cref="FieldDoc"/> instances should
         /// be set by specifying <paramref name="fillFields"/>.
         /// </summary>
-        protected virtual TopFieldDocs Search(Weight weight, FieldDoc after, int nDocs, Sort sort, bool fillFields, bool doDocScores, bool doMaxScore)
+        protected virtual TopFieldDocs Search(Weight weight, FieldDoc? after, int nDocs, Sort sort, bool fillFields, bool doDocScores, bool doMaxScore)
         {
             if (sort is null)
             {
@@ -613,7 +620,7 @@ protected virtual TopFieldDocs Search(Weight weight, FieldDoc after, int nDocs,
         /// whether or not the fields in the returned <see cref="FieldDoc"/> instances should
         /// be set by specifying <paramref name="fillFields"/>.
         /// </summary>
-        protected virtual TopFieldDocs Search(IList<AtomicReaderContext> leaves, Weight weight, FieldDoc after, int nDocs, Sort sort, bool fillFields, bool doDocScores, bool doMaxScore)
+        protected virtual TopFieldDocs Search(IList<AtomicReaderContext> leaves, Weight weight, FieldDoc? after, int nDocs, Sort sort, bool fillFields, bool doDocScores, bool doMaxScore)
         {
             // single thread
             int limit = reader.MaxDoc;
@@ -765,12 +772,12 @@ public virtual Weight CreateNormalizedWeight(Query query)
             private readonly ReentrantLock @lock;
             private readonly IndexSearcher searcher;
             private readonly Weight weight;
-            private readonly ScoreDoc after;
+            private readonly ScoreDoc? after;
             private readonly int nDocs;
             private readonly HitQueue hq;
             private readonly LeafSlice slice;
 
-            public SearcherCallableNoSort(ReentrantLock @lock, IndexSearcher searcher, LeafSlice slice, Weight weight, ScoreDoc after, int nDocs, HitQueue hq)
+            public SearcherCallableNoSort(ReentrantLock @lock, IndexSearcher searcher, LeafSlice slice, Weight weight, ScoreDoc? after, int nDocs, HitQueue hq)
             {
                 this.@lock = @lock;
                 this.searcher = searcher;
@@ -818,11 +825,11 @@ public TopDocs Call()
             private readonly TopFieldCollector hq;
             private readonly Sort sort;
             private readonly LeafSlice slice;
-            private readonly FieldDoc after;
+            private readonly FieldDoc? after;
             private readonly bool doDocScores;
             private readonly bool doMaxScore;
 
-            public SearcherCallableWithSort(ReentrantLock @lock, IndexSearcher searcher, LeafSlice slice, Weight weight, FieldDoc after, int nDocs, TopFieldCollector hq, Sort sort, bool doDocScores, bool doMaxScore)
+            public SearcherCallableWithSort(ReentrantLock @lock, IndexSearcher searcher, LeafSlice slice, Weight weight, FieldDoc? after, int nDocs, TopFieldCollector hq, Sort sort, bool doDocScores, bool doMaxScore)
             {
                 this.@lock = @lock;
                 this.searcher = searcher;
@@ -1016,4 +1023,5 @@ public virtual CollectionStatistics CollectionStatistics(string field)
             return new CollectionStatistics(field, reader.MaxDoc, docCount, sumTotalTermFreq, sumDocFreq);
         }
     }
-}
\ No newline at end of file
+}
+#nullable restore
\ No newline at end of file

From 8f93c532302d182e7abfa7459947e8c3ba800ac3 Mon Sep 17 00:00:00 2001
From: unknown <laimis@gmail.com>
Date: Fri, 14 Apr 2023 11:25:29 -0700
Subject: [PATCH 08/11] nullable enable

---
 src/Lucene.Net/Search/IndexSearcher.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index 974aee4f48..3f4c899c47 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -878,6 +878,7 @@ public TopFieldDocs Call()
             }
         }
 
+        #nullable restore
         /// <summary>
         /// A helper class that wraps a <see cref="TaskSchedulerCompletionService{T}"/> and provides an
         /// iterable interface to the completed <see cref="Func{T}"/> delegates.
@@ -956,7 +957,8 @@ IEnumerator IEnumerable.GetEnumerator()
                 return this;
             }
         }
-
+        #nullable enable
+        
         /// <summary>
         /// A class holding a subset of the <see cref="IndexSearcher"/>s leaf contexts to be
         /// executed within a single thread.

From ca71b4e0a3a15bfb835c0c217a83ec578eec2f8b Mon Sep 17 00:00:00 2001
From: unknown <laimis@gmail.com>
Date: Fri, 14 Apr 2023 11:27:52 -0700
Subject: [PATCH 09/11] update comments

---
 src/Lucene.Net/Search/IndexSearcher.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index 3f4c899c47..2ef5a9e783 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -144,7 +144,7 @@ public IndexSearcher(IndexReaderContext context, TaskScheduler? executor)
         /// control whether the leaf slices are allocated in the base class or subclass.
         /// </summary>
         /// <remarks>
-        /// If executor is non-<c>null</c> and you choose to skip allocating the leaf slices
+        /// If <paramref name="executor"/> is non-<c>null</c> and you choose to skip allocating the leaf slices
         /// (i.e. <paramref name="allocateLeafSlices"/> == <c>false</c>), you must
         /// set the <see cref="m_leafSlices"/> field in your subclass constructor.
         /// This is commonly done by calling <see cref="GetSlices(IList{AtomicReaderContext})"/>

From 9113263642c564d03ba2f4742fd3f5925956f6a5 Mon Sep 17 00:00:00 2001
From: Shad Storhaug <shad@shadstorhaug.com>
Date: Sat, 15 Apr 2023 05:41:16 +0700
Subject: [PATCH 10/11] Lucene.Net.Search.IndexSearcher: Reviewed and added
 null guard clauses for all non-nullable parameters. Marked nullable
 parameters as such. Documented when ArgumentNullReferenceException is
 expected to be thrown from each method overload.

---
 src/Lucene.Net/Search/IndexSearcher.cs | 160 +++++++++++++++++++------
 1 file changed, 123 insertions(+), 37 deletions(-)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index 2ef5a9e783..17fa5b1324 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -104,6 +104,7 @@ public class IndexSearcher
 
         /// <summary>
         /// Creates a searcher searching the provided index. </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="r"/> is <c>null</c>.</exception>
         public IndexSearcher(IndexReader r)
             : this(r, executor: null)
         {
@@ -117,8 +118,9 @@ public IndexSearcher(IndexReader r)
         /// <para/>
         /// @lucene.experimental
         /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="r"/> is <c>null</c>.</exception>
         public IndexSearcher(IndexReader r, TaskScheduler? executor)
-            : this(r.Context, executor)
+            : this(r?.Context!, executor)
         {
         }
 
@@ -132,6 +134,7 @@ public IndexSearcher(IndexReader r, TaskScheduler? executor)
         /// <para/>
         /// @lucene.experimental 
         /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="context"/> is <c>null</c>.</exception>
         /// <seealso cref="IndexReaderContext"/>
         /// <seealso cref="IndexReader.Context"/>
         public IndexSearcher(IndexReaderContext context, TaskScheduler? executor)
@@ -154,6 +157,7 @@ public IndexSearcher(IndexReaderContext context, TaskScheduler? executor)
         /// as a member field or property inside a custom override of
         /// <see cref="GetSlices(IList{AtomicReaderContext})"/>.
         /// </remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="context"/> is <c>null</c>.</exception>
         [SuppressMessage("CodeQuality", "IDE0079:Remove unnecessary suppression", Justification = "This is a SonarCloud issue")]
         [SuppressMessage("CodeQuality", "S1699:Constructors should only call non-overridable methods", Justification = "Required for continuity with Lucene's design")]
         protected IndexSearcher(IndexReaderContext context, TaskScheduler? executor, bool allocateLeafSlices)
@@ -180,6 +184,7 @@ protected IndexSearcher(IndexReaderContext context, TaskScheduler? executor, boo
         /// <para/>
         /// @lucene.experimental
         /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="context"/> is <c>null</c>.</exception>
         /// <seealso cref="IndexReaderContext"/>
         /// <seealso cref="IndexReader.Context"/>
         public IndexSearcher(IndexReaderContext context)
@@ -192,8 +197,13 @@ public IndexSearcher(IndexReaderContext context)
         /// Each <see cref="LeafSlice"/> is executed in a single thread. By default there
         /// will be one <see cref="LeafSlice"/> per leaf (<see cref="AtomicReaderContext"/>).
         /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="leaves"/> is <c>null</c>.</exception>
         protected virtual LeafSlice[] GetSlices(IList<AtomicReaderContext> leaves)
         {
+            // LUCENENET: Added guard clause
+            if (leaves is null)
+                throw new ArgumentNullException(nameof(leaves));
+
             LeafSlice[] slices = new LeafSlice[leaves.Count];
             for (int i = 0; i < slices.Length; i++)
             {
@@ -217,6 +227,7 @@ public virtual Document Doc(int docID)
         /// <summary>
         /// Sugar for <code>.IndexReader.Document(docID, fieldVisitor)</code> </summary>
         /// <seealso cref="IndexReader.Document(int, StoredFieldVisitor)"/>
+        /// <exception cref="ArgumentNullException"><paramref name="fieldVisitor"/> is <c>null</c>.</exception>
         public virtual void Doc(int docID, StoredFieldVisitor fieldVisitor)
         {
             reader.Document(docID, fieldVisitor);
@@ -225,7 +236,7 @@ public virtual void Doc(int docID, StoredFieldVisitor fieldVisitor)
         /// <summary>
         /// Sugar for <code>.IndexReader.Document(docID, fieldsToLoad)</code> </summary>
         /// <seealso cref="IndexReader.Document(int, ISet{string})"/>
-        public virtual Document Doc(int docID, ISet<string> fieldsToLoad)
+        public virtual Document Doc(int docID, ISet<string>? fieldsToLoad)
         {
             return reader.Document(docID, fieldsToLoad);
         }
@@ -248,6 +259,7 @@ public virtual Similarity Similarity
 
         /// <summary>
         /// @lucene.internal </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> is <c>null</c>.</exception>
         protected virtual Query WrapFilter(Query query, Filter? filter)
         {
             return (filter is null) ? query : new FilteredQuery(query, filter);
@@ -264,7 +276,8 @@ protected virtual Query WrapFilter(Query query, Filter? filter)
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        public virtual TopDocs SearchAfter(ScoreDoc after, Query query, int n)
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> is <c>null</c>.</exception>
+        public virtual TopDocs SearchAfter(ScoreDoc? after, Query query, int n)
         {
             return Search(CreateNormalizedWeight(query), after, n);
         }
@@ -280,7 +293,8 @@ public virtual TopDocs SearchAfter(ScoreDoc after, Query query, int n)
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n)
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> is <c>null</c>.</exception>
+        public virtual TopDocs SearchAfter(ScoreDoc? after, Query query, Filter? filter, int n)
         {
             return Search(CreateNormalizedWeight(WrapFilter(query, filter)), after, n);
         }
@@ -291,6 +305,7 @@ public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, i
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> is <c>null</c>.</exception>
         public virtual TopDocs Search(Query query, int n)
         {
             return Search(query, filter: null, n);
@@ -298,7 +313,7 @@ public virtual TopDocs Search(Query query, int n)
 
         /// <summary>
         /// Finds the top <paramref name="n"/>
-        /// hits for <paramref name="query"/>, applying <paramref name="filter"/> if non-null.
+        /// hits for <paramref name="query"/>, applying <paramref name="filter"/> if non-<c>null</c>.
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
@@ -314,11 +329,13 @@ public virtual TopDocs Search(Query query, Filter? filter, int n)
         /// document.
         /// </summary>
         /// <param name="query"> To match documents </param>
-        /// <param name="filter"> Ef non-null, used to permit documents to be collected. </param>
+        /// <param name="filter"> Ef non-<c>null</c>, used to permit documents to be collected. </param>
         /// <param name="results"> To receive hits </param>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        public virtual void Search(Query query, Filter filter, ICollector results)
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> or
+        ///         <paramref name="results"/> is <c>null</c>.</exception>
+        public virtual void Search(Query query, Filter? filter, ICollector results)
         {
             Search(m_leafContexts, CreateNormalizedWeight(WrapFilter(query, filter)), results);
         }
@@ -330,6 +347,8 @@ public virtual void Search(Query query, Filter filter, ICollector results)
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> or
+        ///         <paramref name="results"/> is <c>null</c>.</exception>
         public virtual void Search(Query query, ICollector results)
         {
             Search(m_leafContexts, CreateNormalizedWeight(query), results);
@@ -347,7 +366,9 @@ public virtual void Search(Query query, ICollector results)
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        public virtual TopFieldDocs Search(Query query, Filter filter, int n, Sort sort)
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> or
+        ///         <paramref name="sort"/> is <c>null</c>.</exception>
+        public virtual TopFieldDocs Search(Query query, Filter? filter, int n, Sort sort)
         {
             return Search(CreateNormalizedWeight(WrapFilter(query, filter)), n, sort, false, false);
         }
@@ -366,7 +387,9 @@ public virtual TopFieldDocs Search(Query query, Filter filter, int n, Sort sort)
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        public virtual TopFieldDocs Search(Query query, Filter filter, int n, Sort sort, bool doDocScores, bool doMaxScore)
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> or
+        ///         <paramref name="sort"/> is <c>null</c>.</exception>
+        public virtual TopFieldDocs Search(Query query, Filter? filter, int n, Sort sort, bool doDocScores, bool doMaxScore)
         {
             return Search(CreateNormalizedWeight(WrapFilter(query, filter)), n, sort, doDocScores, doMaxScore);
         }
@@ -382,26 +405,24 @@ public virtual TopFieldDocs Search(Query query, Filter filter, int n, Sort sort,
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <seealso cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n, Sort sort)
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> or
+        ///         <paramref name="sort"/> is <c>null</c>.</exception>
+        public virtual TopDocs SearchAfter(ScoreDoc? after, Query query, Filter? filter, int n, Sort sort)
         {
             FieldDoc? fieldDoc = GetScoreDocAsFieldDocIfNotNull(after);
 
             return Search(CreateNormalizedWeight(WrapFilter(query, filter)), fieldDoc, n, sort, true, false, false);
         }
 
-        private static FieldDoc? GetScoreDocAsFieldDocIfNotNull(ScoreDoc after)
+        private static FieldDoc? GetScoreDocAsFieldDocIfNotNull(ScoreDoc? after)
         {
             FieldDoc? fieldDoc = null;
-            if (after != null && !(after is FieldDoc))
+            // LUCENENET: Simplified type check
+            if (after is not null)
             {
                 // TODO: if we fix type safety of TopFieldDocs we can
                 // remove this
-                throw new ArgumentException("after must be a FieldDoc; got " + after);
-            }
-
-            if (after != null && after is FieldDoc)
-            {
-                fieldDoc = (FieldDoc)after;
+                fieldDoc = after as FieldDoc ?? throw new ArgumentException($"{nameof(after)} must be a {nameof(FieldDoc)}; got {after}");
             }
 
             return fieldDoc;
@@ -414,6 +435,8 @@ public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, i
         /// <param name="sort"> The <see cref="Lucene.Net.Search.Sort"/> object </param>
         /// <returns> The top docs, sorted according to the supplied <see cref="Lucene.Net.Search.Sort"/> instance </returns>
         /// <exception cref="IOException"> if there is a low-level I/O error </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> or
+        ///         <paramref name="sort"/> is <c>null</c>.</exception>
         public virtual TopFieldDocs Search(Query query, int n, Sort sort)
         {
             return Search(CreateNormalizedWeight(query), n, sort, false, false);
@@ -430,7 +453,9 @@ public virtual TopFieldDocs Search(Query query, int n, Sort sort)
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        public virtual TopDocs SearchAfter(ScoreDoc after, Query query, int n, Sort sort)
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> or
+        ///         <paramref name="sort"/> is <c>null</c>.</exception>
+        public virtual TopDocs SearchAfter(ScoreDoc? after, Query query, int n, Sort sort)
         {
             var fieldDoc = GetScoreDocAsFieldDocIfNotNull(after);
 
@@ -453,7 +478,9 @@ public virtual TopDocs SearchAfter(ScoreDoc after, Query query, int n, Sort sort
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n, Sort sort, bool doDocScores, bool doMaxScore)
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> or
+        ///         <paramref name="sort"/> is <c>null</c>.</exception>
+        public virtual TopDocs SearchAfter(ScoreDoc? after, Query query, Filter? filter, int n, Sort sort, bool doDocScores, bool doMaxScore)
         {
             var fieldDoc = GetScoreDocAsFieldDocIfNotNull(after);
 
@@ -468,6 +495,7 @@ public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, i
         /// <see cref="IndexSearcher.Search(Query,Filter,int)"/> instead. </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="weight"/> is <c>null</c>.</exception>
         protected virtual TopDocs Search(Weight weight, ScoreDoc? after, int nDocs)
         {
             int limit = reader.MaxDoc;
@@ -487,13 +515,16 @@ protected virtual TopDocs Search(Weight weight, ScoreDoc? after, int nDocs)
             }
             else
             {
+                // LUCENENET: Added guard clauses
+                if (weight is null)
+                    throw new ArgumentNullException(nameof(weight));
+                if (m_leafSlices is null)
+                    throw new InvalidOperationException($"When the constructor is passed a non-null {nameof(TaskScheduler)}, {nameof(m_leafSlices)} must also be set to a non-null value in the constructor.");
+
                 HitQueue hq = new HitQueue(nDocs, prePopulate: false);
                 ReentrantLock @lock = new ReentrantLock();
                 ExecutionHelper<TopDocs> runner = new ExecutionHelper<TopDocs>(executor);
 
-                if (m_leafSlices is null)
-                    throw new InvalidOperationException($"When the constructor is passed a non-null {nameof(TaskScheduler)}, {nameof(m_leafSlices)} must also be set to a non-null value in the constructor.");
-
                 for (int i = 0; i < m_leafSlices.Length; i++) // search each sub
                 {
                     runner.Submit(new SearcherCallableNoSort(@lock, this, m_leafSlices[i], weight, after, nDocs, hq).Call);
@@ -528,8 +559,14 @@ protected virtual TopDocs Search(Weight weight, ScoreDoc? after, int nDocs)
         /// <see cref="IndexSearcher.Search(Query,Filter,int)"/> instead. </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="leaves"/> or
+        ///         <paramref name="weight"/> is <c>null</c>.</exception>
         protected virtual TopDocs Search(IList<AtomicReaderContext> leaves, Weight weight, ScoreDoc? after, int nDocs)
         {
+            // LUCENENET: Added guard clause
+            if (weight is null)
+                throw new ArgumentNullException(nameof(weight));
+
             // single thread
             int limit = reader.MaxDoc;
             if (limit == 0)
@@ -554,6 +591,8 @@ protected virtual TopDocs Search(IList<AtomicReaderContext> leaves, Weight weigh
         /// </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="weight"/> or
+        ///         <paramref name="sort"/> is <c>null</c>.</exception>
         protected virtual TopFieldDocs Search(Weight weight, int nDocs, Sort sort, bool doDocScores, bool doMaxScore)
         {
             return Search(weight, after: null, nDocs, sort, true, doDocScores, doMaxScore);
@@ -564,12 +603,12 @@ protected virtual TopFieldDocs Search(Weight weight, int nDocs, Sort sort, bool
         /// whether or not the fields in the returned <see cref="FieldDoc"/> instances should
         /// be set by specifying <paramref name="fillFields"/>.
         /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="weight"/> or
+        ///         <paramref name="sort"/> is <c>null</c>.</exception>
         protected virtual TopFieldDocs Search(Weight weight, FieldDoc? after, int nDocs, Sort sort, bool fillFields, bool doDocScores, bool doMaxScore)
         {
             if (sort is null)
-            {
                 throw new ArgumentNullException(nameof(sort), "Sort must not be null"); // LUCENENET specific - changed from IllegalArgumentException to ArgumentNullException (.NET convention)
-            }
 
             int limit = reader.MaxDoc;
             if (limit == 0)
@@ -585,14 +624,17 @@ protected virtual TopFieldDocs Search(Weight weight, FieldDoc? after, int nDocs,
             }
             else
             {
+                // LUCENENET: Added guard clauses
+                if (weight is null)
+                    throw new ArgumentNullException(nameof(weight));
+                if (m_leafSlices is null)
+                    throw new InvalidOperationException($"When the constructor is passed a non-null {nameof(TaskScheduler)}, {nameof(m_leafSlices)} must also be set to a non-null value in the constructor.");
+
                 TopFieldCollector topCollector = TopFieldCollector.Create(sort, nDocs, after, fillFields, doDocScores, doMaxScore, false);
 
                 ReentrantLock @lock = new ReentrantLock();
                 ExecutionHelper<TopFieldDocs> runner = new ExecutionHelper<TopFieldDocs>(executor);
 
-                if (m_leafSlices is null)
-                    throw new InvalidOperationException($"When the constructor is passed a non-null {nameof(TaskScheduler)}, {nameof(m_leafSlices)} must also be set to a non-null value in the constructor.");
-
                 for (int i = 0; i < m_leafSlices.Length; i++) // search each leaf slice
                 {
                     runner.Submit(new SearcherCallableWithSort(@lock, this, m_leafSlices[i], weight, after, nDocs, topCollector, sort, doDocScores, doMaxScore).Call);
@@ -620,8 +662,14 @@ protected virtual TopFieldDocs Search(Weight weight, FieldDoc? after, int nDocs,
         /// whether or not the fields in the returned <see cref="FieldDoc"/> instances should
         /// be set by specifying <paramref name="fillFields"/>.
         /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="leaves"/> or
+        ///          <paramref name="weight"/> is <c>null</c>.</exception>
         protected virtual TopFieldDocs Search(IList<AtomicReaderContext> leaves, Weight weight, FieldDoc? after, int nDocs, Sort sort, bool fillFields, bool doDocScores, bool doMaxScore)
         {
+            // LUCENENET: Added guard clause
+            if (weight is null)
+                throw new ArgumentNullException(nameof(weight));
+
             // single thread
             int limit = reader.MaxDoc;
             if (limit == 0)
@@ -653,8 +701,18 @@ protected virtual TopFieldDocs Search(IList<AtomicReaderContext> leaves, Weight
         ///          To receive hits </param>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="leaves"/>, <paramref name="weight"/>,
+        ///         or <paramref name="collector"/> is <c>null</c>.</exception>
         protected virtual void Search(IList<AtomicReaderContext> leaves, Weight weight, ICollector collector)
         {
+            // LUCENENET: Added guard clauses
+            if (leaves is null)
+                throw new ArgumentNullException(nameof(leaves));
+            if (weight is null)
+                throw new ArgumentNullException(nameof(weight));
+            if (collector is null)
+                throw new ArgumentNullException(nameof(collector));
+
             // TODO: should we make this
             // threaded...?  the Collector could be sync'd?
             // always use single thread:
@@ -690,9 +748,13 @@ protected virtual void Search(IList<AtomicReaderContext> leaves, Weight weight,
         /// Expert: called to re-write queries into primitive queries. </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
-        public virtual Query Rewrite(Query original)
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> is <c>null</c>.</exception>
+        public virtual Query Rewrite(Query query) // LUCENENET: renamed parameter from "original" to "query" so our exception message is consistent across the API
         {
-            Query query = original;
+            // LUCENENET: Added guard clause
+            if (query is null)
+                throw new ArgumentNullException(nameof(query));
+
             for (Query rewrittenQuery = query.Rewrite(reader); rewrittenQuery != query; rewrittenQuery = query.Rewrite(reader))
             {
                 query = rewrittenQuery;
@@ -709,6 +771,7 @@ public virtual Query Rewrite(Query original)
         /// Computing an explanation is as expensive as executing the query over the
         /// entire index.
         /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> is <c>null</c>.</exception>
         public virtual Explanation Explain(Query query, int doc)
         {
             return Explain(CreateNormalizedWeight(query), doc);
@@ -726,8 +789,13 @@ public virtual Explanation Explain(Query query, int doc)
         /// <para/>Applications should call <see cref="IndexSearcher.Explain(Query, int)"/>. </summary>
         /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
         ///         <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="weight"/> is <c>null</c>.</exception>
         protected virtual Explanation Explain(Weight weight, int doc)
         {
+            // LUCENENET: Added guard clause
+            if (weight is null)
+                throw new ArgumentNullException(nameof(weight));
+
             int n = ReaderUtil.SubIndex(doc, m_leafContexts);
             AtomicReaderContext ctx = m_leafContexts[n];
             int deBasedDoc = doc - ctx.DocBase;
@@ -743,6 +811,7 @@ protected virtual Explanation Explain(Weight weight, int doc)
         /// <para/>
         /// @lucene.internal
         /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="query"/> is <c>null</c>.</exception>
         public virtual Weight CreateNormalizedWeight(Query query)
         {
             query = Rewrite(query);
@@ -878,7 +947,7 @@ public TopFieldDocs Call()
             }
         }
 
-        #nullable restore
+#nullable restore
         /// <summary>
         /// A helper class that wraps a <see cref="TaskSchedulerCompletionService{T}"/> and provides an
         /// iterable interface to the completed <see cref="Func{T}"/> delegates.
@@ -957,7 +1026,7 @@ IEnumerator IEnumerable.GetEnumerator()
                 return this;
             }
         }
-        #nullable enable
+#nullable enable
         
         /// <summary>
         /// A class holding a subset of the <see cref="IndexSearcher"/>s leaf contexts to be
@@ -969,9 +1038,15 @@ public class LeafSlice
         {
             internal AtomicReaderContext[] Leaves { get; private set; }
 
+            /// <summary>
+            /// Initializes a new instance of <see cref="LeafSlice"/> with
+            /// the specified <paramref name="leaves"/>.
+            /// </summary>
+            /// <param name="leaves">The collection of leaves.</param>
+            /// <exception cref="ArgumentNullException"><paramref name="leaves"/> is <c>null</c>.</exception>
             public LeafSlice(params AtomicReaderContext[] leaves)
             {
-                this.Leaves = leaves;
+                this.Leaves = leaves ?? throw new ArgumentNullException(nameof(leaves)); // LUCENENET: Added guard clause
             }
         }
 
@@ -988,8 +1063,16 @@ public override string ToString()
         /// <para/>
         /// @lucene.experimental
         /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="term"/> or
+        /// <paramref name="context"/> is <c>null</c>.</exception>
         public virtual TermStatistics TermStatistics(Term term, TermContext context)
         {
+            // LUCENENET: Added guard clauses
+            if (term is null)
+                throw new ArgumentNullException(nameof(term));
+            if (context is null)
+                throw new ArgumentNullException(nameof(context));
+
             return new TermStatistics(term.Bytes, context.DocFreq, context.TotalTermFreq);
         }
 
@@ -1003,13 +1086,17 @@ public virtual TermStatistics TermStatistics(Term term, TermContext context)
         /// </summary>
         public virtual CollectionStatistics CollectionStatistics(string field)
         {
+            // LUCENENET: Added guard clause
+            if (field is null)
+                throw new ArgumentNullException(nameof(field));
+
             int docCount;
             long sumTotalTermFreq;
             long sumDocFreq;
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(field != null);
+            // LUCENENET specific - replaced debug assert check for field being null with above guard clause
 
-            Terms terms = MultiFields.GetTerms(reader, field);
+            Terms? terms = MultiFields.GetTerms(reader, field);
             if (terms is null)
             {
                 docCount = 0;
@@ -1025,5 +1112,4 @@ public virtual CollectionStatistics CollectionStatistics(string field)
             return new CollectionStatistics(field, reader.MaxDoc, docCount, sumTotalTermFreq, sumDocFreq);
         }
     }
-}
-#nullable restore
\ No newline at end of file
+}
\ No newline at end of file

From d9f4daa8264d322d96459d9e12c2f2a3a4f455e3 Mon Sep 17 00:00:00 2001
From: Shad Storhaug <shad@shadstorhaug.com>
Date: Sat, 15 Apr 2023 06:15:16 +0700
Subject: [PATCH 11/11] Lucene.Net.Search.IndexSearcher: Added null guard
 clause for Doc(int, StoredFieldVisitor)

---
 src/Lucene.Net/Search/IndexSearcher.cs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index 17fa5b1324..b7f0f13bdd 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -165,8 +165,7 @@ protected IndexSearcher(IndexReaderContext context, TaskScheduler? executor, boo
             if (context is null)
                 throw new ArgumentNullException(nameof(context));
 
-            if (Debugging.AssertsEnabled)
-                Debugging.Assert(context.IsTopLevel,"IndexSearcher's ReaderContext must be topLevel for reader {0}", context.Reader);
+            if (Debugging.AssertsEnabled) Debugging.Assert(context.IsTopLevel, "IndexSearcher's ReaderContext must be topLevel for reader {0}", context.Reader);
 
             reader = context.Reader;
             this.executor = executor;
@@ -230,6 +229,9 @@ public virtual Document Doc(int docID)
         /// <exception cref="ArgumentNullException"><paramref name="fieldVisitor"/> is <c>null</c>.</exception>
         public virtual void Doc(int docID, StoredFieldVisitor fieldVisitor)
         {
+            if (fieldVisitor is null)
+                throw new ArgumentNullException(nameof(fieldVisitor));
+
             reader.Document(docID, fieldVisitor);
         }