Replace ${name} with $name where possible.

pkg/analyzer/test/generated/all_the_rest.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.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 352 matching lines @@
       }
       if (lexeme.startsWith("<?")) {
         return ht.TokenType.DIRECTIVE;
       }
       if (_isTag(lexeme)) {
         return ht.TokenType.TAG;
       }
       return ht.TokenType.TEXT;
     }
     JUnitTestCase.fail(
-        "Unknown expected token ${count}: ${(expected != null ? expected.runtimeType : "null")}");
+        "Unknown expected token $count: ${(expected != null ? expected.runtimeType : "null")}");
     return null;
   }
 
   bool _isTag(String lexeme) {
     if (lexeme.length == 0 || !Character.isLetter(lexeme.codeUnitAt(0))) {
       return false;
     }
     for (int index = 1; index < lexeme.length; index++) {
       int ch = lexeme.codeUnitAt(index);
       if (!Character.isLetterOrDigit(ch) && ch != 0x2D && ch != 0x5F) {
@@ skipping 18 matching lines @@
     JUnitTestCase.assertEquals(-1, previousToken.offset);
     JUnitTestCase.assertSame(token, previousToken.next);
     JUnitTestCase.assertEquals(0, token.offset);
     while (token.type != ht.TokenType.EOF) {
       if (count == expectedTokens.length) {
         JUnitTestCase.fail("too many parsed tokens");
       }
       Object expected = expectedTokens[count];
       ht.TokenType expectedTokenType = _getExpectedTokenType(count, expected);
       JUnitTestCase.assertSameMsg(
-          "token ${count}",
+          "token $count",
           expectedTokenType,
           token.type);
       if (expectedTokenType.lexeme != null) {
         JUnitTestCase.assertEqualsMsg(
-            "token ${count}",
+            "token $count",
             expectedTokenType.lexeme,
             token.lexeme);
       } else {
-        JUnitTestCase.assertEqualsMsg("token ${count}", expected, token.lexeme);
+        JUnitTestCase.assertEqualsMsg("token $count", expected, token.lexeme);
       }
       count++;
       previousToken = token;
       token = token.next;
       JUnitTestCase.assertSame(previousToken, token.previous);
     }
     JUnitTestCase.assertSame(token, token.next);
     JUnitTestCase.assertEquals(input.length, token.offset);
     if (count != expectedTokens.length) {
       JUnitTestCase.assertTrueMsg("not enough parsed tokens", false);
@@ skipping 2283 matching lines @@
   AstNode findExpression(int offset, Predicate<AstNode> predicate) {
     Expression expression = ht.HtmlUnitUtils.getExpression(indexUnit, offset);
     return expression != null ? expression.getAncestor(predicate) : null;
   }
 
   /**
    * Returns the [SimpleIdentifier] at the given search pattern. Fails if not found.
    */
   SimpleIdentifier findIdentifier(String search) {
     SimpleIdentifier identifier = findIdentifierMaybe(search);
-    JUnitTestCase.assertNotNullMsg("${search} in ${indexContent}", identifier);
+    JUnitTestCase.assertNotNullMsg("$search in $indexContent", identifier);
     // check that offset/length of the identifier is valid
     {
       int offset = identifier.offset;
       int end = identifier.end;
       String contentStr = indexContent.substring(offset, end);
       JUnitTestCase.assertEquals(identifier.name, contentStr);
     }
     // done
     return identifier;
   }
@@ skipping 683 matching lines @@
     EvaluationResult result = _getExpressionValue(contents);
     DartObject value = result.value;
     JUnitTestCase.assertNotNull(value);
     ParameterizedType type = value.type;
     JUnitTestCase.assertNotNull(type);
     JUnitTestCase.assertEquals("String", type.name);
     JUnitTestCase.assertEquals(expectedValue, value.stringValue);
   }
 
   EvaluationResult _getExpressionValue(String contents) {
-    Source source = addSource("var x = ${contents};");
+    Source source = addSource("var x = $contents;");
     LibraryElement library = resolve(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, library);
     JUnitTestCase.assertNotNull(unit);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSizeOfList(1, declarations);
     CompilationUnitMember declaration = declarations[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TopLevelVariableDeclaration,
         TopLevelVariableDeclaration,
@@ skipping 1058 matching lines @@
     JUnitTestCase.assertNotNull(result.value);
     DartObjectImpl value = result.value;
     JUnitTestCase.assertTrue(value.isUnknown);
   }
 
   void _checkInstanceCreationOptionalParams(bool isFieldFormal, bool isNamed,
       bool hasDefault) {
     String fieldName = "j";
     String paramName = isFieldFormal ? fieldName : "i";
     String formalParam =
-        "${(isFieldFormal ? "this." : "int ")}${paramName}${(hasDefault ? " = 3" : "")}";
+        "${(isFieldFormal ? "this." : "int ")}$paramName${(hasDefault ? " = 3" : "")}";
     CompilationUnit compilationUnit = resolveSource("""
 const x = const A();
 const y = const A(${isNamed ? '$paramName: ' : ''}10);
 class A {
-  const A(${isNamed ? "{${formalParam}}" : "[${formalParam}]"})${isFieldFormal ? "" : " : ${fieldName} = ${paramName}"};
-  final int ${fieldName};
+  const A(${isNamed ? "{$formalParam}" : "[$formalParam]"})${isFieldFormal ? "" : " : $fieldName = $paramName"};
+  final int $fieldName;
 }""");
     EvaluationResultImpl x =
         _evaluateInstanceCreationExpression(compilationUnit, "x");
     Map<String, DartObjectImpl> fieldsOfX = _assertType(x, "A");
     EngineTestCase.assertSizeOfMap(1, fieldsOfX);
     if (hasDefault) {
       _assertIntField(fieldsOfX, fieldName, 3);
     } else {
       _assertNullField(fieldsOfX, fieldName);
     }
     EvaluationResultImpl y =
         _evaluateInstanceCreationExpression(compilationUnit, "y");
     Map<String, DartObjectImpl> fieldsOfY = _assertType(y, "A");
     EngineTestCase.assertSizeOfMap(1, fieldsOfY);
     _assertIntField(fieldsOfY, fieldName, 10);
   }
 
   void _checkInstanceCreation_withSupertypeParams(bool isExplicit) {
     String superCall = isExplicit ? " : super()" : "";
     CompilationUnit compilationUnit = resolveSource("""
 class A<T> {
   const A();
 }
 class B<T, U> extends A<T> {
   const B()$superCall;
 }
 class C<T, U> extends A<U> {
-  const C()${superCall};
+  const C()$superCall;
 }
 const b_int_num = const B<int, num>();
 const c_int_num = const C<int, num>();""");
     EvaluationResultImpl b_int_num =
         _evaluateInstanceCreationExpression(compilationUnit, "b_int_num");
     Map<String, DartObjectImpl> b_int_num_fields =
         _assertType(b_int_num, "B<int, num>");
     _assertFieldType(b_int_num_fields, GenericState.SUPERCLASS_FIELD, "A<int>");
     EvaluationResultImpl c_int_num =
         _evaluateInstanceCreationExpression(compilationUnit, "c_int_num");
     Map<String, DartObjectImpl> c_int_num_fields =
         _assertType(c_int_num, "C<int, num>");
     _assertFieldType(c_int_num_fields, GenericState.SUPERCLASS_FIELD, "A<num>");
   }
 
   EvaluationResultImpl _check_fromEnvironment_bool(String valueInEnvironment,
       String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
-        defaultExpr == null ? "" : ", defaultValue: ${defaultExpr}";
+        defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
     CompilationUnit compilationUnit = resolveSource(
-                "const ${varName} = const bool.fromEnvironment('${envVarName}'${defaultArg});");
+                "const $varName = const bool.fromEnvironment('$envVarName'$defaultArg);");
     return _evaluateInstanceCreationExpression(compilationUnit, varName);
   }
 
   EvaluationResultImpl _check_fromEnvironment_int(String valueInEnvironment,
       String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
-        defaultExpr == null ? "" : ", defaultValue: ${defaultExpr}";
+        defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
     CompilationUnit compilationUnit = resolveSource(
-                "const ${varName} = const int.fromEnvironment('${envVarName}'${defaultArg});");
+                "const $varName = const int.fromEnvironment('$envVarName'$defaultArg);");
     return _evaluateInstanceCreationExpression(compilationUnit, varName);
   }
 
   EvaluationResultImpl _check_fromEnvironment_string(String valueInEnvironment,
       String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
-        defaultExpr == null ? "" : ", defaultValue: ${defaultExpr}";
+        defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
     CompilationUnit compilationUnit = resolveSource(
-                "const ${varName} = const String.fromEnvironment('${envVarName}'${defaultArg});");
+                "const $varName = const String.fromEnvironment('$envVarName'$defaultArg);");
     return _evaluateInstanceCreationExpression(compilationUnit, varName);
   }
 
   EvaluationResultImpl
       _evaluateInstanceCreationExpression(CompilationUnit compilationUnit,
       String name) {
     Expression expression =
         findTopLevelConstantExpression(compilationUnit, name);
     return (expression as InstanceCreationExpression).evaluationResult;
   }
@@ skipping 3076 matching lines @@
         Keyword.SET,
         functionName,
         AstFactory.functionExpression2(
             AstFactory.formalParameterList([]),
             AstFactory.blockFunctionBody2([])));
     declaration.accept(builder);
     List<PropertyAccessorElement> accessors = holder.accessors;
     EngineTestCase.assertLength(1, accessors);
     PropertyAccessorElement accessor = accessors[0];
     JUnitTestCase.assertNotNull(accessor);
