Fix errors in documentation comments

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

@@ -49,7 +49,7 @@ namespace Antlr4.Runtime.Atn
 
         /// <summary>
         /// This UUID indicates an extension of
-        /// <see cref="#ADDED_PRECEDENCE_TRANSITIONS">#ADDED_PRECEDENCE_TRANSITIONS</see>
+        /// <see cref="BaseSerializedUuid"/>
         /// for the addition of lexer actions encoded as a sequence of
         /// <see cref="ILexerAction">ILexerAction</see>
         /// instances.
@@ -100,19 +100,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="Guid"/>
         /// 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="Guid"/>
         /// 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="Guid"/>
         /// of the actual serialized ATN which is
         /// currently being deserialized.
         /// </param>

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

@@ -59,7 +59,7 @@ namespace Antlr4.Runtime.Atn
         /// <see cref="hashCode">hashCode</see>
         /// since the hash code is an element
         /// of the performance-critical
-        /// <see cref="LexerATNConfig.hashCode">LexerATNConfig#hashCode</see>
+        /// <see cref="ATNConfig.GetHashCode()"/>
         /// operation.
         /// </summary>
         private readonly int hashCode;

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

@@ -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="Lexer.Channel"/>
     /// 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="Lexer.Channel"/>
         /// .
         /// </param>
         public LexerChannelAction(int channel)
@@ -102,7 +102,7 @@ namespace Antlr4.Runtime.Atn
         /// <summary>
         /// <inheritDoc></inheritDoc>
         /// <p>This action is implemented by calling
-        /// <see cref="Antlr4.Runtime.Lexer.Channel(int)">Antlr4.Runtime.Lexer.Channel(int)</see>
+        /// <see cref="Lexer.Channel"/>
         /// with the
         /// value provided by
         /// <see cref="GetChannel()">GetChannel()</see>

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

@@ -95,7 +95,7 @@ namespace Antlr4.Runtime.Atn
         /// <summary>
         /// <inheritDoc></inheritDoc>
         /// <p>This action is implemented by calling
-        /// <see cref="Antlr4.Runtime.Lexer.Type(int)">Antlr4.Runtime.Lexer.Type(int)</see>
+        /// <see cref="Lexer.Type"/>
         /// with the
         /// value provided by
         /// <see cref="GetType()">GetType()</see>

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

@@ -180,7 +180,7 @@ namespace Antlr4.Runtime.Atn
     /// 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>
     /// 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>
     /// locks on
@@ -204,10 +204,10 @@ namespace Antlr4.Runtime.Atn
     /// . Once into the DFA, the DFA simulation does not reference the
     /// <see cref="Antlr4.Runtime.Dfa.DFA.states">Antlr4.Runtime.Dfa.DFA.states</see>
     /// 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-
@@ -240,13 +240,13 @@ namespace Antlr4.Runtime.Atn
     /// parser.
     /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Interpreter()">getInterpreter()</see>
     /// .
-    /// <see cref="PredictionMode(PredictionMode)">setPredictionMode</see>
+    /// <see cref="PredictionMode"/>
     /// <code>(</code>
-    /// <see cref="PredictionMode.Sll">PredictionMode.Sll</see>
+    /// <see cref="Atn.PredictionMode.Sll"/>
     /// <code>)</code>
     /// ;
     /// parser.
-    /// <see cref="Antlr4.Runtime.Parser.ErrorHandler(IAntlrErrorStrategy)">setErrorHandler</see>
+    /// <see cref="Parser.ErrorHandler"/>
     /// (new
     /// <see cref="Antlr4.Runtime.BailErrorStrategy">Antlr4.Runtime.BailErrorStrategy</see>
     /// ());
@@ -1444,7 +1444,7 @@ namespace Antlr4.Runtime.Atn
         /// 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{Symbol, ATNInterpreter}(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

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

@@ -137,7 +137,7 @@ namespace Antlr4.Runtime.Atn
             /// The hash code is only a function of the
             /// <see cref="ATNState.stateNumber">ATNState.stateNumber</see>
             /// and
-            /// <see cref="ATNConfig#context">ATNConfig#context</see>
+            /// <see cref="ATNConfig.context"/>
             /// .
             /// </summary>
             public override int GetHashCode(ATNConfig o)
