* Update Sharpen namespace to Antlr4.Runtime.Sharpen at code generation time

* Support self-closing tags in XML documentation comments
* Use self-closing see tags when the content is just the name of the referenced item

reference/sharpen

@@ -1 +1 @@
-Subproject commit 186a1f5709f05b92b367e96f40db80cdcb082ac6
+Subproject commit a0560d197e8a96bfea52f9bf663cf8bc58127047

reference/sharpen-all-options.txt

@@ -6,6 +6,7 @@
 -paramCountFileNames
 -separateInterfaceConstants
 -maxColumns 1000
+-sharpenNamespace Antlr4.Runtime.Sharpen
 
 -methodMapping System.out.println System.Console.WriteLine
 
@@ -23,46 +24,46 @@
 -methodMapping java.util.ArrayList.addAll AddRange      
 
 -fullyQualify File  
--namespaceMapping java.lang.ref Sharpen
--namespaceMapping java.lang Sharpen
+-namespaceMapping java.lang.ref Antlr4.Runtime.Sharpen
+-namespaceMapping java.lang Antlr4.Runtime.Sharpen
 -namespaceMapping java.io System.IO
--namespaceMapping java.util.concurrent.atomic Sharpen
--namespaceMapping java.util.concurrent.locks Sharpen
--namespaceMapping java.util.concurrent Sharpen
--namespaceMapping java.util.zip Sharpen
--namespaceMapping java.util.regex Sharpen
--namespaceMapping java.util Sharpen
--namespaceMapping java.nio.channels Sharpen
--namespaceMapping java.nio.charset Sharpen
--namespaceMapping java.nio Sharpen
--namespaceMapping java.text Sharpen
--namespaceMapping java.net Sharpen
--namespaceMapping javax.crypto.interfaces Sharpen
--namespaceMapping javax.crypto.spec Sharpen
--namespaceMapping javax.crypto Sharpen
--namespaceMapping java.security.interfaces Sharpen
--namespaceMapping java.security.spec Sharpen
--namespaceMapping java.security.cert Sharpen
--namespaceMapping java.security Sharpen
--namespaceMapping javax.net.ssl Sharpen
+-namespaceMapping java.util.concurrent.atomic Antlr4.Runtime.Sharpen
+-namespaceMapping java.util.concurrent.locks Antlr4.Runtime.Sharpen
+-namespaceMapping java.util.concurrent Antlr4.Runtime.Sharpen
+-namespaceMapping java.util.zip Antlr4.Runtime.Sharpen
+-namespaceMapping java.util.regex Antlr4.Runtime.Sharpen
+-namespaceMapping java.util Antlr4.Runtime.Sharpen
+-namespaceMapping java.nio.channels Antlr4.Runtime.Sharpen
+-namespaceMapping java.nio.charset Antlr4.Runtime.Sharpen
+-namespaceMapping java.nio Antlr4.Runtime.Sharpen
+-namespaceMapping java.text Antlr4.Runtime.Sharpen
+-namespaceMapping java.net Antlr4.Runtime.Sharpen
+-namespaceMapping javax.crypto.interfaces Antlr4.Runtime.Sharpen
+-namespaceMapping javax.crypto.spec Antlr4.Runtime.Sharpen
+-namespaceMapping javax.crypto Antlr4.Runtime.Sharpen
+-namespaceMapping java.security.interfaces Antlr4.Runtime.Sharpen
+-namespaceMapping java.security.spec Antlr4.Runtime.Sharpen
+-namespaceMapping java.security.cert Antlr4.Runtime.Sharpen
+-namespaceMapping java.security Antlr4.Runtime.Sharpen
+-namespaceMapping javax.net.ssl Antlr4.Runtime.Sharpen
 -methodMapping java.lang.Object.memberwiseClone Clone
--methodMapping java.nio.charset.Charset.forName Sharpen.Extensions.GetEncoding
+-methodMapping java.nio.charset.Charset.forName Antlr4.Runtime.Sharpen.Extensions.GetEncoding
 -methodMapping java.util.ArrayList.trimToSize TrimExcess
--methodMapping java.lang.Integer.toOctalString Sharpen.Extensions.ToOctalString
--methodMapping java.lang.Integer.toHexString Sharpen.Extensions.ToHexString
--methodMapping java.lang.Integer.bitCount Sharpen.Extensions.BitCount
--methodMapping java.lang.Integer.numberOfLeadingZeros Sharpen.Extensions.NumberOfLeadingZeros
--methodMapping java.lang.Integer.numberOfTrailingZeros Sharpen.Extensions.NumberOfTrailingZeros
--methodMapping java.lang.Integer.lowestOneBit Sharpen.Extensions.LowestOneBit
--methodMapping java.lang.Boolean.valueOf Sharpen.Extensions.ValueOf
+-methodMapping java.lang.Integer.toOctalString Antlr4.Runtime.Sharpen.Extensions.ToOctalString
+-methodMapping java.lang.Integer.toHexString Antlr4.Runtime.Sharpen.Extensions.ToHexString
+-methodMapping java.lang.Integer.bitCount Antlr4.Runtime.Sharpen.Extensions.BitCount
+-methodMapping java.lang.Integer.numberOfLeadingZeros Antlr4.Runtime.Sharpen.Extensions.NumberOfLeadingZeros
+-methodMapping java.lang.Integer.numberOfTrailingZeros Antlr4.Runtime.Sharpen.Extensions.NumberOfTrailingZeros
+-methodMapping java.lang.Integer.lowestOneBit Antlr4.Runtime.Sharpen.Extensions.LowestOneBit
+-methodMapping java.lang.Boolean.valueOf Antlr4.Runtime.Sharpen.Extensions.ValueOf
 -methodMapping java.lang.Boolean.parseBoolean System.Boolean.Parse
--methodMapping java.lang.Integer.valueOf Sharpen.Extensions.ValueOf
--methodMapping java.lang.Integer.toString Sharpen.Extensions.ToString
--methodMapping java.lang.Long.valueOf Sharpen.Extensions.ValueOf
+-methodMapping java.lang.Integer.valueOf Antlr4.Runtime.Sharpen.Extensions.ValueOf
+-methodMapping java.lang.Integer.toString Antlr4.Runtime.Sharpen.Extensions.ToString
+-methodMapping java.lang.Long.valueOf Antlr4.Runtime.Sharpen.Extensions.ValueOf
 -methodMapping java.util.Random.nextInt Next
 -methodMapping java.util.Arrays.binarySearch System.Array.BinarySearch
--methodMapping java.util.TimeZone.getTimeZone Sharpen.Extensions.GetTimeZone
--methodMapping java.lang.Throwable.initCause Sharpen.Extensions.InitCause
+-methodMapping java.util.TimeZone.getTimeZone Antlr4.Runtime.Sharpen.Extensions.GetTimeZone
+-methodMapping java.lang.Throwable.initCause Antlr4.Runtime.Sharpen.Extensions.InitCause
 -methodMapping java.lang.Character.isSpaceChar System.Char.IsWhiteSpace
 -methodMapping java.lang.Character.isLowerCase System.Char.IsLower
 -methodMapping java.lang.Character.isUpperCase System.Char.IsUpper
@@ -73,31 +74,31 @@
 -methodMapping java.lang.System.gc System.GC.Collect
 -methodMapping java.lang.System.runFinalization System.GC.WaitForPendingFinalizers
 -methodMapping java.lang.System.getenv(String) System.Environment.GetEnvironmentVariable
--methodMapping java.lang.System.getenv() Sharpen.Runtime.GetEnv
--methodMapping java.net.InetAddress.getLocalHost Sharpen.Runtime.GetLocalHost
+-methodMapping java.lang.System.getenv() Antlr4.Runtime.Sharpen.Runtime.GetEnv
+-methodMapping java.net.InetAddress.getLocalHost Antlr4.Runtime.Sharpen.Runtime.GetLocalHost
 -methodMapping java.net.InetAddress.getCanonicalHostName ToString
--methodMapping java.util.Locale.Locale(String,String,String) Sharpen.Extensions.CreateLocale
+-methodMapping java.util.Locale.Locale(String,String,String) Antlr4.Runtime.Sharpen.Extensions.CreateLocale
 -methodMapping java.util.zip.Deflater.end Finish
 -methodMapping java.util.zip.Inflater.end Finish
 -methodMapping java.io.PrintWriter.print Write
 -methodMapping java.io.PrintWriter.println WriteLine
--methodMapping java.lang.ArrayIndexOutOfBoundsException.ArrayIndexOutOfBoundsException(int) Sharpen.Extensions.CreateIndexOutOfRangeException
+-methodMapping java.lang.ArrayIndexOutOfBoundsException.ArrayIndexOutOfBoundsException(int) Antlr4.Runtime.Sharpen.Extensions.CreateIndexOutOfRangeException
 -methodMapping java.lang.Appendable.append(java.lang.CharSequence,int,int) AppendRange
--methodMapping java.util.Date.Date(long) Sharpen.Extensions.CreateDate
--methodMapping java.lang.Long.signum Sharpen.Extensions.Signum
+-methodMapping java.util.Date.Date(long) Antlr4.Runtime.Sharpen.Extensions.CreateDate
+-methodMapping java.lang.Long.signum Antlr4.Runtime.Sharpen.Extensions.Signum
 -methodMapping java.util.Collection.add AddItem
 -methodMapping java.util.ArrayList.removeElement Remove
--methodMapping java.net.InetAddress.getByName Sharpen.Extensions.GetAddressByName
--methodMapping java.net.ServerSocket.ServerSocket Sharpen.Extensions.CreateServerSocket
--methodMapping java.net.Socket.Socket Sharpen.Extensions.CreateSocket
+-methodMapping java.net.InetAddress.getByName Antlr4.Runtime.Sharpen.Extensions.GetAddressByName
+-methodMapping java.net.ServerSocket.ServerSocket Antlr4.Runtime.Sharpen.Extensions.CreateServerSocket
+-methodMapping java.net.Socket.Socket Antlr4.Runtime.Sharpen.Extensions.CreateSocket
 -methodMapping java.net.Socket.bind Bind2
 -methodMapping java.net.InetAddress.getAddress GetAddressBytes
 -methodMapping java.math.BigInteger.toByteArray GetBytes
 -methodMapping java.util.Vector.remove RemoveElement
--methodMapping java.util.concurrent.Semaphore.Semaphore Sharpen.Extensions.CreateSemaphore
+-methodMapping java.util.concurrent.Semaphore.Semaphore Antlr4.Runtime.Sharpen.Extensions.CreateSemaphore
 -methodMapping java.util.concurrent.Semaphore.acquire WaitOne
 -methodMapping java.lang.ProcessBuilder.command SetCommand
--methodMapping java.io.IOException.IOException(java.lang.Throwable) Sharpen.Extensions.CreateIOException
+-methodMapping java.io.IOException.IOException(java.lang.Throwable) Antlr4.Runtime.Sharpen.Extensions.CreateIOException
 -fieldMapping java.util.Locale.US InvariantCulture
 -typeMapping java.lang.Comparable System.IComparable
 -typeMapping java.lang.Comparable<> System.IComparable
@@ -106,18 +107,18 @@
 -typeMapping java.util.Set<> System.Collections.Generic.HashSet
 -typeMapping java.util.concurrent.ConcurrentMap<,> System.Collections.Concurrent.ConcurrentDictionary
 -typeMapping java.util.concurrent.ConcurrentHashMap<,> System.Collections.Concurrent.ConcurrentDictionary
--typeMapping java.io.File Sharpen.FilePath
+-typeMapping java.io.File Antlr4.Runtime.Sharpen.FilePath
 -typeMapping java.lang.StringBuilder System.Text.StringBuilder
 -typeMapping java.nio.charset.Charset System.Text.Encoding
 -typeMapping java.util.Locale System.Globalization.CultureInfo
 -typeMapping java.io.Closeable System.IDisposable
--typeMapping java.lang.Error Sharpen.Error
+-typeMapping java.lang.Error Antlr4.Runtime.Sharpen.Error
 -typeMapping java.lang.NumberFormatException System.FormatException
--typeMapping java.util.Collections Sharpen.Collections
+-typeMapping java.util.Collections Antlr4.Runtime.Sharpen.Collections
 -typeMapping java.util.LinkedList<> System.Collections.Generic.List
 -typeMapping java.net.URL System.Uri
--typeMapping java.lang.IndexOutOfRangeException Sharpen.IndexOutOfRangeException
--typeMapping java.lang.Process Sharpen.SystemProcess
+-typeMapping java.lang.IndexOutOfRangeException Antlr4.Runtime.Sharpen.IndexOutOfRangeException
+-typeMapping java.lang.Process Antlr4.Runtime.Sharpen.SystemProcess
 -typeMapping java.net.InetAddress System.Net.IPAddress
 -typeMapping java.util.TimeZone System.TimeZoneInfo
 -typeMapping java.util.ArrayList<> System.Collections.Generic.List
@@ -130,7 +131,7 @@
 -typeMapping java.util.SortedSet<> System.Collections.Generic.ICollection
 -typeMapping java.lang.AssertionError System.Exception
 -typeMapping java.io.InterruptedIOException System.Threading.ThreadInterruptedException
--typeMapping java.lang.RuntimeException Sharpen.RuntimeException
+-typeMapping java.lang.RuntimeException Antlr4.Runtime.Sharpen.RuntimeException
 -typeMapping java.net.MalformedURLException System.UriFormatException
 -typeMapping java.lang.Package System.Reflection.Assembly
 -typeMapping java.net.InetSocketAddress System.Net.IPEndPoint
@@ -138,7 +139,7 @@
 -typeMapping java.net.Socket System.Net.Sockets.Socket
 -typeMapping java.net.ServerSocket System.Net.Sockets.Socket
 -typeMapping java.math.BigInteger System.Numerics.BigInteger
--typeMapping java.util.Properties Sharpen.Properties
+-typeMapping java.util.Properties Antlr4.Runtime.Sharpen.Properties
 -typeMapping java.util.concurrent.Semaphore System.Threading.Semaphore
 -typeMapping java.util.Enumeration System.Collections.Generic.IEnumeration
 -typeMapping java.lang.ProcessBuilder System.Diagnostics.ProcessStartInfo

runtime/CSharp/Antlr4.Runtime/ANTLRFileStream.cs

@@ -28,13 +28,13 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using System.IO;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
     /// <summary>
     /// This is an
-    /// <see cref="AntlrInputStream">AntlrInputStream</see>
+    /// <see cref="AntlrInputStream"/>
     /// that is loaded from a file all at once
     /// when you construct the object.
     /// </summary>
@@ -42,20 +42,20 @@ namespace Antlr4.Runtime
     {
         protected internal string fileName;
 
-        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.IO.IOException"/>
         public AntlrFileStream(string fileName)
             : this(fileName, null)
         {
         }
 
-        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.IO.IOException"/>
         public AntlrFileStream(string fileName, string encoding)
         {
             this.fileName = fileName;
             Load(fileName, encoding);
         }
 
-        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.IO.IOException"/>
         public virtual void Load(string fileName, string encoding)
         {
             if (fileName == null)

runtime/CSharp/Antlr4.Runtime/ANTLRInputStream.cs

@@ -31,20 +31,20 @@ using System;
 using System.IO;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
     /// <summary>
     /// Vacuum all input from a
-    /// <see cref="System.IO.StreamReader">System.IO.StreamReader</see>
+    /// <see cref="System.IO.StreamReader"/>
     /// /
-    /// <see cref="System.IO.Stream">System.IO.Stream</see>
+    /// <see cref="System.IO.Stream"/>
     /// and then treat it
     /// like a
     /// <code>char[]</code>
     /// buffer. Can also pass in a
-    /// <see cref="string">string</see>
+    /// <see cref="string"/>
     /// or
     /// <code>char[]</code>
     /// to use.
@@ -86,43 +86,43 @@ namespace Antlr4.Runtime
             this.n = numberOfActualCharsInArray;
         }
 
-        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.IO.IOException"/>
         public AntlrInputStream(StreamReader r)
             : this(r, InitialBufferSize, ReadBufferSize)
         {
         }
 
-        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.IO.IOException"/>
         public AntlrInputStream(StreamReader r, int initialSize)
             : this(r, initialSize, ReadBufferSize)
         {
         }
 
-        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.IO.IOException"/>
         public AntlrInputStream(StreamReader r, int initialSize, int readChunkSize)
         {
             Load(r, initialSize, readChunkSize);
         }
 
-        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.IO.IOException"/>
         public AntlrInputStream(Stream input)
             : this(new StreamReader(input), InitialBufferSize)
         {
         }
 
-        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.IO.IOException"/>
         public AntlrInputStream(Stream input, int initialSize)
             : this(new StreamReader(input), initialSize)
         {
         }
 
-        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.IO.IOException"/>
         public AntlrInputStream(Stream input, int initialSize, int readChunkSize)
             : this(new StreamReader(input), initialSize, readChunkSize)
         {
         }
 
-        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.IO.IOException"/>
         public virtual void Load(StreamReader r, int size, int readChunkSize)
         {
             if (r == null)

runtime/CSharp/Antlr4.Runtime/Atn/ATN.cs

@@ -34,7 +34,7 @@ using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -81,7 +81,7 @@ namespace Antlr4.Runtime.Atn
         /// For lexer ATNs, this maps the rule index to the resulting token type.
         /// For parser ATNs, this maps the rule index to the generated bypass token
         /// type if the
-        /// <see cref="ATNDeserializationOptions.GenerateRuleBypassTransitions()">ATNDeserializationOptions.GenerateRuleBypassTransitions()</see>
+        /// <see cref="ATNDeserializationOptions.GenerateRuleBypassTransitions()"/>
         /// deserialization option was specified; otherwise, this is
         /// <code>null</code>
         /// .
@@ -90,7 +90,7 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// For lexer ATNs, this is an array of
-        /// <see cref="ILexerAction">ILexerAction</see>
+        /// <see cref="ILexerAction"/>
         /// objects which may
         /// be referenced by action transitions in the ATN.
         /// </summary>
@@ -161,7 +161,7 @@ namespace Antlr4.Runtime.Atn
         /// If
         /// <code>ctx</code>
         /// is
-        /// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
+        /// <see cref="PredictionContext.EmptyLocal"/>
         /// , the set of tokens will not include what can follow
         /// the rule surrounding
         /// <code>s</code>
@@ -184,7 +184,7 @@ namespace Antlr4.Runtime.Atn
         /// <code>s</code>
         /// and
         /// staying in same rule.
-        /// <see cref="Antlr4.Runtime.IToken.Epsilon">Antlr4.Runtime.IToken.Epsilon</see>
+        /// <see cref="Antlr4.Runtime.IToken.Epsilon"/>
         /// is in set if we reach end of
         /// rule.
         /// </summary>
@@ -260,17 +260,17 @@ namespace Antlr4.Runtime.Atn
         /// considers the complete parser context, but does not evaluate semantic
         /// predicates (i.e. all predicates encountered during the calculation are
         /// assumed true). If a path in the ATN exists from the starting state to the
-        /// <see cref="RuleStopState">RuleStopState</see>
+        /// <see cref="RuleStopState"/>
         /// of the outermost context without matching any
         /// symbols,
-        /// <see cref="Antlr4.Runtime.IToken.Eof">Antlr4.Runtime.IToken.Eof</see>
+        /// <see cref="Antlr4.Runtime.IToken.Eof"/>
         /// is added to the returned set.
         /// <p>If
         /// <code>context</code>
         /// is
         /// <code>null</code>
         /// , it is treated as
-        /// <see cref="ParserRuleContext#EMPTY">ParserRuleContext#EMPTY</see>
+        /// <see cref="ParserRuleContext#EMPTY"/>
         /// .</p>
         /// </summary>
         /// <param name="stateNumber">the ATN state number</param>

runtime/CSharp/Antlr4.Runtime/Atn/ATNConfig.cs

@@ -33,7 +33,7 @@ using System.Text;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/ATNConfigSet.cs

@@ -32,7 +32,7 @@ using System.Collections.Generic;
 using System.Text;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -41,16 +41,16 @@ namespace Antlr4.Runtime.Atn
     {
         /// <summary>
         /// This maps (state, alt) -&gt; merged
-        /// <see cref="ATNConfig">ATNConfig</see>
+        /// <see cref="ATNConfig"/>
         /// . The key does not account for
         /// the
-        /// <see cref="ATNConfig.SemanticContext()">ATNConfig.SemanticContext()</see>
+        /// <see cref="ATNConfig.SemanticContext()"/>
         /// of the value, which is only a problem if a single
         /// <code>ATNConfigSet</code>
         /// contains two configs with the same state and alternative
         /// but different semantic contexts. When this case arises, the first config
         /// added to this map stays, and the remaining configs are placed in
-        /// <see cref="unmerged">unmerged</see>
+        /// <see cref="unmerged"/>
         /// .
         /// <p>
         /// This map is only used for optimizing the process of adding configs to the set,
@@ -63,7 +63,7 @@ namespace Antlr4.Runtime.Atn
         /// <summary>
         /// This is an "overflow" list holding configs which cannot be merged with one
         /// of the configs in
-        /// <see cref="mergedConfigs">mergedConfigs</see>
+        /// <see cref="mergedConfigs"/>
         /// but have a colliding key. This
         /// occurs when two configs in the set have the same state and alternative but
         /// different semantic contexts.
@@ -92,14 +92,14 @@ namespace Antlr4.Runtime.Atn
         /// <code>true</code>
         /// , this config set represents configurations where the entire
         /// outer context has been consumed by the ATN interpreter. This prevents the
-        /// <see cref="ParserATNSimulator.Closure(ATNConfigSet, ATNConfigSet, bool, bool, PredictionContextCache, bool)">ParserATNSimulator.Closure(ATNConfigSet, ATNConfigSet, bool, bool, PredictionContextCache, bool)</see>
+        /// <see cref="ParserATNSimulator.Closure(ATNConfigSet, ATNConfigSet, bool, bool, PredictionContextCache, bool)"/>
         /// from pursuing the global FOLLOW when a
         /// rule stop state is reached with an empty prediction context.
         /// <p>
         /// Note:
         /// <code>outermostConfigSet</code>
         /// and
-        /// <see cref="dipsIntoOuterContext">dipsIntoOuterContext</see>
+        /// <see cref="dipsIntoOuterContext"/>
         /// should never
         /// be true at the same time.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/Atn/ATNDeserializationOptions.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using System;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/ATNDeserializer.cs

@@ -34,7 +34,7 @@ using System.IO;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -54,9 +54,9 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// This UUID indicates an extension of
-        /// <see cref="#ADDED_PRECEDENCE_TRANSITIONS">#ADDED_PRECEDENCE_TRANSITIONS</see>
+        /// <see cref="#ADDED_PRECEDENCE_TRANSITIONS"/>
         /// for the addition of lexer actions encoded as a sequence of
-        /// <see cref="ILexerAction">ILexerAction</see>
+        /// <see cref="ILexerAction"/>
         /// instances.
         /// </summary>
         private static readonly UUID AddedLexerActions;
@@ -105,19 +105,19 @@ namespace Antlr4.Runtime.Atn
         /// <summary>
         /// Determines if a particular serialized representation of an ATN supports
         /// a particular feature, identified by the
-        /// <see cref="Sharpen.UUID">Sharpen.UUID</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.UUID"/>
         /// used for serializing
         /// the ATN at the time the feature was first introduced.
         /// </summary>
         /// <param name="feature">
         /// The
-        /// <see cref="Sharpen.UUID">Sharpen.UUID</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.UUID"/>
         /// marking the first time the feature was
         /// supported in the serialized ATN.
         /// </param>
         /// <param name="actualUuid">
         /// The
-        /// <see cref="Sharpen.UUID">Sharpen.UUID</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.UUID"/>
         /// of the actual serialized ATN which is
         /// currently being deserialized.
         /// </param>
@@ -588,10 +588,10 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Analyze the
-        /// <see cref="StarLoopEntryState">StarLoopEntryState</see>
+        /// <see cref="StarLoopEntryState"/>
         /// states in the specified ATN to set
         /// the
-        /// <see cref="StarLoopEntryState.precedenceRuleDecision">StarLoopEntryState.precedenceRuleDecision</see>
+        /// <see cref="StarLoopEntryState.precedenceRuleDecision"/>
         /// field to the
         /// correct value.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/Atn/ATNSerializer.cs

@@ -34,7 +34,7 @@ using System.IO;
 using System.Text;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -662,7 +662,7 @@ namespace Antlr4.Runtime.Atn
                         }
                         // turn on the bit above max "\uFFFF" value so that we pad with zeros
                         // then only take last 4 digits
-                        string hex = Sharpen.Runtime.Substring(Sharpen.Extensions.ToHexString(t | unchecked((int)(0x10000))).ToUpper(), 1, 5);
+                        string hex = Sharpen.Runtime.Substring(Antlr4.Runtime.Sharpen.Extensions.ToHexString(t | unchecked((int)(0x10000))).ToUpper(), 1, 5);
                         string unicodeStr = "'\\u" + hex + "'";
                         return unicodeStr;
                     }

runtime/CSharp/Antlr4.Runtime/Atn/ATNSimulator.cs

@@ -32,7 +32,7 @@ using System.Collections.Generic;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/ATNState.cs

@@ -32,23 +32,23 @@ using System.Collections.Generic;
 using System.Globalization;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
     /// <summary>
     /// The following images show the relation of states and
-    /// <see cref="transitions">transitions</see>
+    /// <see cref="transitions"/>
     /// for various grammar constructs.
     /// <ul>
     /// <li>Solid edges marked with an &#0949; indicate a required
-    /// <see cref="EpsilonTransition">EpsilonTransition</see>
+    /// <see cref="EpsilonTransition"/>
     /// .</li>
     /// <li>Dashed edges indicate locations where any transition derived from
-    /// <see cref="Transition">Transition</see>
+    /// <see cref="Transition"/>
     /// might appear.</li>
     /// <li>Dashed nodes are place holders for either a sequence of linked
-    /// <see cref="BasicState">BasicState</see>
+    /// <see cref="BasicState"/>
     /// states or the inclusion of a block representing a nested
     /// construct in one of the forms below.</li>
     /// <li>Nodes showing multiple outgoing alternatives with a
@@ -95,7 +95,7 @@ namespace Antlr4.Runtime.Atn
     {
         public const int InitialNumTransitions = 4;
 
-        public static readonly IList<string> serializationNames = Sharpen.Collections.UnmodifiableList(Arrays.AsList("INVALID", "BASIC", "RULE_START", "BLOCK_START", "PLUS_BLOCK_START", "STAR_BLOCK_START", "TOKEN_START", "RULE_STOP", "BLOCK_END", "STAR_LOOP_BACK", "STAR_LOOP_ENTRY", "PLUS_LOOP_BACK", "LOOP_END"));
+        public static readonly IList<string> serializationNames = Antlr4.Runtime.Sharpen.Collections.UnmodifiableList(Arrays.AsList("INVALID", "BASIC", "RULE_START", "BLOCK_START", "PLUS_BLOCK_START", "STAR_BLOCK_START", "TOKEN_START", "RULE_STOP", "BLOCK_END", "STAR_LOOP_BACK", "STAR_LOOP_ENTRY", "PLUS_LOOP_BACK", "LOOP_END"));
 
         public const int InvalidStateNumber = -1;
 
@@ -131,13 +131,13 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// For all states except
-        /// <see cref="RuleStopState">RuleStopState</see>
+        /// <see cref="RuleStopState"/>
         /// , this returns the state
         /// number. Returns -1 for stop states.
         /// </summary>
         /// <returns>
         /// -1 for
-        /// <see cref="RuleStopState">RuleStopState</see>
+        /// <see cref="RuleStopState"/>
         /// , otherwise the state number
         /// </returns>
         public virtual int NonStopStateNumber

runtime/CSharp/Antlr4.Runtime/Atn/ATNType.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/AbstractPredicateTransition.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/ActionTransition.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/AmbiguityInfo.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -45,7 +45,7 @@ namespace Antlr4.Runtime.Atn
     /// determine that the SLL conflict is truly an ambiguity. For example, if none
     /// of the ATN configurations in the conflicting SLL configuration set have
     /// traversed a global follow transition (i.e.
-    /// <see cref="ATNConfig.ReachesIntoOuterContext()">ATNConfig.ReachesIntoOuterContext()</see>
+    /// <see cref="ATNConfig.ReachesIntoOuterContext()"/>
     /// is
     /// <code>false</code>
     /// for all
@@ -56,19 +56,19 @@ namespace Antlr4.Runtime.Atn
     /// configuration set is not equal to the minimum represented alternative in the
     /// conflicting SLL configuration set. Grammars and inputs which result in this
     /// scenario are unable to use
-    /// <see cref="PredictionMode.Sll">PredictionMode.Sll</see>
+    /// <see cref="PredictionMode.Sll"/>
     /// , which in turn means
     /// they cannot use the two-stage parsing strategy to improve parsing performance
     /// for that input.</p>
     /// </remarks>
-    /// <seealso cref="ParserATNSimulator.ReportAmbiguity(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.Dfa.DFAState, int, int, bool, Sharpen.BitSet, ATNConfigSet)">ParserATNSimulator.ReportAmbiguity(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.Dfa.DFAState, int, int, bool, Sharpen.BitSet, ATNConfigSet)</seealso>
-    /// <seealso cref="Antlr4.Runtime.IParserErrorListener.ReportAmbiguity(Antlr4.Runtime.Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Sharpen.BitSet, ATNConfigSet)">Antlr4.Runtime.IParserErrorListener.ReportAmbiguity(Antlr4.Runtime.Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Sharpen.BitSet, ATNConfigSet)</seealso>
+    /// <seealso cref="ParserATNSimulator.ReportAmbiguity(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.Dfa.DFAState, int, int, bool, Antlr4.Runtime.Sharpen.BitSet, ATNConfigSet)"/>
+    /// <seealso cref="Antlr4.Runtime.IParserErrorListener.ReportAmbiguity(Antlr4.Runtime.Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Antlr4.Runtime.Sharpen.BitSet, ATNConfigSet)"/>
     /// <since>4.3</since>
     public class AmbiguityInfo : DecisionEventInfo
     {
         /// <summary>
         /// Constructs a new instance of the
-        /// <see cref="AmbiguityInfo">AmbiguityInfo</see>
+        /// <see cref="AmbiguityInfo"/>
         /// class with the
         /// specified detailed ambiguity information.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/Atn/ArrayPredictionContext.cs

@@ -31,7 +31,7 @@ using System;
 using System.Collections.Generic;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/AtomTransition.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/BasicBlockStartState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/BasicState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/BlockEndState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/BlockStartState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/ContextSensitivityInfo.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -43,19 +43,19 @@ namespace Antlr4.Runtime.Atn
     /// equal to the minimum represented alternative in the conflicting SLL
     /// configuration set. Grammars and inputs which result in this scenario are
     /// unable to use
-    /// <see cref="PredictionMode.Sll">PredictionMode.Sll</see>
+    /// <see cref="PredictionMode.Sll"/>
     /// , which in turn means they cannot use
     /// the two-stage parsing strategy to improve parsing performance for that
     /// input.</p>
     /// </remarks>
-    /// <seealso cref="ParserATNSimulator.ReportContextSensitivity(Antlr4.Runtime.Dfa.DFA, int, SimulatorState, int, int)">ParserATNSimulator.ReportContextSensitivity(Antlr4.Runtime.Dfa.DFA, int, SimulatorState, int, int)</seealso>
-    /// <seealso cref="Antlr4.Runtime.IParserErrorListener.ReportContextSensitivity(Antlr4.Runtime.Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, SimulatorState)">Antlr4.Runtime.IParserErrorListener.ReportContextSensitivity(Antlr4.Runtime.Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, SimulatorState)</seealso>
+    /// <seealso cref="ParserATNSimulator.ReportContextSensitivity(Antlr4.Runtime.Dfa.DFA, int, SimulatorState, int, int)"/>
+    /// <seealso cref="Antlr4.Runtime.IParserErrorListener.ReportContextSensitivity(Antlr4.Runtime.Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, SimulatorState)"/>
     /// <since>4.3</since>
     public class ContextSensitivityInfo : DecisionEventInfo
     {
         /// <summary>
         /// Constructs a new instance of the
-        /// <see cref="ContextSensitivityInfo">ContextSensitivityInfo</see>
+        /// <see cref="ContextSensitivityInfo"/>
         /// class
         /// with the specified detailed context sensitivity information.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/Atn/DecisionEventInfo.cs

@@ -30,7 +30,7 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -47,7 +47,7 @@ namespace Antlr4.Runtime.Atn
     {
         /// <summary>The invoked decision number which this event is related to.</summary>
         /// <remarks>The invoked decision number which this event is related to.</remarks>
-        /// <seealso cref="ATN.decisionToState">ATN.decisionToState</seealso>
+        /// <seealso cref="ATN.decisionToState"/>
         public readonly int decision;
 
         /// <summary>

runtime/CSharp/Antlr4.Runtime/Atn/DecisionInfo.cs

@@ -29,7 +29,7 @@
  */
 using System.Collections.Generic;
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -49,14 +49,14 @@ namespace Antlr4.Runtime.Atn
     {
         /// <summary>
         /// The decision number, which is an index into
-        /// <see cref="ATN.decisionToState">ATN.decisionToState</see>
+        /// <see cref="ATN.decisionToState"/>
         /// .
         /// </summary>
         public readonly int decision;
 
         /// <summary>
         /// The total number of times
-        /// <see cref="ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)">ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)</see>
+        /// <see cref="ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)"/>
         /// was
         /// invoked for this decision.
         /// </summary>
@@ -64,21 +64,21 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// The total time spent in
-        /// <see cref="ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)">ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)</see>
+        /// <see cref="ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)"/>
         /// for
         /// this decision, in nanoseconds.
         /// <p>
         /// The value of this field contains the sum of differential results obtained
         /// by
-        /// <see cref="Sharpen.Runtime.NanoTime()">Sharpen.Runtime.NanoTime()</see>
+        /// <see cref="Sharpen.Runtime.NanoTime()"/>
         /// , and is not adjusted to compensate for JIT
         /// and/or garbage collection overhead. For best accuracy, use a modern JVM
         /// implementation that provides precise results from
-        /// <see cref="Sharpen.Runtime.NanoTime()">Sharpen.Runtime.NanoTime()</see>
+        /// <see cref="Sharpen.Runtime.NanoTime()"/>
         /// , and perform profiling in a separate process
         /// which is warmed up by parsing the input prior to profiling. If desired,
         /// call
-        /// <see cref="ATNSimulator.ClearDFA()">ATNSimulator.ClearDFA()</see>
+        /// <see cref="ATNSimulator.ClearDFA()"/>
         /// to reset the DFA cache to its initial
         /// state before starting the profiling measurement pass.</p>
         /// </summary>
@@ -89,9 +89,9 @@ namespace Antlr4.Runtime.Atn
         /// The sum of the lookahead required for SLL prediction for this decision.
         /// Note that SLL prediction is used before LL prediction for performance
         /// reasons even when
-        /// <see cref="PredictionMode.Ll">PredictionMode.Ll</see>
+        /// <see cref="PredictionMode.Ll"/>
         /// or
-        /// <see cref="PredictionMode.LlExactAmbigDetection">PredictionMode.LlExactAmbigDetection</see>
+        /// <see cref="PredictionMode.LlExactAmbigDetection"/>
         /// is used.
         /// </remarks>
         public long SLL_TotalLook;
@@ -122,9 +122,9 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Gets the
-        /// <see cref="LookaheadEventInfo">LookaheadEventInfo</see>
+        /// <see cref="LookaheadEventInfo"/>
         /// associated with the event where the
-        /// <see cref="SLL_MaxLook">SLL_MaxLook</see>
+        /// <see cref="SLL_MaxLook"/>
         /// value was set.
         /// </summary>
         public LookaheadEventInfo SLL_MaxLookEvent;
@@ -145,9 +145,9 @@ namespace Antlr4.Runtime.Atn
         /// Gets the minimum lookahead required for any single LL prediction to
         /// complete for this decision. An LL prediction completes when the algorithm
         /// reaches a unique prediction, a conflict state (for
-        /// <see cref="PredictionMode.Ll">PredictionMode.Ll</see>
+        /// <see cref="PredictionMode.Ll"/>
         /// , an ambiguity state (for
-        /// <see cref="PredictionMode.LlExactAmbigDetection">PredictionMode.LlExactAmbigDetection</see>
+        /// <see cref="PredictionMode.LlExactAmbigDetection"/>
         /// , or a syntax error.
         /// </remarks>
         public long LL_MinLook;
@@ -160,60 +160,60 @@ namespace Antlr4.Runtime.Atn
         /// Gets the maximum lookahead required for any single LL prediction to
         /// complete for this decision. An LL prediction completes when the algorithm
         /// reaches a unique prediction, a conflict state (for
-        /// <see cref="PredictionMode.Ll">PredictionMode.Ll</see>
+        /// <see cref="PredictionMode.Ll"/>
         /// , an ambiguity state (for
-        /// <see cref="PredictionMode.LlExactAmbigDetection">PredictionMode.LlExactAmbigDetection</see>
+        /// <see cref="PredictionMode.LlExactAmbigDetection"/>
         /// , or a syntax error.
         /// </remarks>
         public long LL_MaxLook;
 
         /// <summary>
         /// Gets the
-        /// <see cref="LookaheadEventInfo">LookaheadEventInfo</see>
+        /// <see cref="LookaheadEventInfo"/>
         /// associated with the event where the
-        /// <see cref="LL_MaxLook">LL_MaxLook</see>
+        /// <see cref="LL_MaxLook"/>
         /// value was set.
         /// </summary>
         public LookaheadEventInfo LL_MaxLookEvent;
 
         /// <summary>
         /// A collection of
-        /// <see cref="ContextSensitivityInfo">ContextSensitivityInfo</see>
+        /// <see cref="ContextSensitivityInfo"/>
         /// instances describing the
         /// context sensitivities encountered during LL prediction for this decision.
         /// </summary>
-        /// <seealso cref="ContextSensitivityInfo">ContextSensitivityInfo</seealso>
+        /// <seealso cref="ContextSensitivityInfo"/>
         public readonly IList<ContextSensitivityInfo> contextSensitivities = new List<ContextSensitivityInfo>();
 
         /// <summary>
         /// A collection of
-        /// <see cref="ErrorInfo">ErrorInfo</see>
+        /// <see cref="ErrorInfo"/>
         /// instances describing the parse errors
         /// identified during calls to
-        /// <see cref="ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)">ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)</see>
+        /// <see cref="ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)"/>
         /// for
         /// this decision.
         /// </summary>
-        /// <seealso cref="ErrorInfo">ErrorInfo</seealso>
+        /// <seealso cref="ErrorInfo"/>
         public readonly IList<ErrorInfo> errors = new List<ErrorInfo>();
 
         /// <summary>
         /// A collection of
-        /// <see cref="AmbiguityInfo">AmbiguityInfo</see>
+        /// <see cref="AmbiguityInfo"/>
         /// instances describing the
         /// ambiguities encountered during LL prediction for this decision.
         /// </summary>
-        /// <seealso cref="AmbiguityInfo">AmbiguityInfo</seealso>
+        /// <seealso cref="AmbiguityInfo"/>
         public readonly IList<AmbiguityInfo> ambiguities = new List<AmbiguityInfo>();
 
         /// <summary>
         /// A collection of
-        /// <see cref="PredicateEvalInfo">PredicateEvalInfo</see>
+        /// <see cref="PredicateEvalInfo"/>
         /// instances describing the
         /// results of evaluating individual predicates during prediction for this
         /// decision.
         /// </summary>
-        /// <seealso cref="PredicateEvalInfo">PredicateEvalInfo</seealso>
+        /// <seealso cref="PredicateEvalInfo"/>
         public readonly IList<PredicateEvalInfo> predicateEvals = new List<PredicateEvalInfo>();
 
         /// <summary>
@@ -231,9 +231,9 @@ namespace Antlr4.Runtime.Atn
         /// future parsing of this decision. Otherwise, the SLL parsing algorithm
         /// will use ATN transitions exclusively.</p>
         /// </remarks>
-        /// <seealso cref="SLL_ATNTransitions">SLL_ATNTransitions</seealso>
-        /// <seealso cref="ParserATNSimulator.ComputeTargetState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.Dfa.DFAState, Antlr4.Runtime.ParserRuleContext, int, bool, PredictionContextCache)">ParserATNSimulator.ComputeTargetState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.Dfa.DFAState, Antlr4.Runtime.ParserRuleContext, int, bool, PredictionContextCache)</seealso>
-        /// <seealso cref="LexerATNSimulator.ComputeTargetState(Antlr4.Runtime.ICharStream, Antlr4.Runtime.Dfa.DFAState, int)">LexerATNSimulator.ComputeTargetState(Antlr4.Runtime.ICharStream, Antlr4.Runtime.Dfa.DFAState, int)</seealso>
+        /// <seealso cref="SLL_ATNTransitions"/>
+        /// <seealso cref="ParserATNSimulator.ComputeTargetState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.Dfa.DFAState, Antlr4.Runtime.ParserRuleContext, int, bool, PredictionContextCache)"/>
+        /// <seealso cref="LexerATNSimulator.ComputeTargetState(Antlr4.Runtime.ICharStream, Antlr4.Runtime.Dfa.DFAState, int)"/>
         public long SLL_ATNTransitions;
 
         /// <summary>
@@ -246,8 +246,8 @@ namespace Antlr4.Runtime.Atn
         /// <p>If the ATN simulator implementation does not use DFA caching for SLL
         /// transitions, this value will be 0.</p>
         /// </remarks>
-        /// <seealso cref="ParserATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)">ParserATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)</seealso>
-        /// <seealso cref="LexerATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)">LexerATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)</seealso>
+        /// <seealso cref="ParserATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)"/>
+        /// <seealso cref="LexerATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)"/>
         public long SLL_DFATransitions;
 
         /// <summary>
@@ -258,15 +258,15 @@ namespace Antlr4.Runtime.Atn
         /// Gets the total number of times SLL prediction completed in a conflict
         /// state, resulting in fallback to LL prediction.
         /// <p>Note that this value is not related to whether or not
-        /// <see cref="PredictionMode.Sll">PredictionMode.Sll</see>
+        /// <see cref="PredictionMode.Sll"/>
         /// may be used successfully with a particular
         /// grammar. If the ambiguity resolution algorithm applied to the SLL
         /// conflicts for this decision produce the same result as LL prediction for
         /// this decision,
-        /// <see cref="PredictionMode.Sll">PredictionMode.Sll</see>
+        /// <see cref="PredictionMode.Sll"/>
         /// would produce the same overall
         /// parsing result as
-        /// <see cref="PredictionMode.Ll">PredictionMode.Ll</see>
+        /// <see cref="PredictionMode.Ll"/>
         /// .</p>
         /// </remarks>
         public long LL_Fallback;
@@ -286,9 +286,9 @@ namespace Antlr4.Runtime.Atn
         /// future parsing of this decision. Otherwise, the LL parsing algorithm will
         /// use ATN transitions exclusively.</p>
         /// </remarks>
-        /// <seealso cref="LL_DFATransitions">LL_DFATransitions</seealso>
-        /// <seealso cref="ParserATNSimulator.ComputeTargetState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.Dfa.DFAState, Antlr4.Runtime.ParserRuleContext, int, bool, PredictionContextCache)">ParserATNSimulator.ComputeTargetState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.Dfa.DFAState, Antlr4.Runtime.ParserRuleContext, int, bool, PredictionContextCache)</seealso>
-        /// <seealso cref="LexerATNSimulator.ComputeTargetState(Antlr4.Runtime.ICharStream, Antlr4.Runtime.Dfa.DFAState, int)">LexerATNSimulator.ComputeTargetState(Antlr4.Runtime.ICharStream, Antlr4.Runtime.Dfa.DFAState, int)</seealso>
+        /// <seealso cref="LL_DFATransitions"/>
+        /// <seealso cref="ParserATNSimulator.ComputeTargetState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.Dfa.DFAState, Antlr4.Runtime.ParserRuleContext, int, bool, PredictionContextCache)"/>
+        /// <seealso cref="LexerATNSimulator.ComputeTargetState(Antlr4.Runtime.ICharStream, Antlr4.Runtime.Dfa.DFAState, int)"/>
         public long LL_ATNTransitions;
 
         /// <summary>
@@ -301,13 +301,13 @@ namespace Antlr4.Runtime.Atn
         /// <p>If the ATN simulator implementation does not use DFA caching for LL
         /// transitions, this value will be 0.</p>
         /// </remarks>
-        /// <seealso cref="ParserATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)">ParserATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)</seealso>
-        /// <seealso cref="LexerATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)">LexerATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)</seealso>
+        /// <seealso cref="ParserATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)"/>
+        /// <seealso cref="LexerATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState, int)"/>
         public long LL_DFATransitions;
 
         /// <summary>
         /// Constructs a new instance of the
-        /// <see cref="DecisionInfo">DecisionInfo</see>
+        /// <see cref="DecisionInfo"/>
         /// class to contain
         /// statistics for a particular decision.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/Atn/DecisionState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/EmptyPredictionContext.cs

@@ -30,7 +30,7 @@
 using System;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/EpsilonTransition.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/ErrorInfo.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -43,14 +43,14 @@ namespace Antlr4.Runtime.Atn
     /// algorithm is unable to identify an alternative which would lead to a
     /// successful parse.
     /// </remarks>
-    /// <seealso cref="Antlr4.Runtime.Parser.NotifyErrorListeners(Antlr4.Runtime.IToken, string, Antlr4.Runtime.RecognitionException)">Antlr4.Runtime.Parser.NotifyErrorListeners(Antlr4.Runtime.IToken, string, Antlr4.Runtime.RecognitionException)</seealso>
-    /// <seealso cref="Antlr4.Runtime.IANTLRErrorListener{Symbol}.SyntaxError{T}(Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}, object, int, int, string, Antlr4.Runtime.RecognitionException)">Antlr4.Runtime.IANTLRErrorListener&lt;Symbol&gt;.SyntaxError&lt;T&gt;(Antlr4.Runtime.Recognizer&lt;Symbol, ATNInterpreter&gt;, object, int, int, string, Antlr4.Runtime.RecognitionException)</seealso>
+    /// <seealso cref="Antlr4.Runtime.Parser.NotifyErrorListeners(Antlr4.Runtime.IToken, string, Antlr4.Runtime.RecognitionException)"/>
+    /// <seealso cref="Antlr4.Runtime.IANTLRErrorListener{Symbol}.SyntaxError{T}(Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}, object, int, int, string, Antlr4.Runtime.RecognitionException)"/>
     /// <since>4.3</since>
     public class ErrorInfo : DecisionEventInfo
     {
         /// <summary>
         /// Constructs a new instance of the
-        /// <see cref="ErrorInfo">ErrorInfo</see>
+        /// <see cref="ErrorInfo"/>
         /// class with the
         /// specified detailed syntax error information.
         /// </summary>
@@ -58,7 +58,7 @@ namespace Antlr4.Runtime.Atn
         /// <param name="state">
         /// The final simulator state reached during prediction
         /// prior to reaching the
-        /// <see cref="ATNSimulator.Error">ATNSimulator.Error</see>
+        /// <see cref="ATNSimulator.Error"/>
         /// state
         /// </param>
         /// <param name="input">The input token stream</param>

runtime/CSharp/Antlr4.Runtime/Atn/ILexerAction.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -58,7 +58,7 @@ namespace Antlr4.Runtime.Atn
         /// <remarks>
         /// Gets whether the lexer action is position-dependent. Position-dependent
         /// actions may have different semantics depending on the
-        /// <see cref="Antlr4.Runtime.ICharStream">Antlr4.Runtime.ICharStream</see>
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
         /// index at the time the action is executed.
         /// <p>Many lexer commands, including
         /// <code>type</code>
@@ -69,7 +69,7 @@ namespace Antlr4.Runtime.Atn
         /// , do not check the input index during their execution.
         /// Actions like this are position-independent, and may be stored more
         /// efficiently as part of the
-        /// <see cref="ATNConfig.ActionExecutor()">ATNConfig.ActionExecutor()</see>
+        /// <see cref="ATNConfig.ActionExecutor()"/>
         /// .</p>
         /// </remarks>
         /// <returns>
@@ -77,7 +77,7 @@ namespace Antlr4.Runtime.Atn
         /// <code>true</code>
         /// if the lexer action semantics can be affected by the
         /// position of the input
-        /// <see cref="Antlr4.Runtime.ICharStream">Antlr4.Runtime.ICharStream</see>
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
         /// at the time it is executed;
         /// otherwise,
         /// <code>false</code>
@@ -90,7 +90,7 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Execute the lexer action in the context of the specified
-        /// <see cref="Antlr4.Runtime.Lexer">Antlr4.Runtime.Lexer</see>
+        /// <see cref="Antlr4.Runtime.Lexer"/>
         /// .
         /// <p>For position-dependent actions, the input stream must already be
         /// positioned correctly prior to calling this method.</p>

runtime/CSharp/Antlr4.Runtime/Atn/LL1Analyzer.cs

@@ -30,7 +30,7 @@
 using System.Collections.Generic;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -55,7 +55,7 @@ namespace Antlr4.Runtime.Atn
         /// <summary>
         /// Calculates the SLL(1) expected lookahead set for each outgoing transition
         /// of an
-        /// <see cref="ATNState">ATNState</see>
+        /// <see cref="ATNState"/>
         /// . The returned array has one element for each
         /// outgoing transition in
         /// <code>s</code>
@@ -111,7 +111,7 @@ namespace Antlr4.Runtime.Atn
         /// and the end of the rule containing
         /// <code>s</code>
         /// is reached,
-        /// <see cref="Antlr4.Runtime.IToken.Epsilon">Antlr4.Runtime.IToken.Epsilon</see>
+        /// <see cref="Antlr4.Runtime.IToken.Epsilon"/>
         /// is added to the result set.
         /// If
         /// <code>ctx</code>
@@ -119,7 +119,7 @@ namespace Antlr4.Runtime.Atn
         /// <code>null</code>
         /// and the end of the outermost rule is
         /// reached,
-        /// <see cref="Antlr4.Runtime.IToken.Eof">Antlr4.Runtime.IToken.Eof</see>
+        /// <see cref="Antlr4.Runtime.IToken.Eof"/>
         /// is added to the result set.</p>
         /// </summary>
         /// <param name="s">the ATN state</param>
@@ -157,7 +157,7 @@ namespace Antlr4.Runtime.Atn
         /// and the end of the rule containing
         /// <code>s</code>
         /// is reached,
-        /// <see cref="Antlr4.Runtime.IToken.Epsilon">Antlr4.Runtime.IToken.Epsilon</see>
+        /// <see cref="Antlr4.Runtime.IToken.Epsilon"/>
         /// is added to the result set.
         /// If
         /// <code>ctx</code>
@@ -165,13 +165,13 @@ namespace Antlr4.Runtime.Atn
         /// <code>PredictionContext#EMPTY_LOCAL</code>
         /// and the end of the outermost rule is
         /// reached,
-        /// <see cref="Antlr4.Runtime.IToken.Eof">Antlr4.Runtime.IToken.Eof</see>
+        /// <see cref="Antlr4.Runtime.IToken.Eof"/>
         /// is added to the result set.</p>
         /// </summary>
         /// <param name="s">the ATN state</param>
         /// <param name="stopState">
         /// the ATN state to stop at. This can be a
-        /// <see cref="BlockEndState">BlockEndState</see>
+        /// <see cref="BlockEndState"/>
         /// to detect epsilon paths through a closure.
         /// </param>
         /// <param name="ctx">
@@ -210,17 +210,17 @@ namespace Antlr4.Runtime.Atn
         /// If
         /// <code>ctx</code>
         /// is
-        /// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
+        /// <see cref="PredictionContext.EmptyLocal"/>
         /// and
         /// <code>stopState</code>
         /// or the end of the rule containing
         /// <code>s</code>
         /// is reached,
-        /// <see cref="Antlr4.Runtime.IToken.Epsilon">Antlr4.Runtime.IToken.Epsilon</see>
+        /// <see cref="Antlr4.Runtime.IToken.Epsilon"/>
         /// is added to the result set. If
         /// <code>ctx</code>
         /// is not
-        /// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
+        /// <see cref="PredictionContext.EmptyLocal"/>
         /// and
         /// <code>addEOF</code>
         /// is
@@ -228,18 +228,18 @@ namespace Antlr4.Runtime.Atn
         /// and
         /// <code>stopState</code>
         /// or the end of the outermost rule is reached,
-        /// <see cref="Antlr4.Runtime.IToken.Eof">Antlr4.Runtime.IToken.Eof</see>
+        /// <see cref="Antlr4.Runtime.IToken.Eof"/>
         /// is added to the result set.
         /// </summary>
         /// <param name="s">the ATN state.</param>
         /// <param name="stopState">
         /// the ATN state to stop at. This can be a
-        /// <see cref="BlockEndState">BlockEndState</see>
+        /// <see cref="BlockEndState"/>
         /// to detect epsilon paths through a closure.
         /// </param>
         /// <param name="ctx">
         /// The outer context, or
-        /// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
+        /// <see cref="PredictionContext.EmptyLocal"/>
         /// if
         /// the outer context should not be used.
         /// </param>
@@ -265,18 +265,18 @@ namespace Antlr4.Runtime.Atn
         /// and "see through them", otherwise
         /// <code>false</code>
         /// to treat semantic predicates as opaque and add
-        /// <see cref="HitPred">HitPred</see>
+        /// <see cref="HitPred"/>
         /// to the
         /// result if one is encountered.
         /// </param>
         /// <param name="addEOF">
         /// Add
-        /// <see cref="Antlr4.Runtime.IToken.Eof">Antlr4.Runtime.IToken.Eof</see>
+        /// <see cref="Antlr4.Runtime.IToken.Eof"/>
         /// to the result if the end of the
         /// outermost context is reached. This parameter has no effect if
         /// <code>ctx</code>
         /// is
-        /// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
+        /// <see cref="PredictionContext.EmptyLocal"/>
         /// .
         /// </param>
         protected internal virtual void Look(ATNState s, ATNState stopState, PredictionContext ctx, IntervalSet look, HashSet<ATNConfig> lookBusy, BitSet calledRuleStack, bool seeThruPreds, bool addEOF)

runtime/CSharp/Antlr4.Runtime/Atn/LexerATNSimulator.cs

@@ -32,7 +32,7 @@ using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -53,7 +53,7 @@ namespace Antlr4.Runtime.Atn
         /// When we hit an accept state in either the DFA or the ATN, we
         /// have to notify the character stream to start buffering characters
         /// via
-        /// <see cref="Antlr4.Runtime.IIntStream.Mark()">Antlr4.Runtime.IIntStream.Mark()</see>
+        /// <see cref="Antlr4.Runtime.IIntStream.Mark()"/>
         /// and record the current state. The current sim state
         /// includes the current index into the input, the current line,
         /// and current character position in that line. Note that the Lexer is
@@ -288,7 +288,7 @@ namespace Antlr4.Runtime.Atn
         /// <code>t</code>
         /// does not lead to a valid DFA state, this method
         /// returns
-        /// <see cref="ATNSimulator.Error">ATNSimulator.Error</see>
+        /// <see cref="ATNSimulator.Error"/>
         /// .
         /// </returns>
         [NotNull]
@@ -605,24 +605,24 @@ namespace Antlr4.Runtime.Atn
         /// is
         /// <code>true</code>
         /// , this method was called before
-        /// <see cref="Consume(Antlr4.Runtime.ICharStream)">Consume(Antlr4.Runtime.ICharStream)</see>
+        /// <see cref="Consume(Antlr4.Runtime.ICharStream)"/>
         /// for the matched character. This method should call
-        /// <see cref="Consume(Antlr4.Runtime.ICharStream)">Consume(Antlr4.Runtime.ICharStream)</see>
+        /// <see cref="Consume(Antlr4.Runtime.ICharStream)"/>
         /// before evaluating the predicate to ensure position
         /// sensitive values, including
-        /// <see cref="Antlr4.Runtime.Lexer.Text()">Antlr4.Runtime.Lexer.Text()</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Text()"/>
         /// ,
-        /// <see cref="Antlr4.Runtime.Lexer.Line()">Antlr4.Runtime.Lexer.Line()</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Line()"/>
         /// ,
         /// and
-        /// <see cref="Antlr4.Runtime.Lexer.Column()">Antlr4.Runtime.Lexer.Column()</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Column()"/>
         /// , properly reflect the current
         /// lexer state. This method should restore
         /// <code>input</code>
         /// and the simulator
         /// to the original state before returning (i.e. undo the actions made by the
         /// call to
-        /// <see cref="Consume(Antlr4.Runtime.ICharStream)">Consume(Antlr4.Runtime.ICharStream)</see>
+        /// <see cref="Consume(Antlr4.Runtime.ICharStream)"/>
         /// .</p>
         /// </remarks>
         /// <param name="input">The input stream.</param>

runtime/CSharp/Antlr4.Runtime/Atn/LexerActionExecutor.cs

@@ -30,7 +30,7 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -44,7 +44,7 @@ namespace Antlr4.Runtime.Atn
     /// <p>The executor tracks position information for position-dependent lexer actions
     /// efficiently, ensuring that actions appearing only at the end of the rule do
     /// not cause bloating of the
-    /// <see cref="Antlr4.Runtime.Dfa.DFA">Antlr4.Runtime.Dfa.DFA</see>
+    /// <see cref="Antlr4.Runtime.Dfa.DFA"/>
     /// created for the lexer.</p>
     /// </remarks>
     /// <author>Sam Harwell</author>
@@ -56,17 +56,17 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Caches the result of
-        /// <see cref="hashCode">hashCode</see>
+        /// <see cref="hashCode"/>
         /// since the hash code is an element
         /// of the performance-critical
-        /// <see cref="LexerATNConfig#hashCode">LexerATNConfig#hashCode</see>
+        /// <see cref="LexerATNConfig#hashCode"/>
         /// operation.
         /// </summary>
         private readonly int hashCode;
 
         /// <summary>
         /// Constructs an executor for a sequence of
-        /// <see cref="ILexerAction">ILexerAction</see>
+        /// <see cref="ILexerAction"/>
         /// actions.
         /// </summary>
         /// <param name="lexerActions">The lexer actions to execute.</param>
@@ -83,7 +83,7 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Creates a
-        /// <see cref="LexerActionExecutor">LexerActionExecutor</see>
+        /// <see cref="LexerActionExecutor"/>
         /// which executes the actions for
         /// the input
         /// <code>lexerActionExecutor</code>
@@ -94,7 +94,7 @@ namespace Antlr4.Runtime.Atn
         /// <param name="lexerActionExecutor">
         /// The executor for actions already traversed by
         /// the lexer while matching a token within a particular
-        /// <see cref="ATNConfig">ATNConfig</see>
+        /// <see cref="ATNConfig"/>
         /// . If this is
         /// <code>null</code>
         /// , the method behaves as though
@@ -108,7 +108,7 @@ namespace Antlr4.Runtime.Atn
         /// </param>
         /// <returns>
         /// A
-        /// <see cref="LexerActionExecutor">LexerActionExecutor</see>
+        /// <see cref="LexerActionExecutor"/>
         /// for executing the combine actions
         /// of
         /// <code>lexerActionExecutor</code>
@@ -130,17 +130,17 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Creates a
-        /// <see cref="LexerActionExecutor">LexerActionExecutor</see>
+        /// <see cref="LexerActionExecutor"/>
         /// which encodes the current offset
         /// for position-dependent lexer actions.
         /// <p>Normally, when the executor encounters lexer actions where
-        /// <see cref="ILexerAction.IsPositionDependent()">ILexerAction.IsPositionDependent()</see>
+        /// <see cref="ILexerAction.IsPositionDependent()"/>
         /// returns
         /// <code>true</code>
         /// , it calls
-        /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)">Antlr4.Runtime.IIntStream.Seek(int)</see>
+        /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
         /// on the input
-        /// <see cref="Antlr4.Runtime.ICharStream">Antlr4.Runtime.ICharStream</see>
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
         /// to set the input
         /// position to the <em>end</em> of the current token. This behavior provides
         /// for efficient DFA representation of lexer actions which appear at the end
@@ -164,7 +164,7 @@ namespace Antlr4.Runtime.Atn
         /// </param>
         /// <returns>
         /// A
-        /// <see cref="LexerActionExecutor">LexerActionExecutor</see>
+        /// <see cref="LexerActionExecutor"/>
         /// which stores input stream offsets
         /// for all position-dependent lexer actions.
         /// </returns>
@@ -203,16 +203,16 @@ namespace Antlr4.Runtime.Atn
         /// <summary>
         /// Execute the actions encapsulated by this executor within the context of a
         /// particular
-        /// <see cref="Antlr4.Runtime.Lexer">Antlr4.Runtime.Lexer</see>
+        /// <see cref="Antlr4.Runtime.Lexer"/>
         /// .
         /// <p>This method calls
-        /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)">Antlr4.Runtime.IIntStream.Seek(int)</see>
+        /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
         /// to set the position of the
         /// <code>input</code>
         /// 
-        /// <see cref="Antlr4.Runtime.ICharStream">Antlr4.Runtime.ICharStream</see>
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
         /// prior to calling
-        /// <see cref="ILexerAction.Execute(Antlr4.Runtime.Lexer)">ILexerAction.Execute(Antlr4.Runtime.Lexer)</see>
+        /// <see cref="ILexerAction.Execute(Antlr4.Runtime.Lexer)"/>
         /// on a position-dependent action. Before the
         /// method returns, the input position will be restored to the same position
         /// it was in when the method was invoked.</p>
@@ -221,7 +221,7 @@ namespace Antlr4.Runtime.Atn
         /// <param name="input">
         /// The input stream which is the source for the current token.
         /// When this method is called, the current
-        /// <see cref="Antlr4.Runtime.IIntStream.Index()">Antlr4.Runtime.IIntStream.Index()</see>
+        /// <see cref="Antlr4.Runtime.IIntStream.Index()"/>
         /// for
         /// <code>input</code>
         /// should be the start of the following token, i.e. 1
@@ -229,7 +229,7 @@ namespace Antlr4.Runtime.Atn
         /// </param>
         /// <param name="startIndex">
         /// The token start index. This value may be passed to
-        /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)">Antlr4.Runtime.IIntStream.Seek(int)</see>
+        /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
         /// to set the
         /// <code>input</code>
         /// position to the beginning

runtime/CSharp/Antlr4.Runtime/Atn/LexerActionType.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/LexerChannelAction.cs

@@ -30,7 +30,7 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -38,7 +38,7 @@ namespace Antlr4.Runtime.Atn
     /// Implements the
     /// <code>channel</code>
     /// lexer action by calling
-    /// <see cref="Antlr4.Runtime.Lexer.Channel(int)">Antlr4.Runtime.Lexer.Channel(int)</see>
+    /// <see cref="Antlr4.Runtime.Lexer.Channel(int)"/>
     /// with the assigned channel.
     /// </summary>
     /// <author>Sam Harwell</author>
@@ -54,7 +54,7 @@ namespace Antlr4.Runtime.Atn
         /// </summary>
         /// <param name="channel">
         /// The channel value to pass to
-        /// <see cref="Antlr4.Runtime.Lexer.Channel(int)">Antlr4.Runtime.Lexer.Channel(int)</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Channel(int)"/>
         /// .
         /// </param>
         public LexerChannelAction(int channel)
@@ -64,12 +64,12 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Gets the channel to use for the
-        /// <see cref="Antlr4.Runtime.IToken">Antlr4.Runtime.IToken</see>
+        /// <see cref="Antlr4.Runtime.IToken"/>
         /// created by the lexer.
         /// </summary>
         /// <returns>
         /// The channel to use for the
-        /// <see cref="Antlr4.Runtime.IToken">Antlr4.Runtime.IToken</see>
+        /// <see cref="Antlr4.Runtime.IToken"/>
         /// created by the lexer.
         /// </returns>
         public int Channel
@@ -80,10 +80,10 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
-        /// <see cref="LexerActionType.Channel">LexerActionType.Channel</see>
+        /// <see cref="LexerActionType.Channel"/>
         /// .
         /// </returns>
         public LexerActionType ActionType
@@ -94,7 +94,7 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
         /// <code>false</code>
@@ -109,12 +109,12 @@ namespace Antlr4.Runtime.Atn
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>This action is implemented by calling
-        /// <see cref="Antlr4.Runtime.Lexer.Channel(int)">Antlr4.Runtime.Lexer.Channel(int)</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Channel(int)"/>
         /// with the
         /// value provided by
-        /// <see cref="Channel()">Channel()</see>
+        /// <see cref="Channel()"/>
         /// .</p>
         /// </summary>
         public void Execute(Lexer lexer)

runtime/CSharp/Antlr4.Runtime/Atn/LexerCustomAction.cs

@@ -30,18 +30,18 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
     /// <summary>
     /// Executes a custom lexer action by calling
-    /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)">Antlr4.Runtime.Recognizer&lt;Symbol, ATNInterpreter&gt;.Action(Antlr4.Runtime.RuleContext, int, int)</see>
+    /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
     /// with the
     /// rule and action indexes assigned to the custom action. The implementation of
     /// a custom action is added to the generated code for the lexer in an override
     /// of
-    /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)">Antlr4.Runtime.Recognizer&lt;Symbol, ATNInterpreter&gt;.Action(Antlr4.Runtime.RuleContext, int, int)</see>
+    /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
     /// when the grammar is compiled.
     /// <p>This class may represent embedded actions created with the <code>{...}</code>
     /// syntax in ANTLR 4, as well as actions created for lexer commands where the
@@ -65,12 +65,12 @@ namespace Antlr4.Runtime.Atn
         /// </remarks>
         /// <param name="ruleIndex">
         /// The rule index to use for calls to
-        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)">Antlr4.Runtime.Recognizer&lt;Symbol, ATNInterpreter&gt;.Action(Antlr4.Runtime.RuleContext, int, int)</see>
+        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
         /// .
         /// </param>
         /// <param name="actionIndex">
         /// The action index to use for calls to
-        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)">Antlr4.Runtime.Recognizer&lt;Symbol, ATNInterpreter&gt;.Action(Antlr4.Runtime.RuleContext, int, int)</see>
+        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
         /// .
         /// </param>
         public LexerCustomAction(int ruleIndex, int actionIndex)
