dartfmt pkg/compiler

pkg/compiler/lib/src/js_backend/namer.dart

 // Copyright (c) 2011, 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.
 
 part of js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  *
  * Names are generated through three stages:
@@ skipping 84 matching lines @@
  *
  * 3. The `is` and operator uses the following names:
  *
  *        $is<NAME>
  *        $as<NAME>
  *
  * For local variables, the [Namer] only provides *proposed names*. These names
  * must be disambiguated elsewhere.
  */
 class Namer {
-
   static const List<String> javaScriptKeywords = const <String>[
     // These are current keywords.
     "break", "delete", "function", "return", "typeof", "case", "do", "if",
     "switch", "var", "catch", "else", "in", "this", "void", "continue",
     "false", "instanceof", "throw", "while", "debugger", "finally", "new",
     "true", "with", "default", "for", "null", "try",
 
     // These are future keywords.
     "abstract", "double", "goto", "native", "static", "boolean", "enum",
     "implements", "package", "super", "byte", "export", "import", "private",
     "synchronized", "char", "extends", "int", "protected", "throws",
     "class", "final", "interface", "public", "transient", "const", "float",
     "long", "short", "volatile"
   ];
 
-  static const List<String> reservedPropertySymbols =
-      const <String>[
-        "__proto__", "prototype", "constructor", "call",
-        // "use strict" disallows the use of "arguments" and "eval" as
-        // variable names or property names. See ECMA-262, Edition 5.1,
-        // section 11.1.5 (for the property names).
-        "eval", "arguments"];
+  static const List<String> reservedPropertySymbols = const <String>[
+    "__proto__", "prototype", "constructor", "call",
+    // "use strict" disallows the use of "arguments" and "eval" as
+    // variable names or property names. See ECMA-262, Edition 5.1,
+    // section 11.1.5 (for the property names).
+    "eval", "arguments"
+  ];
 
   // Symbols that we might be using in our JS snippets.
   static const List<String> reservedGlobalSymbols = const <String>[
     // Section references are from Ecma-262
     // (http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf)
 
     // 15.1.1 Value Properties of the Global Object
     "NaN", "Infinity", "undefined",
 
     // 15.1.2 Function Properties of the Global Object
@@ skipping 106 matching lines @@
     // These keywords trigger the loading of the java-plugin. For the
     // next-generation plugin, this results in starting a new Java process.
     "java", "Packages", "netscape", "sun", "JavaObject", "JavaClass",
     "JavaArray", "JavaMember",
 
     // ES6 collections.
     "Map",
   ];
 
   static const List<String> reservedGlobalObjectNames = const <String>[
-      "A",
-      "B",
-      "C", // Global object for *C*onstants.
-      "D",
-      "E",
-      "F",
-      "G",
-      "H", // Global object for internal (*H*elper) libraries.
-      // I is used for used for the Isolate function.
-      "J", // Global object for the interceptor library.
-      "K",
-      "L",
-      "M",
-      "N",
-      "O",
-      "P", // Global object for other *P*latform libraries.
-      "Q",
-      "R",
-      "S",
-      "T",
-      "U",
-      "V",
-      "W", // Global object for *W*eb libraries (dart:html).
-      "X",
-      "Y",
-      "Z",
+    "A",
+    "B",
+    "C", // Global object for *C*onstants.
+    "D",
+    "E",
+    "F",
+    "G",
+    "H", // Global object for internal (*H*elper) libraries.
+    // I is used for used for the Isolate function.
+    "J", // Global object for the interceptor library.
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P", // Global object for other *P*latform libraries.
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W", // Global object for *W*eb libraries (dart:html).
+    "X",
+    "Y",
+    "Z",
   ];
 
   static const List<String> reservedGlobalHelperFunctions = const <String>[
-      "init",
-      "Isolate",
+    "init",
+    "Isolate",
   ];
 
   static final List<String> userGlobalObjects =
       new List.from(reservedGlobalObjectNames)
-      ..remove('C')
-      ..remove('H')
-      ..remove('J')
-      ..remove('P')
-      ..remove('W');
+        ..remove('C')
+        ..remove('H')
+        ..remove('J')
+        ..remove('P')
+        ..remove('W');
 
   Set<String> _jsReserved = null;
+
   /// Names that cannot be used by members, top level and static
   /// methods.
   Set<String> get jsReserved {
     if (_jsReserved == null) {
       _jsReserved = new Set<String>();
       _jsReserved.addAll(javaScriptKeywords);
       _jsReserved.addAll(reservedPropertySymbols);
     }
     return _jsReserved;
   }
 
   Set<String> _jsVariableReserved = null;
+
   /// Names that cannot be used by local variables and parameters.
   Set<String> get jsVariableReserved {
     if (_jsVariableReserved == null) {
       _jsVariableReserved = new Set<String>();
       _jsVariableReserved.addAll(javaScriptKeywords);
       _jsVariableReserved.addAll(reservedPropertySymbols);
       _jsVariableReserved.addAll(reservedGlobalSymbols);
       _jsVariableReserved.addAll(reservedGlobalObjectNames);
       // 26 letters in the alphabet, 25 not counting I.
       assert(reservedGlobalObjectNames.length == 25);
@@ skipping 131 matching lines @@
 
   /**
    * Some closures must contain their name. The name is stored in
    * [STATIC_CLOSURE_NAME_NAME].
    */
   String get STATIC_CLOSURE_NAME_NAME => r'$name';
   String get closureInvocationSelectorName => Identifiers.call;
   bool get shouldMinify => false;
 
   NamingScope _getPrivateScopeFor(PrivatelyNamedJSEntity entity) {
-    return _privateNamingScopes.putIfAbsent(entity.rootOfScope,
-                                            () => new NamingScope());
+    return _privateNamingScopes.putIfAbsent(
+        entity.rootOfScope, () => new NamingScope());
   }
 
   /// Returns the string that is to be used as the result of a call to
   /// [JS_GET_NAME] at [node] with argument [name].
   jsAst.Name getNameForJsGetName(Node node, JsGetName name) {
     switch (name) {
-      case JsGetName.GETTER_PREFIX: return asName(getterPrefix);
-      case JsGetName.SETTER_PREFIX: return asName(setterPrefix);
-      case JsGetName.CALL_PREFIX: return asName(callPrefix);
-      case JsGetName.CALL_PREFIX0: return asName('${callPrefix}\$0');
-      case JsGetName.CALL_PREFIX1: return asName('${callPrefix}\$1');
-      case JsGetName.CALL_PREFIX2: return asName('${callPrefix}\$2');
-      case JsGetName.CALL_PREFIX3: return asName('${callPrefix}\$3');
-      case JsGetName.CALL_CATCH_ALL: return asName(callCatchAllName);
-      case JsGetName.REFLECTABLE: return asName(reflectableField);
+      case JsGetName.GETTER_PREFIX:
+        return asName(getterPrefix);
+      case JsGetName.SETTER_PREFIX:
+        return asName(setterPrefix);
+      case JsGetName.CALL_PREFIX:
+        return asName(callPrefix);
+      case JsGetName.CALL_PREFIX0:
+        return asName('${callPrefix}\$0');
+      case JsGetName.CALL_PREFIX1:
+        return asName('${callPrefix}\$1');
+      case JsGetName.CALL_PREFIX2:
+        return asName('${callPrefix}\$2');
+      case JsGetName.CALL_PREFIX3:
+        return asName('${callPrefix}\$3');
+      case JsGetName.CALL_CATCH_ALL:
+        return asName(callCatchAllName);
+      case JsGetName.REFLECTABLE:
+        return asName(reflectableField);
       case JsGetName.CLASS_DESCRIPTOR_PROPERTY:
         return asName(classDescriptorProperty);
       case JsGetName.REQUIRED_PARAMETER_PROPERTY:
         return asName(requiredParameterField);
-      case JsGetName.DEFAULT_VALUES_PROPERTY: return asName(defaultValuesField);
-      case JsGetName.CALL_NAME_PROPERTY: return asName(callNameField);
-      case JsGetName.DEFERRED_ACTION_PROPERTY: return asName(deferredAction);
-      case JsGetName.OPERATOR_AS_PREFIX: return asName(operatorAsPrefix);
-      case JsGetName.SIGNATURE_NAME: return asName(operatorSignature);
-      case JsGetName.TYPEDEF_TAG: return asName(typedefTag);
+      case JsGetName.DEFAULT_VALUES_PROPERTY:
+        return asName(defaultValuesField);
+      case JsGetName.CALL_NAME_PROPERTY:
+        return asName(callNameField);
+      case JsGetName.DEFERRED_ACTION_PROPERTY:
+        return asName(deferredAction);
+      case JsGetName.OPERATOR_AS_PREFIX:
+        return asName(operatorAsPrefix);
+      case JsGetName.SIGNATURE_NAME:
+        return asName(operatorSignature);
+      case JsGetName.TYPEDEF_TAG:
+        return asName(typedefTag);
       case JsGetName.FUNCTION_TYPE_VOID_RETURN_TAG:
         return asName(functionTypeVoidReturnTag);
       case JsGetName.FUNCTION_TYPE_RETURN_TYPE_TAG:
         return asName(functionTypeReturnTypeTag);
       case JsGetName.FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG:
         return asName(functionTypeRequiredParametersTag);
       case JsGetName.FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG:
         return asName(functionTypeOptionalParametersTag);
       case JsGetName.FUNCTION_TYPE_NAMED_PARAMETERS_TAG:
         return asName(functionTypeNamedParametersTag);
       case JsGetName.IS_INDEXABLE_FIELD_NAME:
         return operatorIs(helpers.jsIndexingBehaviorInterface);
       case JsGetName.NULL_CLASS_TYPE_NAME:
         return runtimeTypeName(coreClasses.nullClass);
       case JsGetName.OBJECT_CLASS_TYPE_NAME:
         return runtimeTypeName(coreClasses.objectClass);
       case JsGetName.FUNCTION_CLASS_TYPE_NAME:
         return runtimeTypeName(coreClasses.functionClass);
       default:
-        reporter.reportErrorMessage(
-          node,
-          MessageKind.GENERIC,
-          {'text': 'Error: Namer has no name for "$name".'});
+        reporter.reportErrorMessage(node, MessageKind.GENERIC,
+            {'text': 'Error: Namer has no name for "$name".'});
         return asName('BROKEN');
     }
   }
 
   /// Return a reference to the given [name].
   ///
   /// This is used to ensure that every use site of a name has a unique node so
   /// that we can properly attribute source information.
   jsAst.Name _newReference(jsAst.Name name) {
     return new _NameReference(name);
@@ skipping 13 matching lines @@
       result = getFreshName(constantScope, longName);
       constantNames[constant] = result;
     }
     return _newReference(result);
   }
 
   /// Proposed name for [constant].
   String constantLongName(ConstantValue constant) {
     String longName = constantLongNames[constant];
     if (longName == null) {
-      longName = new ConstantNamingVisitor(compiler, constantHasher)
-          .getName(constant);
+      longName =
+          new ConstantNamingVisitor(compiler, constantHasher).getName(constant);
       constantLongNames[constant] = longName;
     }
     return longName;
   }
 
   String breakLabelName(LabelDefinition label) {
     return '\$${label.labelName}\$${label.target.nestingLevel}';
   }
 
   String implicitBreakLabelName(JumpTarget target) {
@@ skipping 50 matching lines @@
     String name = Elements.reconstructConstructorNameSourceString(method);
     // We include the method suffix on constructor bodies. It has no purpose,
     // but this way it produces the same names as previous versions of the
     // Namer class did.
     List<String> suffix = callSuffixForSignature(method.functionSignature);
     return '$name\$${suffix.join(r'$')}';
   }
 
   /// Name for a constructor body.
   jsAst.Name constructorBodyName(FunctionElement ctor) {
-    return _disambiguateInternalMember(ctor,
-        () => _proposeNameForConstructorBody(ctor));
+    return _disambiguateInternalMember(
+        ctor, () => _proposeNameForConstructorBody(ctor));
   }
 
   /// Annotated name for [method] encoding arity and named parameters.
   jsAst.Name instanceMethodName(FunctionElement method) {
     if (method.isGenerativeConstructorBody) {
       return constructorBodyName(method);
     }
     return invocationName(new Selector.fromElement(method));
   }
 
   String _jsNameHelper(Element e) {
     String jsInteropName = backend.nativeData.getJsInteropName(e);
-    if (jsInteropName != null && jsInteropName.isNotEmpty)
-      return jsInteropName;
+    if (jsInteropName != null && jsInteropName.isNotEmpty) return jsInteropName;
     return e.isLibrary ? 'self' : e.name;
   }
 
   /// Returns a JavaScript path specifying the context in which
   /// [element.fixedBackendName] should be evaluated. Only applicable for
   /// elements using typed JavaScript interop.
   /// For example: fixedBackendPath for the static method createMap in the
   /// Map class of the goog.map JavaScript library would have path
   /// "goog.maps.Map".
   String fixedBackendPath(Element element) {
@@ skipping 47 matching lines @@
         suffixes.add(param.name);
       }
     }
     return suffixes;
   }
 
   /// Annotated name for the member being invoked by [selector].
   jsAst.Name invocationName(Selector selector) {
     switch (selector.kind) {
       case SelectorKind.GETTER:
-        jsAst.Name disambiguatedName =
-            _disambiguateMember(selector.memberName);
+        jsAst.Name disambiguatedName = _disambiguateMember(selector.memberName);
         return deriveGetterName(disambiguatedName);
 
       case SelectorKind.SETTER:
-        jsAst.Name disambiguatedName =
-            _disambiguateMember(selector.memberName);
+        jsAst.Name disambiguatedName = _disambiguateMember(selector.memberName);
         return deriveSetterName(disambiguatedName);
 
       case SelectorKind.OPERATOR:
       case SelectorKind.INDEX:
         String operatorIdentifier = operatorNameToIdentifier(selector.name);
         jsAst.Name disambiguatedName =
             _disambiguateOperator(operatorIdentifier);
         return disambiguatedName; // Operators are not annotated.
 
       case SelectorKind.CALL:
         List<String> suffix = callSuffixForStructure(selector.callStructure);
         if (selector.name == Identifiers.call) {
           // Derive the annotated name for this variant of 'call'.
           return deriveCallMethodName(suffix);
         }
         jsAst.Name disambiguatedName =
             _disambiguateMember(selector.memberName, suffix);
         return disambiguatedName; // Methods other than call are not annotated.
 
       default:
-        reporter.internalError(
-            CURRENT_ELEMENT_SPANNABLE,
+        reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
             'Unexpected selector kind: ${selector.kind}');
         return null;
     }
   }
 
   /**
    * Returns the internal name used for an invocation mirror of this selector.
    */