@@ -393,7 +393,7 @@ namespace Antlr4.Runtime.Atn
         /// <code>(s, j, ctx, _)</code>
         /// for
         /// <code>i!=j</code>
-        /// .
+        /// .</p>
         /// <p/>
         /// Reduce these configuration subsets to the set of possible alternatives.
         /// You can compute the alternative subsets in one pass as follows:

runtime/CSharp/Antlr4.Runtime/BailErrorStrategy.cs

@@ -65,7 +65,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"/>
     public class BailErrorStrategy : DefaultErrorStrategy
     {
         /// <summary>

runtime/CSharp/Antlr4.Runtime/BufferedTokenStream.cs

@@ -49,9 +49,9 @@ namespace Antlr4.Runtime
     /// . 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="TokenConstants.DefaultChannel"/>
     /// or
-    /// <see cref="IToken.HiddenChannel">IToken.HiddenChannel</see>
+    /// <see cref="TokenConstants.HiddenChannel"/>
     /// , use a filtering token stream such a
     /// <see cref="CommonTokenStream">CommonTokenStream</see>
     /// .</p>
@@ -104,7 +104,7 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Indicates whether the
-        /// <see cref="IToken.Eof">IToken.Eof</see>
+        /// <see cref="TokenConstants.Eof"/>
         /// token has been fetched from
         /// <see cref="tokenSource">tokenSource</see>
         /// and added to
@@ -129,7 +129,7 @@ namespace Antlr4.Runtime
         /// : The check to prevent adding multiple EOF symbols into
         /// <see cref="tokens">tokens</see>
         /// is trivial with this field.</li>
-        /// <ul>
+        /// </ul>
         /// </summary>
         protected internal bool fetchedEOF;
 

runtime/CSharp/Antlr4.Runtime/CommonToken.cs

@@ -43,7 +43,7 @@ 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="Tuple{T1, T2}"/>
         /// which is used as the default value of
         /// <see cref="source">source</see>
         /// for tokens that do not have a source.
@@ -51,38 +51,22 @@ namespace Antlr4.Runtime
         protected internal static readonly Tuple<ITokenSource, ICharStream> EmptySource = Tuple.Create<ITokenSource, ICharStream>(null, null);
 
         /// <summary>
-        /// This is the backing field for
+        /// This is the backing field for the <see cref="Type"/> property.
-        /// <see cref="Type()">Type()</see>
-        /// and
-        /// <see cref="Type(int)">Type(int)</see>
-        /// .
         /// </summary>
         protected internal int type;
 
         /// <summary>
-        /// This is the backing field for
+        /// This is the backing field for the <see cref="Line"/> property.
-        /// <see cref="Line()">Line()</see>
-        /// and
-        /// <see cref="Line(int)">Line(int)</see>
-        /// .
         /// </summary>
         protected internal int line;
 
         /// <summary>
-        /// This is the backing field for
+        /// This is the backing field for the <see cref="Column"/> property.
-        /// <see cref="Column()">Column()</see>
-        /// and
-        /// <see cref="Column(int)">Column(int)</see>
-        /// .
         /// </summary>
         protected internal int charPositionInLine = -1;
 
         /// <summary>
-        /// This is the backing field for
+        /// This is the backing field for the <see cref="Channel"/> property.
-        /// <see cref="Channel()">Channel()</see>
-        /// and
-        /// <see cref="Channel(int)">Channel(int)</see>
-        /// .
         /// </summary>
         protected internal int channel = TokenConstants.DefaultChannel;
 
@@ -99,47 +83,30 @@ namespace Antlr4.Runtime
         /// <see cref="CommonTokenFactory">CommonTokenFactory</see>
         /// 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="Tuple{T1, T2}"/>
         /// containing these values.</p>
         /// </summary>
         [NotNull]
         protected internal Tuple<ITokenSource, ICharStream> source;
 
         /// <summary>
-        /// This is the backing field for
+        /// This is the backing field for the <see cref="Text"/> property.
-        /// <see cref="Text()">Text()</see>
-        /// when the token text is
-        /// explicitly set in the constructor or via
-        /// <see cref="Text(string)">Text(string)</see>
-        /// .
         /// </summary>
-        /// <seealso cref="Text()">Text()</seealso>
+        /// <seealso cref="Text"/>
         protected internal string text;
 
         /// <summary>
-        /// This is the backing field for
+        /// This is the backing field for the <see cref="TokenIndex"/> property.
-        /// <see cref="TokenIndex()">TokenIndex()</see>
-        /// and
-        /// <see cref="TokenIndex(int)">TokenIndex(int)</see>
-        /// .
         /// </summary>
         protected internal int index = -1;
 
         /// <summary>
-        /// This is the backing field for
+        /// This is the backing field for the <see cref="StartIndex"/> property.
-        /// <see cref="StartIndex()">StartIndex()</see>
-        /// and
-        /// <see cref="SetStartIndex(int)">SetStartIndex(int)</see>
-        /// .
         /// </summary>
         protected internal int start;
 
         /// <summary>
-        /// This is the backing field for
+        /// This is the backing field for the <see cref="StopIndex"/> property.
-        /// <see cref="StopIndex()">StopIndex()</see>
-        /// and
-        /// <see cref="SetStopIndex(int)">SetStopIndex(int)</see>
-        /// .
         /// </summary>
         protected internal int stop;
 
@@ -202,7 +169,7 @@ namespace Antlr4.Runtime
         /// <see cref="text">text</see>
         /// field and
         /// the
-        /// <see cref="Antlr4.Runtime.Misc.Tuple2{T1, T2}">Antlr4.Runtime.Misc.Tuple2&lt;T1, T2&gt;</see>
+        /// <see cref="Tuple{T1, T2}"/>
         /// stored in
         /// <see cref="source">source</see>
         /// . Otherwise,

runtime/CSharp/Antlr4.Runtime/CommonTokenFactory.cs

@@ -55,7 +55,7 @@ namespace Antlr4.Runtime
 
         /// <summary>
         /// Indicates whether
-        /// <see cref="CommonToken.Text(string)">CommonToken.Text(string)</see>
+        /// <see cref="CommonToken.Text"/>
         /// 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

runtime/CSharp/Antlr4.Runtime/CommonTokenStream.cs

@@ -54,12 +54,12 @@ namespace Antlr4.Runtime
     /// <p>
     /// By default, tokens are placed on the default channel
     /// (
-    /// <see cref="IToken.DefaultChannel">IToken.DefaultChannel</see>
+    /// <see cref="TokenConstants.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"/>
     /// .
     /// </p>
     /// <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="TokenConstants.DefaultChannel"/>
         /// , which matches the
         /// default channel assigned to tokens created by the lexer.</p>
         /// </remarks>
@@ -89,7 +89,7 @@ namespace Antlr4.Runtime
         /// <see cref="CommonTokenStream">CommonTokenStream</see>
         /// using the specified token
         /// source and the default token channel (
-        /// <see cref="IToken.DefaultChannel">IToken.DefaultChannel</see>
+        /// <see cref="TokenConstants.DefaultChannel"/>
         /// ).
         /// </summary>
         /// <param name="tokenSource">The token source.</param>
@@ -109,7 +109,7 @@ namespace Antlr4.Runtime
         /// or have the
         /// <see cref="IToken.Type()">IToken.Type()</see>
         /// equal to
-        /// <see cref="IToken.Eof">IToken.Eof</see>
+        /// <see cref="TokenConstants.Eof"/>
         /// will be returned by the
         /// token stream lookahead methods.
         /// </summary>

runtime/CSharp/Antlr4.Runtime/ConsoleErrorListener.cs

@@ -40,7 +40,7 @@ namespace Antlr4.Runtime
     {
         /// <summary>
         /// Provides a default instance of
-        /// <see cref="ConsoleErrorListener">ConsoleErrorListener</see>
+        /// <see cref="ConsoleErrorListener{Symbol}"/>
         /// .
         /// </summary>
         public static readonly ConsoleErrorListener<Symbol> Instance = new ConsoleErrorListener<Symbol>();

runtime/CSharp/Antlr4.Runtime/DefaultErrorStrategy.cs

@@ -527,7 +527,7 @@ namespace Antlr4.Runtime
         /// , it will have
         /// call chain:</p>
         /// <pre>
-        /// stat &rarr; expr &rarr; atom
+        /// stat &#x2192; expr &#x2192; atom
         /// </pre>
         /// and it will be trying to match the
         /// <code>')'</code>

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

@@ -97,7 +97,7 @@ namespace Antlr4.Runtime.Dfa
         /// which is not stored in
         /// <see cref="states">states</see>
         /// . 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.
@@ -199,7 +199,7 @@ namespace Antlr4.Runtime.Dfa
         /// ; otherwise, it is initialized to a new
         /// <see cref="DFAState">DFAState</see>
         /// 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

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

@@ -48,7 +48,7 @@ namespace Antlr4.Runtime.Dfa
     /// input a1a2..an, the DFA is in a state that represents the
     /// subset T of the states of the ATN that are reachable from the
     /// ATN's start state along some path labeled a1a2..an."
-    /// In conventional NFA→DFA conversion, therefore, the subset T
+    /// In conventional NFA→DFA conversion, therefore, the subset T
     /// would be a bitset representing the set of states the
     /// ATN could be in.  We need to track the alt predicted by each
     /// state as well, however.  More importantly, we need to maintain

runtime/CSharp/Antlr4.Runtime/ITokenSource.cs

@@ -124,7 +124,7 @@ namespace Antlr4.Runtime
         /// Gets the name of the underlying input source. This method returns a
         /// non-null, non-empty string. If such a name is not known, this method
         /// returns
-        /// <see cref="IIntStream.UnknownSourceName">IIntStream.UnknownSourceName</see>
+        /// <see cref="IntStreamConstants.UnknownSourceName"/>
         /// .
         /// </remarks>
         string SourceName

runtime/CSharp/Antlr4.Runtime/ListTokenSource.cs

@@ -42,7 +42,7 @@ namespace Antlr4.Runtime
     /// <see cref="IToken">IToken</see>
     /// objects.
     /// <p>If the final token in the list is an
-    /// <see cref="IToken.Eof">IToken.Eof</see>
+    /// <see cref="TokenConstants.Eof"/>
     /// token, it will be used
     /// as the EOF token for every call to
     /// <see cref="NextToken()">NextToken()</see>
@@ -89,11 +89,7 @@ namespace Antlr4.Runtime
         protected internal IToken eofToken;
 
         /// <summary>
-        /// This is the backing field for
+        /// This is the backing field for the <see cref="TokenFactory"/> property.
-        /// <see cref="TokenFactory()">TokenFactory()</see>
-        /// and
-        /// <see cref="setTokenFactory">setTokenFactory</see>
-        /// .
         /// </summary>
         private ITokenFactory _factory = CommonTokenFactory.Default;
 

runtime/CSharp/Antlr4.Runtime/Misc/Utils.cs

@@ -143,10 +143,10 @@ namespace Antlr4.Runtime.Misc
             }
         }
 
