Fix interpretation of string contents after interpolation expressions.

pkg/analyzer/test/generated/parser_test.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.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 1541 matching lines @@
     parse3("parseClassMember", <Object>["C"], "int +() {}",
         [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
   }
 
   void test_missingKeywordOperator_parseClassMember_afterVoid() {
     parse3("parseClassMember", <Object>["C"], "void +() {}",
         [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
   }
 
   void test_missingMethodParameters_void_block() {
-    MethodDeclaration method = parse3("parseClassMember",
-        <Object>["C"], "void m {} }",
-        [ParserErrorCode.MISSING_METHOD_PARAMETERS]);
+    MethodDeclaration method = parse3("parseClassMember", <Object>["C"],
+        "void m {} }", [ParserErrorCode.MISSING_METHOD_PARAMETERS]);
     expect(method.parameters, hasLength(0));
   }
 
   void test_missingMethodParameters_void_expression() {
     parse3("parseClassMember", <Object>["C"], "void m => null; }",
         [ParserErrorCode.MISSING_METHOD_PARAMETERS]);
   }
 
   void test_missingNameInLibraryDirective() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(
@@ skipping 284 matching lines @@
     parse4("parseSwitchStatement",
         "switch (a) {default: return 0; default: return 1; default: return 2;}",
         [
       ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES,
       ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES
     ]);
   }
 
   void test_topLevel_getter() {
     FunctionDeclaration funct = parse3("parseCompilationUnitMember",
-        <Object>[emptyCommentAndMetadata()],
-        "get x => 7;");
+        <Object>[emptyCommentAndMetadata()], "get x => 7;");
     expect(funct.functionExpression.parameters, isNull);
   }
 
   void test_topLevelOperator_withoutType() {
     parse3("parseCompilationUnitMember", <Object>[emptyCommentAndMetadata()],
         "operator +(bool x, bool y) => x | y;",
         [ParserErrorCode.TOP_LEVEL_OPERATOR]);
   }
 
   void test_topLevelOperator_withType() {
@@ skipping 7068 matching lines @@
   void test_parseStringLiteral_adjacent() {
     AdjacentStrings literal = parse4("parseStringLiteral", "'a' 'b'");
     NodeList<StringLiteral> strings = literal.strings;
     expect(strings, hasLength(2));
     StringLiteral firstString = strings[0];
     StringLiteral secondString = strings[1];
     expect((firstString as SimpleStringLiteral).value, "a");
     expect((secondString as SimpleStringLiteral).value, "b");
   }
 
+  void test_parseStringLiteral_endsWithInterpolation() {
+    StringLiteral literal = parse4('parseStringLiteral', r"'x$y'");
+    expect(literal, new isInstanceOf<StringInterpolation>());
+    StringInterpolation interpolation = literal;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, 'x');
+    expect(
+        interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
+    expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, '');
+  }
+
   void test_parseStringLiteral_interpolated() {
     StringInterpolation literal =
         parse4("parseStringLiteral", "'a \${b} c \$this d'");
     NodeList<InterpolationElement> elements = literal.elements;
     expect(elements, hasLength(5));
     expect(elements[0] is InterpolationString, isTrue);
     expect(elements[1] is InterpolationExpression, isTrue);
     expect(elements[2] is InterpolationString, isTrue);
     expect(elements[3] is InterpolationExpression, isTrue);
     expect(elements[4] is InterpolationString, isTrue);
   }
 
   void test_parseStringLiteral_multiline_encodedSpace() {
     SimpleStringLiteral literal =
         parse4("parseStringLiteral", "'''\\x20\na'''");
     expect(literal.literal, isNotNull);
     expect(literal.value, " \na");
   }
 
+  void test_parseStringLiteral_multiline_endsWithInterpolation() {
+    StringLiteral literal = parse4('parseStringLiteral', r"'''x$y'''");
+    expect(literal, new isInstanceOf<StringInterpolation>());
+    StringInterpolation interpolation = literal;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, 'x');
+    expect(
+        interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
+    expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, '');
+  }
+
   void test_parseStringLiteral_multiline_escapedBackslash() {
     SimpleStringLiteral literal = parse4("parseStringLiteral", "'''\\\\\na'''");
     expect(literal.literal, isNotNull);
     expect(literal.value, "\\\na");
   }
 
   void test_parseStringLiteral_multiline_escapedBackslash_raw() {
     SimpleStringLiteral literal =
         parse4("parseStringLiteral", "r'''\\\\\na'''");
     expect(literal.literal, isNotNull);
@@ skipping 31 matching lines @@
     expect(literal.literal, isNotNull);
     expect(literal.value, "\t\na");
   }
 
   void test_parseStringLiteral_multiline_escapedTab_raw() {
     SimpleStringLiteral literal = parse4("parseStringLiteral", "r'''\\t\na'''");
     expect(literal.literal, isNotNull);
     expect(literal.value, "\\t\na");
   }
 
+  void test_parseStringLiteral_multiline_quoteAfterInterpolation() {
+    StringLiteral literal = parse4('parseStringLiteral', r"""'''$x'y'''""");
+    expect(literal, new isInstanceOf<StringInterpolation>());
+    StringInterpolation interpolation = literal;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, '');
+    expect(
+        interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
+    expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, "'y");
+  }
+
+  void test_parseStringLiteral_multiline_startsWithInterpolation() {
+    StringLiteral literal = parse4('parseStringLiteral', r"'''${x}y'''");
+    expect(literal, new isInstanceOf<StringInterpolation>());
+    StringInterpolation interpolation = literal;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, '');
+    expect(
+        interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
+    expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, 'y');
+  }
+
   void test_parseStringLiteral_multiline_twoSpaces() {
     SimpleStringLiteral literal = parse4("parseStringLiteral", "'''  \na'''");
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseStringLiteral_multiline_twoSpaces_raw() {
     SimpleStringLiteral literal = parse4("parseStringLiteral", "r'''  \na'''");
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseStringLiteral_multiline_untrimmed() {
     SimpleStringLiteral literal = parse4("parseStringLiteral", "''' a\nb'''");
     expect(literal.literal, isNotNull);
     expect(literal.value, " a\nb");
   }
 
+  void test_parseStringLiteral_quoteAfterInterpolation() {
+    StringLiteral literal = parse4('parseStringLiteral', r"""'$x"'""");
+    expect(literal, new isInstanceOf<StringInterpolation>());
+    StringInterpolation interpolation = literal;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, '');
+    expect(
+        interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
+    expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, '"');
+  }
+
   void test_parseStringLiteral_single() {
     SimpleStringLiteral literal = parse4("parseStringLiteral", "'a'");
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
+  void test_parseStringLiteral_startsWithInterpolation() {
+    StringLiteral literal = parse4('parseStringLiteral', r"'${x}y'");
+    expect(literal, new isInstanceOf<StringInterpolation>());
+    StringInterpolation interpolation = literal;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, '');
+    expect(
+        interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
+    expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, 'y');
+  }
+
   void test_parseSuperConstructorInvocation_named() {
     SuperConstructorInvocation invocation =
         parse4("parseSuperConstructorInvocation", "super.a()");
     expect(invocation.argumentList, isNotNull);
     expect(invocation.constructorName, isNotNull);
     expect(invocation.superKeyword, isNotNull);
     expect(invocation.period, isNotNull);
   }
 
   void test_parseSuperConstructorInvocation_unnamed() {
@@ skipping 972 matching lines @@
         new Scanner(null, new CharSequenceReader(source), listener);
     Token tokenStream = scanner.tokenize();
     //
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser, methodName, <Object>[tokenStream], tokenStream) as Token;
   }
 }