@@ -81,7 +81,7 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Gets the rule index to use for calls to
-        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)">Antlr4.Runtime.Recognizer&lt;Symbol, ATNInterpreter&gt;.Action(Antlr4.Runtime.RuleContext, int, int)</see>
+        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
         /// .
         /// </summary>
         /// <returns>The rule index for the custom action.</returns>
@@ -95,7 +95,7 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Gets the action index to use for calls to
-        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)">Antlr4.Runtime.Recognizer&lt;Symbol, ATNInterpreter&gt;.Action(Antlr4.Runtime.RuleContext, int, int)</see>
+        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
         /// .
         /// </summary>
         /// <returns>The action index for the custom action.</returns>
@@ -107,10 +107,10 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
-        /// <see cref="LexerActionType.Custom">LexerActionType.Custom</see>
+        /// <see cref="LexerActionType.Custom"/>
         /// .
         /// </returns>
         public LexerActionType ActionType
@@ -125,11 +125,11 @@ namespace Antlr4.Runtime.Atn
         /// <remarks>
         /// Gets whether the lexer action is position-dependent. Position-dependent
         /// actions may have different semantics depending on the
-        /// <see cref="Antlr4.Runtime.ICharStream">Antlr4.Runtime.ICharStream</see>
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
         /// index at the time the action is executed.
         /// <p>Custom actions are position-dependent since they may represent a
         /// user-defined embedded action which makes calls to methods like
-        /// <see cref="Antlr4.Runtime.Lexer.Text()">Antlr4.Runtime.Lexer.Text()</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Text()"/>
         /// .</p>
         /// </remarks>
         /// <returns>
@@ -146,9 +146,9 @@ namespace Antlr4.Runtime.Atn
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>Custom actions are implemented by calling
-        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)">Antlr4.Runtime.Recognizer&lt;Symbol, ATNInterpreter&gt;.Action(Antlr4.Runtime.RuleContext, int, int)</see>
+        /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
         /// with the
         /// appropriate rule and action indexes.</p>
         /// </summary>

runtime/CSharp/Antlr4.Runtime/Atn/LexerIndexedCustomAction.cs

@@ -30,24 +30,24 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
     /// <summary>
     /// This implementation of
-    /// <see cref="ILexerAction">ILexerAction</see>
+    /// <see cref="ILexerAction"/>
     /// is used for tracking input offsets
     /// for position-dependent actions within a
-    /// <see cref="LexerActionExecutor">LexerActionExecutor</see>
+    /// <see cref="LexerActionExecutor"/>
     /// .
     /// <p>This action is not serialized as part of the ATN, and is only required for
     /// position-dependent lexer actions which appear at a location other than the
     /// end of a rule. For more information about DFA optimizations employed for
     /// lexer actions, see
-    /// <see cref="LexerActionExecutor.Append(LexerActionExecutor, ILexerAction)">LexerActionExecutor.Append(LexerActionExecutor, ILexerAction)</see>
+    /// <see cref="LexerActionExecutor.Append(LexerActionExecutor, ILexerAction)"/>
     /// and
-    /// <see cref="LexerActionExecutor.FixOffsetBeforeMatch(int)">LexerActionExecutor.FixOffsetBeforeMatch(int)</see>
+    /// <see cref="LexerActionExecutor.FixOffsetBeforeMatch(int)"/>
     /// .</p>
     /// </summary>
     /// <author>Sam Harwell</author>
@@ -61,17 +61,17 @@ namespace Antlr4.Runtime.Atn
         /// <summary>
         /// Constructs a new indexed custom action by associating a character offset
         /// with a
-        /// <see cref="ILexerAction">ILexerAction</see>
+        /// <see cref="ILexerAction"/>
         /// .
         /// <p>Note: This class is only required for lexer actions for which
-        /// <see cref="ILexerAction.IsPositionDependent()">ILexerAction.IsPositionDependent()</see>
+        /// <see cref="ILexerAction.IsPositionDependent()"/>
         /// returns
         /// <code>true</code>
         /// .</p>
         /// </summary>
         /// <param name="offset">
         /// The offset into the input
-        /// <see cref="Antlr4.Runtime.ICharStream">Antlr4.Runtime.ICharStream</see>
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
         /// , relative to
         /// the token start index, at which the specified lexer action should be
         /// executed.
@@ -79,7 +79,7 @@ namespace Antlr4.Runtime.Atn
         /// <param name="action">
         /// The lexer action to execute at a particular offset in the
         /// input
-        /// <see cref="Antlr4.Runtime.ICharStream">Antlr4.Runtime.ICharStream</see>
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
         /// .
         /// </param>
         public LexerIndexedCustomAction(int offset, ILexerAction action)
@@ -90,14 +90,14 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Gets the location in the input
-        /// <see cref="Antlr4.Runtime.ICharStream">Antlr4.Runtime.ICharStream</see>
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
         /// at which the lexer
         /// action should be executed. The value is interpreted as an offset relative
         /// to the token start index.
         /// </summary>
         /// <returns>
         /// The location in the input
-        /// <see cref="Antlr4.Runtime.ICharStream">Antlr4.Runtime.ICharStream</see>
+        /// <see cref="Antlr4.Runtime.ICharStream"/>
         /// at which the lexer
         /// action should be executed.
         /// </returns>
@@ -113,7 +113,7 @@ namespace Antlr4.Runtime.Atn
         /// <remarks>Gets the lexer action to execute.</remarks>
         /// <returns>
         /// A
-        /// <see cref="ILexerAction">ILexerAction</see>
+        /// <see cref="ILexerAction"/>
         /// object which executes the lexer action.
         /// </returns>
         public ILexerAction Action
@@ -124,14 +124,14 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns the result of calling
-        /// <see cref="ActionType()">ActionType()</see>
+        /// <see cref="ActionType()"/>
         /// on the
-        /// <see cref="ILexerAction">ILexerAction</see>
+        /// <see cref="ILexerAction"/>
         /// returned by
-        /// <see cref="Action()">Action()</see>
+        /// <see cref="Action()"/>
         /// .
         /// </returns>
         public LexerActionType ActionType
@@ -142,7 +142,7 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
         /// <code>true</code>
@@ -157,11 +157,11 @@ namespace Antlr4.Runtime.Atn
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>This method calls
-        /// <see cref="Execute(Antlr4.Runtime.Lexer)">Execute(Antlr4.Runtime.Lexer)</see>
+        /// <see cref="Execute(Antlr4.Runtime.Lexer)"/>
         /// on the result of
-        /// <see cref="Action()">Action()</see>
+        /// <see cref="Action()"/>
         /// using the provided
         /// <code>lexer</code>
         /// .</p>

runtime/CSharp/Antlr4.Runtime/Atn/LexerModeAction.cs

@@ -30,7 +30,7 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -38,7 +38,7 @@ namespace Antlr4.Runtime.Atn
     /// Implements the
     /// <code>mode</code>
     /// lexer action by calling
-    /// <see cref="Antlr4.Runtime.Lexer.Mode(int)">Antlr4.Runtime.Lexer.Mode(int)</see>
+    /// <see cref="Antlr4.Runtime.Lexer.Mode(int)"/>
     /// with
     /// the assigned mode.
     /// </summary>