-        /// <summary>Convert array of strings to string&rarr;index map.</summary>
+        /// <summary>Convert array of strings to string&#x2192;index map.</summary>
         /// <remarks>
-        /// Convert array of strings to string&rarr;index map. Useful for
+        /// Convert array of strings to string&#x2192;index map. Useful for
-        /// converting rulenames to name&rarr;ruleindex map.
+        /// converting rulenames to name&#x2192;ruleindex map.
         /// </remarks>
         public static IDictionary<string, int> ToMap(string[] keys)
         {

runtime/CSharp/Antlr4.Runtime/TokenStreamRewriter.cs

@@ -239,11 +239,11 @@ namespace Antlr4.Runtime
         /// <remarks>
         /// You may have multiple, named streams of rewrite operations.
         /// I'm calling these things "programs."
-        /// Maps String (name) &rarr; rewrite (List)
+        /// Maps String (name) &#x2192; rewrite (List)
         /// </remarks>
         protected internal readonly IDictionary<string, IList<TokenStreamRewriter.RewriteOperation>> programs;
 
-        /// <summary>Map String (program name) &rarr; Integer index</summary>
+        /// <summary>Map String (program name) &#x2192; Integer index</summary>
         protected internal readonly IDictionary<string, int> lastRewriteTokenIndexes;
 
         public TokenStreamRewriter(ITokenStream tokens)
@@ -578,7 +578,7 @@ namespace Antlr4.Runtime
         /// insert with replace and delete this replace.
         /// 3. throw exception if index in same range as previous replace
         /// Don't actually delete; make op null in list. Easier to walk list.
-        /// Later we can throw as we add to index &rarr; op map.
+        /// Later we can throw as we add to index &#x2192; op map.
         /// Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
         /// inserted stuff would be before the replace range.  But, if you
         /// add tokens in front of a method body '{' and then delete the method

runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreeMatch.cs

@@ -134,7 +134,7 @@ namespace Antlr4.Runtime.Tree.Pattern
         /// <code>label</code>
         /// .
         /// <p>For example, for pattern
-        /// <code><id:ID></code>
+        /// <code>&lt;id:ID&gt;</code>
         /// ,
         /// <code>get("id")</code>
         /// returns the
@@ -146,9 +146,9 @@ namespace Antlr4.Runtime.Tree.Pattern
         /// <code>null</code>
         /// .</p>
         /// <p>Pattern tags like
-        /// <code><ID></code>
+        /// <code>&lt;ID&gt;</code>
         /// and
-        /// <code><expr></code>
+        /// <code>&lt;expr&gt;</code>
         /// without labels are
         /// considered to be labeled with
         /// <code>ID</code>
@@ -194,15 +194,15 @@ namespace Antlr4.Runtime.Tree.Pattern
         /// the result will contain <em>all</em> of the following.</p>
         /// <ul>
         /// <li>Parse tree nodes matching tags of the form
-        /// <code><foo:anyRuleName></code>
+        /// <code>&lt;foo:anyRuleName&gt;</code>
         /// and
-        /// <code><foo:AnyTokenName></code>
+        /// <code>&lt;foo:AnyTokenName&gt;</code>
         /// .</li>
         /// <li>Parse tree nodes matching tags of the form
-        /// <code><anyLabel:foo></code>
+        /// <code>&lt;anyLabel:foo&gt;</code>
         /// .</li>
         /// <li>Parse tree nodes matching tags of the form
-        /// <code><foo></code>
+        /// <code>&lt;foo&gt;</code>
         /// .</li>
         /// </ul>
         /// </remarks>
@@ -227,9 +227,9 @@ namespace Antlr4.Runtime.Tree.Pattern
             return nodes;
         }
 
