Replace ${name} with $name where possible.

pkg/analyzer/test/generated/scanner_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.
 
 // 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.scanner_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
@@ skipping 399 matching lines @@
    *
    * @param prefix the unchanged text before the edit region
    * @param removed the text that was removed from the original contents
    * @param added the text that was added to the modified contents
    * @param suffix the unchanged text after the edit region
    */
   void _scan(String prefix, String removed, String added, String suffix) {
     //
     // Compute the information needed to perform the test.
     //
-    String originalContents = "${prefix}${removed}${suffix}";
-    String modifiedContents = "${prefix}${added}${suffix}";
+    String originalContents = "$prefix$removed$suffix";
+    String modifiedContents = "$prefix$added$suffix";
     int replaceStart = prefix.length;
     Source source = new TestSource();
     //
     // Scan the original contents.
     //
     GatheringErrorListener originalListener = new GatheringErrorListener();
     Scanner originalScanner = new Scanner(source, new CharSequenceReader(originalContents), originalListener);
     _originalTokens = originalScanner.tokenize();
     JUnitTestCase.assertNotNull(_originalTokens);
     //
@@ skipping 734 matching lines @@
     _assertToken(TokenType.STRING, "r'string'");
   }
 
   void test_string_raw_simple_unterminated_eof() {
     String source = "r'string";
     _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7, source, [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_raw_simple_unterminated_eol() {
     String source = "r'string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8, "${source}\n", [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8, "$source\n", [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_simple_double() {
     _assertToken(TokenType.STRING, "\"string\"");
   }
 
   void test_string_simple_escapedDollar() {
     _assertToken(TokenType.STRING, "'a\\\$b'");
   }
 
@@ skipping 73 matching lines @@
     _assertToken(TokenType.STRING, "'string'");
   }
 
   void test_string_simple_unterminated_eof() {
     String source = "'string";
     _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 6, source, [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_simple_unterminated_eol() {
     String source = "'string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7, "${source}\r", [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7, "$source\r", [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_simple_unterminated_interpolation_block() {
     _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 6, "'\${name", [
         new StringToken(TokenType.STRING, "'", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 1),
         new StringToken(TokenType.IDENTIFIER, "name", 3),
         new StringToken(TokenType.STRING, "", 7)]);
   }
 
@@ skipping 31 matching lines @@
     JUnitTestCase.assertEquals(TokenType.EOF, token.type);
     Token comment = token.precedingComments;
     JUnitTestCase.assertNotNull(comment);
     JUnitTestCase.assertEquals(commentType, comment.type);
     JUnitTestCase.assertEquals(0, comment.offset);
     JUnitTestCase.assertEquals(source.length, comment.length);
     JUnitTestCase.assertEquals(source, comment.lexeme);
     //
     // Test with a trailing end-of-line marker
     //
-    token = _scan("${source}\n");
+    token = _scan("$source\n");
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.EOF, token.type);
     comment = token.precedingComments;
     JUnitTestCase.assertNotNull(comment);
     JUnitTestCase.assertEquals(commentType, comment.type);
     JUnitTestCase.assertEquals(0, comment.offset);
     JUnitTestCase.assertEquals(source.length, comment.length);
     JUnitTestCase.assertEquals(source, comment.lexeme);
   }
 
@@ skipping 35 matching lines @@
   void _assertKeywordToken(String source) {
     Token token = _scan(source);
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.KEYWORD, token.type);
     JUnitTestCase.assertEquals(0, token.offset);
     JUnitTestCase.assertEquals(source.length, token.length);
     JUnitTestCase.assertEquals(source, token.lexeme);
     Object value = token.value();
     JUnitTestCase.assertTrue(value is Keyword);
     JUnitTestCase.assertEquals(source, (value as Keyword).syntax);
-    token = _scan(" ${source} ");
+    token = _scan(" $source ");
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.KEYWORD, token.type);
     JUnitTestCase.assertEquals(1, token.offset);
     JUnitTestCase.assertEquals(source.length, token.length);
     JUnitTestCase.assertEquals(source, token.lexeme);
     value = token.value();
     JUnitTestCase.assertTrue(value is Keyword);
     JUnitTestCase.assertEquals(source, (value as Keyword).syntax);
     JUnitTestCase.assertEquals(TokenType.EOF, token.next.type);
   }
