Replace ${name} with $name where possible.

pkg/analyzer/lib/src/generated/source_io.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.source.io;
 
 import 'source.dart';
@@ skipping 14 matching lines @@
    * Append the system file separator to the given path unless the path already ends with a
    * separator.
    *
    * @param path the path to which the file separator is to be added
    * @return a path that ends with the system file separator
    */
   static String _appendFileSeparator(String path) {
     if (path == null || path.length <= 0 || path.codeUnitAt(path.length - 1) == JavaFile.separatorChar) {
       return path;
     }
-    return "${path}${JavaFile.separator}";
+    return "$path${JavaFile.separator}";
   }
 
   /**
    * The container's path (not `null`).
    */
   String _path;
 
   /**
    * Construct a container representing the specified directory and containing any sources whose
    * [Source#getFullName] starts with the directory's path. This is a convenience method,
@@ skipping 24 matching lines @@
    * Answer the receiver's path, used to determine if a source is contained in the receiver.
    *
    * @return the path (not `null`, not empty)
    */
   String get path => _path;
 
   @override
   int get hashCode => _path.hashCode;
 
   @override
-  String toString() => "SourceContainer[${_path}]";
+  String toString() => "SourceContainer[$_path]";
 }
 
 /**
  * Instances of the class `FileBasedSource` implement a source that represents a file.
  */
 class FileBasedSource implements Source {
   /**
    * The URI from which this source was originally derived.
    */
   final Uri uri;
@@ skipping 77 matching lines @@
 
   @override
   Uri resolveRelativeUri(Uri containedUri) {
     try {
       Uri baseUri = uri;
       bool isOpaque = uri.isAbsolute && !uri.path.startsWith('/');
       if (isOpaque) {
         String scheme = uri.scheme;
         String part = uri.path;
         if (scheme == DartUriResolver.DART_SCHEME && part.indexOf('/') < 0) {
-          part = "${part}/${part}.dart";
+          part = "$part/$part.dart";
         }
-        baseUri = parseUriWithException("${scheme}:/${part}");
+        baseUri = parseUriWithException("$scheme:/$part");
       }
       Uri result = baseUri.resolveUri(containedUri);
       if (isOpaque) {
         result = parseUriWithException("${result.scheme}:${result.path.substring(1)}");
       }
       return result;
     } catch (exception, stackTrace) {
-      throw new AnalysisException("Could not resolve URI (${containedUri}) relative to source (${uri})", new CaughtException(exception, stackTrace));
+      throw new AnalysisException("Could not resolve URI ($containedUri) relative to source ($uri)", new CaughtException(exception, stackTrace));
     }
   }
 
   @override
   String toString() {
     if (file == null) {
       return "<unknown source>";
     }
     return file.getAbsolutePath();
   }
@@ skipping 203 matching lines @@
     if (source is FileBasedSource) {
       String sourcePath = source.file.getPath();
       for (JavaFile packagesDirectory in _packagesDirectories) {
         List<JavaFile> pkgFolders = packagesDirectory.listFiles();
         if (pkgFolders != null) {
           for (JavaFile pkgFolder in pkgFolders) {
             try {
               String pkgCanonicalPath = pkgFolder.getCanonicalPath();
               if (sourcePath.startsWith(pkgCanonicalPath)) {
                 String relPath = sourcePath.substring(pkgCanonicalPath.length);
-                return parseUriWithException("${PACKAGE_SCHEME}:${pkgFolder.getName()}${relPath}");
+                return parseUriWithException("$PACKAGE_SCHEME:${pkgFolder.getName()}$relPath");
               }
             } catch (e) {
             }
           }
         }
       }
     }
     return null;
   }
 
   /**
    * Answer the canonical file for the specified package.
    *
    * @param packagesDirectory the "packages" directory (not `null`)
    * @param pkgName the package name (not `null`, not empty)
    * @param relPath the path relative to the package directory (not `null`, no leading slash,
    *          but may be empty string)
    * @return the file (not `null`)
    */
   JavaFile getCanonicalFile(JavaFile packagesDirectory, String pkgName, String relPath) {
     JavaFile pkgDir = new JavaFile.relative(packagesDirectory, pkgName);
     try {
       pkgDir = pkgDir.getCanonicalFile();
     } on JavaIOException catch (e) {
       if (!e.toString().contains("Required key not available")) {
-        AnalysisEngine.instance.logger.logError2("Canonical failed: ${pkgDir}", e);
+        AnalysisEngine.instance.logger.logError2("Canonical failed: $pkgDir", e);
       } else if (_CanLogRequiredKeyIoException) {
         _CanLogRequiredKeyIoException = false;
-        AnalysisEngine.instance.logger.logError2("Canonical failed: ${pkgDir}", e);
+        AnalysisEngine.instance.logger.logError2("Canonical failed: $pkgDir", e);
       }
     }
     return new JavaFile.relative(pkgDir, relPath.replaceAll('/', new String.fromCharCode(JavaFile.separatorChar)));
   }
 
   /**
    * @return `true` if "file" was found in "packagesDir", and it is part of the "lib" folder
    *         of the application that contains in this "packagesDir".
    */
   bool _isSelfReference(JavaFile packagesDir, JavaFile file) {
     JavaFile rootDir = packagesDir.getParentFile();
     if (rootDir == null) {
       return false;
     }
     String rootPath = rootDir.getAbsolutePath();
     String filePath = file.getAbsolutePath();
-    return filePath.startsWith("${rootPath}/lib");
+    return filePath.startsWith("$rootPath/lib");
   }
 }
 
 /**
  * Instances of the class `RelativeFileUriResolver` resolve `file` URI's.
  */
 class RelativeFileUriResolver extends UriResolver {
   /**
    * The name of the `file` scheme.
    */
@@ skipping 32 matching lines @@
       for (JavaFile dir in _relativeDirectories) {
         JavaFile file = new JavaFile.relative(dir, filePath);
         if (file.exists()) {
           return new FileBasedSource.con2(uri, file);
         }
       }
     }
     return null;
   }
 }