-  jsAst.Name invocationMirrorInternalName(Selector selector)
-      => invocationName(selector);
+  jsAst.Name invocationMirrorInternalName(Selector selector) =>
+      invocationName(selector);
 
   /**
    * Returns the disambiguated name for the given field, used for constructing
    * the getter and setter names.
    */
   jsAst.Name fieldAccessorName(FieldElement element) {
     return element.isInstanceMember
         ? _disambiguateMember(element.memberName)
         : _disambiguateGlobal(element);
   }
@@ skipping 40 matching lines @@
 
     // Some elements, like e.g. instances of BoxFieldElement are special.
     // They are created with a unique and safe name for the element model.
     // While their name is unique, it is not very readable. So we try to
     // preserve the original, proposed name.
     // However, as boxes are not really instances of classes, the usual naming
     // scheme that tries to avoid name clashes with super classes does not
     // apply. So we can directly grab a name.
     Entity asEntity = element;
     if (asEntity is JSEntity) {
-      return _disambiguateInternalMember(element,
-                                         () => asEntity.declaredEntity.name);
+      return _disambiguateInternalMember(
+          element, () => asEntity.declaredEntity.name);
     }
 
     // If the name of the field might clash with another field,
     // use a mangled field name to avoid potential clashes.
     // Note that if the class extends a native class, that native class might
     // have fields with fixed backend names, so we assume the worst and always
     // mangle the field names of classes extending native classes.
     // Methods on such classes are stored on the interceptor, not the instance,
     // so only fields have the potential to clash with a native property name.
     ClassWorld classWorld = compiler.world;
