Revert optimization for RendererBase to use a plain type for the dictionary key (#632)

Don't try to use the MT pointer on unsupported platforms

readme.md

@@ -14,7 +14,7 @@ You can **try Markdig online** and compare it to other implementations on [babel
 - **Abstract Syntax Tree** with precise source code location for syntax tree, useful when building a Markdown editor.
   - Checkout [MarkdownEditor for Visual Studio](https://visualstudiogallery.msdn.microsoft.com/eaab33c3-437b-4918-8354-872dfe5d1bfe) powered by Markdig!
 - Converter to **HTML**
-- Passing more than **600+ tests** from the latest [CommonMark specs (0.29)](http://spec.commonmark.org/)
+- Passing more than **600+ tests** from the latest [CommonMark specs (0.30)](http://spec.commonmark.org/)
 - Includes all the core elements of CommonMark:
   - including **GFM fenced code blocks**.  
 - **Extensible** architecture

src/Markdig.Tests/TestContainerBlocks.cs

@@ -88,5 +88,102 @@ namespace Markdig.Tests
 
             Assert.Throws<ArgumentException>(() => container[0] = two); // two already has a parent
         }
+
+        [Test]
+        public void Contains()
+        {
+            var container = new MockContainerBlock();
+            var block = new ParagraphBlock();
+
+            Assert.False(container.Contains(block));
+
+            container.Add(block);
+            Assert.True(container.Contains(block));
+
+            container.Add(new ParagraphBlock());
+            Assert.True(container.Contains(block));
+
+            container.Insert(0, new ParagraphBlock());
+            Assert.True(container.Contains(block));
+        }
+
+        [Test]
+        public void Remove()
+        {
+            var container = new MockContainerBlock();
+            var block = new ParagraphBlock();
+
+            Assert.False(container.Remove(block));
+            Assert.AreEqual(0, container.Count);
+            Assert.Throws<ArgumentOutOfRangeException>(() => container.RemoveAt(0));
+            Assert.AreEqual(0, container.Count);
+
+            container.Add(block);
+            Assert.AreEqual(1, container.Count);
+            Assert.True(container.Remove(block));
+            Assert.AreEqual(0, container.Count);
+            Assert.False(container.Remove(block));
+            Assert.AreEqual(0, container.Count);
+
+            container.Add(block);
+            Assert.AreEqual(1, container.Count);
+            container.RemoveAt(0);
+            Assert.AreEqual(0, container.Count);
+            Assert.Throws<ArgumentOutOfRangeException>(() => container.RemoveAt(0));
+            Assert.AreEqual(0, container.Count);
+
+            container.Add(new ParagraphBlock { Column = 1 });
+            container.Add(new ParagraphBlock { Column = 2 });
+            container.Add(new ParagraphBlock { Column = 3 });
+            container.Add(new ParagraphBlock { Column = 4 });
+            Assert.AreEqual(4, container.Count);
+
+            container.RemoveAt(2);
+            Assert.AreEqual(3, container.Count);
+            Assert.AreEqual(4, container[2].Column);
+
+            Assert.True(container.Remove(container[1]));
+            Assert.AreEqual(2, container.Count);
+            Assert.AreEqual(1, container[0].Column);
+            Assert.AreEqual(4, container[1].Column);
+            Assert.Throws<IndexOutOfRangeException>(() => _ = container[2]);
+        }
+
+        [Test]
+        public void CopyTo()
+        {
+            var container = new MockContainerBlock();
+
+            var destination = new Block[4];
+            container.CopyTo(destination, 0);
+            container.CopyTo(destination, 1);
+            container.CopyTo(destination, -1);
+            container.CopyTo(destination, 5);
+            Assert.Null(destination[0]);
+
+            container.Add(new ParagraphBlock());
+            container.CopyTo(destination, 0);
+            Assert.NotNull(destination[0]);
+            Assert.Null(destination[1]);
+            Assert.Null(destination[2]);
+            Assert.Null(destination[3]);
+
+            container.CopyTo(destination, 2);
+            Assert.NotNull(destination[0]);
+            Assert.Null(destination[1]);
+            Assert.NotNull(destination[2]);
+            Assert.Null(destination[3]);
+
+            Array.Clear(destination);
+
+            container.Add(new ParagraphBlock());
+            container.CopyTo(destination, 1);
+            Assert.Null(destination[0]);
+            Assert.NotNull(destination[1]);
+            Assert.NotNull(destination[2]);
+            Assert.Null(destination[3]);
+
+            Assert.Throws<IndexOutOfRangeException>(() => container.CopyTo(destination, 3));
+        }
     }
 }

src/Markdig/Parsers/HtmlBlockParser.cs

@@ -159,8 +159,8 @@ namespace Markdig.Parsers
 
             int tagIndex = match.Value;
 
-            // Cannot start with </script </pre or </style
-            if ((tagIndex == 49 || tagIndex == 50 || tagIndex == 53))
+            // Cannot start with </script </pre or </style or </textArea
+            if ((tagIndex == 49 || tagIndex == 50 || tagIndex == 53 || tagIndex == 56))
             {
                 if (c == '/' || hasLeadingClose)
                 {
@@ -241,6 +241,15 @@ namespace Markdig.Parsers
                                 htmlBlock.UpdateSpanEnd(index + "</style>".Length);
                                 result = BlockState.Break;
                             }
+                            else
+                            {
+                                index = line.IndexOf("</textarea>", 0, true);
+                                if (index >= 0)
+                                {
+                                    htmlBlock.UpdateSpanEnd(index + "</textarea>".Length);
+                                    result = BlockState.Break;
+                                }
+                            }
                         }
                     }
                     break;
@@ -289,7 +298,7 @@ namespace Markdig.Parsers
             return BlockState.Continue;
         }
 
