migrate raw string to new syntax in dartdoc

pkg/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.
 
 /// Maintains the internal state needed to parse inline span elements in
 /// markdown.
 class InlineParser {
   static List<InlineSyntax> get syntaxes {
     // Lazy initialize.
     if (_syntaxes == null) {
       _syntaxes = <InlineSyntax>[
         new AutolinkSyntax(),
         new LinkSyntax(),
         // "*" surrounded by spaces is left alone.
-        new TextSyntax(@' \* '),
+        new TextSyntax(r' \* '),
         // "_" surrounded by spaces is left alone.
-        new TextSyntax(@' _ '),
+        new TextSyntax(r' _ '),
         // Leave already-encoded HTML entities alone. Ensures we don't turn
         // "&amp;" into "&amp;amp;"
-        new TextSyntax(@'&[#a-zA-Z0-9]*;'),
+        new TextSyntax(r'&[#a-zA-Z0-9]*;'),
         // Encode "&".
-        new TextSyntax(@'&', sub: '&amp;'),
+        new TextSyntax(r'&', sub: '&amp;'),
         // Encode "<". (Why not encode ">" too? Gruber is toying with us.)
-        new TextSyntax(@'<', sub: '&lt;'),
+        new TextSyntax(r'<', sub: '&lt;'),
         // Parse "**strong**" tags.
-        new TagSyntax(@'\*\*', tag: 'strong'),
+        new TagSyntax(r'\*\*', tag: 'strong'),
         // Parse "__strong__" tags.
-        new TagSyntax(@'__', tag: 'strong'),
+        new TagSyntax(r'__', tag: 'strong'),
         // Parse "*emphasis*" tags.
-        new TagSyntax(@'\*', tag: 'em'),
+        new TagSyntax(r'\*', tag: 'em'),
         // Parse "_emphasis_" tags.
         // TODO(rnystrom): Underscores in the middle of a word should not be
         // parsed as emphasis like_in_this.
-        new TagSyntax(@'_', tag: 'em'),
+        new TagSyntax(r'_', tag: 'em'),
         // Parse inline code within double backticks: "``code``".
-        new CodeSyntax(@'``\s?((?:.|\n)*?)\s?``'),
+        new CodeSyntax(r'``\s?((?:.|\n)*?)\s?``'),
         // Parse inline code within backticks: "`code`".
-        new CodeSyntax(@'`([^`]*)`')
+        new CodeSyntax(r'`([^`]*)`')
       ];
     }
 
     return _syntaxes;
   }
 
   static List<InlineSyntax> _syntaxes;
 
   /// The string of markdown being parsed.
   final String source;
@@ skipping 126 matching lines @@
 
     // Insert the substitution.
     parser.addNode(new Text(substitute));
     return true;
   }
 }
 
 /// Matches autolinks like `<http://foo.com>`.
 class AutolinkSyntax extends InlineSyntax {
   AutolinkSyntax()
-    : super(@'<((http|https|ftp)://[^>]*)>');
+    : super(r'<((http|https|ftp)://[^>]*)>');
   // TODO(rnystrom): Make case insensitive.
 
   bool onMatch(InlineParser parser, Match match) {
     final url = match[1];
 
     final anchor = new Element.text('a', escapeHtml(url));
     anchor.attributes['href'] = url;
     parser.addNode(anchor);
 
     return true;
@@ skipping 23 matching lines @@
     return true;
   }
 }
 
 /// Matches inline links like `[blah] [id]` and `[blah] (url)`.
 class LinkSyntax extends TagSyntax {
   /// 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    = @'\s?\[([^\]]*)\]';        // "[id]" reflink id.
-    final title      = @'(?:[ ]*"([^"]+)"|)';     // Optional title in quotes.
+    final refLink    = r'\s?\[([^\]]*)\]';        // "[id]" reflink id.
+    final title      = r'(?:[ ]*"([^"]+)"|)';     // Optional title in quotes.
     final inlineLink = '\\s?\\(([^ )]+)$title\\)'; // "(url "title")" link.
     return '\](?:($refLink|$inlineLink)|)';
 
     // The groups matched by this are:
     // 1: Will be non-empty if it's either a ref or inline link. Will be empty
     //    if it's just a bare pair of square brackets with nothing after them.
     // 2: Contains the id inside [] for a reference-style link.
     // 3: Contains the URL for an inline link.
     // 4: Contains the title, if present, for an inline link.
   }
 
   LinkSyntax()
-    : super(@'\[', end: linkPattern);
+    : super(r'\[', end: linkPattern);
 
   bool onMatchEnd(InlineParser parser, Match match, TagState state) {
     var url;
     var title;
 
     // If we didn't match refLink or inlineLink, then it means there was
     // nothing after the first square bracket, so it isn't a normal markdown
     // link at all. Instead, we allow users of the library to specify a special
     // resolver function ([setImplicitLinkResolver]) that may choose to handle
     // this. Otherwise, it's just treated as plain text.
@@ skipping 133 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;
   }
 }