@@ skipping 10 matching lines @@
     return _disambiguateMember(element.memberName);
   }
 
   bool _isShadowingSuperField(Element element) {
     return element.enclosingClass.hasFieldShadowedBy(element);
   }
 
   /// True if [class_] is a non-native class that inherits from a native class.
   bool _isUserClassExtendingNative(ClassElement class_) {
     return !backend.isNative(class_) &&
-           backend.isNativeOrExtendsNative(class_.superclass);
+        backend.isNativeOrExtendsNative(class_.superclass);
   }
 
   /// Annotated name for the setter of [element].
   jsAst.Name setterForElement(MemberElement element) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
     jsAst.Name name = _disambiguateMember(element.memberName);
     return deriveSetterName(name);
   }
 
@@ skipping 55 matching lines @@
 
   /// Generates a unique key for [library].
   ///
   /// Keys are meant to be used in maps and should not be visible in the output.
   String _generateLibraryKey(LibraryElement library) {
     return _libraryKeys.putIfAbsent(library, () {
       String keyBase = library.name;
       int counter = 0;
       String key = keyBase;
       while (_libraryKeys.values.contains(key)) {
-        key ="$keyBase${counter++}";
+        key = "$keyBase${counter++}";
       }
       return key;
     });
   }
 
   /// Returns the disambiguated name for a top-level or static element.
   ///
   /// The resulting name is unique within the global-member namespace.
   jsAst.Name _disambiguateGlobal(Element element) {
     // TODO(asgerf): We can reuse more short names if we disambiguate with
@@ skipping 18 matching lines @@
   ///
   /// [suffixes] denote an extension of [originalName] to distiguish it from
   /// other members with that name. These are used to encode the arity and
   /// named parameters to a method. Disambiguating the same [originalName] with
   /// different [suffixes] will yield different disambiguated names.
   ///
   /// The resulting name, and its associated annotated names, are unique
   /// to the ([originalName], [suffixes]) pair within the instance-member
   /// namespace.
   jsAst.Name _disambiguateMember(Name originalName,
-                                 [List<String> suffixes = const []]) {
+      [List<String> suffixes = const []]) {
     // Build a string encoding the library name, if the name is private.
-    String libraryKey = originalName.isPrivate
-            ? _generateLibraryKey(originalName.library)
-            : '';
+    String libraryKey =
+        originalName.isPrivate ? _generateLibraryKey(originalName.library) : '';
 
     // In the unique key, separate the name parts by '@'.
     // This avoids clashes since the original names cannot contain that symbol.
     String key = '$libraryKey@${originalName.text}@${suffixes.join('@')}';
     jsAst.Name newName = userInstanceMembers[key];
     if (newName == null) {
       String proposedName = privateName(originalName);
       if (!suffixes.isEmpty) {
         // In the proposed name, separate the name parts by '$', because the
         // proposed name must be a valid identifier, but not necessarily unique.
         proposedName += r'$' + suffixes.join(r'$');
       }
       newName = getFreshName(instanceScope, proposedName,
-                             sanitizeForAnnotations: true);
+          sanitizeForAnnotations: true);
       userInstanceMembers[key] = newName;
     }
     return _newReference(newName);
   }
 
   /// Returns the disambiguated name for the instance member identified by
   /// [key].
   ///
   /// When a name for an element is requested by key, it may not be requested
   /// by element at the same time, as two different names would be returned.
   ///
   /// If key has not yet been registered, [proposeName] is used to generate
   /// a name proposal for the given key.
   ///
   /// [key] must not clash with valid instance names. This is typically
   /// achieved by using at least one character in [key] that is not valid in
   /// identifiers, for example the @ symbol.
   jsAst.Name _disambiguateMemberByKey(String key, String proposeName()) {
     jsAst.Name newName = userInstanceMembers[key];
     if (newName == null) {
       String name = proposeName();
-      newName = getFreshName(instanceScope, name,
-                             sanitizeForAnnotations: true);
+      newName = getFreshName(instanceScope, name, sanitizeForAnnotations: true);
       userInstanceMembers[key] = newName;
     }
     return _newReference(newName);
   }
 
   /// Forces the public instance member with [originalName] to have the given
   /// [disambiguatedName].
   ///
   /// The [originalName] must not have been disambiguated before, and the
   /// [disambiguatedName] must not have been used.
   ///
   /// Using [_disambiguateMember] with the given [originalName] and no suffixes
   /// will subsequently return [disambiguatedName].