-    JUnitTestCase.assertEquals("${functionName}=", accessor.name);
+    JUnitTestCase.assertEquals("$functionName=", accessor.name);
     JUnitTestCase.assertSame(accessor, declaration.element);
     JUnitTestCase.assertSame(accessor, declaration.functionExpression.element);
     JUnitTestCase.assertFalse(accessor.isGetter);
     JUnitTestCase.assertTrue(accessor.isSetter);
     JUnitTestCase.assertFalse(accessor.isSynthetic);
     PropertyInducingElement variable = accessor.variable;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TopLevelVariableElement,
         TopLevelVariableElement,
         variable);
@@ skipping 277 matching lines @@
     FieldElement field = fields[0];
     JUnitTestCase.assertNotNull(field);
     JUnitTestCase.assertEquals(methodName, field.name);
     JUnitTestCase.assertTrue(field.isSynthetic);
     JUnitTestCase.assertNull(field.getter);
     PropertyAccessorElement setter = field.setter;
     JUnitTestCase.assertNotNull(setter);
     JUnitTestCase.assertFalse(setter.isAbstract);
     JUnitTestCase.assertTrue(setter.isSetter);
     JUnitTestCase.assertFalse(setter.isSynthetic);
-    JUnitTestCase.assertEquals("${methodName}=", setter.name);
+    JUnitTestCase.assertEquals("$methodName=", setter.name);
     JUnitTestCase.assertEquals(methodName, setter.displayName);
     JUnitTestCase.assertEquals(field, setter.variable);
     EngineTestCase.assertLength(0, setter.functions);
     EngineTestCase.assertLength(0, setter.labels);
     EngineTestCase.assertLength(0, setter.localVariables);
     EngineTestCase.assertLength(0, setter.parameters);
   }
 
   void test_visitMethodDeclaration_setter_abstract() {
     ElementHolder holder = new ElementHolder();
@@ skipping 13 matching lines @@
     FieldElement field = fields[0];
     JUnitTestCase.assertNotNull(field);
     JUnitTestCase.assertEquals(methodName, field.name);
     JUnitTestCase.assertTrue(field.isSynthetic);
     JUnitTestCase.assertNull(field.getter);
     PropertyAccessorElement setter = field.setter;
     JUnitTestCase.assertNotNull(setter);
     JUnitTestCase.assertTrue(setter.isAbstract);
     JUnitTestCase.assertTrue(setter.isSetter);
     JUnitTestCase.assertFalse(setter.isSynthetic);
-    JUnitTestCase.assertEquals("${methodName}=", setter.name);
+    JUnitTestCase.assertEquals("$methodName=", setter.name);
     JUnitTestCase.assertEquals(methodName, setter.displayName);
     JUnitTestCase.assertEquals(field, setter.variable);
     EngineTestCase.assertLength(0, setter.functions);
     EngineTestCase.assertLength(0, setter.labels);
     EngineTestCase.assertLength(0, setter.localVariables);
     EngineTestCase.assertLength(0, setter.parameters);
   }
 
   void test_visitMethodDeclaration_setter_external() {
     ElementHolder holder = new ElementHolder();
@@ skipping 12 matching lines @@
     FieldElement field = fields[0];
     JUnitTestCase.assertNotNull(field);
     JUnitTestCase.assertEquals(methodName, field.name);
     JUnitTestCase.assertTrue(field.isSynthetic);
     JUnitTestCase.assertNull(field.getter);
     PropertyAccessorElement setter = field.setter;
     JUnitTestCase.assertNotNull(setter);
     JUnitTestCase.assertFalse(setter.isAbstract);
     JUnitTestCase.assertTrue(setter.isSetter);
     JUnitTestCase.assertFalse(setter.isSynthetic);
-    JUnitTestCase.assertEquals("${methodName}=", setter.name);
+    JUnitTestCase.assertEquals("$methodName=", setter.name);
     JUnitTestCase.assertEquals(methodName, setter.displayName);
     JUnitTestCase.assertEquals(field, setter.variable);
     EngineTestCase.assertLength(0, setter.functions);
     EngineTestCase.assertLength(0, setter.labels);
     EngineTestCase.assertLength(0, setter.localVariables);
     EngineTestCase.assertLength(0, setter.parameters);
   }
 
   void test_visitMethodDeclaration_static() {
     ElementHolder holder = new ElementHolder();
@@ skipping 2067 matching lines @@
 }
 
 
 class HtmlUnitBuilderTest_ExpectedLibrary {
   final HtmlUnitBuilderTest HtmlUnitBuilderTest_this;
   final List<HtmlUnitBuilderTest_ExpectedVariable> _expectedVariables;
   HtmlUnitBuilderTest_ExpectedLibrary(this.HtmlUnitBuilderTest_this,
       this._expectedVariables);
   void _validate(int scriptIndex, EmbeddedHtmlScriptElementImpl script) {
     LibraryElement library = script.scriptLibrary;
-    JUnitTestCase.assertNotNullMsg("script ${scriptIndex}", library);
+    JUnitTestCase.assertNotNullMsg("script $scriptIndex", library);
     JUnitTestCase.assertSameMsg(
-        "script ${scriptIndex}",
+        "script $scriptIndex",
         HtmlUnitBuilderTest_this._context,
         script.context);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNullMsg("script ${scriptIndex}", unit);
+    JUnitTestCase.assertNotNullMsg("script $scriptIndex", unit);
     List<TopLevelVariableElement> variables = unit.topLevelVariables;
     EngineTestCase.assertLength(_expectedVariables.length, variables);
     for (int index = 0; index < variables.length; index++) {
       _expectedVariables[index].validate(scriptIndex, variables[index]);
     }
     JUnitTestCase.assertSameMsg(
-        "script ${scriptIndex}",
+        "script $scriptIndex",
         script,
         library.enclosingElement);
   }
 }
 
 
 class HtmlUnitBuilderTest_ExpectedVariable {
   final String _expectedName;
   HtmlUnitBuilderTest_ExpectedVariable(this._expectedName);
   void validate(int scriptIndex, TopLevelVariableElement variable) {
-    JUnitTestCase.assertNotNullMsg("script ${scriptIndex}", variable);
+    JUnitTestCase.assertNotNullMsg("script $scriptIndex", variable);
     JUnitTestCase.assertEqualsMsg(
-        "script ${scriptIndex}",
+        "script $scriptIndex",
         _expectedName,
         variable.name);
   }
 }
 
 
 /**
  * Instances of the class `HtmlWarningCodeTest` test the generation of HTML warning codes.
  */
 class HtmlWarningCodeTest extends EngineTestCase {
@@ skipping 660 matching lines @@
    */
   int _expectedAttributeIndex = 0;
   /**
    * Assert that no errors were found while traversing any of the AST structures that have been
    * visited.
    */
   void assertValid() {
     while (_expectedTagsIndex < _expectedTagsInOrderVisited.length) {
       String expectedTag =
           _expectedTagsInOrderVisited[_expectedTagsIndex++]._tag;
-      _errors.add("Expected to visit node with tag: ${expectedTag}");
+      _errors.add("Expected to visit node with tag: $expectedTag");
     }
     if (!_errors.isEmpty) {
       StringBuffer buffer = new StringBuffer();
       buffer.write("Invalid XML structure:");
       for (String message in _errors) {
         buffer.writeln();
         buffer.write("   ");
         buffer.write(message);
       }
       JUnitTestCase.fail(buffer.toString());
@@ skipping 27 matching lines @@
       _errors.add(
           "Expected ${actual.runtimeType} to have parent of type XmlTagNode");
     }
     String actualName = actual.name;
     String actualValue = actual.valueToken.lexeme;
     if (_expectedAttributeIndex < _expectedAttributeKeyValuePairs.length) {
       String expectedName =
           _expectedAttributeKeyValuePairs[_expectedAttributeIndex];
       if (expectedName != actualName) {
         _errors.add(
-            "Expected ${(_expectedTagsIndex - 1)} tag: ${_expectedTagsInOrderVisited[_expectedTagsIndex - 1]._tag} attribute ${(_expectedAttributeIndex ~/ 2)} to have name: ${expectedName} but found: ${actualName}");
+            "Expected ${(_expectedTagsIndex - 1)} tag: ${_expectedTagsInOrderVisited[_expectedTagsIndex - 1]._tag} attribute ${(_expectedAttributeIndex ~/ 2)} to have name: $expectedName but found: $actualName");
       }
       String expectedValue =
           _expectedAttributeKeyValuePairs[_expectedAttributeIndex + 1];
       if (expectedValue != actualValue) {
         _errors.add(
-            "Expected ${(_expectedTagsIndex - 1)} tag: ${_expectedTagsInOrderVisited[_expectedTagsIndex - 1]._tag} attribute ${(_expectedAttributeIndex ~/ 2)} to have value: ${expectedValue} but found: ${actualValue}");
+            "Expected ${(_expectedTagsIndex - 1)} tag: ${_expectedTagsInOrderVisited[_expectedTagsIndex - 1]._tag} attribute ${(_expectedAttributeIndex ~/ 2)} to have value: $expectedValue but found: $actualValue");
       }
     } else {
       _errors.add(
-          "Unexpected ${(_expectedTagsIndex - 1)} tag: ${_expectedTagsInOrderVisited[_expectedTagsIndex - 1]._tag} attribute ${(_expectedAttributeIndex ~/ 2)} name: ${actualName} value: ${actualValue}");
+          "Unexpected ${(_expectedTagsIndex - 1)} tag: ${_expectedTagsInOrderVisited[_expectedTagsIndex - 1]._tag} attribute ${(_expectedAttributeIndex ~/ 2)} name: $actualName value: $actualValue");
     }
     _expectedAttributeIndex += 2;
     _validateNode(actual);
     return super.visitXmlAttributeNode(actual);
   }
   @override
   Object visitXmlTagNode(ht.XmlTagNode actual) {
     if (!(actual.parent is ht.HtmlUnit || actual.parent is ht.XmlTagNode)) {
       _errors.add(
           "Expected ${actual.runtimeType} to have parent of type HtmlUnit or XmlTagNode");
     }
     if (_expectedTagsInOrderVisited != null) {
       String actualTag = actual.tag;
       if (_expectedTagsIndex < _expectedTagsInOrderVisited.length) {
         XmlValidator_Tag expected =
             _expectedTagsInOrderVisited[_expectedTagsIndex];
         if (expected._tag != actualTag) {
           _errors.add(
-              "Expected ${_expectedTagsIndex} tag: ${expected._tag} but found: ${actualTag}");
+              "Expected $_expectedTagsIndex tag: ${expected._tag} but found: $actualTag");
         }
         _expectedAttributeKeyValuePairs = expected._attributes._keyValuePairs;
         int expectedAttributeCount =
             _expectedAttributeKeyValuePairs.length ~/
             2;
         int actualAttributeCount = actual.attributes.length;
         if (expectedAttributeCount != actualAttributeCount) {
           _errors.add(
-              "Expected ${_expectedTagsIndex} tag: ${expected._tag} to have ${expectedAttributeCount} attributes but found ${actualAttributeCount}");
+              "Expected $_expectedTagsIndex tag: ${expected._tag} to have $expectedAttributeCount attributes but found $actualAttributeCount");
         }
         _expectedAttributeIndex = 0;
         _expectedTagsIndex++;
         JUnitTestCase.assertNotNull(actual.attributeEnd);
         JUnitTestCase.assertNotNull(actual.contentEnd);
         int count = 0;
         ht.Token token = actual.attributeEnd.next;
         ht.Token lastToken = actual.contentEnd;
         while (!identical(token, lastToken)) {
           token = token.next;
           if (++count > 1000) {
             JUnitTestCase.fail(
-                "Expected ${_expectedTagsIndex} tag: ${expected._tag} to have a sequence of tokens from getAttributeEnd() to getContentEnd()");
+                "Expected $_expectedTagsIndex tag: ${expected._tag} to have a sequence of tokens from getAttributeEnd() to getContentEnd()");
             break;
           }
         }
         if (actual.attributeEnd.type == ht.TokenType.GT) {
           if (ht.HtmlParser.SELF_CLOSING.contains(actual.tag)) {
             JUnitTestCase.assertNull(actual.closingTag);
           } else {
             JUnitTestCase.assertNotNull(actual.closingTag);
           }
         } else if (actual.attributeEnd.type == ht.TokenType.SLASH_GT) {
           JUnitTestCase.assertNull(actual.closingTag);
         } else {
           JUnitTestCase.fail(
               "Unexpected attribute end token: ${actual.attributeEnd.lexeme}");
         }
         if (expected._content != null && expected._content != actual.content) {
           _errors.add(
-              "Expected ${_expectedTagsIndex} tag: ${expected._tag} to have content '${expected._content}' but found '${actual.content}'");
+              "Expected $_expectedTagsIndex tag: ${expected._tag} to have content '${expected._content}' but found '${actual.content}'");
         }
         if (expected._children.length != actual.tagNodes.length) {
           _errors.add(
-              "Expected ${_expectedTagsIndex} tag: ${expected._tag} to have ${expected._children.length} children but found ${actual.tagNodes.length}");
+              "Expected $_expectedTagsIndex tag: ${expected._tag} to have ${expected._children.length} children but found ${actual.tagNodes.length}");
         } else {
           for (int index = 0; index < expected._children.length; index++) {
             String expectedChildTag = expected._children[index]._tag;
             String actualChildTag = actual.tagNodes[index].tag;
             if (expectedChildTag != actualChildTag) {
               _errors.add(
-                  "Expected ${_expectedTagsIndex} tag: ${expected._tag} child ${index} to have tag: ${expectedChildTag} but found: ${actualChildTag}");
+                  "Expected $_expectedTagsIndex tag: ${expected._tag} child $index to have tag: $expectedChildTag but found: $actualChildTag");
             }
           }
         }
       } else {
-        _errors.add("Visited unexpected tag: ${actualTag}");
+        _errors.add("Visited unexpected tag: $actualTag");
       }
     }
     _validateNode(actual);
     return super.visitXmlTagNode(actual);
   }
   /**
    * Append the specified tags to the array in depth first order
    *
    * @param expected the array to which the tags are added (not `null`)
    * @param expectedTags the expected tags to be added (not `null`, contains no `null`s)
@@ skipping 17 matching lines @@
     if (nodeStart < 0 || nodeLength < 0) {
       _errors.add("No source info for ${node.runtimeType}");
     }
     ht.XmlNode parent = node.parent;
     if (parent != null) {
       int nodeEnd = nodeStart + nodeLength;
       int parentStart = parent.offset;
       int parentEnd = parentStart + parent.length;
       if (nodeStart < parentStart) {
         _errors.add(
-            "Invalid source start (${nodeStart}) for ${node.runtimeType} inside ${parent.runtimeType} (${parentStart})");
+            "Invalid source start ($nodeStart) for ${node.runtimeType} inside ${parent.runtimeType} ($parentStart)");
       }
       if (nodeEnd > parentEnd) {
         _errors.add(
-            "Invalid source end (${nodeEnd}) for ${node.runtimeType} inside ${parent.runtimeType} (${parentStart})");
+            "Invalid source end ($nodeEnd) for ${node.runtimeType} inside ${parent.runtimeType} ($parentStart)");
       }
     }
   }
 }
 
 
 class XmlValidator_Attributes {
   final List<String> _keyValuePairs;
   XmlValidator_Attributes(this._keyValuePairs);
 }
@@ skipping 41 matching lines @@
   void _validate(int scriptIndex, HtmlScriptElement script) {
     if (_expectedLibrary != null) {
       _validateEmbedded(scriptIndex, script);
     } else {
       _validateExternal(scriptIndex, script);
     }
   }
   void _validateEmbedded(int scriptIndex, HtmlScriptElement script) {
     if (script is! EmbeddedHtmlScriptElementImpl) {
       JUnitTestCase.fail(
-          "Expected script ${scriptIndex} to be embedded, but found ${(script != null ? script.runtimeType : "null")}");
+          "Expected script $scriptIndex to be embedded, but found ${(script != null ? script.runtimeType : "null")}");
     }
     EmbeddedHtmlScriptElementImpl embeddedScript =
         script as EmbeddedHtmlScriptElementImpl;
     _expectedLibrary._validate(scriptIndex, embeddedScript);
   }
   void _validateExternal(int scriptIndex, HtmlScriptElement script) {
     if (script is! ExternalHtmlScriptElementImpl) {
       JUnitTestCase.fail(
-          "Expected script ${scriptIndex} to be external with src=${_expectedExternalScriptName} but found ${(script != null ? script.runtimeType : "null")}");
+          "Expected script $scriptIndex to be external with src=$_expectedExternalScriptName but found ${(script != null ? script.runtimeType : "null")}");
     }
     ExternalHtmlScriptElementImpl externalScript =
         script as ExternalHtmlScriptElementImpl;
     Source scriptSource = externalScript.scriptSource;
     if (_expectedExternalScriptName == null) {
-      JUnitTestCase.assertNullMsg("script ${scriptIndex}", scriptSource);
+      JUnitTestCase.assertNullMsg("script $scriptIndex", scriptSource);
     } else {
-      JUnitTestCase.assertNotNullMsg("script ${scriptIndex}", scriptSource);
+      JUnitTestCase.assertNotNullMsg("script $scriptIndex", scriptSource);
       String actualExternalScriptName = scriptSource.shortName;
       JUnitTestCase.assertEqualsMsg(
-          "script ${scriptIndex}",
+          "script $scriptIndex",
           _expectedExternalScriptName,
           actualExternalScriptName);
     }
   }
 }