@@ skipping 22 matching lines @@
     JUnitTestCase.assertNotNull(originalToken);
     JUnitTestCase.assertEquals(expectedType, originalToken.type);
     JUnitTestCase.assertEquals(0, originalToken.offset);
     JUnitTestCase.assertEquals(source.length, originalToken.length);
     JUnitTestCase.assertEquals(source, originalToken.lexeme);
     if (expectedType == TokenType.SCRIPT_TAG) {
       // Adding space before the script tag is not allowed, and adding text at the end changes nothing.
       return originalToken;
     } else if (expectedType == TokenType.SINGLE_LINE_COMMENT) {
       // Adding space to an end-of-line comment changes the comment.
-      Token tokenWithSpaces = _scan(" ${source}");
+      Token tokenWithSpaces = _scan(" $source");
       JUnitTestCase.assertNotNull(tokenWithSpaces);
       JUnitTestCase.assertEquals(expectedType, tokenWithSpaces.type);
       JUnitTestCase.assertEquals(1, tokenWithSpaces.offset);
       JUnitTestCase.assertEquals(source.length, tokenWithSpaces.length);
       JUnitTestCase.assertEquals(source, tokenWithSpaces.lexeme);
       return originalToken;
     } else if (expectedType == TokenType.INT || expectedType == TokenType.DOUBLE) {
       Token tokenWithLowerD = _scan("${source}d");
       JUnitTestCase.assertNotNull(tokenWithLowerD);
       JUnitTestCase.assertEquals(expectedType, tokenWithLowerD.type);
       JUnitTestCase.assertEquals(0, tokenWithLowerD.offset);
       JUnitTestCase.assertEquals(source.length, tokenWithLowerD.length);
       JUnitTestCase.assertEquals(source, tokenWithLowerD.lexeme);
       Token tokenWithUpperD = _scan("${source}D");
       JUnitTestCase.assertNotNull(tokenWithUpperD);
       JUnitTestCase.assertEquals(expectedType, tokenWithUpperD.type);
       JUnitTestCase.assertEquals(0, tokenWithUpperD.offset);
       JUnitTestCase.assertEquals(source.length, tokenWithUpperD.length);
       JUnitTestCase.assertEquals(source, tokenWithUpperD.lexeme);
     }
-    Token tokenWithSpaces = _scan(" ${source} ");
+    Token tokenWithSpaces = _scan(" $source ");
     JUnitTestCase.assertNotNull(tokenWithSpaces);
     JUnitTestCase.assertEquals(expectedType, tokenWithSpaces.type);
     JUnitTestCase.assertEquals(1, tokenWithSpaces.offset);
     JUnitTestCase.assertEquals(source.length, tokenWithSpaces.length);
     JUnitTestCase.assertEquals(source, tokenWithSpaces.lexeme);
     JUnitTestCase.assertEquals(TokenType.EOF, originalToken.next.type);
     return originalToken;
   }
 
   /**
    * Assert that when scanned the given source contains a sequence of tokens identical to the given
    * tokens.
    *
    * @param source the source to be scanned
    * @param expectedTokens the tokens that are expected to be in the source
    */
   void _assertTokens(String source, List<Token> expectedTokens) {
     Token token = _scan(source);
     _checkTokens(token, expectedTokens);
   }
 
   void _checkTokens(Token firstToken, List<Token> expectedTokens) {
     JUnitTestCase.assertNotNull(firstToken);
     Token token = firstToken;
     for (int i = 0; i < expectedTokens.length; i++) {
       Token expectedToken = expectedTokens[i];
-      JUnitTestCase.assertEqualsMsg("Wrong type for token ${i}", expectedToken.type, token.type);
-      JUnitTestCase.assertEqualsMsg("Wrong offset for token ${i}", expectedToken.offset, token.offset);
-      JUnitTestCase.assertEqualsMsg("Wrong length for token ${i}", expectedToken.length, token.length);
-      JUnitTestCase.assertEqualsMsg("Wrong lexeme for token ${i}", expectedToken.lexeme, token.lexeme);
+      JUnitTestCase.assertEqualsMsg("Wrong type for token $i", expectedToken.type, token.type);
+      JUnitTestCase.assertEqualsMsg("Wrong offset for token $i", expectedToken.offset, token.offset);
+      JUnitTestCase.assertEqualsMsg("Wrong length for token $i", expectedToken.length, token.length);
+      JUnitTestCase.assertEqualsMsg("Wrong lexeme for token $i", expectedToken.lexeme, token.lexeme);
       token = token.next;
       JUnitTestCase.assertNotNull(token);
     }
     JUnitTestCase.assertEquals(TokenType.EOF, token.type);
   }
 
   Token _scan(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Token token = _scanWithListener(source, listener);
     listener.assertNoErrors();
@@ skipping 154 matching lines @@
 }
 
 main() {
   _ut.groupSep = ' | ';
   runReflectiveTests(CharSequenceReaderTest);
   runReflectiveTests(IncrementalScannerTest);
   runReflectiveTests(KeywordStateTest);
   runReflectiveTests(ScannerTest);
   runReflectiveTests(TokenTypeTest);
 }