third_party/pkg/markdown: update to 0.7.0 which fixes static warnings

third_party/pkg/markdown/lib/src/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.
 
 library markdown.inline_parser;
 
 import 'ast.dart';
 import 'document.dart';
 import 'util.dart';
 
 /// Maintains the internal state needed to parse inline span elements in
 /// markdown.
 class InlineParser {
-  static List<InlineSyntax>  defaultSyntaxes = <InlineSyntax>[
+  static List<InlineSyntax> _defaultSyntaxes = <InlineSyntax>[
     // This first regexp matches plain text to accelerate parsing.  It must
     // be written so that it does not match any prefix of any following
     // syntax.  Most markdown is plain text, so it is faster to match one
     // regexp per 'word' rather than fail to match all the following regexps
     // at each non-syntax character position.  It is much more important
     // that the regexp is fast than complete (for example, adding grouping
     // is likely to slow the regexp down enough to negate its benefit).
     // Since it is purely for optimization, it can be removed for debugging.
 
     // TODO(amouravski): this regex will glom up any custom syntaxes unless
@@ skipping 32 matching lines @@
     new CodeSyntax(r'`([^`]*)`')
     // We will add the LinkSyntax once we know about the specific link resolver.
   ];
 
   /// The string of markdown being parsed.
   final String source;
 
   /// The markdown document this parser is parsing.
   final Document document;
 
-  List<InlineSyntax> syntaxes;
+  final List<InlineSyntax> syntaxes = <InlineSyntax>[];
 
   /// The current read position.
   int pos = 0;
 
   /// Starting position of the last unconsumed text.
   int start = 0;
 
   final List<TagState> _stack;
 
   InlineParser(this.source, this.document)
     : _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;
     }
+    syntaxes.addAll(_defaultSyntaxes);
     // Custom link resolvers goes after the generic text syntax.
     syntaxes.insertAll(1, [
       new LinkSyntax(linkResolver: document.linkResolver),
       new ImageLinkSyntax(linkResolver: document.linkResolver)
     ]);
   }
 
   List<Node> parse() {
     // Make a fake top tag to hold the results.
     _stack.add(new TagState(0, 0, null));
@@ skipping 21 matching lines @@
       if (matched) continue;
 
       // If we got here, it's just text.
       advanceBy(1);
     }
 
     // Unwind any unmatched tags and get the results.
     return _stack[0].close(this, null);
   }
 
-  writeText() {
+  void writeText() {
     writeTextRange(start, pos);
     start = pos;
   }
 
-  writeTextRange(int start, int end) {
+  void writeTextRange(int start, int end) {
     if (end > start) {
       final text = source.substring(start, end);
       final nodes = _stack.last.children;
 
       // If the previous node is text too, just append.
       if ((nodes.length > 0) && (nodes.last is Text)) {
         final newNode = new Text('${nodes.last.text}$text');
         nodes[nodes.length - 1] = newNode;
       } else {
         nodes.add(new Text(text));
       }
     }
   }
 
-  addNode(Node node) {
+  void addNode(Node node) {
     _stack.last.children.add(node);
   }
 
   // TODO(rnystrom): Only need this because RegExp doesn't let you start
   // searching from a given offset.
   String get currentSource => source.substring(pos, source.length);
 
   bool get isDone => pos == source.length;
 
   void advanceBy(int length) {
@@ skipping 25 matching lines @@
       return true;
     }
     return false;
   }
 
   bool onMatch(InlineParser parser, Match match);
 }
 
 /// Matches stuff that should just be passed through as straight text.
 class TextSyntax extends InlineSyntax {
-  String substitute;
+  final String substitute;
   TextSyntax(String pattern, {String sub})
     : super(pattern),
       substitute = sub;
 
   bool onMatch(InlineParser parser, Match match) {
     if (substitute == null) {
       // Just use the original matched text.
       parser.advanceBy(match[0].length);
       return false;
     }
@@ skipping 40 matching lines @@
   }
 
   bool onMatchEnd(InlineParser parser, Match match, TagState state) {
     parser.addNode(new Element(tag, state.children));
     return true;
   }
 }
 
 /// Matches inline links like `[blah] [id]` and `[blah] (url)`.
 class LinkSyntax extends TagSyntax {
-  Resolver linkResolver;
+  final Resolver linkResolver;
 
   /// The regex for the end of a link needs to handle both reference style and
   /// inline styles as well as optional titles for inline links. To make that
   /// a bit more palatable, this breaks it into pieces.
   static get linkPattern {
     final refLink    = r'\s?\[([^\]]*)\]';        // "[id]" reflink id.
     final title      = r'(?:[ ]*"([^"]+)"|)';     // Optional title in quotes.
     final inlineLink = '\\s?\\(([^ )]+)$title\\)'; // "(url "title")" link.
     return '\](?:($refLink|$inlineLink)|)';
 
@@ skipping 71 matching lines @@
     Node node = createNode(parser, match, state);
     if (node == null) return false;
     parser.addNode(node);
     return true;
   }
 }
 
 /// Matches images like `![alternate text](url "optional title")` and
 /// `![alternate text][url reference]`.
 class ImageLinkSyntax extends LinkSyntax {
-  Resolver linkResolver;
+  final Resolver linkResolver;
   ImageLinkSyntax({this.linkResolver})
     : super(pattern: r'!\[');
 
-  Node createNode(InlineParser parser, Match match, TagState state) {
-    Node node = super.createNode(parser, match, state);
+  Element createNode(InlineParser parser, Match match, TagState state) {
+    Element node = super.createNode(parser, match, state);
     if (node == null) return null;
 
     final Element imageElement = new Element.withTag("img")
       ..attributes["src"] = node.attributes["href"]
       ..attributes["title"] = node.attributes["title"]
       ..attributes["alt"] = node.children
         .map((e) => isNullOrEmpty(e) || e is! Text ? '' : e.text)
         .join(' ');
 
     cleanMap(imageElement.attributes);
@@ skipping 15 matching lines @@
   bool onMatch(InlineParser parser, Match match) {
     parser.addNode(new Element.text('code', escapeHtml(match[1])));
     return true;
   }
 }
 
 /// Keeps track of a currently open tag while it is being parsed. The parser
 /// maintains a stack of these so it can handle nested tags.
 class TagState {
   /// The point in the original source where this tag started.
-  int startPos;
+  final int startPos;
 
   /// The point in the original source where open tag ended.
-  int endPos;
+  final int endPos;
 
   /// The syntax that created this node.
   final TagSyntax syntax;
 
   /// The children of this node. Will be `null` for text nodes.
   final List<Node> children;
 
   TagState(this.startPos, this.endPos, this.syntax)
     : children = <Node>[];
 
@@ skipping 45 matching lines @@
       parser.consume(endMatch[0].length);
     } else {
       // Didn't close correctly so revert to text.
       parser.start = startPos;
       parser.advanceBy(endMatch[0].length);
     }
 
     return null;
   }
 }