Fix for issue 18598

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import "dart:math" as math;
@@ skipping 6188 matching lines @@
    * <pre>
    * exportDirective ::=
    *     metadata 'export' stringLiteral combinator*';'
    * </pre>
    *
    * @param commentAndMetadata the metadata to be associated with the directive
    * @return the export directive that was parsed
    */
   ExportDirective _parseExportDirective(CommentAndMetadata commentAndMetadata) {
     Token exportKeyword = _expectKeyword(Keyword.EXPORT);
-    StringLiteral libraryUri = parseStringLiteral();
+    StringLiteral libraryUri = _parseUri();
     List<Combinator> combinators = _parseCombinators();
     Token semicolon = _expectSemicolon();
     return new ExportDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         exportKeyword,
         libraryUri,
         combinators,
         semicolon);
   }
@@ skipping 676 matching lines @@
    * <pre>
    * importDirective ::=
    *     metadata 'import' stringLiteral ('as' identifier)? combinator*';'
    * </pre>
    *
    * @param commentAndMetadata the metadata to be associated with the directive
    * @return the import directive that was parsed
    */
   ImportDirective _parseImportDirective(CommentAndMetadata commentAndMetadata) {
     Token importKeyword = _expectKeyword(Keyword.IMPORT);
-    StringLiteral libraryUri = parseStringLiteral();
+    StringLiteral libraryUri = _parseUri();
     Token deferredToken = null;
     Token asToken = null;
     SimpleIdentifier prefix = null;
     if (_matchesKeyword(Keyword.DEFERRED)) {
       if (_parseDeferredLibraries) {
         deferredToken = andAdvance;
       } else {
         _reportErrorForCurrentToken(
             ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED);
         _advance();
@@ skipping 840 matching lines @@
           ofKeyword);
       Token semicolon = _expect(TokenType.SEMICOLON);
       return new PartOfDirective(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           partKeyword,
           ofKeyword,
           libraryName,
           semicolon);
     }
-    StringLiteral partUri = parseStringLiteral();
+    StringLiteral partUri = _parseUri();
     Token semicolon = _expect(TokenType.SEMICOLON);
     return new PartDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         partKeyword,
         partUri,
         semicolon);
   }
 
   /**
@@ skipping 837 matching lines @@
     } else if (_matches(TokenType.PLUS)) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
       return _createSyntheticIdentifier();
     } else if (_matchesString(_AWAIT)) {
       return _parseAwaitExpression();
     }
     return _parsePostfixExpression();
   }
 
   /**
+   * Parse a string literal representing a URI.
+   */
+  StringLiteral _parseUri() {
+    bool iskeywordAfterUri(Token token) =>
+        token.lexeme == Keyword.AS.syntax ||
+            token.lexeme == _HIDE ||
+            token.lexeme == _SHOW;
+    if (!_matches(TokenType.STRING) &&
+        !_matches(TokenType.SEMICOLON) &&
+        !iskeywordAfterUri(_currentToken)) {
+      // Attempt to recover in the case where the URI was not enclosed in
+      // quotes.
+      Token token = _currentToken;
+      while ((_tokenMatchesIdentifier(token) && !iskeywordAfterUri(token)) ||
+          _tokenMatches(token, TokenType.COLON) ||
+          _tokenMatches(token, TokenType.SLASH) ||
+          _tokenMatches(token, TokenType.PERIOD) ||
+          _tokenMatches(token, TokenType.PERIOD_PERIOD) ||
+          _tokenMatches(token, TokenType.PERIOD_PERIOD_PERIOD) ||
+          _tokenMatches(token, TokenType.INT) ||
+          _tokenMatches(token, TokenType.DOUBLE)) {
+        token = token.next;
+      }
+      if (_tokenMatches(token, TokenType.SEMICOLON) ||
+          iskeywordAfterUri(token)) {
+        Token endToken = token.previous;
+        token = _currentToken;
+        int endOffset = token.end;
+        StringBuffer buffer = new StringBuffer();
+        buffer.write(token.lexeme);
+        while (token != endToken) {
+          token = token.next;
+          if (token.offset != endOffset || token.precedingComments != null) {
+            return parseStringLiteral();
+          }
+          buffer.write(token.lexeme);
+          endOffset = token.end;
+        }
+        String value = buffer.toString();
+        Token newToken =
+            new StringToken(TokenType.STRING, "'$value'", _currentToken.offset);
+        _reportErrorForToken(
+            ParserErrorCode.NON_STRING_LITERAL_AS_URI,
+            newToken);
+        _currentToken = endToken.next;
+        return new SimpleStringLiteral(newToken, value);
+      }
+    }
+    return parseStringLiteral();
+  }
+
+  /**
    * Parse a variable declaration.
    *
    * <pre>
    * variableDeclaration ::=
    *     identifier ('=' expression)?
    * </pre>
    *
    * @return the variable declaration that was parsed
    */
   VariableDeclaration _parseVariableDeclaration() {
@@ skipping 1836 matching lines @@
   static const ParserErrorCode NON_IDENTIFIER_LIBRARY_NAME =
       const ParserErrorCode(
           'NON_IDENTIFIER_LIBRARY_NAME',
           "The name of a library must be an identifier");
 
   static const ParserErrorCode NON_PART_OF_DIRECTIVE_IN_PART =
       const ParserErrorCode(
           'NON_PART_OF_DIRECTIVE_IN_PART',
           "The part-of directive must be the only directive in a part");
 
+  static const ParserErrorCode NON_STRING_LITERAL_AS_URI =
+      const ParserErrorCode(
+          'NON_STRING_LITERAL_AS_URI',
+          "The URI must be a string literal",
+          "Enclose the URI in either single or double quotes.");
+
   static const ParserErrorCode NON_USER_DEFINABLE_OPERATOR =
       const ParserErrorCode(
           'NON_USER_DEFINABLE_OPERATOR',
           "The operator '{0}' is not user definable");
 
   static const ParserErrorCode NORMAL_BEFORE_OPTIONAL_PARAMETERS =
       const ParserErrorCode(
           'NORMAL_BEFORE_OPTIONAL_PARAMETERS',
           "Normal parameters must occur before optional parameters");
 
@@ skipping 1545 matching lines @@
    * Copy resolution data from one node to another.
    *
    * @param fromNode the node from which resolution information will be copied
    * @param toNode the node to which resolution information will be copied
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }