Replace ${name} with $name where possible.

pkg/analyzer/lib/src/generated/element.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.element;
 
 import 'dart:collection';
@@ skipping 149 matching lines @@
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChildren(_properties, visitor);
     safelyVisitChildren(_scopeProperties, visitor);
     super.visitChildren(visitor);
   }
 
   @override
-  String get identifier => "AngularComponent@${_annotationOffset}";
+  String get identifier => "AngularComponent@$_annotationOffset";
 }
 
 /**
  * The interface `AngularControllerElement` defines the Angular controller described by
  * <code>Controller</code> annotation.
  */
 abstract class AngularControllerElement implements AngularHasSelectorElement {
 }
 
 /**
@@ skipping 83 matching lines @@
     this._properties = properties;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChildren(_properties, visitor);
     super.visitChildren(visitor);
   }
 
   @override
-  String get identifier => "Decorator@${_offset}";
+  String get identifier => "Decorator@$_offset";
 }
 
 /**
  * The interface `AngularElement` defines the behavior of objects representing information
  * about an Angular specific element.
  */
 abstract class AngularElement implements ToolkitObjectElement {
   /**
    * An empty array of Angular elements.
    */
@@ skipping 439 matching lines @@
    */
   AngularViewElementImpl(this.templateUri, this.templateUriOffset) : super(null, -1);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitAngularViewElement(this);
 
   @override
   ElementKind get kind => ElementKind.ANGULAR_VIEW;
 
   @override
-  String get identifier => "AngularView@${templateUriOffset}";
+  String get identifier => "AngularView@$templateUriOffset";
 }
 
 /**
  * For AST nodes that could be in both the getter and setter contexts ([IndexExpression]s and
  * [SimpleIdentifier]s), the additional resolved elements are stored in the AST node, in an
  * [AuxiliaryElements]. Since resolved elements are either statically resolved or resolved
  * using propagated type information, this class is a wrapper for a pair of
  * [ExecutableElement]s, not just a single [ExecutableElement].
  */
 class AuxiliaryElements {
@@ skipping 2626 matching lines @@
   @override
   Element get enclosingElement => _enclosingElement;
 
   @override
   String getExtendedDisplayName(String shortName) {
     if (shortName == null) {
       shortName = displayName;
     }
     Source source = this.source;
     if (source != null) {
-      return "${shortName} (${source.fullName})";
+      return "$shortName (${source.fullName})";
     }
     return shortName;
   }
 
   @override
   LibraryElement get library => getAncestor((element) => element is LibraryElement);
 
   @override
   ElementLocation get location => new ElementLocationImpl.con1(this);
 
@@ skipping 1511 matching lines @@
     if (name != null) {
       buffer.write(name);
     }
     super.appendTo(buffer);
   }
 
   @override
   String get identifier {
     String identifier = super.identifier;
     if (!isStatic) {
-      identifier += "@${nameOffset}";
+      identifier += "@$nameOffset";
     }
     return identifier;
   }
 }
 
 /**
  * The interface `FunctionType` defines the behavior common to objects representing the type
  * of a function, method, constructor, getter, or setter. Function types come in three variations:
  * <ol>
  * * The types of functions that only have required parameters. These have the general form
@@ skipping 1470 matching lines @@
     safelyVisitChild(prefix, visitor);
   }
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("import ");
     (importedLibrary as LibraryElementImpl).appendTo(buffer);
   }
 
   @override
-  String get identifier => "${(importedLibrary as LibraryElementImpl).identifier}@${nameOffset}";
+  String get identifier => "${(importedLibrary as LibraryElementImpl).identifier}@$nameOffset";
 }
 
 /**
  * The interface `InterfaceType` defines the behavior common to objects representing the type
  * introduced by either a class or an interface, or a reference to such a type.
  */
 abstract class InterfaceType implements ParameterizedType {
   /**
    * An empty array of types.
    */
@@ skipping 1080 matching lines @@
 }
 
 /**
  * Combination of [AngularTagSelectorElementImpl] and [HasAttributeSelectorElementImpl].
  */
 class IsTagHasAttributeSelectorElementImpl extends AngularSelectorElementImpl {
   String _tagName;
 
   String _attributeName;
 
-  IsTagHasAttributeSelectorElementImpl(String tagName, String attributeName) : super("${tagName}[${attributeName}]", -1) {
+  IsTagHasAttributeSelectorElementImpl(String tagName, String attributeName) : super("$tagName[$attributeName]", -1) {
     this._tagName = tagName;
     this._attributeName = attributeName;
   }
 
   @override
   bool apply(XmlTagNode node) => node.tag == _tagName && node.getAttribute(_attributeName) != null;
 
   String get attributeName => _attributeName;
 
   String get tagName => _tagName;
@@ skipping 822 matching lines @@
   }
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(type);
     buffer.write(" ");
     buffer.write(displayName);
   }
 
   @override
-  String get identifier => "${super.identifier}@${nameOffset}";
+  String get identifier => "${super.identifier}@$nameOffset";
 }
 
 /**
  * The abstract class `Member` defines the behavior common to elements that represent members
  * of parameterized types.
  */
 abstract class Member implements Element {
   /**
    * The element on which the parameterized element was created.
    */
@@ skipping 1621 matching lines @@
   void appendTo(StringBuffer buffer) {
     buffer.write(isGetter ? "get " : "set ");
     buffer.write(variable.displayName);
     super.appendTo(buffer);
   }
 
   @override
   String get identifier {
     String name = displayName;
     String suffix = isGetter ? "?" : "=";
-    return "${name}${suffix}";
+    return "$name$suffix";
   }
 }
 
 /**
  * Instances of the class `PropertyAccessorMember` represent a property accessor element
  * defined in a parameterized type where the values of the type parameters are known.
  */
 class PropertyAccessorMember extends ExecutableMember implements PropertyAccessorElement {
   /**
    * If the given property accessor's type is different when any type parameters from the defining
@@ skipping 1758 matching lines @@
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 }