-        private static readonly CompactPrefixTree<int> HtmlTags = new(65, 93, 82)
+        private static readonly CompactPrefixTree<int> HtmlTags = new(66, 94, 83)
         {
             { "address", 0 },
             { "article", 1 },
@@ -347,15 +356,16 @@ namespace Markdig.Parsers
             { "style", 53 },    // <=== special group 1
             { "summary", 54 },
             { "table", 55 },
-            { "tbody", 56 },
-            { "td", 57 },
-            { "tfoot", 58 },
-            { "th", 59 },
-            { "thead", 60 },
-            { "title", 61 },
-            { "tr", 62 },
-            { "track", 63 },
-            { "ul", 64 }
+            { "textarea", 56 }, // <=== special group 1
+            { "tbody", 57 },
+            { "td", 58 },
+            { "tfoot", 59 },
+            { "th", 60 },
+            { "thead", 61 },
+            { "title", 62 },
+            { "tr", 63 },
+            { "track", 64 },
+            { "ul", 65 }
         };
     }
 }

src/Markdig/Renderers/RendererBase.cs

@@ -4,7 +4,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using Markdig.Helpers;
 using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
@@ -17,20 +19,7 @@ namespace Markdig.Renderers
     /// <seealso cref="IMarkdownRenderer" />
     public abstract class RendererBase : IMarkdownRenderer
     {
-        private readonly struct KeyWrapper : IEquatable<KeyWrapper>
-        {
-            public readonly IntPtr Key;
-
-            public KeyWrapper(IntPtr key) => Key = key;
-
-            public bool Equals(KeyWrapper other) => Key == other.Key;
-
-            public override int GetHashCode() => Key.GetHashCode();
-
-            public override bool Equals(object? obj) => throw new NotImplementedException();
-        }
-
-        private readonly Dictionary<KeyWrapper, IMarkdownObjectRenderer?> _renderersPerType = new();
+        private readonly Dictionary<Type, IMarkdownObjectRenderer?> _renderersPerType = new();
         internal int _childrenDepth = 0;
 
         /// <summary>
@@ -40,13 +29,11 @@ namespace Markdig.Renderers
 
         private IMarkdownObjectRenderer? GetRendererInstance(MarkdownObject obj)
         {
-            KeyWrapper key = GetKeyForType(obj);
-            Type objectType = obj.GetType();
-
+            var key = obj.GetType();
             for (int i = 0; i < ObjectRenderers.Count; i++)
             {
                 var renderer = ObjectRenderers[i];
-                if (renderer.Accept(this, objectType))
+                if (renderer.Accept(this, key))
                 {
                     _renderersPerType[key] = renderer;
                     return renderer;
@@ -154,7 +141,7 @@ namespace Markdig.Renderers
             // Calls before writing an object
             ObjectWriteBefore?.Invoke(this, obj);
 
-            if (!_renderersPerType.TryGetValue(GetKeyForType(obj), out IMarkdownObjectRenderer? renderer))
+            if (!_renderersPerType.TryGetValue(obj.GetType(), out IMarkdownObjectRenderer? renderer))
             {
                 renderer = GetRendererInstance(obj);
             }
@@ -175,22 +162,5 @@ namespace Markdig.Renderers
             // Calls after writing an object
             ObjectWriteAfter?.Invoke(this, obj);
         }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static KeyWrapper GetKeyForType(MarkdownObject obj)
-        {
-#if NET
-            IntPtr methodTablePtr = Unsafe.Add(ref Unsafe.As<RawData>(obj).Data, -1);
-            return new KeyWrapper(methodTablePtr);
-#else
-            IntPtr typeHandle = Type.GetTypeHandle(obj).Value;
-            return new KeyWrapper(typeHandle);
-#endif
-        }
-
-        private sealed class RawData
-        {
-            public IntPtr Data;
-        }
     }
 }

src/Markdig/Syntax/ContainerBlock.cs

@@ -130,7 +130,7 @@ namespace Markdig.Syntax
             BlockWrapper[] children = _children;
             for (int i = 0; i < Count && i < children.Length; i++)
             {
-                array[arrayIndex + 1] = children[i].Block;
+                array[arrayIndex + i] = children[i].Block;
             }
         }
 
@@ -193,7 +193,7 @@ namespace Markdig.Syntax
 
         public void RemoveAt(int index)
         {
-            if ((uint)index > (uint)Count)
+            if ((uint)index >= (uint)Count)
                 ThrowHelper.ArgumentOutOfRangeException_index();
 
             Count--;

src/Markdig/Syntax/LinkReferenceDefinitionGroup.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using Markdig.Helpers;
 
 namespace Markdig.Syntax
@@ -15,12 +16,18 @@ namespace Markdig.Syntax
     /// <seealso cref="ContainerBlock" />
     public class LinkReferenceDefinitionGroup : ContainerBlock
     {
+#if NET452
+        private static readonly StringComparer _unicodeIgnoreCaseComparer = StringComparer.InvariantCultureIgnoreCase;
+#else
+        private static readonly StringComparer _unicodeIgnoreCaseComparer = CultureInfo.InvariantCulture.CompareInfo.GetStringComparer(CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace);
+#endif
+
         /// <summary>
         /// Initializes a new instance of the <see cref="LinkReferenceDefinitionGroup"/> class.
         /// </summary>
         public LinkReferenceDefinitionGroup() : base(null)
         {
-            Links = new Dictionary<string, LinkReferenceDefinition>(StringComparer.OrdinalIgnoreCase);
+            Links = new Dictionary<string, LinkReferenceDefinition>(_unicodeIgnoreCaseComparer);
         }
 
         /// <summary>