@@ -55,7 +55,7 @@ namespace Antlr4.Runtime.Atn
         /// </summary>
         /// <param name="mode">
         /// The mode value to pass to
-        /// <see cref="Antlr4.Runtime.Lexer.Mode(int)">Antlr4.Runtime.Lexer.Mode(int)</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Mode(int)"/>
         /// .
         /// </param>
         public LexerModeAction(int mode)
@@ -78,10 +78,10 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
-        /// <see cref="LexerActionType.Mode">LexerActionType.Mode</see>
+        /// <see cref="LexerActionType.Mode"/>
         /// .
         /// </returns>
         public LexerActionType ActionType
@@ -92,7 +92,7 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
         /// <code>false</code>
@@ -107,12 +107,12 @@ namespace Antlr4.Runtime.Atn
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>This action is implemented by calling
-        /// <see cref="Antlr4.Runtime.Lexer.Mode(int)">Antlr4.Runtime.Lexer.Mode(int)</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Mode(int)"/>
         /// with the
         /// value provided by
-        /// <see cref="Mode()">Mode()</see>
+        /// <see cref="Mode()"/>
         /// .</p>
         /// </summary>
         public void Execute(Lexer lexer)

runtime/CSharp/Antlr4.Runtime/Atn/LexerMoreAction.cs

@@ -30,7 +30,7 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -38,13 +38,13 @@ namespace Antlr4.Runtime.Atn
     /// Implements the
     /// <code>more</code>
     /// lexer action by calling
-    /// <see cref="Antlr4.Runtime.Lexer.More()">Antlr4.Runtime.Lexer.More()</see>
+    /// <see cref="Antlr4.Runtime.Lexer.More()"/>
     /// .
     /// <p>The
     /// <code>more</code>
     /// command does not have any parameters, so this action is
     /// implemented as a singleton instance exposed by
-    /// <see cref="Instance">Instance</see>
+    /// <see cref="Instance"/>
     /// .</p>
     /// </summary>
     /// <author>Sam Harwell</author>
@@ -64,10 +64,10 @@ namespace Antlr4.Runtime.Atn
         {
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
-        /// <see cref="LexerActionType.More">LexerActionType.More</see>
+        /// <see cref="LexerActionType.More"/>
         /// .
         /// </returns>
         public LexerActionType ActionType
@@ -78,7 +78,7 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
         /// <code>false</code>
@@ -93,9 +93,9 @@ namespace Antlr4.Runtime.Atn
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>This action is implemented by calling
-        /// <see cref="Antlr4.Runtime.Lexer.More()">Antlr4.Runtime.Lexer.More()</see>
+        /// <see cref="Antlr4.Runtime.Lexer.More()"/>
         /// .</p>
         /// </summary>
         public void Execute(Lexer lexer)

runtime/CSharp/Antlr4.Runtime/Atn/LexerPopModeAction.cs

@@ -30,7 +30,7 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -38,13 +38,13 @@ namespace Antlr4.Runtime.Atn
     /// Implements the
     /// <code>popMode</code>
     /// lexer action by calling
-    /// <see cref="Antlr4.Runtime.Lexer.PopMode()">Antlr4.Runtime.Lexer.PopMode()</see>
+    /// <see cref="Antlr4.Runtime.Lexer.PopMode()"/>
     /// .
     /// <p>The
     /// <code>popMode</code>
     /// command does not have any parameters, so this action is
     /// implemented as a singleton instance exposed by
-    /// <see cref="Instance">Instance</see>
+    /// <see cref="Instance"/>
     /// .</p>
     /// </summary>
     /// <author>Sam Harwell</author>
@@ -64,10 +64,10 @@ namespace Antlr4.Runtime.Atn
         {
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
-        /// <see cref="LexerActionType.PopMode">LexerActionType.PopMode</see>
+        /// <see cref="LexerActionType.PopMode"/>
         /// .
         /// </returns>
         public LexerActionType ActionType
@@ -78,7 +78,7 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
         /// <code>false</code>
@@ -93,9 +93,9 @@ namespace Antlr4.Runtime.Atn
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>This action is implemented by calling
-        /// <see cref="Antlr4.Runtime.Lexer.PopMode()">Antlr4.Runtime.Lexer.PopMode()</see>
+        /// <see cref="Antlr4.Runtime.Lexer.PopMode()"/>
         /// .</p>
         /// </summary>
         public void Execute(Lexer lexer)

runtime/CSharp/Antlr4.Runtime/Atn/LexerPushModeAction.cs

@@ -30,7 +30,7 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -38,7 +38,7 @@ namespace Antlr4.Runtime.Atn
     /// Implements the
     /// <code>pushMode</code>
     /// lexer action by calling
-    /// <see cref="Antlr4.Runtime.Lexer.PushMode(int)">Antlr4.Runtime.Lexer.PushMode(int)</see>
+    /// <see cref="Antlr4.Runtime.Lexer.PushMode(int)"/>
     /// with the assigned mode.
     /// </summary>
     /// <author>Sam Harwell</author>
@@ -54,7 +54,7 @@ namespace Antlr4.Runtime.Atn
         /// </summary>
         /// <param name="mode">
         /// The mode value to pass to
-        /// <see cref="Antlr4.Runtime.Lexer.PushMode(int)">Antlr4.Runtime.Lexer.PushMode(int)</see>
+        /// <see cref="Antlr4.Runtime.Lexer.PushMode(int)"/>
         /// .
         /// </param>
         public LexerPushModeAction(int mode)
@@ -77,10 +77,10 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
-        /// <see cref="LexerActionType.PushMode">LexerActionType.PushMode</see>
+        /// <see cref="LexerActionType.PushMode"/>
         /// .
         /// </returns>
         public LexerActionType ActionType
@@ -91,7 +91,7 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
         /// <code>false</code>
@@ -106,12 +106,12 @@ namespace Antlr4.Runtime.Atn
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>This action is implemented by calling
-        /// <see cref="Antlr4.Runtime.Lexer.PushMode(int)">Antlr4.Runtime.Lexer.PushMode(int)</see>
+        /// <see cref="Antlr4.Runtime.Lexer.PushMode(int)"/>
         /// with the
         /// value provided by
-        /// <see cref="Mode()">Mode()</see>
+        /// <see cref="Mode()"/>
         /// .</p>
         /// </summary>
         public void Execute(Lexer lexer)

runtime/CSharp/Antlr4.Runtime/Atn/LexerSkipAction.cs

@@ -30,7 +30,7 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -38,13 +38,13 @@ namespace Antlr4.Runtime.Atn
     /// Implements the
     /// <code>skip</code>
     /// lexer action by calling
-    /// <see cref="Antlr4.Runtime.Lexer.Skip()">Antlr4.Runtime.Lexer.Skip()</see>
+    /// <see cref="Antlr4.Runtime.Lexer.Skip()"/>
     /// .
     /// <p>The
     /// <code>skip</code>
     /// command does not have any parameters, so this action is
     /// implemented as a singleton instance exposed by
-    /// <see cref="Instance">Instance</see>
+    /// <see cref="Instance"/>
     /// .</p>
     /// </summary>
     /// <author>Sam Harwell</author>
@@ -64,10 +64,10 @@ namespace Antlr4.Runtime.Atn
         {
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
-        /// <see cref="LexerActionType.Skip">LexerActionType.Skip</see>
+        /// <see cref="LexerActionType.Skip"/>
         /// .
         /// </returns>
         public LexerActionType ActionType
@@ -78,7 +78,7 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
         /// <code>false</code>
@@ -93,9 +93,9 @@ namespace Antlr4.Runtime.Atn
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>This action is implemented by calling
-        /// <see cref="Antlr4.Runtime.Lexer.Skip()">Antlr4.Runtime.Lexer.Skip()</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Skip()"/>
         /// .</p>
         /// </summary>
         public void Execute(Lexer lexer)

runtime/CSharp/Antlr4.Runtime/Atn/LexerTypeAction.cs

@@ -30,7 +30,7 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -38,7 +38,7 @@ namespace Antlr4.Runtime.Atn
     /// Implements the
     /// <code>type</code>
     /// lexer action by calling
-    /// <see cref="Antlr4.Runtime.Lexer.Type(int)">Antlr4.Runtime.Lexer.Type(int)</see>
+    /// <see cref="Antlr4.Runtime.Lexer.Type(int)"/>
     /// with the assigned type.
     /// </summary>
     /// <author>Sam Harwell</author>
@@ -54,7 +54,7 @@ namespace Antlr4.Runtime.Atn
         /// </summary>
         /// <param name="type">
         /// The type to assign to the token using
-        /// <see cref="Antlr4.Runtime.Lexer.Type(int)">Antlr4.Runtime.Lexer.Type(int)</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Type(int)"/>
         /// .
         /// </param>
         public LexerTypeAction(int type)
@@ -73,10 +73,10 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
-        /// <see cref="LexerActionType.Type">LexerActionType.Type</see>
+        /// <see cref="LexerActionType.Type"/>
         /// .
         /// </returns>
         public virtual LexerActionType ActionType
@@ -87,7 +87,7 @@ namespace Antlr4.Runtime.Atn
             }
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         /// <returns>
         /// This method returns
         /// <code>false</code>
@@ -102,12 +102,12 @@ namespace Antlr4.Runtime.Atn
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>This action is implemented by calling
-        /// <see cref="Antlr4.Runtime.Lexer.Type(int)">Antlr4.Runtime.Lexer.Type(int)</see>
+        /// <see cref="Antlr4.Runtime.Lexer.Type(int)"/>
         /// with the
         /// value provided by
-        /// <see cref="Type()">Type()</see>
+        /// <see cref="Type()"/>
         /// .</p>
         /// </summary>
         public virtual void Execute(Lexer lexer)

runtime/CSharp/Antlr4.Runtime/Atn/LookaheadEventInfo.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -46,7 +46,7 @@ namespace Antlr4.Runtime.Atn
     {
         /// <summary>
         /// Constructs a new instance of the
-        /// <see cref="LookaheadEventInfo">LookaheadEventInfo</see>
+        /// <see cref="LookaheadEventInfo"/>
         /// class with
         /// the specified detailed lookahead information.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/Atn/LoopEndState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/NotSetTransition.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/OrderedATNConfigSet.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/ParseInfo.cs

@@ -31,7 +31,7 @@ using System.Collections.Generic;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -55,13 +55,13 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Gets an array of
-        /// <see cref="DecisionInfo">DecisionInfo</see>
+        /// <see cref="DecisionInfo"/>
         /// instances containing the profiling
         /// information gathered for each decision in the ATN.
         /// </summary>
         /// <returns>
         /// An array of
-        /// <see cref="DecisionInfo">DecisionInfo</see>
+        /// <see cref="DecisionInfo"/>
         /// instances, indexed by decision
         /// number.
         /// </returns>
@@ -80,7 +80,7 @@ namespace Antlr4.Runtime.Atn
         /// <remarks>
         /// Gets the decision numbers for decisions that required one or more
         /// full-context predictions during parsing. These are decisions for which
-        /// <see cref="DecisionInfo.LL_Fallback">DecisionInfo.LL_Fallback</see>
+        /// <see cref="DecisionInfo.LL_Fallback"/>
         /// is non-zero.
         /// </remarks>
         /// <returns>
@@ -110,7 +110,7 @@ namespace Antlr4.Runtime.Atn
         /// <remarks>
         /// Gets the total time spent during prediction across all decisions made
         /// during parsing. This value is the sum of
-        /// <see cref="DecisionInfo.timeInPrediction">DecisionInfo.timeInPrediction</see>
+        /// <see cref="DecisionInfo.timeInPrediction"/>
         /// for all decisions.
         /// </remarks>
         public virtual long GetTotalTimeInPrediction()
@@ -131,7 +131,7 @@ namespace Antlr4.Runtime.Atn
         /// <remarks>
         /// Gets the total number of SLL lookahead operations across all decisions
         /// made during parsing. This value is the sum of
-        /// <see cref="DecisionInfo.SLL_TotalLook">DecisionInfo.SLL_TotalLook</see>
+        /// <see cref="DecisionInfo.SLL_TotalLook"/>
         /// for all decisions.
         /// </remarks>
         public virtual long GetTotalSLLLookaheadOps()
@@ -152,7 +152,7 @@ namespace Antlr4.Runtime.Atn
         /// <remarks>
         /// Gets the total number of LL lookahead operations across all decisions
         /// made during parsing. This value is the sum of
-        /// <see cref="DecisionInfo.LL_TotalLook">DecisionInfo.LL_TotalLook</see>
+        /// <see cref="DecisionInfo.LL_TotalLook"/>
         /// for all decisions.
         /// </remarks>
         public virtual long GetTotalLLLookaheadOps()
@@ -213,9 +213,9 @@ namespace Antlr4.Runtime.Atn
         /// prediction across all decisions made during parsing.
         /// <p>
         /// This value is the sum of
-        /// <see cref="GetTotalSLLATNLookaheadOps()">GetTotalSLLATNLookaheadOps()</see>
+        /// <see cref="GetTotalSLLATNLookaheadOps()"/>
         /// and
-        /// <see cref="GetTotalLLATNLookaheadOps()">GetTotalLLATNLookaheadOps()</see>
+        /// <see cref="GetTotalLLATNLookaheadOps()"/>
         /// .</p>
         /// </remarks>
         public virtual long GetTotalATNLookaheadOps()

runtime/CSharp/Antlr4.Runtime/Atn/ParserATNSimulator.cs

@@ -33,7 +33,7 @@ using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -162,52 +162,52 @@ namespace Antlr4.Runtime.Atn
     /// All instances of the same parser share the same decision DFAs through a
     /// static field. Each instance gets its own ATN simulator but they share the
     /// same
-    /// <see cref="ATN.decisionToDFA">ATN.decisionToDFA</see>
+    /// <see cref="ATN.decisionToDFA"/>
     /// field. They also share a
-    /// <see cref="PredictionContextCache">PredictionContextCache</see>
+    /// <see cref="PredictionContextCache"/>
     /// object that makes sure that all
-    /// <see cref="PredictionContext">PredictionContext</see>
+    /// <see cref="PredictionContext"/>
     /// objects are shared among the DFA states. This makes
     /// a big size difference.</p>
     /// <p>
     /// <strong>THREAD SAFETY</strong></p>
     /// <p>
     /// The
-    /// <see cref="ParserATNSimulator">ParserATNSimulator</see>
+    /// <see cref="ParserATNSimulator"/>
     /// locks on the
-    /// <see cref="ATN.decisionToDFA">ATN.decisionToDFA</see>
+    /// <see cref="ATN.decisionToDFA"/>
     /// field when
     /// it adds a new DFA object to that array.
-    /// <see cref="AddDFAEdge(Antlr4.Runtime.Dfa.DFAState, int, Antlr4.Runtime.Dfa.DFAState)">AddDFAEdge(Antlr4.Runtime.Dfa.DFAState, int, Antlr4.Runtime.Dfa.DFAState)</see>
+    /// <see cref="AddDFAEdge(Antlr4.Runtime.Dfa.DFAState, int, Antlr4.Runtime.Dfa.DFAState)"/>
     /// locks on the DFA for the current decision when setting the
-    /// <see cref="DFAState#edges">DFAState#edges</see>
+    /// <see cref="DFAState#edges"/>
     /// field.
-    /// <see cref="AddDFAState(Antlr4.Runtime.Dfa.DFA, ATNConfigSet, PredictionContextCache)">AddDFAState(Antlr4.Runtime.Dfa.DFA, ATNConfigSet, PredictionContextCache)</see>
+    /// <see cref="AddDFAState(Antlr4.Runtime.Dfa.DFA, ATNConfigSet, PredictionContextCache)"/>
     /// locks on
     /// the DFA for the current decision when looking up a DFA state to see if it
     /// already exists. We must make sure that all requests to add DFA states that
     /// are equivalent result in the same shared DFA object. This is because lots of
     /// threads will be trying to update the DFA at once. The
-    /// <see cref="AddDFAState(Antlr4.Runtime.Dfa.DFA, ATNConfigSet, PredictionContextCache)">AddDFAState(Antlr4.Runtime.Dfa.DFA, ATNConfigSet, PredictionContextCache)</see>
+    /// <see cref="AddDFAState(Antlr4.Runtime.Dfa.DFA, ATNConfigSet, PredictionContextCache)"/>
     /// method also locks inside the DFA lock
     /// but this time on the shared context cache when it rebuilds the
     /// configurations'
-    /// <see cref="PredictionContext">PredictionContext</see>
+    /// <see cref="PredictionContext"/>
     /// objects using cached
     /// subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
     /// safe as long as we can guarantee that all threads referencing
     /// <code>s.edge[t]</code>
     /// get the same physical target
-    /// <see cref="Antlr4.Runtime.Dfa.DFAState">Antlr4.Runtime.Dfa.DFAState</see>
+    /// <see cref="Antlr4.Runtime.Dfa.DFAState"/>
     /// , or
     /// <code>null</code>
     /// . Once into the DFA, the DFA simulation does not reference the
-    /// <see cref="Antlr4.Runtime.Dfa.DFA.states">Antlr4.Runtime.Dfa.DFA.states</see>
+    /// <see cref="Antlr4.Runtime.Dfa.DFA.states"/>
     /// map. It follows the
-    /// <see cref="DFAState#edges">DFAState#edges</see>
+    /// <see cref="DFAState#edges"/>
     /// field to new
     /// targets. The DFA simulator will either find
-    /// <see cref="DFAState#edges">DFAState#edges</see>
+    /// <see cref="DFAState#edges"/>
     /// to be
     /// <code>null</code>
     /// , to be non-
@@ -217,7 +217,7 @@ namespace Antlr4.Runtime.Atn
     /// null, or
     /// <code>dfa.edges[t]</code>
     /// to be non-null. The
-    /// <see cref="AddDFAEdge(Antlr4.Runtime.Dfa.DFAState, int, Antlr4.Runtime.Dfa.DFAState)">AddDFAEdge(Antlr4.Runtime.Dfa.DFAState, int, Antlr4.Runtime.Dfa.DFAState)</see>
+    /// <see cref="AddDFAEdge(Antlr4.Runtime.Dfa.DFAState, int, Antlr4.Runtime.Dfa.DFAState)"/>
     /// method could be racing to set the field
     /// but in either case the DFA simulator works; if
     /// <code>null</code>
@@ -234,7 +234,7 @@ namespace Antlr4.Runtime.Atn
     /// point in doing full LL, which is slower. We only have to try LL if we get a
     /// syntax error. For maximum speed, Sam starts the parser set to pure SLL
     /// mode with the
-    /// <see cref="Antlr4.Runtime.BailErrorStrategy">Antlr4.Runtime.BailErrorStrategy</see>
+    /// <see cref="Antlr4.Runtime.BailErrorStrategy"/>
     /// :</p>
     /// <pre>
     /// parser.
@@ -242,13 +242,13 @@ namespace Antlr4.Runtime.Atn
     /// .
     /// <see cref="PredictionMode(PredictionMode)">setPredictionMode</see>
     /// <code>(</code>
-    /// <see cref="PredictionMode.Sll">PredictionMode.Sll</see>
+    /// <see cref="PredictionMode.Sll"/>
     /// <code>)</code>
     /// ;
     /// parser.
     /// <see cref="Antlr4.Runtime.Parser.ErrorHandler(IAntlrErrorStrategy)">setErrorHandler</see>
     /// (new
-    /// <see cref="Antlr4.Runtime.BailErrorStrategy">Antlr4.Runtime.BailErrorStrategy</see>
+    /// <see cref="Antlr4.Runtime.BailErrorStrategy"/>
     /// ());
     /// </pre>
     /// <p>
@@ -271,31 +271,31 @@ namespace Antlr4.Runtime.Atn
     /// alternatives.</p>
     /// <p>
     /// Let's say we have a set of SLL conflicting alternatives
-    /// <code></code>
+    /// <code/>
     /// 
     /// 1, 2, 3}} and
     /// a smaller LL set called <em>s</em>. If <em>s</em> is
-    /// <code></code>
+    /// <code/>
     /// 
     /// 2, 3}}, then SLL
     /// parsing will get an error because SLL will pursue alternative 1. If
     /// <em>s</em> is
-    /// <code></code>
+    /// <code/>
     /// 
     /// 1, 2}} or
-    /// <code></code>
+    /// <code/>
     /// 
     /// 1, 3}} then both SLL and LL will
     /// choose the same alternative because alternative one is the minimum of either
     /// set. If <em>s</em> is
-    /// <code></code>
+    /// <code/>
     /// 
     /// 2}} or
-    /// <code></code>
+    /// <code/>
     /// 
     /// 3}} then SLL will get a syntax
     /// error. If <em>s</em> is
-    /// <code></code>
+    /// <code/>
     /// 
     /// 1}} then SLL will succeed.</p>
     /// <p>
@@ -357,7 +357,7 @@ namespace Antlr4.Runtime.Atn
         /// <code>true</code>
         /// , ambiguous alternatives are reported when they are
         /// encountered within
-        /// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)">ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)</see>
+        /// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)"/>
         /// . When
         /// <code>false</code>
         /// , these messages
@@ -875,15 +875,15 @@ namespace Antlr4.Runtime.Atn
         /// <summary>
         /// This method is used to improve the localization of error messages by
         /// choosing an alternative rather than throwing a
-        /// <see cref="Antlr4.Runtime.NoViableAltException">Antlr4.Runtime.NoViableAltException</see>
+        /// <see cref="Antlr4.Runtime.NoViableAltException"/>
         /// in particular prediction scenarios where the
-        /// <see cref="ATNSimulator.Error">ATNSimulator.Error</see>
+        /// <see cref="ATNSimulator.Error"/>
         /// state was reached during ATN simulation.
         /// <p>
         /// The default implementation of this method uses the following
         /// algorithm to identify an ATN configuration which successfully parsed the
         /// decision entry rule. Choosing such an alternative ensures that the
-        /// <see cref="Antlr4.Runtime.ParserRuleContext">Antlr4.Runtime.ParserRuleContext</see>
+        /// <see cref="Antlr4.Runtime.ParserRuleContext"/>
         /// returned by the calling rule will be complete
         /// and valid, and the syntax error will be reported later at a more
         /// localized location.</p>
@@ -892,7 +892,7 @@ namespace Antlr4.Runtime.Atn
         /// <code>configs</code>
         /// reached the end of the
         /// decision rule, return
-        /// <see cref="ATN.InvalidAltNumber">ATN.InvalidAltNumber</see>
+        /// <see cref="ATN.InvalidAltNumber"/>
         /// .</li>
         /// <li>If all configurations in
         /// <code>configs</code>
@@ -918,16 +918,16 @@ namespace Antlr4.Runtime.Atn
         /// <p>
         /// In some scenarios, the algorithm described above could predict an
         /// alternative which will result in a
-        /// <see cref="Antlr4.Runtime.FailedPredicateException">Antlr4.Runtime.FailedPredicateException</see>
+        /// <see cref="Antlr4.Runtime.FailedPredicateException"/>
         /// in
         /// parser. Specifically, this could occur if the <em>only</em> configuration
         /// capable of successfully parsing to the end of the decision rule is
         /// blocked by a semantic predicate. By choosing this alternative within
-        /// <see cref="AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)">AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)</see>
+        /// <see cref="AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)"/>
         /// instead of throwing a
-        /// <see cref="Antlr4.Runtime.NoViableAltException">Antlr4.Runtime.NoViableAltException</see>
+        /// <see cref="Antlr4.Runtime.NoViableAltException"/>
         /// , the resulting
-        /// <see cref="Antlr4.Runtime.FailedPredicateException">Antlr4.Runtime.FailedPredicateException</see>
+        /// <see cref="Antlr4.Runtime.FailedPredicateException"/>
         /// in the parser will identify the specific
         /// predicate which is preventing the parser from successfully parsing the
         /// decision rule, which helps developers identify and correct logic errors
@@ -936,7 +936,7 @@ namespace Antlr4.Runtime.Atn
         /// </summary>
         /// <param name="input">
         /// The input
-        /// <see cref="Antlr4.Runtime.ITokenStream">Antlr4.Runtime.ITokenStream</see>
+        /// <see cref="Antlr4.Runtime.ITokenStream"/>
         /// </param>
         /// <param name="startIndex">
         /// The start index for the current prediction, which is
@@ -947,17 +947,17 @@ namespace Antlr4.Runtime.Atn
         /// </param>
         /// <param name="previous">
         /// The ATN simulation state immediately before the
-        /// <see cref="ATNSimulator.Error">ATNSimulator.Error</see>
+        /// <see cref="ATNSimulator.Error"/>
         /// state was reached
         /// </param>
         /// <returns>
         /// The value to return from
-        /// <see cref="AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)">AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)</see>
+        /// <see cref="AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)"/>
         /// , or
-        /// <see cref="ATN.InvalidAltNumber">ATN.InvalidAltNumber</see>
+        /// <see cref="ATN.InvalidAltNumber"/>
         /// if a suitable alternative was not
         /// identified and
-        /// <see cref="AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)">AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)</see>
+        /// <see cref="AdaptivePredict(Antlr4.Runtime.ITokenStream, int, Antlr4.Runtime.ParserRuleContext)"/>
         /// should report an error instead.
         /// </returns>
         protected internal virtual int HandleNoViableAlt(ITokenStream input, int startIndex, SimulatorState previous)
@@ -1108,12 +1108,12 @@ namespace Antlr4.Runtime.Atn
         /// Compute a target state for an edge in the DFA, and attempt to add the
         /// computed state and corresponding edge to the DFA.
         /// </remarks>
-        /// <param name="dfa"></param>
+        /// <param name="dfa"/>
         /// <param name="s">The current DFA state</param>
-        /// <param name="remainingGlobalContext"></param>
+        /// <param name="remainingGlobalContext"/>
         /// <param name="t">The next input symbol</param>
-        /// <param name="useContext"></param>
-        /// <param name="contextCache"></param>
+        /// <param name="useContext"/>
+        /// <param name="contextCache"/>
         /// <returns>
         /// The computed target DFA state for the given input symbol
         /// <code>t</code>
@@ -1121,7 +1121,7 @@ namespace Antlr4.Runtime.Atn
         /// <code>t</code>
         /// does not lead to a valid DFA state, this method
         /// returns
-        /// <see cref="ATNSimulator.Error">ATNSimulator.Error</see>
+        /// <see cref="ATNSimulator.Error"/>
         /// .
         /// </returns>
         [NotNull]
@@ -1230,7 +1230,7 @@ namespace Antlr4.Runtime.Atn
         /// Return a configuration set containing only the configurations from
         /// <code>configs</code>
         /// which are in a
-        /// <see cref="RuleStopState">RuleStopState</see>
+        /// <see cref="RuleStopState"/>
         /// . If all
         /// configurations in
         /// <code>configs</code>
@@ -1242,7 +1242,7 @@ namespace Antlr4.Runtime.Atn
         /// <param name="configs">the configuration set to update</param>
         /// <param name="contextCache">
         /// the
-        /// <see cref="PredictionContext">PredictionContext</see>
+        /// <see cref="PredictionContext"/>
         /// cache
         /// </param>
         /// <returns>
@@ -1432,14 +1432,14 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// This method transforms the start state computed by
-        /// <see cref="ComputeStartState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ParserRuleContext, bool)">ComputeStartState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ParserRuleContext, bool)</see>
+        /// <see cref="ComputeStartState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ParserRuleContext, bool)"/>
         /// to the special start state used by a
         /// precedence DFA for a particular precedence value. The transformation
         /// process applies the following changes to the start state's configuration
         /// set.
         /// <ol>
         /// <li>Evaluate the precedence predicates for each configuration using
-        /// <see cref="SemanticContext.EvalPrecedence(Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}, Antlr4.Runtime.RuleContext)">SemanticContext.EvalPrecedence(Antlr4.Runtime.Recognizer&lt;Symbol, ATNInterpreter&gt;, Antlr4.Runtime.RuleContext)</see>
+        /// <see cref="SemanticContext.EvalPrecedence(Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}, Antlr4.Runtime.RuleContext)"/>
         /// .</li>
         /// <li>Remove all configurations which predict an alternative greater than
         /// 1, for which another configuration that predicts alternative 1 is in the
@@ -1490,14 +1490,14 @@ namespace Antlr4.Runtime.Atn
         /// </summary>
         /// <param name="configs">
         /// The configuration set computed by
-        /// <see cref="ComputeStartState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ParserRuleContext, bool)">ComputeStartState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ParserRuleContext, bool)</see>
+        /// <see cref="ComputeStartState(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ParserRuleContext, bool)"/>
         /// as the start state for the DFA.
         /// </param>
         /// <returns>
         /// The transformed configuration set representing the start state
         /// for a precedence DFA at a particular precedence level (determined by
         /// calling
-        /// <see cref="Antlr4.Runtime.Parser.Precedence()">Antlr4.Runtime.Parser.Precedence()</see>
+        /// <see cref="Antlr4.Runtime.Parser.Precedence()"/>
         /// ).
         /// </returns>
         [NotNull]
@@ -1700,13 +1700,13 @@ namespace Antlr4.Runtime.Atn
         /// evaluate the following but it may change in the future:</p>
         /// <ul>
         /// <li>Precedence predicates (represented by
-        /// <see cref="PrecedencePredicate">PrecedencePredicate</see>
+        /// <see cref="PrecedencePredicate"/>
         /// ) are not currently evaluated
         /// through this method.</li>
         /// <li>Operator predicates (represented by
-        /// <see cref="AND">AND</see>
+        /// <see cref="AND"/>
         /// and
-        /// <see cref="OR">OR</see>
+        /// <see cref="OR"/>
         /// ) are evaluated as a single semantic
         /// context, rather than evaluating the operands individually.
         /// Implementations which require evaluation results from individual

runtime/CSharp/Antlr4.Runtime/Atn/PlusBlockStartState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -38,7 +38,7 @@ namespace Antlr4.Runtime.Atn
     /// loop. Technically a decision state, but
     /// we don't use for code generation; somebody might need it, so I'm defining
     /// it for completeness. In reality, the
-    /// <see cref="PlusLoopbackState">PlusLoopbackState</see>
+    /// <see cref="PlusLoopbackState"/>
     /// node is the
     /// real decision-making note for
     /// <code>A+</code>

runtime/CSharp/Antlr4.Runtime/Atn/PlusLoopbackState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/PredicateEvalInfo.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -41,7 +41,7 @@ namespace Antlr4.Runtime.Atn
     /// This class represents profiling event information for semantic predicate
     /// evaluations which occur during prediction.
     /// </remarks>
-    /// <seealso cref="ParserATNSimulator.EvalSemanticContext(Antlr4.Runtime.Dfa.DFAState.PredPrediction[], Antlr4.Runtime.ParserRuleContext, bool)">ParserATNSimulator.EvalSemanticContext(Antlr4.Runtime.Dfa.DFAState.PredPrediction[], Antlr4.Runtime.ParserRuleContext, bool)</seealso>
+    /// <seealso cref="ParserATNSimulator.EvalSemanticContext(Antlr4.Runtime.Dfa.DFAState.PredPrediction[], Antlr4.Runtime.ParserRuleContext, bool)"/>
     /// <since>4.3</since>
     public class PredicateEvalInfo : DecisionEventInfo
     {
@@ -52,25 +52,25 @@ namespace Antlr4.Runtime.Atn
         /// <summary>
         /// The alternative number for the decision which is guarded by the semantic
         /// context
-        /// <see cref="semctx">semctx</see>
+        /// <see cref="semctx"/>
         /// . Note that other ATN
         /// configurations may predict the same alternative which are guarded by
         /// other semantic contexts and/or
-        /// <see cref="SemanticContext.None">SemanticContext.None</see>
+        /// <see cref="SemanticContext.None"/>
         /// .
         /// </summary>
         public readonly int predictedAlt;
 
         /// <summary>
         /// The result of evaluating the semantic context
-        /// <see cref="semctx">semctx</see>
+        /// <see cref="semctx"/>
         /// .
         /// </summary>
         public readonly bool evalResult;
 
         /// <summary>
         /// Constructs a new instance of the
-        /// <see cref="PredicateEvalInfo">PredicateEvalInfo</see>
+        /// <see cref="PredicateEvalInfo"/>
         /// class with the
         /// specified detailed predicate evaluation information.
         /// </summary>
@@ -90,11 +90,11 @@ namespace Antlr4.Runtime.Atn
         /// guarded by the semantic context
         /// <code>semctx</code>
         /// . See
-        /// <see cref="predictedAlt">predictedAlt</see>
+        /// <see cref="predictedAlt"/>
         /// for more information.
         /// </param>
-        /// <seealso cref="ParserATNSimulator.EvalSemanticContext(SemanticContext, Antlr4.Runtime.ParserRuleContext, int)">ParserATNSimulator.EvalSemanticContext(SemanticContext, Antlr4.Runtime.ParserRuleContext, int)</seealso>
-        /// <seealso cref="SemanticContext.Eval(Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}, Antlr4.Runtime.RuleContext)">SemanticContext.Eval(Antlr4.Runtime.Recognizer&lt;Symbol, ATNInterpreter&gt;, Antlr4.Runtime.RuleContext)</seealso>
+        /// <seealso cref="ParserATNSimulator.EvalSemanticContext(SemanticContext, Antlr4.Runtime.ParserRuleContext, int)"/>
+        /// <seealso cref="SemanticContext.Eval(Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}, Antlr4.Runtime.RuleContext)"/>
         public PredicateEvalInfo(SimulatorState state, int decision, ITokenStream input, int startIndex, int stopIndex, SemanticContext semctx, bool evalResult, int predictedAlt)
             : base(decision, state, input, startIndex, stopIndex, state.useContext)
         {

runtime/CSharp/Antlr4.Runtime/Atn/PredicateTransition.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/PredictionContext.cs

@@ -33,7 +33,7 @@ using System.Text;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -53,7 +53,7 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// Stores the computed hash code of this
-        /// <see cref="PredictionContext">PredictionContext</see>
+        /// <see cref="PredictionContext"/>
         /// . The hash
         /// code is computed in parts to match the following reference algorithm.
         /// <pre>
@@ -61,10 +61,10 @@ namespace Antlr4.Runtime.Atn
         /// int hash =
         /// <see cref="Antlr4.Runtime.Misc.MurmurHash.Initialize()">MurmurHash.initialize</see>
         /// (
-        /// <see cref="InitialHash">InitialHash</see>
+        /// <see cref="InitialHash"/>
         /// );
         /// for (int i = 0; i &lt;
-        /// <see cref="Size()">Size()</see>
+        /// <see cref="Size()"/>
         /// ; i++) {
         /// hash =
         /// <see cref="Antlr4.Runtime.Misc.MurmurHash.Update(int, int)">MurmurHash.update</see>
@@ -73,7 +73,7 @@ namespace Antlr4.Runtime.Atn
         /// (i));
         /// }
         /// for (int i = 0; i &lt;
-        /// <see cref="Size()">Size()</see>
+        /// <see cref="Size()"/>
         /// ; i++) {
         /// hash =
         /// <see cref="Antlr4.Runtime.Misc.MurmurHash.Update(int, int)">MurmurHash.update</see>
@@ -84,7 +84,7 @@ namespace Antlr4.Runtime.Atn
         /// hash =
         /// <see cref="Antlr4.Runtime.Misc.MurmurHash.Finish(int, int)">MurmurHash.finish</see>
         /// (hash, 2 *
-        /// <see cref="Size()">Size()</see>
+        /// <see cref="Size()"/>
         /// );
         /// return hash;
         /// }

runtime/CSharp/Antlr4.Runtime/Atn/PredictionContextCache.cs

@@ -29,13 +29,13 @@
  */
 using System.Collections.Generic;
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
     /// <summary>
     /// Used to cache
-    /// <see cref="PredictionContext">PredictionContext</see>
+    /// <see cref="PredictionContext"/>
     /// objects. Its used for the shared
     /// context cash associated with contexts in DFA states. This cache
     /// can be used for both lexers and parsers.

runtime/CSharp/Antlr4.Runtime/Atn/PredictionMode.cs

@@ -30,7 +30,7 @@
 using System.Collections.Generic;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -58,15 +58,15 @@ namespace Antlr4.Runtime.Atn
         /// <p>
         /// When using this prediction mode, the parser will either return a correct
         /// parse tree (i.e. the same parse tree that would be returned with the
-        /// <see cref="Ll">Ll</see>
+        /// <see cref="Ll"/>
         /// prediction mode), or it will report a syntax error. If a
         /// syntax error is encountered when using the
-        /// <see cref="Sll">Sll</see>
+        /// <see cref="Sll"/>
         /// prediction mode,
         /// it may be due to either an actual syntax error in the input or indicate
         /// that the particular combination of grammar and input requires the more
         /// powerful
-        /// <see cref="Ll">Ll</see>
+        /// <see cref="Ll"/>
         /// prediction abilities to complete successfully.</p>
         /// <p>
         /// This prediction mode does not provide any guarantees for prediction
@@ -97,7 +97,7 @@ namespace Antlr4.Runtime.Atn
         /// <remarks>
         /// The LL(*) prediction mode with exact ambiguity detection. In addition to
         /// the correctness guarantees provided by the
-        /// <see cref="Ll">Ll</see>
+        /// <see cref="Ll"/>
         /// prediction mode,
         /// this prediction mode instructs the prediction algorithm to determine the
         /// complete and exact set of ambiguous alternatives for every ambiguous
@@ -133,9 +133,9 @@ namespace Antlr4.Runtime.Atn
 
             /// <summary>
             /// The hash code is only a function of the
-            /// <see cref="ATNState.stateNumber">ATNState.stateNumber</see>
+            /// <see cref="ATNState.stateNumber"/>
             /// and
-            /// <see cref="ATNConfig#context">ATNConfig#context</see>
+            /// <see cref="ATNConfig#context"/>
             /// .
             /// </summary>
             public override int GetHashCode(ATNConfig o)
@@ -180,10 +180,10 @@ namespace Antlr4.Runtime.Atn
         /// <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
         /// conflicting subsets should fall back to full LL, even if the
         /// configuration sets don't resolve to the same alternative (e.g.
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1,2}} and
-        /// <code></code>
+        /// <code/>
         /// 
         /// 3,4}}. If there is at least one non-conflicting
         /// configuration, SLL could continue with the hopes that more lookahead will
@@ -237,12 +237,12 @@ namespace Antlr4.Runtime.Atn
         /// This means that SLL termination detection can totally ignore semantic
         /// predicates.</p>
         /// <p>Implementation-wise,
-        /// <see cref="ATNConfigSet">ATNConfigSet</see>
+        /// <see cref="ATNConfigSet"/>
         /// combines stack contexts but not
         /// semantic predicate contexts so we might see two configurations like the
         /// following.</p>
         /// <p>
-        /// <code></code>
+        /// <code/>
         /// (s, 1, x,
         /// ), (s, 1, x', {p})}</p>
         /// <p>Before testing these configurations against others, we have to merge
@@ -255,14 +255,14 @@ namespace Antlr4.Runtime.Atn
         /// when looking for conflicts in
         /// the following configurations.</p>
         /// <p>
-        /// <code></code>
+        /// <code/>
         /// (s, 1, x,
         /// ), (s, 1, x', {p}), (s, 2, x'', {})}</p>
         /// <p>If the configuration set has predicates (as indicated by
-        /// <see cref="ATNConfigSet.HasSemanticContext()">ATNConfigSet.HasSemanticContext()</see>
+        /// <see cref="ATNConfigSet.HasSemanticContext()"/>
         /// ), this algorithm makes a copy of
         /// the configurations to strip out all of the predicates so that a standard
-        /// <see cref="ATNConfigSet">ATNConfigSet</see>
+        /// <see cref="ATNConfigSet"/>
         /// will merge everything ignoring predicates.</p>
         /// </remarks>
         public static bool HasSLLConflictTerminatingPrediction(PredictionMode mode, ATNConfigSet configs)
@@ -300,7 +300,7 @@ namespace Antlr4.Runtime.Atn
         /// Checks if any configuration in
         /// <code>configs</code>
         /// is in a
-        /// <see cref="RuleStopState">RuleStopState</see>
+        /// <see cref="RuleStopState"/>
         /// . Configurations meeting this condition have reached
         /// the end of the decision rule (local context) or end of start rule (full
         /// context).
@@ -312,7 +312,7 @@ namespace Antlr4.Runtime.Atn
         /// if any configuration in
         /// <code>configs</code>
         /// is in a
-        /// <see cref="RuleStopState">RuleStopState</see>
+        /// <see cref="RuleStopState"/>
         /// , otherwise
         /// <code>false</code>
         /// </returns>
@@ -332,7 +332,7 @@ namespace Antlr4.Runtime.Atn
         /// Checks if all configurations in
         /// <code>configs</code>
         /// are in a
-        /// <see cref="RuleStopState">RuleStopState</see>
+        /// <see cref="RuleStopState"/>
         /// . Configurations meeting this condition have reached
         /// the end of the decision rule (local context) or end of start rule (full
         /// context).
@@ -344,7 +344,7 @@ namespace Antlr4.Runtime.Atn
         /// if all configurations in
         /// <code>configs</code>
         /// are in a
-        /// <see cref="RuleStopState">RuleStopState</see>
+        /// <see cref="RuleStopState"/>
         /// , otherwise
         /// <code>false</code>
         /// </returns>
@@ -379,12 +379,12 @@ namespace Antlr4.Runtime.Atn
         /// and singleton subsets with
         /// non-conflicting configurations. Two configurations conflict if they have
         /// identical
-        /// <see cref="ATNConfig#state">ATNConfig#state</see>
+        /// <see cref="ATNConfig#state"/>
         /// and
-        /// <see cref="ATNConfig#context">ATNConfig#context</see>
+        /// <see cref="ATNConfig#context"/>
         /// values
         /// but different
-        /// <see cref="ATNConfig.Alt()">ATNConfig.Alt()</see>
+        /// <see cref="ATNConfig.Alt()"/>
         /// value, e.g.
         /// <code>(s, i, ctx, _)</code>
         /// and
@@ -396,7 +396,7 @@ namespace Antlr4.Runtime.Atn
         /// Reduce these configuration subsets to the set of possible alternatives.
         /// You can compute the alternative subsets in one pass as follows:
         /// <p/>
-        /// <code></code>
+        /// <code/>
         /// A_s,ctx =
         /// i | (s, i, ctx, _)}} for each configuration in
         /// <code>C</code>
@@ -528,16 +528,16 @@ namespace Antlr4.Runtime.Atn
         /// ,
         /// <code>(s', 2, y)</code>
         /// yields non-conflicting set
-        /// <code></code>
+        /// <code/>
         /// 
         /// 3}} U conflicting sets
-        /// <code></code>
+        /// <code/>
         /// min(
         /// 1,2})} U
-        /// <code></code>
+        /// <code/>
         /// min(
         /// 1,2})} =
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1,3}} =&gt; continue
         /// </li>
@@ -552,16 +552,16 @@ namespace Antlr4.Runtime.Atn
         /// ,
         /// <code>(s'', 1, z)</code>
         /// yields non-conflicting set
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1}} U conflicting sets
-        /// <code></code>
+        /// <code/>
         /// min(
         /// 1,2})} U