-        /// <summary>Return a mapping from label &rarr; [list of nodes].</summary>
+        /// <summary>Return a mapping from label &#x2192; [list of nodes].</summary>
         /// <remarks>
-        /// Return a mapping from label &rarr; [list of nodes].
+        /// Return a mapping from label &#x2192; [list of nodes].
         /// <p>The map includes special entries corresponding to the names of rules and
         /// tokens referenced in tags in the original pattern. For additional
         /// information, see the description of

runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreePattern.cs

@@ -38,7 +38,7 @@ namespace Antlr4.Runtime.Tree.Pattern
 {
     /// <summary>
     /// A pattern like
-    /// <code><ID> = <expr>;</code>
+    /// <code>&lt;ID&gt; = &lt;expr&gt;;</code>
     /// converted to a
     /// <see cref="Antlr4.Runtime.Tree.IParseTree">Antlr4.Runtime.Tree.IParseTree</see>
     /// by

runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreePatternMatcher.cs

@@ -45,7 +45,7 @@ namespace Antlr4.Runtime.Tree.Pattern
     /// <p>Patterns are strings of source input text with special tags representing
     /// token or rule references such as:</p>
     /// <p>
-    /// <code><ID> = <expr>;</code>
+    /// <code>&lt;ID&gt; = &lt;expr&gt;;</code>
     /// </p>
     /// <p>Given a pattern start rule such as
     /// <code>statement</code>
@@ -61,12 +61,12 @@ namespace Antlr4.Runtime.Tree.Pattern
     /// routines can compare an actual
     /// <see cref="Antlr4.Runtime.Tree.IParseTree">Antlr4.Runtime.Tree.IParseTree</see>
     /// from a parse with this pattern. Tag
-    /// <code><ID></code>
+    /// <code>&lt;ID&gt;</code>
     /// matches
     /// any
     /// <code>ID</code>
     /// token and tag
-    /// <code><expr></code>
+    /// <code>&lt;expr&gt;</code>
     /// references the result of the
     /// <code>expr</code>
     /// rule (generally an instance of
@@ -95,7 +95,7 @@ namespace Antlr4.Runtime.Tree.Pattern
     /// object that
     /// contains the parse tree, the parse tree pattern, and a map from tag name to
     /// matched nodes (more below). A subtree that fails to match, returns with
-    /// <see cref="ParseTreeMatch#mismatchedNode">ParseTreeMatch#mismatchedNode</see>
+    /// <see cref="ParseTreeMatch.mismatchedNode"/>
     /// set to the first tree node that did not
     /// match.</p>
     /// <p>For efficiency, you can compile a tree pattern in string form to a
@@ -118,7 +118,7 @@ namespace Antlr4.Runtime.Tree.Pattern
     /// <see cref="ParseTreePatternMatcher">ParseTreePatternMatcher</see>
     /// constructor are used to parse the pattern in string form. The lexer converts
     /// the
-    /// <code><ID> = <expr>;</code>
+    /// <code>&lt;ID&gt; = &lt;expr&gt;;</code>
     /// into a sequence of four tokens (assuming lexer
     /// throws out whitespace or puts it on a hidden channel). Be aware that the
     /// input stream is reset for the lexer (but not the parser; a
@@ -127,7 +127,7 @@ namespace Antlr4.Runtime.Tree.Pattern
     /// fields you have put into the lexer might get changed when this mechanism asks
     /// it to scan the pattern string.</p>
     /// <p>Normally a parser does not accept token
-    /// <code><expr></code>
+    /// <code>&lt;expr&gt;</code>
     /// as a valid
     /// <code>expr</code>
     /// but, from the parser passed in, we create a special version of
@@ -135,7 +135,7 @@ namespace Antlr4.Runtime.Tree.Pattern
     /// <see cref="Antlr4.Runtime.Atn.ATN">Antlr4.Runtime.Atn.ATN</see>
     /// ) that allows imaginary
     /// tokens representing rules (
-    /// <code><expr></code>
+    /// <code>&lt;expr&gt;</code>
     /// ) to match entire rules. We call
     /// these <em>bypass alternatives</em>.</p>
     /// <p>Delimiters are
@@ -391,7 +391,7 @@ namespace Antlr4.Runtime.Tree.Pattern
         /// <code>patternTree</code>
         /// , filling
         /// <code>match.</code>
-        /// <see cref="ParseTreeMatch#labels">labels</see>
+        /// <see cref="ParseTreeMatch.labels"/>
         /// .
         /// </summary>
         /// <returns>
@@ -519,7 +519,7 @@ namespace Antlr4.Runtime.Tree.Pattern
         /// Is
         /// <code>t</code>
         /// 
-        /// <code>(expr <expr>)</code>
+        /// <code>(expr &lt;expr&gt;)</code>
         /// subtree?
         /// </summary>
         protected internal virtual RuleTagToken GetRuleTagToken(IParseTree t)
@@ -599,7 +599,7 @@ namespace Antlr4.Runtime.Tree.Pattern
 
         /// <summary>
         /// Split
-        /// <code><ID> = <e:expr> ;</code>
+        /// <code>&lt;ID&gt; = &lt;e:expr&gt; ;</code>
         /// into 4 chunks for tokenizing by
         /// <see cref="Tokenize(string)">Tokenize(string)</see>
         /// .

runtime/CSharp/Antlr4.Runtime/Tree/Pattern/RuleTagToken.cs

@@ -39,7 +39,7 @@ namespace Antlr4.Runtime.Tree.Pattern
     /// <see cref="Antlr4.Runtime.IToken">Antlr4.Runtime.IToken</see>
     /// object representing an entire subtree matched by a parser
     /// rule; e.g.,
-    /// <code><expr></code>
+    /// <code>&lt;expr&gt;</code>
     /// . These tokens are created for
     /// <see cref="TagChunk">TagChunk</see>
     /// chunks where the tag corresponds to a parser rule.
@@ -146,7 +146,7 @@ namespace Antlr4.Runtime.Tree.Pattern
         /// <summary>
         /// <inheritDoc></inheritDoc>
         /// <p>Rule tag tokens are always placed on the
-        /// <see cref="Antlr4.Runtime.IToken.DefaultChannel">Antlr4.Runtime.IToken.DefaultChannel</see>
+        /// <see cref="TokenConstants.DefaultChannel"/>
         /// .</p>
         /// </summary>
         public virtual int Channel