-  void reservePublicMemberName(String originalName,
-                               String disambiguatedName) {
+  void reservePublicMemberName(String originalName, String disambiguatedName) {
     // Build a key that corresponds to the one built in disambiguateMember.
     String libraryPrefix = ''; // Public names have an empty library prefix.
     String suffix = ''; // We don't need any suffixes.
     String key = '$libraryPrefix@$originalName@$suffix';
     assert(!userInstanceMembers.containsKey(key));
     assert(!instanceScope.isUsed(disambiguatedName));
     userInstanceMembers[key] = new StringBackedName(disambiguatedName);
     instanceScope.registerUse(disambiguatedName);
   }
 
   /// Disambiguated name unique to [element].
   ///
   /// This is used as the property name for fields, type variables,
   /// constructor bodies, and super-accessors.
   ///
   /// The resulting name is unique within the instance-member namespace.
-  jsAst.Name _disambiguateInternalMember(Element element,
-                                         String proposeName()) {
+  jsAst.Name _disambiguateInternalMember(
+      Element element, String proposeName()) {
     jsAst.Name newName = internalInstanceMembers[element];
     if (newName == null) {
       String name = proposeName();
 
       Entity asEntity = element;
       if (asEntity is PrivatelyNamedJSEntity) {
         NamingScope scope = _getPrivateScopeFor(asEntity);
         newName = getFreshName(scope, name,
-                               sanitizeForAnnotations: true,
-                               sanitizeForNatives: false);
+            sanitizeForAnnotations: true, sanitizeForNatives: false);
         internalInstanceMembers[element] = newName;
       } else {
         bool mayClashNative =
             _isUserClassExtendingNative(element.enclosingClass);
         newName = getFreshName(instanceScope, name,
-                               sanitizeForAnnotations: true,
-                               sanitizeForNatives: mayClashNative);
+            sanitizeForAnnotations: true, sanitizeForNatives: mayClashNative);
         internalInstanceMembers[element] = newName;
       }
     }
     return _newReference(newName);
   }
 
   /// Disambiguated name for the given operator.
   ///
   /// [operatorIdentifier] must be the operator's identifier, e.g.
   /// `$add` and not `+`.
   ///
   /// The resulting name is unique within the instance-member namespace.
   jsAst.Name _disambiguateOperator(String operatorIdentifier) {
     jsAst.Name newName = userInstanceOperators[operatorIdentifier];
     if (newName == null) {
       newName = getFreshName(instanceScope, operatorIdentifier);
       userInstanceOperators[operatorIdentifier] = newName;
     }
     return _newReference(newName);
   }
 