-        /// <code></code>
+        /// <code/>
         /// min(
         /// 1,2})} =
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1}} =&gt; stop and predict 1</li>
         /// <li>
@@ -573,17 +573,17 @@ namespace Antlr4.Runtime.Atn
         /// ,
         /// <code>(s', 2, y)</code>
         /// yields conflicting, reduced sets
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1}} U
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1}} =
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1}} =&gt; stop and predict 1, can announce
         /// ambiguity
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1,2}}</li>
         /// <li>
@@ -595,13 +595,13 @@ namespace Antlr4.Runtime.Atn
         /// ,
         /// <code>(s', 3, y)</code>
         /// yields conflicting, reduced sets
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1}} U
-        /// <code></code>
+        /// <code/>
         /// 
         /// 2}} =
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1,2}} =&gt; continue</li>
         /// <li>
@@ -613,13 +613,13 @@ namespace Antlr4.Runtime.Atn
         /// ,
         /// <code>(s', 4, y)</code>
         /// yields conflicting, reduced sets
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1}} U
-        /// <code></code>
+        /// <code/>
         /// 
         /// 3}} =
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1,3}} =&gt; continue</li>
         /// </ul>
@@ -633,20 +633,20 @@ namespace Antlr4.Runtime.Atn
         /// have more than one alternative and all
         /// <code>A_i</code>
         /// are the same. If
-        /// <code></code>
+        /// <code/>
         /// A=
         /// {1,2}, {1,3}}}, then regular LL prediction would terminate
         /// because the resolved set is
-        /// <code></code>
+        /// <code/>
         /// 
         /// 1}}. To determine what the real
         /// ambiguity is, we have to know whether the ambiguity is between one and
         /// two or one and three so we keep going. We can only stop prediction when
         /// we need exact ambiguity detection when the sets look like
-        /// <code></code>
+        /// <code/>
         /// A=
         /// {1,2}}} or
-        /// <code></code>
+        /// <code/>
         /// 
         /// {1,2},{1,2}}}, etc...</p>
         /// </remarks>
@@ -666,11 +666,11 @@ namespace Antlr4.Runtime.Atn
         /// 
         /// <code>true</code>
         /// if every
-        /// <see cref="Sharpen.BitSet">Sharpen.BitSet</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
         /// in
         /// <code>altsets</code>
         /// has
-        /// <see cref="Sharpen.BitSet.Cardinality()">cardinality</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see>
         /// &gt; 1, otherwise
         /// <code>false</code>
         /// </returns>
@@ -692,9 +692,9 @@ namespace Antlr4.Runtime.Atn
         /// if
         /// <code>altsets</code>
         /// contains a
-        /// <see cref="Sharpen.BitSet">Sharpen.BitSet</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
         /// with
-        /// <see cref="Sharpen.BitSet.Cardinality()">cardinality</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see>
         /// 1, otherwise
         /// <code>false</code>
         /// </returns>
@@ -723,9 +723,9 @@ namespace Antlr4.Runtime.Atn
         /// if
         /// <code>altsets</code>
         /// contains a
-        /// <see cref="Sharpen.BitSet">Sharpen.BitSet</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
         /// with
-        /// <see cref="Sharpen.BitSet.Cardinality()">cardinality</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see>
         /// &gt; 1, otherwise
         /// <code>false</code>
         /// </returns>
@@ -775,7 +775,7 @@ namespace Antlr4.Runtime.Atn
         /// Returns the unique alternative predicted by all alternative subsets in
         /// <code>altsets</code>
         /// . If no such alternative exists, this method returns
-        /// <see cref="ATN.InvalidAltNumber">ATN.InvalidAltNumber</see>
+        /// <see cref="ATN.InvalidAltNumber"/>
         /// .
         /// </summary>
         /// <param name="altsets">a collection of alternative subsets</param>
@@ -796,7 +796,7 @@ namespace Antlr4.Runtime.Atn
         /// <remarks>
         /// Gets the complete set of represented alternatives for a collection of
         /// alternative subsets. This method returns the union of each
-        /// <see cref="Sharpen.BitSet">Sharpen.BitSet</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
         /// in
         /// <code>altsets</code>
         /// .

runtime/CSharp/Antlr4.Runtime/Atn/ProfilingATNSimulator.cs

@@ -31,7 +31,7 @@ using System;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/RangeTransition.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/RuleStartState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/RuleStopState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/RuleTransition.cs

@@ -30,7 +30,7 @@
 using System;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/SemanticContext.cs

@@ -32,7 +32,7 @@ using System.Collections.Generic;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -49,23 +49,23 @@ namespace Antlr4.Runtime.Atn
     /// <code>p1||p2</code>
     /// .
     /// <p>I have scoped the
-    /// <see cref="AND">AND</see>
+    /// <see cref="AND"/>
     /// ,
-    /// <see cref="OR">OR</see>
+    /// <see cref="OR"/>
     /// , and
-    /// <see cref="Predicate">Predicate</see>
+    /// <see cref="Predicate"/>
     /// subclasses of
