PR feedback

src/Lucene.Net.Tests.Analysis.Common/Analysis/Position/PositionFilterTest.cs

@@ -106,12 +106,11 @@ public virtual void TestReset()
 
         /// <summary>
         /// Tests ShingleFilter up to six shingles against six terms.
-        ///  Tests PositionFilter setting all but the first positionIncrement to zero. </summary> </exception>
-        /// <exception cref="IOException"> <seealso cref= Token#next(Token) </seealso>
+        ///  Tests PositionFilter setting all but the first positionIncrement to zero.
+        /// </summary>
         [Test]
         public virtual void Test6GramFilterNoPositions()
         {
-
             ShingleFilter filter = new ShingleFilter(new TestTokenStream(this, TEST_TOKEN), 6);
             AssertTokenStreamContents
 #pragma warning disable 612, 618

src/Lucene.Net/Analysis/Token.cs

@@ -65,17 +65,16 @@ namespace Lucene.Net.Analysis
     /// Failing that, to create a new <see cref="Token"/> you should first use
     /// one of the constructors that starts with null text.  To load
     /// the token from a char[] use <see cref="ICharTermAttribute.CopyBuffer(char[], int, int)"/>.
-    /// To load from a <see cref="string"/> use <see cref="ICharTermAttribute.SetEmpty()"/> followed by
+    /// To load from a <see cref="string"/> use <see cref="ICharTermAttribute.Clear()"/> (or <see cref="CharTermAttributeExtensions.SetEmpty(ICharTermAttribute)"/>) followed by
     /// <see cref="ICharTermAttribute.Append(string)"/> or <see cref="ICharTermAttribute.Append(string, int, int)"/>.
     /// Alternatively you can get the <see cref="Token"/>'s termBuffer by calling either <see cref="ICharTermAttribute.Buffer"/>,
     /// if you know that your text is shorter than the capacity of the termBuffer
     /// or <see cref="ICharTermAttribute.ResizeBuffer(int)"/>, if there is any possibility
     /// that you may need to grow the buffer. Fill in the characters of your term into this
     /// buffer, with <see cref="string.ToCharArray(int, int)"/> if loading from a string,
     /// or with <see cref="System.Array.Copy(System.Array, int, System.Array, int, int)"/>,
-    /// and finally assign to <see cref="ICharTermAttribute.Length"/> to
-    /// set the length of the term text.  See <a target="_top"
-    /// href="https://issues.apache.org/jira/browse/LUCENE-969">LUCENE-969</a>
+    /// and finally set the <see cref="ICharTermAttribute.Length"/> of the term text.
+    /// See <a target="_top" href="https://issues.apache.org/jira/browse/LUCENE-969">LUCENE-969</a>
     /// for details.</para>
     /// <para>Typical Token reuse patterns:
     /// <list type="bullet">

src/Lucene.Net/Analysis/TokenAttributes/CharTermAttribute.cs

@@ -78,13 +78,6 @@ public interface ICharTermAttribute : IAttribute, ICharSequence, IAppendable
         // LUCENENET specific: Redefining this[] to make it settable
         new char this[int index] { get; set; }
 
-        /// <summary>
-        /// Sets the length of the termBuffer to zero.
-        /// Use this method before appending contents.
-        /// </summary>
-        /// <seealso cref="Lucene.Net.Analysis.TokenAttributes.Extensions.CharTermAttributeExtensions.SetEmpty(ICharTermAttribute)"/>
-        void Clear();
-
         // the following methods are redefined to get rid of IOException declaration:
 
         /// <summary>

src/Lucene.Net/Analysis/TokenAttributes/CharTermAttributeImpl.cs

@@ -484,8 +484,6 @@ public override void CopyTo(IAttribute target) // LUCENENET specific - intention
 
         char[] ICharTermAttribute.ResizeBuffer(int newSize) => ResizeBuffer(newSize);
 
-        void ICharTermAttribute.Clear() => Clear();
-
         ICharTermAttribute ICharTermAttribute.Append(ICharSequence value) => Append(value);
 
         ICharTermAttribute ICharTermAttribute.Append(ICharSequence value, int startIndex, int count) => Append(value, startIndex, count);

src/Lucene.Net/Support/Analysis/TokenAttributes/Extensions/CharTermAttributeExtensions.cs

@@ -1,24 +1,24 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 using System;
 
 namespace Lucene.Net.Analysis.TokenAttributes.Extensions
 {
+    /*
+     * Licensed to the Apache Software Foundation (ASF) under one or more
+     * contributor license agreements.  See the NOTICE file distributed with
+     * this work for additional information regarding copyright ownership.
+     * The ASF licenses this file to You under the Apache License, Version 2.0
+     * (the "License"); you may not use this file except in compliance with
+     * the License.  You may obtain a copy of the License at
+     *
+     *     http://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+
     /// <summary>
     /// Extension methods on <see cref="ICharTermAttribute"/>.
     /// </summary>

src/Lucene.Net/Util/Attribute.cs

@@ -21,5 +21,11 @@
     public interface IAttribute
     {
         void CopyTo(IAttribute target); // LUCENENET specific - .NET doesn't recognize this method without a cast, so we define it here to ensure it is visible on all IAttribute interfaces
+
+        /// <summary>
+        /// Clears the values in this attribute and resets it to its
+        /// default value.
+        /// </summary>
+        void Clear();
     }
-}
+}

src/Lucene.Net/Util/AttributeImpl.cs

@@ -31,7 +31,8 @@ namespace Lucene.Net.Util
     /// </summary>
     public abstract class Attribute : IAttribute // LUCENENET specific: Not implementing ICloneable per Microsoft's recommendation
     {
-        /// <summary> Clears the values in this <see cref="Attribute"/> and resets it to its
+        /// <summary>
+        /// Clears the values in this <see cref="Attribute"/> and resets it to its
         /// default value. If this implementation implements more than one <see cref="Attribute"/> interface
         /// it clears all.
         /// </summary>
@@ -97,22 +98,22 @@ public string ReflectAsString(bool prependAttClass)
         /// <summary>
         /// This method is for introspection of attributes, it should simply
         /// add the key/values this attribute holds to the given <see cref="IAttributeReflector"/>.
-        /// 
+        ///
         /// <para/>The default implementation calls <see cref="IAttributeReflector.Reflect(Type, string, object)"/> for all
         /// non-static fields from the implementing class, using the field name as key
         /// and the field value as value. The <see cref="IAttribute"/> class is also determined by Reflection.
         /// Please note that the default implementation can only handle single-Attribute
         /// implementations.
-        /// 
+        ///
         /// <para/>Custom implementations look like this (e.g. for a combined attribute implementation):
         /// <code>
-        ///     public void ReflectWith(IAttributeReflector reflector) 
+        ///     public void ReflectWith(IAttributeReflector reflector)
         ///     {
         ///         reflector.Reflect(typeof(ICharTermAttribute), "term", GetTerm());
         ///         reflector.Reflect(typeof(IPositionIncrementAttribute), "positionIncrement", GetPositionIncrement());
         ///     }
         /// </code>
-        /// 
+        ///
         /// <para/>If you implement this method, make sure that for each invocation, the same set of <see cref="IAttribute"/>
         /// interfaces and keys are passed to <see cref="IAttributeReflector.Reflect(Type, string, object)"/> in the same order, but possibly
         /// different values. So don't automatically exclude e.g. <c>null</c> properties!
@@ -154,7 +155,7 @@ public virtual void ReflectWith(IAttributeReflector reflector) // LUCENENET NOTE
         /// fields of this object and prints the values in the following syntax:
         ///
         /// <code>
-        /// public String ToString() 
+        /// public String ToString()
         /// {
         ///     return "start=" + startOffset + ",end=" + endOffset;
         /// }
@@ -205,4 +206,4 @@ public virtual object Clone()
             return base.MemberwiseClone();
         }
     }
-}
+}