Remove insertRange.

sdk/lib/_internal/dartdoc/lib/src/markdown/inline_parser.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of markdown;
 
 /// Maintains the internal state needed to parse inline span elements in
 /// markdown.
 class InlineParser {
   static List<InlineSyntax>  defaultSyntaxes = <InlineSyntax>[
@@ skipping 62 matching lines @@
     : _stack = <TagState>[] {
     /// User specified syntaxes will be the first syntaxes to be evaluated.
     if (document.inlineSyntaxes != null) {
       syntaxes = [];
       syntaxes.addAll(document.inlineSyntaxes);
       syntaxes.addAll(defaultSyntaxes);
     } else {
       syntaxes = defaultSyntaxes;
     }
     // Custom link resolver goes after the generic text syntax.
-    syntaxes.insertRange(1, 1,
-        new LinkSyntax(linkResolver: document.linkResolver));
+    syntaxes.insert(1, new LinkSyntax(linkResolver: document.linkResolver));
   }
 
   List<Node> parse() {
     // Make a fake top tag to hold the results.
     _stack.add(new TagState(0, 0, null));
 
     while (!isDone) {
       bool matched = false;
 
       // See if any of the current tags on the stack match. We don't allow tags
@@ skipping 286 matching lines @@
   /// If this is the last node in the stack, returns its children.
   List<Node> close(InlineParser parser, Match endMatch) {
     // If there are unclosed tags on top of this one when it's closed, that
     // means they are mismatched. Mismatched tags are treated as plain text in
     // markdown. So for each tag above this one, we write its start tag as text
     // and then adds its children to this one's children.
     int index = parser._stack.indexOf(this);
 
     // Remove the unmatched children.
     final unmatchedTags = parser._stack.sublist(index + 1);
-    parser._stack.removeRange(index + 1, parser._stack.length - index - 1);
+    parser._stack.removeRange(index + 1, parser._stack.length);
 
     // Flatten them out onto this tag.
     for (final unmatched in unmatchedTags) {
       // Write the start tag as text.
       parser.writeTextRange(unmatched.startPos, unmatched.endPos);
 
       // Bequeath its children unto this tag.
       children.addAll(unmatched.children);
     }
 
     // Pop this off the stack.
     parser.writeText();
     parser._stack.removeLast();
 
     // If the stack is empty now, this is the special "results" node.
     if (parser._stack.length == 0) return children;
 
     // We are still parsing, so add this to its parent's children.
     if (syntax.onMatchEnd(parser, endMatch, this)) {
       parser.consume(endMatch[0].length);
     } else {
       // Didn't close correctly so revert to text.
       parser.start = startPos;
       parser.advanceBy(endMatch[0].length);
     }
 
     return null;
   }
 }