-    /// <see cref="SemanticContext">SemanticContext</see>
+    /// <see cref="SemanticContext"/>
     /// within the scope of this outer class.</p>
     /// </remarks>
     public abstract class SemanticContext
     {
         /// <summary>
         /// The default
-        /// <see cref="SemanticContext">SemanticContext</see>
+        /// <see cref="SemanticContext"/>
         /// , which is semantically equivalent to
         /// a predicate of the form
-        /// <code></code>
+        /// <code/>
         /// 
         /// true}?}.
         /// </summary>
@@ -92,13 +92,13 @@ namespace Antlr4.Runtime.Atn
         /// <summary>Evaluate the precedence predicates for the context and reduce the result.</summary>
         /// <remarks>Evaluate the precedence predicates for the context and reduce the result.</remarks>
         /// <param name="parser">The parser instance.</param>
-        /// <param name="parserCallStack"></param>
+        /// <param name="parserCallStack"/>
         /// <returns>
         /// The simplified semantic context after precedence predicates are
         /// evaluated, which will be one of the following values.
         /// <ul>
         /// <li>
-        /// <see cref="None">None</see>
+        /// <see cref="None"/>
         /// : if the predicate simplifies to
         /// <code>true</code>
         /// after
@@ -116,7 +116,7 @@ namespace Antlr4.Runtime.Atn
         /// <li>A non-
         /// <code>null</code>
         /// 
-        /// <see cref="SemanticContext">SemanticContext</see>
+        /// <see cref="SemanticContext"/>
         /// : the new simplified
         /// semantic context after precedence predicates are evaluated.</li>
         /// </ul>
@@ -264,7 +264,7 @@ namespace Antlr4.Runtime.Atn
             /// <remarks>Gets the operands for the semantic context operator.</remarks>
             /// <returns>
             /// a collection of
-            /// <see cref="SemanticContext">SemanticContext</see>
+            /// <see cref="SemanticContext"/>
             /// operands for the
             /// operator.
             /// </returns>
@@ -311,7 +311,7 @@ namespace Antlr4.Runtime.Atn
                 if (!precedencePredicates.IsEmpty())
                 {
                     // interested in the transition with the lowest precedence
-                    SemanticContext.PrecedencePredicate reduced = Sharpen.Collections.Min(precedencePredicates);
+                    SemanticContext.PrecedencePredicate reduced = Antlr4.Runtime.Sharpen.Collections.Min(precedencePredicates);
                     operands.AddItem(reduced);
                 }
                 opnds = Sharpen.Collections.ToArray(operands, new SemanticContext[operands.Count]);
@@ -345,7 +345,7 @@ namespace Antlr4.Runtime.Atn
             }
 
             /// <summary>
-            /// <inheritDoc></inheritDoc>
+            /// <inheritDoc/>
             /// <p>
             /// The evaluation of predicates by this context is short-circuiting, but
             /// unordered.</p>
@@ -443,7 +443,7 @@ namespace Antlr4.Runtime.Atn
                 if (!precedencePredicates.IsEmpty())
                 {
                     // interested in the transition with the highest precedence
-                    SemanticContext.PrecedencePredicate reduced = Sharpen.Collections.Max(precedencePredicates);
+                    SemanticContext.PrecedencePredicate reduced = Antlr4.Runtime.Sharpen.Collections.Max(precedencePredicates);
                     operands.AddItem(reduced);
                 }
                 this.opnds = Sharpen.Collections.ToArray(operands, new SemanticContext[operands.Count]);
@@ -477,7 +477,7 @@ namespace Antlr4.Runtime.Atn
             }
 
             /// <summary>
-            /// <inheritDoc></inheritDoc>
+            /// <inheritDoc/>
             /// <p>
             /// The evaluation of predicates by this context is short-circuiting, but
             /// unordered.</p>
@@ -557,7 +557,7 @@ namespace Antlr4.Runtime.Atn
             return result;
         }
 
-        /// <seealso cref="ParserATNSimulator.GetPredsForAmbigAlts(Sharpen.BitSet, ATNConfigSet, int)">ParserATNSimulator.GetPredsForAmbigAlts(Sharpen.BitSet, ATNConfigSet, int)</seealso>
+        /// <seealso cref="ParserATNSimulator.GetPredsForAmbigAlts(Antlr4.Runtime.Sharpen.BitSet, ATNConfigSet, int)"/>
         public static SemanticContext Or(SemanticContext a, SemanticContext b)
         {
             if (a == null)
@@ -599,7 +599,7 @@ namespace Antlr4.Runtime.Atn
             }
             if (result == null)
             {
-                return Sharpen.Collections.EmptyList();
+                return Antlr4.Runtime.Sharpen.Collections.EmptyList();
             }
             return result;
         }

runtime/CSharp/Antlr4.Runtime/Atn/SetTransition.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/SimulatorState.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Dfa;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/SingletonPredictionContext.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/StarBlockStartState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/StarLoopEntryState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -45,12 +45,12 @@ namespace Antlr4.Runtime.Atn
         /// decision making.
         /// <p>This is a computed property that is calculated during ATN deserialization
         /// and stored for use in
-        /// <see cref="ParserATNSimulator">ParserATNSimulator</see>
+        /// <see cref="ParserATNSimulator"/>
         /// and
-        /// <see cref="Antlr4.Runtime.ParserInterpreter">Antlr4.Runtime.ParserInterpreter</see>
+        /// <see cref="Antlr4.Runtime.ParserInterpreter"/>
         /// .</p>
         /// </remarks>
-        /// <seealso cref="Antlr4.Runtime.Dfa.DFA.IsPrecedenceDfa()">Antlr4.Runtime.Dfa.DFA.IsPrecedenceDfa()</seealso>
+        /// <seealso cref="Antlr4.Runtime.Dfa.DFA.IsPrecedenceDfa()"/>
         public bool precedenceRuleDecision;
 
         public override Antlr4.Runtime.Atn.StateType StateType

runtime/CSharp/Antlr4.Runtime/Atn/StarLoopbackState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/StateType.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/TokensStartState.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/Transition.cs

@@ -31,7 +31,7 @@ using System;
 using System.Collections.Generic;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