-  String _generateFreshStringForName(String proposedName,
-      NamingScope scope,
-      {bool sanitizeForAnnotations: false,
-       bool sanitizeForNatives: false}) {
+  String _generateFreshStringForName(String proposedName, NamingScope scope,
+      {bool sanitizeForAnnotations: false, bool sanitizeForNatives: false}) {
     if (sanitizeForAnnotations) {
       proposedName = _sanitizeForAnnotations(proposedName);
     }
     if (sanitizeForNatives) {
       proposedName = _sanitizeForNatives(proposedName);
     }
     proposedName = _sanitizeForKeywords(proposedName);
     String candidate;
     if (scope.isUnused(proposedName)) {
       candidate = proposedName;
@@ skipping 15 matching lines @@
   /// [proposedName] must be a valid JavaScript identifier.
   ///
   /// If [sanitizeForAnnotations] is `true`, then the result is guaranteed not
   /// to have the form of an annotated name.
   ///
   /// If [sanitizeForNatives] it `true`, then the result is guaranteed not to
   /// clash with a property name on a native object.
   ///
   /// Note that [MinifyNamer] overrides this method with one that produces
   /// minified names.
-  jsAst.Name getFreshName(NamingScope scope,
-                          String proposedName,
-                          {bool sanitizeForAnnotations: false,
-                           bool sanitizeForNatives: false}) {
-    String candidate =
-        _generateFreshStringForName(proposedName,
-                                    scope,
-                                    sanitizeForAnnotations:
-                                        sanitizeForAnnotations,
-                                    sanitizeForNatives: sanitizeForNatives);
+  jsAst.Name getFreshName(NamingScope scope, String proposedName,
+      {bool sanitizeForAnnotations: false, bool sanitizeForNatives: false}) {
+    String candidate = _generateFreshStringForName(proposedName, scope,
+        sanitizeForAnnotations: sanitizeForAnnotations,
+        sanitizeForNatives: sanitizeForNatives);
     return new StringBackedName(candidate);
   }
 
   /// Returns a variant of [name] that cannot clash with the annotated
   /// version of another name, that is, the resulting name can never be returned
   /// by [deriveGetterName], [deriveSetterName], [deriveCallMethodName],
   /// [operatorIs], or [substitutionName].
   ///
   /// For example, a name `get$x` would be converted to `$get$x` to ensure it
   /// cannot clash with the getter for `x`.
@@ skipping 30 matching lines @@
 
   /**
    * Returns a proposed name for the given top-level or static element.
    * The returned id is guaranteed to be a valid JS-id.
    */
   String _proposeNameForGlobal(Element element) {
     assert(!element.isInstanceMember);
     String name;
     if (element.isGenerativeConstructor) {
       name = "${element.enclosingClass.name}\$"
-             "${element.name}";
+          "${element.name}";
     } else if (element.isFactoryConstructor) {
       // TODO(johnniwinther): Change factory name encoding as to not include
       // the class-name twice.
       String className = element.enclosingClass.name;
       name = '${className}_${Elements.reconstructConstructorName(element)}';
     } else if (Elements.isStaticOrTopLevel(element)) {
       if (element.isClassMember) {
         ClassElement enclosingClass = element.enclosingClass;
         name = "${enclosingClass.name}_"
-               "${element.name}";
+            "${element.name}";
       } else {
         name = element.name.replaceAll('+', '_');
       }
     } else if (element.isLibrary) {
       LibraryElement library = element;
       name = libraryLongNames[library];
       if (name != null) return name;
       name = library.libraryOrScriptName;
       if (name.contains('.')) {
         // For libraries that have a library tag, we use the last part
         // of the fully qualified name as their base name. For all other
         // libraries, we use the first part of their filename.
         name = library.hasLibraryName
             ? name.substring(name.lastIndexOf('.') + 1)
             : name.substring(0, name.indexOf('.'));
       }
       // The filename based name can contain all kinds of nasty characters. Make
       // sure it is an identifier.
       if (!IDENTIFIER.hasMatch(name)) {
         name = name.replaceAllMapped(NON_IDENTIFIER_CHAR,
             (match) => match[0].codeUnitAt(0).toRadixString(16));
-        if (!IDENTIFIER.hasMatch(name)) {  // e.g. starts with digit.
+        if (!IDENTIFIER.hasMatch(name)) {
+          // e.g. starts with digit.
           name = 'lib_$name';
         }
       }
       // Names constructed based on a libary name will be further disambiguated.
       // However, as names from the same libary should have the same libary
       // name part, we disambiguate the library name here.
-      String disambiguated  = name;
+      String disambiguated = name;
       for (int c = 0; libraryLongNames.containsValue(disambiguated); c++) {
         disambiguated = "$name$c";
       }
       libraryLongNames[library] = disambiguated;
       name = disambiguated;
     } else {
       name = element.name;
     }
     return name;
   }
@@ skipping 36 matching lines @@
       // its element, so we treat this as a user-space global instead of an
       // internal global.
       return _disambiguateGlobal(getInterceptor);
     }
     String suffix = suffixForGetInterceptor(classes);
     return _disambiguateInternalGlobal("${getInterceptor.name}\$$suffix");
   }
 
   /// Property name used for the one-shot interceptor method for the given
   /// [selector] and return-type specialization.
-  jsAst.Name nameForGetOneShotInterceptor(Selector selector,
-                                          Iterable<ClassElement> classes) {
+  jsAst.Name nameForGetOneShotInterceptor(
+      Selector selector, Iterable<ClassElement> classes) {
     // The one-shot name is a global name derived from the invocation name.  To
     // avoid instability we would like the names to be unique and not clash with
     // other global names.
     jsAst.Name root = invocationName(selector);
 
     if (classes.contains(helpers.jsInterceptorClass)) {
       // If the base Interceptor class is in the set of intercepted classes,
       // this is the most general specialization which uses the generic
       // getInterceptor method.
       // TODO(sra): Find a way to get the simple name when Object is not in the
       // set of classes for most general variant, e.g. "$lt$n" could be "$lt".
       return new CompoundName([root, _literalDollar]);
     } else {
       String suffix = suffixForGetInterceptor(classes);
-      return new CompoundName([root, _literalDollar,
-                               new StringBackedName(suffix)]);
+      return new CompoundName(
+          [root, _literalDollar, new StringBackedName(suffix)]);
     }
   }
 
   /// Returns the runtime name for [element].
   ///
   /// This name is used as the basis for deriving `is` and `as` property names
   /// for the given type.
   ///
   /// The result is not always safe as a property name unless prefixing
   /// [operatorIsPrefix] or [operatorAsPrefix]. If this is a function type,
@@ skipping 68 matching lines @@
   /// [reservedGlobalObjectNames].
   bool _isPropertyOfStaticStateHolder(Element element) {
     // TODO(ahe): Make sure this method's documentation is always true and
     // remove the word "intend".
     return
         // TODO(ahe): Re-write these tests to be positive (so it only returns
         // true for static/top-level mutable fields). Right now, a number of
         // other elements, such as bound closures also live in
         // [staticStateHolder].
         !element.isAccessor &&
-        !element.isClass &&
-        !element.isTypedef &&
-        !element.isConstructor &&
-        !element.isFunction &&
-        !element.isLibrary;
+            !element.isClass &&
+            !element.isTypedef &&
+            !element.isConstructor &&
+            !element.isFunction &&
+            !element.isLibrary;
   }
 
   /// Returns [staticStateHolder] or one of [reservedGlobalObjectNames].
   String globalObjectFor(Element element) {
     if (_isPropertyOfStaticStateHolder(element)) return staticStateHolder;
     LibraryElement library = element.library;
     if (library == helpers.interceptorsLibrary) return 'J';
     if (library.isInternalLibrary) return 'H';
     if (library.isPlatformLibrary) {
       if ('${library.canonicalUri}' == 'dart:html') return 'W';
@@ skipping 10 matching lines @@
 
   jsAst.Name lazyInitializerName(Element element) {
     assert(Elements.isStaticOrTopLevelField(element));
     jsAst.Name name = _disambiguateGlobal(element);
     // These are not real dart getters, so do not use GetterName;
     return deriveLazyInitializerName(name);
   }
 
   jsAst.Name staticClosureName(Element element) {
     assert(Elements.isStaticOrTopLevelFunction(element));
-    String enclosing = element.enclosingClass == null
-        ? "" : element.enclosingClass.name;
+    String enclosing =
+        element.enclosingClass == null ? "" : element.enclosingClass.name;
     String library = _proposeNameForGlobal(element.library);
     return _disambiguateInternalGlobal(
         "${library}_${enclosing}_${element.name}\$closure");
   }
 
   // This name is used as part of the name of a TypeConstant
   String uniqueNameForTypeConstantElement(Element element) {
     // TODO(sra): If we replace the period with an identifier character,
     // TypeConstants will have better names in unminified code.
     String library = _proposeNameForGlobal(element.library);
@@ skipping 29 matching lines @@
   jsAst.Name getFunctionTypeName(FunctionType functionType) {
     return functionTypeNameMap.putIfAbsent(functionType, () {
       String proposedName = functionTypeNamer.computeName(functionType);
       return getFreshName(instanceScope, proposedName);
     });
   }
 
   jsAst.Name operatorIsType(DartType type) {
     if (type.isFunctionType) {
       // TODO(erikcorry): Reduce from $isx to ix when we are minifying.
-      return new CompoundName([new StringBackedName(operatorIsPrefix),
-                               _literalUnderscore,
-                               getFunctionTypeName(type)]);
+      return new CompoundName([
+        new StringBackedName(operatorIsPrefix),
+        _literalUnderscore,
+        getFunctionTypeName(type)
+      ]);
     }
     return operatorIs(type.element);
   }
 
   jsAst.Name operatorIs(ClassElement element) {
     // TODO(erikcorry): Reduce from $isx to ix when we are minifying.
-    return new CompoundName([new StringBackedName(operatorIsPrefix),
-                             runtimeTypeName(element)]);
+    return new CompoundName(
+        [new StringBackedName(operatorIsPrefix), runtimeTypeName(element)]);
   }
 
   /// Returns a name that does not clash with reserved JS keywords.
   String _sanitizeForKeywords(String name) {
     if (jsReserved.contains(name)) {
       name = '\$$name';
     }
     assert(!jsReserved.contains(name));
     return name;
   }
 
   jsAst.Name substitutionName(Element element) {
-    return new CompoundName([new StringBackedName(operatorAsPrefix),
-                             runtimeTypeName(element)]);
+    return new CompoundName(
+        [new StringBackedName(operatorAsPrefix), runtimeTypeName(element)]);
   }
 
   /// Translates a [String] into the corresponding [Name] data structure as
   /// used by the namer.
   ///
   /// If [name] is a setter or getter name, the corresponding [GetterName] or
   /// [SetterName] data structure is used.
   jsAst.Name asName(String name) {
     if (name.startsWith(getterPrefix) && name.length > getterPrefix.length) {
       return new GetterName(_literalGetterPrefix,
-                           new StringBackedName(
-                               name.substring(getterPrefix.length)));
+          new StringBackedName(name.substring(getterPrefix.length)));
     }
     if (name.startsWith(setterPrefix) && name.length > setterPrefix.length) {
       return new GetterName(_literalSetterPrefix,
-                            new StringBackedName(
-                                name.substring(setterPrefix.length)));
+          new StringBackedName(name.substring(setterPrefix.length)));
     }
 
     return new StringBackedName(name);
   }
 
   /// Returns a variable name that cannot clash with a keyword, a global
   /// variable, or any name starting with a single '$'.
   ///
   /// Furthermore, this function is injective, that is, it never returns the
   /// same name for two different inputs.
@@ skipping 87 matching lines @@
  *
  *     List_imX                // A List, with hash tag.
  *     C_Sentinel              // const Sentinel(),  "C_" added to avoid clash
  *                             //   with class name.
  *     JSInt_methods           // an interceptor.
  *     Duration_16000          // const Duration(milliseconds: 16)
  *     EventKeyProvider_keyup  // const EventKeyProvider('keyup')
  *
  */
 class ConstantNamingVisitor implements ConstantValueVisitor {
-
   static final RegExp IDENTIFIER = new RegExp(r'^[A-Za-z_$][A-Za-z0-9_$]*$');
   static const MAX_FRAGMENTS = 5;
   static const MAX_EXTRA_LENGTH = 30;
   static const DEFAULT_TAG_LENGTH = 3;
 
   final Compiler compiler;
   final ConstantCanonicalHasher hasher;
 
-  String root = null;     // First word, usually a type name.
-  bool failed = false;    // Failed to generate something pretty.
+  String root = null; // First word, usually a type name.
+  bool failed = false; // Failed to generate something pretty.
   List<String> fragments = <String>[];
   int length = 0;
 
   ConstantNamingVisitor(this.compiler, this.hasher);
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   String getName(ConstantValue constant) {
     _visit(constant);
     if (root == null) return 'CONSTANT';
     if (failed) return '${root}_${getHashTag(constant, DEFAULT_TAG_LENGTH)}';
     if (fragments.length == 1) return 'C_${root}';
     return fragments.join('_');
   }
 
   String getHashTag(ConstantValue constant, int width) =>
       hashWord(hasher.getHash(constant), width);
 
   String hashWord(int hash, int length) {
     hash &= 0x1fffffff;
     StringBuffer sb = new StringBuffer();
     for (int i = 0; i < length; i++) {
       int digit = hash % 62;
-      sb.write('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-          [digit]);
+      sb.write('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'[
+          digit]);
       hash ~/= 62;
       if (hash == 0) break;
     }
     return sb.toString();
   }
 
   void addRoot(String fragment) {
     if (root == null && fragments.isEmpty) {
       root = fragment;
     }
@@ skipping 97 matching lines @@
     }
   }
 
   @override
   void visitType(TypeConstantValue constant, [_]) {
     // Generates something like 'Type_String_k8F', using the simple name of the
     // type and a hash to disambiguate the same name in different libraries.
     addRoot('Type');
     DartType type = constant.representedType;
     String name = type.element?.name;
-    if (name == null) {  // e.g. DartType 'dynamic' has no element.
+    if (name == null) {
+      // e.g. DartType 'dynamic' has no element.
       JavaScriptBackend backend = compiler.backend;
       name = backend.rtiEncoder.getTypeRepresentationForTypeConstant(type);
     }
     addIdentifier(name);
     add(getHashTag(constant, 3));
   }
 
   @override
   void visitInterceptor(InterceptorConstantValue constant, [_]) {
     addRoot(constant.dispatchedType.element.name);
     add('methods');
   }
 
   @override
   void visitSynthetic(SyntheticConstantValue constant, [_]) {
     switch (constant.kind) {
       case SyntheticConstantKind.DUMMY_INTERCEPTOR:
         add('dummy_receiver');
         break;
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
         // Omit. These are opaque deferred indexes with nothing helpful to add.
         break;
       case SyntheticConstantKind.NAME:
         add('name');
         break;
       default:
-        reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
-                               "Unexpected SyntheticConstantValue");
+        reporter.internalError(
+            CURRENT_ELEMENT_SPANNABLE, "Unexpected SyntheticConstantValue");
     }
   }
 
   @override
   void visitDeferred(DeferredConstantValue constant, [_]) {
     addRoot('Deferred');
   }
 }
 
 /**
  * Generates canonical hash values for [ConstantValue]s.
  *
  * Unfortunately, [Constant.hashCode] is not stable under minor perturbations,
  * so it can't be used for generating names.  This hasher keeps consistency
  * between runs by basing hash values of the names of elements, rather than
  * their hashCodes.
  */
 class ConstantCanonicalHasher implements ConstantValueVisitor<int, Null> {
-
   static const _MASK = 0x1fffffff;
   static const _UINT32_LIMIT = 4 * 1024 * 1024 * 1024;
 
-
   final Compiler compiler;
   final Map<ConstantValue, int> hashes = new Map<ConstantValue, int>();
 
   ConstantCanonicalHasher(this.compiler);
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   int getHash(ConstantValue constant) => _visit(constant);
 
   int _visit(ConstantValue constant) {
@@ skipping 112 matching lines @@
   }
 
   static int _hashInt(int value) {
     if (value.abs() < _UINT32_LIMIT) return _MASK & value;
     return _hashDouble(value.toDouble());
   }
 
   static int _hashDouble(double value) {
     double magnitude = value.abs();
     int sign = value < 0 ? 1 : 0;
-    if (magnitude < _UINT32_LIMIT) {  // 2^32
+    if (magnitude < _UINT32_LIMIT) {
+      // 2^32
       int intValue = value.toInt();
       // Integer valued doubles in 32-bit range hash to the same values as ints.
       int hash = _hashInt(intValue);
       if (value == intValue) return hash;
       hash = _combine(hash, sign);
       int fraction = ((magnitude - intValue.abs()) * (_MASK + 1)).toInt();
       hash = _combine(hash, fraction);
       return hash;
     } else if (value.isInfinite) {
       return _combine(6, sign);
@@ skipping 17 matching lines @@
    * [1]: http://en.wikipedia.org/wiki/Jenkins_hash_function
    */
   static int _combine(int hash, int value) {
     hash = _MASK & (hash + value);
     hash = _MASK & (hash + (((_MASK >> 10) & hash) << 10));
     hash = hash ^ (hash >> 6);
     return hash;
   }
 
   static int _finish(int hash) {
-    hash = _MASK & (hash + (((_MASK >> 3) & hash) <<  3));
+    hash = _MASK & (hash + (((_MASK >> 3) & hash) << 3));
     hash = hash & (hash >> 11);
     return _MASK & (hash + (((_MASK >> 15) & hash) << 15));
   }
 }
 
 class FunctionTypeNamer extends BaseDartTypeVisitor {
   final Compiler compiler;
   StringBuffer sb;
 
   FunctionTypeNamer(this.compiler);
@@ skipping 19 matching lines @@
       sb.write('args${type.parameterTypes.length}');
       return;
     }
     visit(type.returnType);
     sb.write('_');
     for (DartType parameter in type.parameterTypes) {
       sb.write('_');
       visit(parameter);
     }
     bool first = false;
-    for (DartType parameter in  type.optionalParameterTypes) {
+    for (DartType parameter in type.optionalParameterTypes) {
       if (!first) {
         sb.write('_');
       }
       sb.write('_');
       visit(parameter);
       first = true;
     }
     if (!type.namedParameterTypes.isEmpty) {
       first = false;
       for (DartType parameter in type.namedParameterTypes) {
         if (!first) {
           sb.write('_');
         }
         sb.write('_');
         visit(parameter);
         first = true;
       }
     }
   }
 }
 
-
 class NamingScope {
   /// Maps proposed names to *suggested* disambiguated names.
   ///
   /// Suggested names are hints to the [MinifyNamer], suggesting that a specific
   /// names be given to the first item with the given proposed name.
   ///
   /// This is currently used in [MinifyNamer] to assign very short minified
   /// names to things that tend to be used very often.
   final Map<String, String> _suggestedNames = new Map<String, String>();
   final Set<String> _usedNames = new Set<String>();
 
   bool isUsed(String name) => _usedNames.contains(name);
   bool isUnused(String name) => !_usedNames.contains(name);
   bool registerUse(String name) => _usedNames.add(name);
 
   String suggestName(String original) => _suggestedNames[original];
   void addSuggestion(String original, String suggestion) {
     assert(!_suggestedNames.containsKey(original));
     _suggestedNames[original] = suggestion;
   }
+
   bool hasSuggestion(String original) => _suggestedNames.containsKey(original);
   bool isSuggestion(String candidate) {
     return _suggestedNames.containsValue(candidate);
   }
 }