@@ -49,7 +49,7 @@ namespace Antlr4.Runtime.Atn
     /// </remarks>
     public abstract class Transition
     {
-        public static readonly IList<string> serializationNames = Sharpen.Collections.UnmodifiableList(Arrays.AsList("INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION", "SET", "NOT_SET", "WILDCARD", "PRECEDENCE"));
+        public static readonly IList<string> serializationNames = Antlr4.Runtime.Sharpen.Collections.UnmodifiableList(Arrays.AsList("INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION", "SET", "NOT_SET", "WILDCARD", "PRECEDENCE"));
 
         /// <summary>The target of this transition.</summary>
         /// <remarks>The target of this transition.</remarks>

runtime/CSharp/Antlr4.Runtime/Atn/TransitionType.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Atn;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/Atn/WildcardTransition.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {

runtime/CSharp/Antlr4.Runtime/BailErrorStrategy.cs

@@ -28,18 +28,18 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
     /// <summary>
     /// This implementation of
-    /// <see cref="IAntlrErrorStrategy">IAntlrErrorStrategy</see>
+    /// <see cref="IAntlrErrorStrategy"/>
     /// responds to syntax errors
     /// by immediately canceling the parse operation with a
-    /// <see cref="ParseCanceledException">ParseCanceledException</see>
+    /// <see cref="ParseCanceledException"/>
     /// . The implementation ensures that the
-    /// <see cref="ParserRuleContext.exception">ParserRuleContext.exception</see>
+    /// <see cref="ParserRuleContext.exception"/>
     /// field is set for all parse tree nodes
     /// that were not completed prior to encountering the error.
     /// <p>
@@ -50,13 +50,13 @@ namespace Antlr4.Runtime
     /// encountered, and immediately fall back to the second stage. In addition to
     /// avoiding wasted work by attempting to recover from errors here, the empty
     /// implementation of
-    /// <see cref="Sync(Parser)">Sync(Parser)</see>
+    /// <see cref="Sync(Parser)"/>
     /// improves the performance of
     /// the first stage.</li>
     /// <li><strong>Silent validation:</strong> When syntax errors are not being
     /// reported or logged, and the parse result is simply ignored if errors occur,
     /// the
-    /// <see cref="BailErrorStrategy">BailErrorStrategy</see>
+    /// <see cref="BailErrorStrategy"/>
     /// avoids wasting work on recovering from errors
     /// when the result will be ignored either way.</li>
     /// </ul>
@@ -64,7 +64,7 @@ namespace Antlr4.Runtime
     /// <code>myparser.setErrorHandler(new BailErrorStrategy());</code>
     /// </p>
     /// </summary>
-    /// <seealso cref="Parser.ErrorHandler(IAntlrErrorStrategy)">Parser.ErrorHandler(IAntlrErrorStrategy)</seealso>
+    /// <seealso cref="Parser.ErrorHandler(IAntlrErrorStrategy)"/>
     public class BailErrorStrategy : DefaultErrorStrategy
     {
         /// <summary>
@@ -72,13 +72,13 @@ namespace Antlr4.Runtime
         /// <code>e</code>
         /// , re-throw it wrapped
         /// in a
-        /// <see cref="ParseCanceledException">ParseCanceledException</see>
+        /// <see cref="ParseCanceledException"/>
         /// so it is not caught by the
         /// rule function catches.  Use
-        /// <see cref="System.Exception.InnerException()">System.Exception.InnerException()</see>
+        /// <see cref="System.Exception.InnerException()"/>
         /// to get the
         /// original
-        /// <see cref="RecognitionException">RecognitionException</see>
+        /// <see cref="RecognitionException"/>
         /// .
         /// </summary>
         public override void Recover(Parser recognizer, RecognitionException e)
@@ -98,7 +98,7 @@ namespace Antlr4.Runtime
         /// Make sure we don't attempt to recover inline; if the parser
         /// successfully recovers, it won't throw an exception.
         /// </remarks>
-        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
         public override IToken RecoverInline(Parser recognizer)
         {
             InputMismatchException e = new InputMismatchException(recognizer);

runtime/CSharp/Antlr4.Runtime/BaseErrorListener.cs

@@ -30,13 +30,13 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
     /// <summary>
     /// Provides an empty default implementation of
-    /// <see cref="IANTLRErrorListener{Symbol}">IANTLRErrorListener&lt;Symbol&gt;</see>
+    /// <see cref="IANTLRErrorListener{Symbol}"/>
     /// . The
     /// default implementation of each method does nothing, but can be overridden as
     /// necessary.

runtime/CSharp/Antlr4.Runtime/BufferedTokenStream.cs

@@ -32,35 +32,35 @@ using System.Collections.Generic;
 using System.Text;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
     /// <summary>
     /// This implementation of
-    /// <see cref="ITokenStream">ITokenStream</see>
+    /// <see cref="ITokenStream"/>
     /// loads tokens from a
-    /// <see cref="ITokenSource">ITokenSource</see>
+    /// <see cref="ITokenSource"/>
     /// on-demand, and places the tokens in a buffer to provide
     /// access to any previous token by index.
     /// <p>
     /// This token stream ignores the value of
-    /// <see cref="IToken.Channel()">IToken.Channel()</see>
+    /// <see cref="IToken.Channel()"/>
     /// . If your
     /// parser requires the token stream filter tokens to only those on a particular
     /// channel, such as
-    /// <see cref="IToken.DefaultChannel">IToken.DefaultChannel</see>
+    /// <see cref="IToken.DefaultChannel"/>
     /// or
-    /// <see cref="IToken.HiddenChannel">IToken.HiddenChannel</see>
+    /// <see cref="IToken.HiddenChannel"/>
     /// , use a filtering token stream such a
-    /// <see cref="CommonTokenStream">CommonTokenStream</see>
+    /// <see cref="CommonTokenStream"/>
     /// .</p>
     /// </summary>
     public class BufferedTokenStream : ITokenStream
     {
         /// <summary>
         /// The
-        /// <see cref="ITokenSource">ITokenSource</see>
+        /// <see cref="ITokenSource"/>
         /// from which tokens for this stream are fetched.
         /// </summary>
         [NotNull]
@@ -70,7 +70,7 @@ namespace Antlr4.Runtime
         /// <remarks>
         /// A collection of all tokens fetched from the token source. The list is
         /// considered a complete view of the input once
-        /// <see cref="fetchedEOF">fetchedEOF</see>
+        /// <see cref="fetchedEOF"/>
         /// is set
         /// to
         /// <code>true</code>
@@ -80,23 +80,23 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// The index into
-        /// <see cref="tokens">tokens</see>
+        /// <see cref="tokens"/>
         /// of the current token (next token to
-        /// <see cref="Consume()">Consume()</see>
+        /// <see cref="Consume()"/>
         /// ).
-        /// <see cref="tokens">tokens</see>
+        /// <see cref="tokens"/>
         /// <code>[</code>
-        /// <see cref="p">p</see>
+        /// <see cref="p"/>
         /// <code>]</code>
         /// should be
         /// <see cref="Lt(int)">LT(1)</see>
         /// .
         /// <p>This field is set to -1 when the stream is first constructed or when
-        /// <see cref="SetTokenSource(ITokenSource)">SetTokenSource(ITokenSource)</see>
+        /// <see cref="SetTokenSource(ITokenSource)"/>
         /// is called, indicating that the first token has
         /// not yet been fetched from the token source. For additional information,
         /// see the documentation of
-        /// <see cref="IIntStream">IIntStream</see>
+        /// <see cref="IIntStream"/>
         /// for a description of
         /// Initializing Methods.</p>
         /// </summary>
@@ -104,30 +104,30 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Indicates whether the
-        /// <see cref="IToken.Eof">IToken.Eof</see>
+        /// <see cref="IToken.Eof"/>
         /// token has been fetched from
-        /// <see cref="tokenSource">tokenSource</see>
+        /// <see cref="tokenSource"/>
         /// and added to
-        /// <see cref="tokens">tokens</see>
+        /// <see cref="tokens"/>
         /// . This field improves
         /// performance for the following cases:
         /// <ul>
         /// <li>
-        /// <see cref="Consume()">Consume()</see>
+        /// <see cref="Consume()"/>
         /// : The lookahead check in
-        /// <see cref="Consume()">Consume()</see>
+        /// <see cref="Consume()"/>
         /// to prevent
         /// consuming the EOF symbol is optimized by checking the values of
-        /// <see cref="fetchedEOF">fetchedEOF</see>
+        /// <see cref="fetchedEOF"/>
         /// and
-        /// <see cref="p">p</see>
+        /// <see cref="p"/>
         /// instead of calling
-        /// <see cref="La(int)">La(int)</see>
+        /// <see cref="La(int)"/>
         /// .</li>
         /// <li>
-        /// <see cref="Fetch(int)">Fetch(int)</see>
+        /// <see cref="Fetch(int)"/>
         /// : The check to prevent adding multiple EOF symbols into
-        /// <see cref="tokens">tokens</see>
+        /// <see cref="tokens"/>
         /// is trivial with this field.</li>
         /// <ul>
         /// </summary>
@@ -233,7 +233,7 @@ namespace Antlr4.Runtime
         /// <code>false</code>
         /// .
         /// </returns>
-        /// <seealso cref="Get(int)">Get(int)</seealso>
+        /// <seealso cref="Get(int)"/>
         protected internal virtual bool Sync(int i)
         {
             System.Diagnostics.Debug.Assert(i >= 0);
@@ -364,7 +364,7 @@ namespace Antlr4.Runtime
         /// exception is thrown in this method, the current stream index should not be
         /// changed.
         /// <p>For example,
-        /// <see cref="CommonTokenStream">CommonTokenStream</see>
+        /// <see cref="CommonTokenStream"/>
         /// overrides this method to ensure that
         /// the seek target is always an on-channel token.</p>
         /// </remarks>
@@ -532,7 +532,7 @@ namespace Antlr4.Runtime
         /// <summary>
         /// Collect all tokens on specified channel to the right of
         /// the current token up until we see a token on
-        /// <see cref="Lexer.DefaultTokenChannel">Lexer.DefaultTokenChannel</see>
+        /// <see cref="Lexer.DefaultTokenChannel"/>
         /// or
         /// EOF. If
         /// <code>channel</code>
@@ -565,7 +565,7 @@ namespace Antlr4.Runtime
         /// <summary>
         /// Collect all hidden tokens (any off-default channel) to the right of
         /// the current token up until we see a token on
-        /// <see cref="Lexer.DefaultTokenChannel">Lexer.DefaultTokenChannel</see>
+        /// <see cref="Lexer.DefaultTokenChannel"/>
         /// or EOF.
         /// </summary>
         public virtual IList<IToken> GetHiddenTokensToRight(int tokenIndex)
@@ -576,7 +576,7 @@ namespace Antlr4.Runtime
         /// <summary>
         /// Collect all tokens on specified channel to the left of
         /// the current token up until we see a token on
-        /// <see cref="Lexer.DefaultTokenChannel">Lexer.DefaultTokenChannel</see>
+        /// <see cref="Lexer.DefaultTokenChannel"/>
         /// .
         /// If
         /// <code>channel</code>
@@ -610,7 +610,7 @@ namespace Antlr4.Runtime
         /// <summary>
         /// Collect all hidden tokens (any off-default channel) to the left of
         /// the current token up until we see a token on
-        /// <see cref="Lexer.DefaultTokenChannel">Lexer.DefaultTokenChannel</see>
+        /// <see cref="Lexer.DefaultTokenChannel"/>
         /// .
         /// </summary>
         public virtual IList<IToken> GetHiddenTokensToLeft(int tokenIndex)

runtime/CSharp/Antlr4.Runtime/CommonToken.cs

@@ -30,7 +30,7 @@
 using System;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
@@ -41,63 +41,63 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// An empty
-        /// <see cref="Antlr4.Runtime.Misc.Tuple2{T1, T2}">Antlr4.Runtime.Misc.Tuple2&lt;T1, T2&gt;</see>
+        /// <see cref="Antlr4.Runtime.Misc.Tuple2{T1, T2}"/>
         /// which is used as the default value of
-        /// <see cref="source">source</see>
+        /// <see cref="source"/>
         /// for tokens that do not have a source.
         /// </summary>
         protected internal static readonly Tuple<ITokenSource, ICharStream> EmptySource = Tuple.Create<ITokenSource, ICharStream>(null, null);
 
         /// <summary>
         /// This is the backing field for
-        /// <see cref="Type()">Type()</see>
+        /// <see cref="Type()"/>
         /// and
-        /// <see cref="Type(int)">Type(int)</see>
+        /// <see cref="Type(int)"/>
         /// .
         /// </summary>
         protected internal int type;
 
         /// <summary>
         /// This is the backing field for
-        /// <see cref="Line()">Line()</see>
+        /// <see cref="Line()"/>
         /// and
-        /// <see cref="Line(int)">Line(int)</see>
+        /// <see cref="Line(int)"/>
         /// .
         /// </summary>
         protected internal int line;
 
         /// <summary>
         /// This is the backing field for
-        /// <see cref="Column()">Column()</see>
+        /// <see cref="Column()"/>
         /// and
-        /// <see cref="Column(int)">Column(int)</see>
+        /// <see cref="Column(int)"/>
         /// .
         /// </summary>
         protected internal int charPositionInLine = -1;
 
         /// <summary>
         /// This is the backing field for
-        /// <see cref="Channel()">Channel()</see>
+        /// <see cref="Channel()"/>
         /// and
-        /// <see cref="Channel(int)">Channel(int)</see>
+        /// <see cref="Channel(int)"/>
         /// .
         /// </summary>
         protected internal int channel = TokenConstants.DefaultChannel;
 
         /// <summary>
         /// This is the backing field for
-        /// <see cref="TokenSource()">TokenSource()</see>
+        /// <see cref="TokenSource()"/>
         /// and
-        /// <see cref="InputStream()">InputStream()</see>
+        /// <see cref="InputStream()"/>
         /// .
         /// <p>
         /// These properties share a field to reduce the memory footprint of
-        /// <see cref="CommonToken">CommonToken</see>
+        /// <see cref="CommonToken"/>
         /// . Tokens created by a
-        /// <see cref="CommonTokenFactory">CommonTokenFactory</see>
+        /// <see cref="CommonTokenFactory"/>
         /// from
         /// the same source and input stream share a reference to the same
-        /// <see cref="Antlr4.Runtime.Misc.Tuple2{T1, T2}">Antlr4.Runtime.Misc.Tuple2&lt;T1, T2&gt;</see>
+        /// <see cref="Antlr4.Runtime.Misc.Tuple2{T1, T2}"/>
         /// containing these values.</p>
         /// </summary>
         [NotNull]
@@ -105,45 +105,45 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// This is the backing field for
-        /// <see cref="Text()">Text()</see>
+        /// <see cref="Text()"/>
         /// when the token text is
         /// explicitly set in the constructor or via
-        /// <see cref="Text(string)">Text(string)</see>
+        /// <see cref="Text(string)"/>
         /// .
         /// </summary>
-        /// <seealso cref="Text()">Text()</seealso>
+        /// <seealso cref="Text()"/>
         protected internal string text;
 
         /// <summary>
         /// This is the backing field for
-        /// <see cref="TokenIndex()">TokenIndex()</see>
+        /// <see cref="TokenIndex()"/>
         /// and
-        /// <see cref="TokenIndex(int)">TokenIndex(int)</see>
+        /// <see cref="TokenIndex(int)"/>
         /// .
         /// </summary>
         protected internal int index = -1;
 
         /// <summary>
         /// This is the backing field for
-        /// <see cref="StartIndex()">StartIndex()</see>
+        /// <see cref="StartIndex()"/>
         /// and
-        /// <see cref="StartIndex(int)">StartIndex(int)</see>
+        /// <see cref="StartIndex(int)"/>
         /// .
         /// </summary>
         protected internal int start;
 
         /// <summary>
         /// This is the backing field for
-        /// <see cref="StopIndex()">StopIndex()</see>
+        /// <see cref="StopIndex()"/>
         /// and
-        /// <see cref="StopIndex(int)">StopIndex(int)</see>
+        /// <see cref="StopIndex(int)"/>
         /// .
         /// </summary>
         protected internal int stop;
 
         /// <summary>
         /// Constructs a new
-        /// <see cref="CommonToken">CommonToken</see>
+        /// <see cref="CommonToken"/>
         /// with the specified token type.
         /// </summary>
         /// <param name="type">The token type.</param>
@@ -170,7 +170,7 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Constructs a new
-        /// <see cref="CommonToken">CommonToken</see>
+        /// <see cref="CommonToken"/>
         /// with the specified token type and
         /// text.
         /// </summary>
@@ -186,34 +186,34 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Constructs a new
-        /// <see cref="CommonToken">CommonToken</see>
+        /// <see cref="CommonToken"/>
         /// as a copy of another
-        /// <see cref="IToken">IToken</see>
+        /// <see cref="IToken"/>
         /// .
         /// <p>
         /// If
         /// <code>oldToken</code>
         /// is also a
-        /// <see cref="CommonToken">CommonToken</see>
+        /// <see cref="CommonToken"/>
         /// instance, the newly
         /// constructed token will share a reference to the
-        /// <see cref="text">text</see>
+        /// <see cref="text"/>
         /// field and
         /// the
-        /// <see cref="Antlr4.Runtime.Misc.Tuple2{T1, T2}">Antlr4.Runtime.Misc.Tuple2&lt;T1, T2&gt;</see>
+        /// <see cref="Antlr4.Runtime.Misc.Tuple2{T1, T2}"/>
         /// stored in
-        /// <see cref="source">source</see>
+        /// <see cref="source"/>
         /// . Otherwise,
-        /// <see cref="text">text</see>
+        /// <see cref="text"/>
         /// will
         /// be assigned the result of calling
-        /// <see cref="Text()">Text()</see>
+        /// <see cref="Text()"/>
         /// , and
-        /// <see cref="source">source</see>
+        /// <see cref="source"/>
         /// will be constructed from the result of
-        /// <see cref="IToken.TokenSource()">IToken.TokenSource()</see>
+        /// <see cref="IToken.TokenSource()"/>
         /// and
-        /// <see cref="IToken.InputStream()">IToken.InputStream()</see>
+        /// <see cref="IToken.InputStream()"/>
         /// .</p>
         /// </summary>
         /// <param name="oldToken">The token to copy.</param>
@@ -269,7 +269,7 @@ namespace Antlr4.Runtime
         /// Explicitly set the text for this token. If {code text} is not
         /// <code>null</code>
         /// , then
-        /// <see cref="Text()">Text()</see>
+        /// <see cref="Text()"/>
         /// will return this value rather than
         /// extracting the text from the input.
         /// </remarks>

runtime/CSharp/Antlr4.Runtime/CommonTokenFactory.cs

@@ -30,22 +30,22 @@
 using System;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
     /// <summary>
     /// This default implementation of
-    /// <see cref="ITokenFactory">ITokenFactory</see>
+    /// <see cref="ITokenFactory"/>
     /// creates
-    /// <see cref="CommonToken">CommonToken</see>
+    /// <see cref="CommonToken"/>
     /// objects.
     /// </summary>
     public class CommonTokenFactory : ITokenFactory
     {
         /// <summary>
         /// The default
-        /// <see cref="CommonTokenFactory">CommonTokenFactory</see>
+        /// <see cref="CommonTokenFactory"/>
         /// instance.
         /// <p>
         /// This token factory does not explicitly copy token text when constructing
@@ -55,20 +55,20 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Indicates whether
-        /// <see cref="CommonToken.Text(string)">CommonToken.Text(string)</see>
+        /// <see cref="CommonToken.Text(string)"/>
         /// should be called after
         /// constructing tokens to explicitly set the text. This is useful for cases
         /// where the input stream might not be able to provide arbitrary substrings
         /// of text from the input after the lexer creates a token (e.g. the
         /// implementation of
-        /// <see cref="ICharStream.GetText(Antlr4.Runtime.Misc.Interval)">ICharStream.GetText(Antlr4.Runtime.Misc.Interval)</see>
+        /// <see cref="ICharStream.GetText(Antlr4.Runtime.Misc.Interval)"/>
         /// in
-        /// <see cref="UnbufferedCharStream">UnbufferedCharStream</see>
+        /// <see cref="UnbufferedCharStream"/>
         /// throws an
-        /// <see cref="System.NotSupportedException">System.NotSupportedException</see>
+        /// <see cref="System.NotSupportedException"/>
         /// ). Explicitly setting the token text
         /// allows
-        /// <see cref="IToken.Text()">IToken.Text()</see>
+        /// <see cref="IToken.Text()"/>
         /// to be called at any time regardless of the
         /// input stream implementation.
         /// <p>
@@ -81,9 +81,9 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Constructs a
-        /// <see cref="CommonTokenFactory">CommonTokenFactory</see>
+        /// <see cref="CommonTokenFactory"/>
         /// with the specified value for
-        /// <see cref="copyText">copyText</see>
+        /// <see cref="copyText"/>
         /// .
         /// <p>
         /// When
@@ -91,13 +91,13 @@ namespace Antlr4.Runtime
         /// is
         /// <code>false</code>
         /// , the
-        /// <see cref="Default">Default</see>
+        /// <see cref="Default"/>
         /// instance
         /// should be used instead of constructing a new instance.</p>
         /// </summary>
         /// <param name="copyText">
         /// The value for
-        /// <see cref="copyText">copyText</see>
+        /// <see cref="copyText"/>
         /// .
         /// </param>
         public CommonTokenFactory(bool copyText)
@@ -107,15 +107,15 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Constructs a
-        /// <see cref="CommonTokenFactory">CommonTokenFactory</see>
+        /// <see cref="CommonTokenFactory"/>
         /// with
-        /// <see cref="copyText">copyText</see>
+        /// <see cref="copyText"/>
         /// set to
         /// <code>false</code>
         /// .
         /// <p>
         /// The
-        /// <see cref="Default">Default</see>
+        /// <see cref="Default"/>
         /// instance should be used instead of calling this
         /// directly.</p>
         /// </summary>

runtime/CSharp/Antlr4.Runtime/CommonTokenStream.cs

@@ -28,45 +28,45 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
     /// <summary>
     /// This class extends
-    /// <see cref="BufferedTokenStream">BufferedTokenStream</see>
+    /// <see cref="BufferedTokenStream"/>
     /// with functionality to filter
     /// token streams to tokens on a particular channel (tokens where
-    /// <see cref="IToken.Channel()">IToken.Channel()</see>
+    /// <see cref="IToken.Channel()"/>
     /// returns a particular value).
     /// <p>
     /// This token stream provides access to all tokens by index or when calling
     /// methods like
-    /// <see cref="BufferedTokenStream.GetText()">BufferedTokenStream.GetText()</see>
+    /// <see cref="BufferedTokenStream.GetText()"/>
     /// . The channel filtering is only used for code
     /// accessing tokens via the lookahead methods
-    /// <see cref="BufferedTokenStream.La(int)">BufferedTokenStream.La(int)</see>
+    /// <see cref="BufferedTokenStream.La(int)"/>
     /// ,
-    /// <see cref="Lt(int)">Lt(int)</see>
+    /// <see cref="Lt(int)"/>
     /// , and
-    /// <see cref="Lb(int)">Lb(int)</see>
+    /// <see cref="Lb(int)"/>
     /// .</p>
     /// <p>
     /// By default, tokens are placed on the default channel
     /// (
-    /// <see cref="IToken.DefaultChannel">IToken.DefaultChannel</see>
+    /// <see cref="IToken.DefaultChannel"/>
     /// ), but may be reassigned by using the
     /// <code>-&gt;channel(HIDDEN)</code>
     /// lexer command, or by using an embedded action to
     /// call
-    /// <see cref="Lexer.Channel(int)">Lexer.Channel(int)</see>
+    /// <see cref="Lexer.Channel(int)"/>
     /// .
     /// </p>
     /// <p>
     /// Note: lexer rules which use the
     /// <code>-&gt;skip</code>
     /// lexer command or call
-    /// <see cref="Lexer.Skip()">Lexer.Skip()</see>
+    /// <see cref="Lexer.Skip()"/>
     /// do not produce tokens at all, so input text matched by
     /// such a rule will not be available as part of the token stream, regardless of
     /// channel.</p>
@@ -78,7 +78,7 @@ namespace Antlr4.Runtime
         /// Specifies the channel to use for filtering tokens.
         /// <p>
         /// The default value is
-        /// <see cref="IToken.DefaultChannel">IToken.DefaultChannel</see>
+        /// <see cref="IToken.DefaultChannel"/>
         /// , which matches the
         /// default channel assigned to tokens created by the lexer.</p>
         /// </remarks>
@@ -86,10 +86,10 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Constructs a new
-        /// <see cref="CommonTokenStream">CommonTokenStream</see>
+        /// <see cref="CommonTokenStream"/>
         /// using the specified token
         /// source and the default token channel (
-        /// <see cref="IToken.DefaultChannel">IToken.DefaultChannel</see>
+        /// <see cref="IToken.DefaultChannel"/>
         /// ).
         /// </summary>
         /// <param name="tokenSource">The token source.</param>
@@ -100,16 +100,16 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Constructs a new
-        /// <see cref="CommonTokenStream">CommonTokenStream</see>
+        /// <see cref="CommonTokenStream"/>
         /// using the specified token
         /// source and filtering tokens to the specified channel. Only tokens whose
-        /// <see cref="IToken.Channel()">IToken.Channel()</see>
+        /// <see cref="IToken.Channel()"/>
         /// matches
         /// <code>channel</code>
         /// or have the
-        /// <see cref="IToken.Type()">IToken.Type()</see>
+        /// <see cref="IToken.Type()"/>
         /// equal to
-        /// <see cref="IToken.Eof">IToken.Eof</see>
+        /// <see cref="IToken.Eof"/>
         /// will be returned by the
         /// token stream lookahead methods.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/ConsoleErrorListener.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
@@ -37,16 +37,16 @@ namespace Antlr4.Runtime
     {
         /// <summary>
         /// Provides a default instance of
-        /// <see cref="ConsoleErrorListener">ConsoleErrorListener</see>
+        /// <see cref="ConsoleErrorListener"/>
         /// .
         /// </summary>
         public static readonly ConsoleErrorListener Instance = new ConsoleErrorListener();
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>
         /// This implementation prints messages to
-        /// <see cref="System.Console.Error">System.Console.Error</see>
+        /// <see cref="System.Console.Error"/>
         /// containing the
         /// values of
         /// <code>line</code>

runtime/CSharp/Antlr4.Runtime/DefaultErrorStrategy.cs

@@ -31,13 +31,13 @@ using System;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
     /// <summary>
     /// This is the default implementation of
-    /// <see cref="IAntlrErrorStrategy">IAntlrErrorStrategy</see>
+    /// <see cref="IAntlrErrorStrategy"/>
     /// used for
     /// error reporting and recovery in ANTLR parsers.
     /// </summary>
@@ -52,7 +52,7 @@ namespace Antlr4.Runtime
         /// error". This is used to suppress reporting multiple error messages while
         /// attempting to recover from a detected syntax error.
         /// </remarks>
-        /// <seealso cref="InErrorRecoveryMode(Parser)">InErrorRecoveryMode(Parser)</seealso>
+        /// <seealso cref="InErrorRecoveryMode(Parser)"/>
         protected internal bool errorRecoveryMode = false;
 
         /// <summary>The index into the input stream where the last error occurred.</summary>
@@ -68,9 +68,9 @@ namespace Antlr4.Runtime
         protected internal IntervalSet lastErrorStates;
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>The default implementation simply calls
-        /// <see cref="EndErrorCondition(Parser)">EndErrorCondition(Parser)</see>
+        /// <see cref="EndErrorCondition(Parser)"/>
         /// to
         /// ensure that the handler is not in error recovery mode.</p>
         /// </summary>
@@ -93,7 +93,7 @@ namespace Antlr4.Runtime
             errorRecoveryMode = true;
         }
 
-        /// <summary><inheritDoc></inheritDoc></summary>
+        /// <summary><inheritDoc/></summary>
         public virtual bool InErrorRecoveryMode(Parser recognizer)
         {
             return errorRecoveryMode;
@@ -107,7 +107,7 @@ namespace Antlr4.Runtime
         /// This method is called to leave error recovery mode after recovering from
         /// a recognition exception.
         /// </remarks>
-        /// <param name="recognizer"></param>
+        /// <param name="recognizer"/>
         protected internal virtual void EndErrorCondition(Parser recognizer)
         {
             errorRecoveryMode = false;
@@ -116,9 +116,9 @@ namespace Antlr4.Runtime
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>The default implementation simply calls
-        /// <see cref="EndErrorCondition(Parser)">EndErrorCondition(Parser)</see>
+        /// <see cref="EndErrorCondition(Parser)"/>
         /// .</p>
         /// </summary>
         public virtual void ReportMatch(Parser recognizer)
@@ -127,31 +127,31 @@ namespace Antlr4.Runtime
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>The default implementation returns immediately if the handler is already
         /// in error recovery mode. Otherwise, it calls
-        /// <see cref="BeginErrorCondition(Parser)">BeginErrorCondition(Parser)</see>
+        /// <see cref="BeginErrorCondition(Parser)"/>
         /// and dispatches the reporting task based on the runtime type of
         /// <code>e</code>
         /// according to the following table.</p>
         /// <ul>
         /// <li>
-        /// <see cref="NoViableAltException">NoViableAltException</see>
+        /// <see cref="NoViableAltException"/>
         /// : Dispatches the call to
-        /// <see cref="ReportNoViableAlternative(Parser, NoViableAltException)">ReportNoViableAlternative(Parser, NoViableAltException)</see>
+        /// <see cref="ReportNoViableAlternative(Parser, NoViableAltException)"/>
         /// </li>
         /// <li>
-        /// <see cref="InputMismatchException">InputMismatchException</see>
+        /// <see cref="InputMismatchException"/>
         /// : Dispatches the call to
-        /// <see cref="ReportInputMismatch(Parser, InputMismatchException)">ReportInputMismatch(Parser, InputMismatchException)</see>
+        /// <see cref="ReportInputMismatch(Parser, InputMismatchException)"/>
         /// </li>
         /// <li>
-        /// <see cref="FailedPredicateException">FailedPredicateException</see>
+        /// <see cref="FailedPredicateException"/>
         /// : Dispatches the call to
-        /// <see cref="ReportFailedPredicate(Parser, FailedPredicateException)">ReportFailedPredicate(Parser, FailedPredicateException)</see>
+        /// <see cref="ReportFailedPredicate(Parser, FailedPredicateException)"/>
         /// </li>
         /// <li>All other types: calls
-        /// <see cref="Parser.NotifyErrorListeners(string)">Parser.NotifyErrorListeners(string)</see>
+        /// <see cref="Parser.NotifyErrorListeners(string)"/>
         /// to report
         /// the exception</li>
         /// </ul>
@@ -198,7 +198,7 @@ namespace Antlr4.Runtime
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>The default implementation resynchronizes the parser by consuming tokens
         /// until we find one in the resynchronization set--loosely the set of tokens
         /// that can follow the current rule.</p>
@@ -233,7 +233,7 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// The default implementation of
-        /// <see cref="IAntlrErrorStrategy.Sync(Parser)">IAntlrErrorStrategy.Sync(Parser)</see>
+        /// <see cref="IAntlrErrorStrategy.Sync(Parser)"/>
         /// makes sure
         /// that the current lookahead symbol is consistent with what were expecting
         /// at this point in the ATN. You can call this anytime but ANTLR only
@@ -245,7 +245,7 @@ namespace Antlr4.Runtime
         /// sync : {consume to what can follow sync} ;
         /// </pre>
         /// At the start of a sub rule upon error,
-        /// <see cref="Sync(Parser)">Sync(Parser)</see>
+        /// <see cref="Sync(Parser)"/>
         /// performs single
         /// token deletion, if possible. If it can't do that, it bails on the current
         /// rule and uses the default error recovery, which consumes until the
@@ -275,7 +275,7 @@ namespace Antlr4.Runtime
         /// some reason speed is suffering for you, you can turn off this
         /// functionality by simply overriding this method as a blank { }.</p>
         /// </summary>
-        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
         public virtual void Sync(Parser recognizer)
         {
             ATNState s = recognizer.Interpreter.atn.states[recognizer.State];
@@ -333,12 +333,12 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// This is called by
-        /// <see cref="ReportError(Parser, RecognitionException)">ReportError(Parser, RecognitionException)</see>
+        /// <see cref="ReportError(Parser, RecognitionException)"/>
         /// when the exception is a
-        /// <see cref="NoViableAltException">NoViableAltException</see>
+        /// <see cref="NoViableAltException"/>
         /// .
         /// </summary>
-        /// <seealso cref="ReportError(Parser, RecognitionException)">ReportError(Parser, RecognitionException)</seealso>
+        /// <seealso cref="ReportError(Parser, RecognitionException)"/>
         /// <param name="recognizer">the parser instance</param>
         /// <param name="e">the recognition exception</param>
         protected internal virtual void ReportNoViableAlternative(Parser recognizer, NoViableAltException e)
@@ -366,12 +366,12 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// This is called by
-        /// <see cref="ReportError(Parser, RecognitionException)">ReportError(Parser, RecognitionException)</see>
+        /// <see cref="ReportError(Parser, RecognitionException)"/>
         /// when the exception is an
-        /// <see cref="InputMismatchException">InputMismatchException</see>
+        /// <see cref="InputMismatchException"/>
         /// .
         /// </summary>
-        /// <seealso cref="ReportError(Parser, RecognitionException)">ReportError(Parser, RecognitionException)</seealso>
+        /// <seealso cref="ReportError(Parser, RecognitionException)"/>
         /// <param name="recognizer">the parser instance</param>
         /// <param name="e">the recognition exception</param>
         protected internal virtual void ReportInputMismatch(Parser recognizer, InputMismatchException e)
@@ -382,12 +382,12 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// This is called by
-        /// <see cref="ReportError(Parser, RecognitionException)">ReportError(Parser, RecognitionException)</see>
+        /// <see cref="ReportError(Parser, RecognitionException)"/>
         /// when the exception is a
-        /// <see cref="FailedPredicateException">FailedPredicateException</see>
+        /// <see cref="FailedPredicateException"/>
         /// .
         /// </summary>
-        /// <seealso cref="ReportError(Parser, RecognitionException)">ReportError(Parser, RecognitionException)</seealso>
+        /// <seealso cref="ReportError(Parser, RecognitionException)"/>
         /// <param name="recognizer">the parser instance</param>
         /// <param name="e">the recognition exception</param>
         protected internal virtual void ReportFailedPredicate(Parser recognizer, FailedPredicateException e)
@@ -411,16 +411,16 @@ namespace Antlr4.Runtime
         /// <code>recognizer</code>
         /// is in error recovery mode.
         /// <p>This method is called when
-        /// <see cref="SingleTokenDeletion(Parser)">SingleTokenDeletion(Parser)</see>
+        /// <see cref="SingleTokenDeletion(Parser)"/>
         /// identifies
         /// single-token deletion as a viable recovery strategy for a mismatched
         /// input error.</p>
         /// <p>The default implementation simply returns if the handler is already in
         /// error recovery mode. Otherwise, it calls
-        /// <see cref="BeginErrorCondition(Parser)">BeginErrorCondition(Parser)</see>
+        /// <see cref="BeginErrorCondition(Parser)"/>
         /// to
         /// enter error recovery mode, followed by calling
-        /// <see cref="Parser.NotifyErrorListeners(string)">Parser.NotifyErrorListeners(string)</see>
+        /// <see cref="Parser.NotifyErrorListeners(string)"/>
         /// .</p>
         /// </remarks>
         /// <param name="recognizer">the parser instance</param>
@@ -450,16 +450,16 @@ namespace Antlr4.Runtime
         /// <code>recognizer</code>
         /// is in error recovery mode.
         /// <p>This method is called when
-        /// <see cref="SingleTokenInsertion(Parser)">SingleTokenInsertion(Parser)</see>
+        /// <see cref="SingleTokenInsertion(Parser)"/>
         /// identifies
         /// single-token insertion as a viable recovery strategy for a mismatched
         /// input error.</p>
         /// <p>The default implementation simply returns if the handler is already in
         /// error recovery mode. Otherwise, it calls
-        /// <see cref="BeginErrorCondition(Parser)">BeginErrorCondition(Parser)</see>
+        /// <see cref="BeginErrorCondition(Parser)"/>
         /// to
         /// enter error recovery mode, followed by calling
-        /// <see cref="Parser.NotifyErrorListeners(string)">Parser.NotifyErrorListeners(string)</see>
+        /// <see cref="Parser.NotifyErrorListeners(string)"/>
         /// .</p>
         /// </remarks>
         /// <param name="recognizer">the parser instance</param>
@@ -477,11 +477,11 @@ namespace Antlr4.Runtime
         }
 
         /// <summary>
-        /// <inheritDoc></inheritDoc>
+        /// <inheritDoc/>
         /// <p>The default implementation attempts to recover from the mismatched input
         /// by using single token insertion and deletion as described below. If the
         /// recovery attempt fails, this method throws an
-        /// <see cref="InputMismatchException">InputMismatchException</see>
+        /// <see cref="InputMismatchException"/>
         /// .</p>
         /// <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>
         /// <p>
@@ -497,7 +497,7 @@ namespace Antlr4.Runtime
         /// <code>LA(2)</code>
         /// token) as the successful result of the match operation.</p>
         /// <p>This recovery strategy is implemented by
-        /// <see cref="SingleTokenDeletion(Parser)">SingleTokenDeletion(Parser)</see>
+        /// <see cref="SingleTokenDeletion(Parser)"/>
         /// .</p>
         /// <p><strong>MISSING TOKEN</strong> (single token insertion)</p>
         /// <p>If current token (at
@@ -507,12 +507,12 @@ namespace Antlr4.Runtime
         /// <code>LA(1)</code>
         /// token, then assume the token is missing
         /// and use the parser's
-        /// <see cref="ITokenFactory">ITokenFactory</see>
+        /// <see cref="ITokenFactory"/>
         /// to create it on the fly. The
         /// "insertion" is performed by returning the created token as the successful
         /// result of the match operation.</p>
         /// <p>This recovery strategy is implemented by
-        /// <see cref="SingleTokenInsertion(Parser)">SingleTokenInsertion(Parser)</see>
+        /// <see cref="SingleTokenInsertion(Parser)"/>
         /// .</p>
         /// <p><strong>EXAMPLE</strong></p>
         /// <p>For example, Input
@@ -541,7 +541,7 @@ namespace Antlr4.Runtime
         /// <code>';'</code>
         /// and
         /// call
-        /// <see cref="RecoverInline(Parser)">RecoverInline(Parser)</see>
+        /// <see cref="RecoverInline(Parser)"/>
         /// . To recover, it sees that
         /// <code>LA(1)==';'</code>
         /// is in the set of tokens that can follow the
@@ -553,7 +553,7 @@ namespace Antlr4.Runtime
         /// <code>')'</code>
         /// .
         /// </summary>
-        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
         public virtual IToken RecoverInline(Parser recognizer)
         {
             // SINGLE TOKEN DELETION
@@ -581,7 +581,7 @@ namespace Antlr4.Runtime
         /// <remarks>
         /// This method implements the single-token insertion inline error recovery
         /// strategy. It is called by
-        /// <see cref="RecoverInline(Parser)">RecoverInline(Parser)</see>
+        /// <see cref="RecoverInline(Parser)"/>
         /// if the single-token
         /// deletion strategy fails to recover from the mismatched input. If this
         /// method returns
@@ -635,7 +635,7 @@ namespace Antlr4.Runtime
         /// <remarks>
         /// This method implements the single-token deletion inline error recovery
         /// strategy. It is called by
-        /// <see cref="RecoverInline(Parser)">RecoverInline(Parser)</see>
+        /// <see cref="RecoverInline(Parser)"/>
         /// to attempt to recover
         /// from mismatched input. If this method returns null, the parser and error
         /// handler state will not have changed. If this method returns non-null,
@@ -643,19 +643,19 @@ namespace Antlr4.Runtime
         /// will <em>not</em> be in error recovery mode since the
         /// returned token was a successful match.
         /// <p>If the single-token deletion is successful, this method calls
-        /// <see cref="ReportUnwantedToken(Parser)">ReportUnwantedToken(Parser)</see>
+        /// <see cref="ReportUnwantedToken(Parser)"/>
         /// to report the error, followed by
-        /// <see cref="Parser.Consume()">Parser.Consume()</see>
+        /// <see cref="Parser.Consume()"/>
         /// to actually "delete" the extraneous token. Then,
         /// before returning
-        /// <see cref="ReportMatch(Parser)">ReportMatch(Parser)</see>
+        /// <see cref="ReportMatch(Parser)"/>
         /// is called to signal a successful
         /// match.</p>
         /// </remarks>
         /// <param name="recognizer">the parser instance</param>
         /// <returns>
         /// the successfully matched
-        /// <see cref="IToken">IToken</see>
+        /// <see cref="IToken"/>
         /// instance if single-token
         /// deletion successfully recovers from the mismatched input, otherwise
         /// <code>null</code>

runtime/CSharp/Antlr4.Runtime/Dependents.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {

runtime/CSharp/Antlr4.Runtime/Dfa/AbstractEdgeMap`1.cs

@@ -29,7 +29,7 @@
  */
 using System.Collections.Generic;
 using Antlr4.Runtime.Dfa;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {

runtime/CSharp/Antlr4.Runtime/Dfa/ArrayEdgeMap`1.cs

@@ -30,7 +30,7 @@
 using System;
 using System.Collections.Generic;
 using Antlr4.Runtime.Dfa;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
@@ -169,7 +169,7 @@ namespace Antlr4.Runtime.Dfa
         {
             if (IsEmpty)
             {
-                return Sharpen.Collections.EmptyMap();
+                return Antlr4.Runtime.Sharpen.Collections.EmptyMap();
             }
             IDictionary<int, T> result = new LinkedHashMap<int, T>();
             for (int i = 0; i < arrayData.Length; i++)

runtime/CSharp/Antlr4.Runtime/Dfa/DFA.cs

@@ -32,7 +32,7 @@ using System.Collections.Concurrent;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
@@ -41,10 +41,10 @@ namespace Antlr4.Runtime.Dfa
         /// <summary>A set of all DFA states.</summary>
         /// <remarks>
         /// A set of all DFA states. Use
-        /// <see cref="System.Collections.IDictionary{K, V}">System.Collections.IDictionary&lt;K, V&gt;</see>
+        /// <see cref="System.Collections.IDictionary{K, V}"/>
         /// so we can get old state back
         /// (
-        /// <see cref="Sharpen.ISet{E}">Sharpen.ISet&lt;E&gt;</see>
+        /// <see cref="Antlr4.Runtime.Sharpen.ISet{E}"/>
         /// only allows you to see if it's there).
         /// </remarks>
         [NotNull]
@@ -69,9 +69,9 @@ namespace Antlr4.Runtime.Dfa
         /// if this DFA is for a precedence decision; otherwise,
         /// <code>false</code>
         /// . This is the backing field for
-        /// <see cref="IsPrecedenceDfa()">IsPrecedenceDfa()</see>
+        /// <see cref="IsPrecedenceDfa()"/>
         /// ,
-        /// <see cref="IsPrecedenceDfa(bool)">IsPrecedenceDfa(bool)</see>
+        /// <see cref="IsPrecedenceDfa(bool)"/>
         /// .
         /// </summary>
         private volatile bool precedenceDfa;
@@ -91,11 +91,11 @@ namespace Antlr4.Runtime.Dfa
         /// <remarks>
         /// Gets whether this DFA is a precedence DFA. Precedence DFAs use a special
         /// start state
-        /// <see cref="s0">s0</see>
+        /// <see cref="s0"/>
         /// which is not stored in
-        /// <see cref="states">states</see>
+        /// <see cref="states"/>
         /// . The
-        /// <see cref="DFAState#edges">DFAState#edges</see>
+        /// <see cref="DFAState#edges"/>
         /// array for this start state contains outgoing edges
         /// supplying individual start states corresponding to specific precedence
         /// values.
@@ -107,7 +107,7 @@ namespace Antlr4.Runtime.Dfa
         /// <code>false</code>
         /// .
         /// </returns>
-        /// <seealso cref="Antlr4.Runtime.Parser.Precedence()">Antlr4.Runtime.Parser.Precedence()</seealso>
+        /// <seealso cref="Antlr4.Runtime.Parser.Precedence()"/>
         /// <summary>Sets whether this is a precedence DFA.</summary>
         /// <remarks>
         /// Sets whether this is a precedence DFA. If the specified value differs
@@ -115,24 +115,24 @@ namespace Antlr4.Runtime.Dfa
         /// otherwise no changes are made to the current DFA.
         /// <ul>
         /// <li>The
-        /// <see cref="states">states</see>
+        /// <see cref="states"/>
         /// map is cleared</li>
         /// <li>If
         /// <code>precedenceDfa</code>
         /// is
         /// <code>false</code>
         /// , the initial state
-        /// <see cref="s0">s0</see>
+        /// <see cref="s0"/>
         /// is set to
         /// <code>null</code>
         /// ; otherwise, it is initialized to a new
-        /// <see cref="DFAState">DFAState</see>
+        /// <see cref="DFAState"/>
         /// with an empty outgoing
-        /// <see cref="DFAState#edges">DFAState#edges</see>
+        /// <see cref="DFAState#edges"/>
         /// array to
         /// store the start states for individual precedence values.</li>
         /// <li>The
-        /// <see cref="precedenceDfa">precedenceDfa</see>
+        /// <see cref="precedenceDfa"/>
         /// field is updated</li>
         /// </ul>
         /// </remarks>
@@ -188,7 +188,7 @@ namespace Antlr4.Runtime.Dfa
         /// if no start state exists for the specified precedence.
         /// </returns>
         /// <exception cref="System.InvalidOperationException">if this is not a precedence DFA.</exception>
-        /// <seealso cref="IsPrecedenceDfa()">IsPrecedenceDfa()</seealso>
+        /// <seealso cref="IsPrecedenceDfa()"/>
         public DFAState GetPrecedenceStartState(int precedence, bool fullContext)
         {
             if (!IsPrecedenceDfa)
@@ -213,7 +213,7 @@ namespace Antlr4.Runtime.Dfa
         /// precedence.
         /// </param>
         /// <exception cref="System.InvalidOperationException">if this is not a precedence DFA.</exception>
-        /// <seealso cref="IsPrecedenceDfa()">IsPrecedenceDfa()</seealso>
+        /// <seealso cref="IsPrecedenceDfa()"/>
         public void SetPrecedenceStartState(int precedence, bool fullContext, DFAState startState)
         {
             if (!IsPrecedenceDfa)

runtime/CSharp/Antlr4.Runtime/Dfa/DFASerializer.cs

@@ -33,7 +33,7 @@ using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {

runtime/CSharp/Antlr4.Runtime/Dfa/DFAState.cs

@@ -33,7 +33,7 @@ using System.Text;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
@@ -84,9 +84,9 @@ namespace Antlr4.Runtime.Dfa
         /// <summary>
         /// if accept state, what ttype do we match or alt do we predict?
         /// This is set to
-        /// <see cref="Antlr4.Runtime.Atn.ATN.InvalidAltNumber">Antlr4.Runtime.Atn.ATN.InvalidAltNumber</see>
+        /// <see cref="Antlr4.Runtime.Atn.ATN.InvalidAltNumber"/>
         /// when
-        /// <see cref="predicates">predicates</see>
+        /// <see cref="predicates"/>
         /// <code>!=null</code>
         /// .
         /// </summary>
@@ -106,7 +106,7 @@ namespace Antlr4.Runtime.Dfa
 
         /// <summary>
         /// This list is computed by
-        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredicateDFAState(DFAState, Antlr4.Runtime.Atn.ATNConfigSet, int)">Antlr4.Runtime.Atn.ParserATNSimulator.PredicateDFAState(DFAState, Antlr4.Runtime.Atn.ATNConfigSet, int)</see>
+        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredicateDFAState(DFAState, Antlr4.Runtime.Atn.ATNConfigSet, int)"/>
         /// .
         /// </summary>
         [Nullable]
@@ -212,7 +212,7 @@ namespace Antlr4.Runtime.Dfa
             {
                 if (edges == null)
                 {
-                    return Sharpen.Collections.EmptyMap();
+                    return Antlr4.Runtime.Sharpen.Collections.EmptyMap();
                 }
                 return edges.ToMap();
             }
@@ -256,14 +256,14 @@ namespace Antlr4.Runtime.Dfa
             {
                 if (contextEdges == null)
                 {
-                    return Sharpen.Collections.EmptyMap();
+                    return Antlr4.Runtime.Sharpen.Collections.EmptyMap();
                 }
                 IDictionary<int, DFAState> map = contextEdges.ToMap();
                 if (map.ContainsKey(-1))
                 {
                     if (map.Count == 1)
                     {
-                        return Sharpen.Collections.SingletonMap(PredictionContext.EmptyFullStateKey, map.Get(-1));
+                        return Antlr4.Runtime.Sharpen.Collections.SingletonMap(PredictionContext.EmptyFullStateKey, map.Get(-1));
                     }
                     else
                     {
@@ -293,17 +293,17 @@ namespace Antlr4.Runtime.Dfa
 
         /// <summary>
         /// Two
-        /// <see cref="DFAState">DFAState</see>
+        /// <see cref="DFAState"/>
         /// instances are equal if their ATN configuration sets
         /// are the same. This method is used to see if a state already exists.
         /// <p>Because the number of alternatives and number of ATN configurations are
         /// finite, there is a finite number of DFA states that can be processed.
         /// This is necessary to show that the algorithm terminates.</p>
         /// <p>Cannot test the DFA state numbers here because in
-        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(DFA, Antlr4.Runtime.Atn.ATNConfigSet, Antlr4.Runtime.Atn.PredictionContextCache)">Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(DFA, Antlr4.Runtime.Atn.ATNConfigSet, Antlr4.Runtime.Atn.PredictionContextCache)</see>
+        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(DFA, Antlr4.Runtime.Atn.ATNConfigSet, Antlr4.Runtime.Atn.PredictionContextCache)"/>
         /// we need to know if any other state
         /// exists that has this exact set of ATN configurations. The
-        /// <see cref="stateNumber">stateNumber</see>
+        /// <see cref="stateNumber"/>
         /// is irrelevant.</p>
         /// </summary>
         public override bool Equals(object o)

runtime/CSharp/Antlr4.Runtime/Dfa/IEdgeMap`1.cs

@@ -30,7 +30,7 @@
 using System.Collections.Generic;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {

runtime/CSharp/Antlr4.Runtime/Dfa/LexerDFASerializer.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {

runtime/CSharp/Antlr4.Runtime/Dfa/SingletonEdgeMap`1.cs

@@ -29,7 +29,7 @@
  */
 using System.Collections.Generic;
 using Antlr4.Runtime.Dfa;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
@@ -159,9 +159,9 @@ namespace Antlr4.Runtime.Dfa
         {
             if (IsEmpty)
             {
-                return Sharpen.Collections.EmptyMap();
+                return Antlr4.Runtime.Sharpen.Collections.EmptyMap();
             }
-            return Sharpen.Collections.SingletonMap(key, value);
+            return Antlr4.Runtime.Sharpen.Collections.SingletonMap(key, value);
         }
     }
 }

runtime/CSharp/Antlr4.Runtime/Dfa/SparseEdgeMap`1.cs

@@ -30,7 +30,7 @@
 using System;
 using System.Collections.Generic;
 using Antlr4.Runtime.Dfa;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
@@ -207,7 +207,7 @@ namespace Antlr4.Runtime.Dfa
         {
             if (IsEmpty)
             {
-                return Sharpen.Collections.EmptyMap();
+                return Antlr4.Runtime.Sharpen.Collections.EmptyMap();
             }
             IDictionary<int, T> result = new LinkedHashMap<int, T>();
             for (int i = 0; i < Count; i++)

runtime/CSharp/Antlr4.Runtime/DiagnosticErrorListener.cs

@@ -31,17 +31,17 @@ using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
     /// <summary>
     /// This implementation of
-    /// <see cref="IANTLRErrorListener{Symbol}">IANTLRErrorListener&lt;Symbol&gt;</see>
+    /// <see cref="IANTLRErrorListener{Symbol}"/>
     /// can be used to identify
     /// certain potential correctness and performance problems in grammars. "Reports"
     /// are made by calling
-    /// <see cref="Parser.NotifyErrorListeners(string)">Parser.NotifyErrorListeners(string)</see>
+    /// <see cref="Parser.NotifyErrorListeners(string)"/>
     /// with the appropriate
     /// message.
     /// <ul>
@@ -69,7 +69,7 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Initializes a new instance of
-        /// <see cref="DiagnosticErrorListener">DiagnosticErrorListener</see>
+        /// <see cref="DiagnosticErrorListener"/>
         /// which only
         /// reports exact ambiguities.
         /// </summary>
@@ -80,7 +80,7 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Initializes a new instance of
-        /// <see cref="DiagnosticErrorListener">DiagnosticErrorListener</see>
+        /// <see cref="DiagnosticErrorListener"/>
         /// , specifying
         /// whether all ambiguities or only exact ambiguities are reported.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/FailedPredicateException.cs

@@ -31,7 +31,7 @@ using System.Globalization;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {

runtime/CSharp/Antlr4.Runtime/IAntlrErrorListener`1.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
@@ -40,12 +40,12 @@ namespace Antlr4.Runtime
         /// <remarks>
         /// Upon syntax error, notify any interested parties. This is not how to
         /// recover from errors or compute error messages.
-        /// <see cref="IAntlrErrorStrategy">IAntlrErrorStrategy</see>
+        /// <see cref="IAntlrErrorStrategy"/>
         /// specifies how to recover from syntax errors and how to compute error
         /// messages. This listener's job is simply to emit a computed message,
         /// though it has enough information to create its own message in many cases.
         /// <p>The
-        /// <see cref="RecognitionException">RecognitionException</see>
+        /// <see cref="RecognitionException"/>
         /// is non-null for all syntax errors except
         /// when we discover mismatched token errors that we can recover from
         /// in-line, without returning from the surrounding rule (via the single

runtime/CSharp/Antlr4.Runtime/IAntlrErrorStrategy.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
@@ -48,7 +48,7 @@ namespace Antlr4.Runtime
     /// <li>A predicate evaluated to false</li>
     /// </ul>
     /// Implementations of this interface report syntax errors by calling
-    /// <see cref="Parser.NotifyErrorListeners(string)">Parser.NotifyErrorListeners(string)</see>
+    /// <see cref="Parser.NotifyErrorListeners(string)"/>
     /// .
     /// <p>TODO: what to do about lexers</p>
     /// </remarks>
@@ -65,17 +65,17 @@ namespace Antlr4.Runtime
         /// <summary>
         /// This method is called when an unexpected symbol is encountered during an
         /// inline match operation, such as
-        /// <see cref="Parser.Match(int)">Parser.Match(int)</see>
+        /// <see cref="Parser.Match(int)"/>
         /// . If the error
         /// strategy successfully recovers from the match failure, this method
         /// returns the
-        /// <see cref="IToken">IToken</see>
+        /// <see cref="IToken"/>
         /// instance which should be treated as the
         /// successful result of the match.
         /// <p>Note that the calling code will not report an error if this method
         /// returns successfully. The error strategy implementation is responsible
         /// for calling
-        /// <see cref="Parser.NotifyErrorListeners(string)">Parser.NotifyErrorListeners(string)</see>
+        /// <see cref="Parser.NotifyErrorListeners(string)"/>
         /// as appropriate.</p>
         /// </summary>
         /// <param name="recognizer">the parser instance</param>
@@ -83,7 +83,7 @@ namespace Antlr4.Runtime
         /// if the error strategy was not able to
         /// recover from the unexpected input symbol
         /// </exception>
-        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
         [NotNull]
         IToken RecoverInline(Parser recognizer);
 
@@ -92,27 +92,27 @@ namespace Antlr4.Runtime
         /// <code>e</code>
         /// . This method is
         /// called after
-        /// <see cref="ReportError(Parser, RecognitionException)">ReportError(Parser, RecognitionException)</see>
+        /// <see cref="ReportError(Parser, RecognitionException)"/>
         /// by the default exception handler
         /// generated for a rule method.
         /// </summary>
-        /// <seealso cref="ReportError(Parser, RecognitionException)">ReportError(Parser, RecognitionException)</seealso>
+        /// <seealso cref="ReportError(Parser, RecognitionException)"/>
         /// <param name="recognizer">the parser instance</param>
         /// <param name="e">the recognition exception to recover from</param>
         /// <exception cref="RecognitionException">
         /// if the error strategy could not recover from
         /// the recognition exception
         /// </exception>
-        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
         void Recover(Parser recognizer, RecognitionException e);
 
         /// <summary>
         /// This method provides the error handler with an opportunity to handle
         /// syntactic or semantic errors in the input stream before they result in a
-        /// <see cref="RecognitionException">RecognitionException</see>
+        /// <see cref="RecognitionException"/>
         /// .
         /// <p>The generated code currently contains calls to
-        /// <see cref="Sync(Parser)">Sync(Parser)</see>
+        /// <see cref="Sync(Parser)"/>
         /// after
         /// entering the decision state of a closure block (
         /// <code>(...)*</code>
@@ -120,17 +120,17 @@ namespace Antlr4.Runtime
         /// <code>(...)+</code>
         /// ).</p>
         /// <p>For an implementation based on Jim Idle's "magic sync" mechanism, see
-        /// <see cref="DefaultErrorStrategy.Sync(Parser)">DefaultErrorStrategy.Sync(Parser)</see>
+        /// <see cref="DefaultErrorStrategy.Sync(Parser)"/>
         /// .</p>
         /// </summary>
-        /// <seealso cref="DefaultErrorStrategy.Sync(Parser)">DefaultErrorStrategy.Sync(Parser)</seealso>
+        /// <seealso cref="DefaultErrorStrategy.Sync(Parser)"/>
         /// <param name="recognizer">the parser instance</param>
         /// <exception cref="RecognitionException">
         /// if an error is detected by the error
         /// strategy but cannot be automatically recovered at the current state in
         /// the parsing process
         /// </exception>
-        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
         void Sync(Parser recognizer);
 
         /// <summary>
@@ -138,12 +138,12 @@ namespace Antlr4.Runtime
         /// <code>recognizer</code>
         /// is in the process of recovering
         /// from an error. In error recovery mode,
-        /// <see cref="Parser.Consume()">Parser.Consume()</see>
+        /// <see cref="Parser.Consume()"/>
         /// adds
         /// symbols to the parse tree by calling
-        /// <see cref="ParserRuleContext.AddErrorNode(IToken)">ParserRuleContext.AddErrorNode(IToken)</see>
+        /// <see cref="ParserRuleContext.AddErrorNode(IToken)"/>
         /// instead of
-        /// <see cref="ParserRuleContext.AddChild(IToken)">ParserRuleContext.AddChild(IToken)</see>
+        /// <see cref="ParserRuleContext.AddChild(IToken)"/>
         /// .
         /// </summary>
         /// <param name="recognizer">the parser instance</param>
@@ -169,7 +169,7 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Report any kind of
-        /// <see cref="RecognitionException">RecognitionException</see>
+        /// <see cref="RecognitionException"/>
         /// . This method is called by
         /// the default exception handler generated for a rule method.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/ICharStream.cs

@@ -29,7 +29,7 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
@@ -48,7 +48,7 @@ namespace Antlr4.Runtime
         /// <code>interval</code>
         /// lies entirely within a marked range. For more
         /// information about marked ranges, see
-        /// <see cref="IIntStream.Mark()">IIntStream.Mark()</see>
+        /// <see cref="IIntStream.Mark()"/>
         /// .
         /// </remarks>
         /// <param name="interval">an interval within the stream</param>

runtime/CSharp/Antlr4.Runtime/IIntStream.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
@@ -38,20 +38,20 @@ namespace Antlr4.Runtime
     /// interface provides <em>marked ranges</em> with support for a minimum level
     /// of buffering necessary to implement arbitrary lookahead during prediction.
     /// For more information on marked ranges, see
-    /// <see cref="Mark()">Mark()</see>
+    /// <see cref="Mark()"/>
     /// .
     /// <p><strong>Initializing Methods:</strong> Some methods in this interface have
     /// unspecified behavior if no call to an initializing method has occurred after
     /// the stream was constructed. The following is a list of initializing methods:</p>
     /// <ul>
     /// <li>
-    /// <see cref="La(int)">La(int)</see>
+    /// <see cref="La(int)"/>
     /// </li>
     /// <li>
-    /// <see cref="Consume()">Consume()</see>
+    /// <see cref="Consume()"/>
     /// </li>
     /// <li>
-    /// <see cref="Size()">Size()</see>
+    /// <see cref="Size()"/>
     /// </li>
     /// </ul>
     /// </remarks>
@@ -80,7 +80,7 @@ namespace Antlr4.Runtime
         /// is
         /// incremented by exactly 1, as that would preclude the ability to implement
         /// filtering streams (e.g.
-        /// <see cref="CommonTokenStream">CommonTokenStream</see>
+        /// <see cref="CommonTokenStream"/>
         /// which distinguishes
         /// between "on-channel" and "off-channel" tokens).
         /// </remarks>
@@ -140,7 +140,7 @@ namespace Antlr4.Runtime
         /// <code>i</code>
         /// represents a position at or beyond the end of the stream,
         /// this method returns
-        /// <see cref="Eof">Eof</see>
+        /// <see cref="Eof"/>
         /// .</p>
         /// <p>The return value is unspecified if
         /// <code>i&lt;0</code>
@@ -236,7 +236,7 @@ namespace Antlr4.Runtime
         /// <code>mark()</code>
         /// , the behavior is unspecified.
         /// <p>For more information and an example, see
-        /// <see cref="Mark()">Mark()</see>
+        /// <see cref="Mark()"/>
         /// .</p>
         /// </summary>
         /// <param name="marker">
@@ -244,7 +244,7 @@ namespace Antlr4.Runtime
         /// <code>mark()</code>
         /// .
         /// </param>
-        /// <seealso cref="Mark()">Mark()</seealso>
+        /// <seealso cref="Mark()"/>
         void Release(int marker);
 
         /// <summary>
@@ -286,13 +286,13 @@ namespace Antlr4.Runtime
         /// <li>
         /// <code>LA(1)</code>
         /// returns
-        /// <see cref="Eof">Eof</see>
+        /// <see cref="Eof"/>
         /// </li>
         /// </ul>
         /// This operation is guaranteed to not throw an exception if
         /// <code>index</code>
         /// lies within a marked region. For more information on marked regions, see
-        /// <see cref="Mark()">Mark()</see>
+        /// <see cref="Mark()"/>
         /// . The behavior of this method is unspecified if no call to
         /// an
         /// <see cref="IIntStream">initializing method</see>
@@ -333,7 +333,7 @@ namespace Antlr4.Runtime
         /// Gets the name of the underlying symbol source. This method returns a
         /// non-null, non-empty string. If such a name is not known, this method
         /// returns
-        /// <see cref="UnknownSourceName">UnknownSourceName</see>
+        /// <see cref="UnknownSourceName"/>
         /// .
         /// </remarks>
         string SourceName
@@ -354,7 +354,7 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// The value returned by
-        /// <see cref="SourceName()">SourceName()</see>
+        /// <see cref="SourceName()"/>
         /// when the actual name of the
         /// underlying source is not known.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/IParserErrorListener.cs

@@ -30,7 +30,7 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
@@ -47,9 +47,9 @@ namespace Antlr4.Runtime
         /// results in an ambiguity.
         /// <p>Each full-context prediction which does not result in a syntax error
         /// will call either
-        /// <see cref="ReportContextSensitivity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, Antlr4.Runtime.Atn.SimulatorState)">ReportContextSensitivity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, Antlr4.Runtime.Atn.SimulatorState)</see>
+        /// <see cref="ReportContextSensitivity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, Antlr4.Runtime.Atn.SimulatorState)"/>
         /// or
-        /// <see cref="ReportAmbiguity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Sharpen.BitSet, Antlr4.Runtime.Atn.ATNConfigSet)">ReportAmbiguity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Sharpen.BitSet, Antlr4.Runtime.Atn.ATNConfigSet)</see>
+        /// <see cref="ReportAmbiguity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Antlr4.Runtime.Sharpen.BitSet, Antlr4.Runtime.Atn.ATNConfigSet)"/>
         /// .</p>
         /// <p>
         /// When
@@ -58,7 +58,7 @@ namespace Antlr4.Runtime
         /// viable alternatives identified by the prediction algorithm. When
         /// <code>ambigAlts</code>
         /// is null, use
-        /// <see cref="Antlr4.Runtime.Atn.ATNConfigSet.RepresentedAlternatives()">Antlr4.Runtime.Atn.ATNConfigSet.RepresentedAlternatives()</see>
+        /// <see cref="Antlr4.Runtime.Atn.ATNConfigSet.RepresentedAlternatives()"/>
         /// to obtain the represented
         /// alternatives from the
         /// <code>configs</code>
@@ -79,7 +79,7 @@ namespace Antlr4.Runtime
         /// least the <em>minimum</em> potentially viable alternative is truly
         /// viable.</p>
         /// <p>When the
-        /// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection">Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection</see>
+        /// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
         /// prediction
         /// mode is used, the parser is required to identify exact ambiguities so
         /// <code>exact</code>
@@ -99,7 +99,7 @@ namespace Antlr4.Runtime
         /// . This is always
         /// <code>true</code>
         /// when
-        /// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection">Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection</see>
+        /// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
         /// is used.
         /// </param>
         /// <param name="ambigAlts">
@@ -158,13 +158,13 @@ namespace Antlr4.Runtime
         /// unique result.
         /// <p>Each full-context prediction which does not result in a syntax error
         /// will call either
-        /// <see cref="ReportContextSensitivity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, Antlr4.Runtime.Atn.SimulatorState)">ReportContextSensitivity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, Antlr4.Runtime.Atn.SimulatorState)</see>
+        /// <see cref="ReportContextSensitivity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, int, Antlr4.Runtime.Atn.SimulatorState)"/>
         /// or
-        /// <see cref="ReportAmbiguity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Sharpen.BitSet, Antlr4.Runtime.Atn.ATNConfigSet)">ReportAmbiguity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Sharpen.BitSet, Antlr4.Runtime.Atn.ATNConfigSet)</see>
+        /// <see cref="ReportAmbiguity(Parser, Antlr4.Runtime.Dfa.DFA, int, int, bool, Antlr4.Runtime.Sharpen.BitSet, Antlr4.Runtime.Atn.ATNConfigSet)"/>
         /// .</p>
         /// <p>For prediction implementations that only evaluate full-context
         /// predictions when an SLL conflict is found (including the default
-        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator">Antlr4.Runtime.Atn.ParserATNSimulator</see>
+        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator"/>
         /// implementation), this method reports cases
         /// where SLL conflicts were resolved to unique full-context predictions,
         /// i.e. the decision was context-sensitive. This report does not necessarily
@@ -180,7 +180,7 @@ namespace Antlr4.Runtime
         /// argument.</p>
         /// <p>Note that the definition of "context sensitivity" in this method
         /// differs from the concept in
-        /// <see cref="Antlr4.Runtime.Atn.DecisionInfo.contextSensitivities">Antlr4.Runtime.Atn.DecisionInfo.contextSensitivities</see>
+        /// <see cref="Antlr4.Runtime.Atn.DecisionInfo.contextSensitivities"/>
         /// .
         /// This method reports all instances where an SLL conflict occurred but LL
         /// parsing produced a unique result, whether or not that unique result

runtime/CSharp/Antlr4.Runtime/IToken.cs

@@ -28,7 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Sharpen;
+using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime
 {
@@ -125,7 +125,7 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Gets the
-        /// <see cref="ITokenSource">ITokenSource</see>
+        /// <see cref="ITokenSource"/>
         /// which created this token.
         /// </summary>
         ITokenSource TokenSource
@@ -135,7 +135,7 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Gets the
-        /// <see cref="ICharStream">ICharStream</see>
+        /// <see cref="ICharStream"/>
         /// from which this token was derived.
         /// </summary>
         ICharStream InputStream