pkg/compiler/lib/src/js_backend/minify_namer.dart - sdk.git - Git at Google

 // 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.namer;

 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  */
 class MinifyNamer extends Namer
     with
         _MinifiedFieldNamer,
         _MinifyConstructorBodyNamer,
         _MinifiedOneShotInterceptorNamer {
   MinifyNamer(JClosedWorld closedWorld, CodegenWorldBuilder codegenWorldBuilder)
       : super(closedWorld, codegenWorldBuilder) {
     reserveBackendNames();
     fieldRegistry = new _FieldNamingRegistry(this);
   }

   _FieldNamingRegistry fieldRegistry;

   String get isolateName => 'I';
   String get isolatePropertiesName => 'p';
   bool get shouldMinify => true;

   final String getterPrefix = 'g';
   final String setterPrefix = 's';
   final String callPrefix = ''; // this will create function names $<n>
   String get requiredParameterField => r'$R';
   String get defaultValuesField => r'$D';
   String get operatorSignature => r'$S';
   String get genericInstantiationPrefix => r'$I';

   final ALPHABET_CHARACTERS = 52; // a-zA-Z.
   final ALPHANUMERIC_CHARACTERS = 62; // a-zA-Z0-9.

   /// You can pass an invalid identifier to this and unlike its non-minifying
   /// counterpart it will never return the proposedName as the new fresh name.
   ///
   /// [sanitizeForNatives] and [sanitizeForAnnotations] are ignored because the
   /// minified names will always avoid clashing with annotated names or natives.
   @override
   String _generateFreshStringForName(String proposedName, NamingScope scope,
       {bool sanitizeForNatives: false, bool sanitizeForAnnotations: false}) {
     String freshName;
     String suggestion = scope.suggestName(proposedName);
     if (suggestion != null && scope.isUnused(suggestion)) {
       freshName = suggestion;
     } else {
       freshName = _getUnusedName(proposedName, scope);
     }
     scope.registerUse(freshName);
     return freshName;
   }

   // From issue 7554.  These should not be used on objects (as instance
   // variables) because they clash with names from the DOM. However, it is
   // OK to use them as fields, as we only access fields directly if we know
   // the receiver type.
   static const List<String> _reservedNativeProperties = const <String>[
     'a', 'b', 'c', 'd', 'e', 'f', 'r', 'x', 'y', 'z', 'Q',
     // 2-letter:
     'ch', 'cx', 'cy', 'db', 'dx', 'dy', 'fr', 'fx', 'fy', 'go', 'id', 'k1',
     'k2', 'k3', 'k4', 'r1', 'r2', 'rx', 'ry', 'x1', 'x2', 'y1', 'y2',
     // 3-letter:
     'add', 'all', 'alt', 'arc', 'CCW', 'cmp', 'dir', 'end', 'get', 'in1',
     'in2', 'INT', 'key', 'log', 'low', 'm11', 'm12', 'm13', 'm14', 'm21',
     'm22', 'm23', 'm24', 'm31', 'm32', 'm33', 'm34', 'm41', 'm42', 'm43',
     'm44', 'max', 'min', 'now', 'ONE', 'put', 'red', 'rel', 'rev', 'RGB',
     'sdp', 'set', 'src', 'tag', 'top', 'uid', 'uri', 'url', 'URL',
     // 4-letter:
     'abbr', 'atob', 'Attr', 'axes', 'axis', 'back', 'BACK', 'beta', 'bias',
     'Blob', 'blue', 'blur', 'BLUR', 'body', 'BOOL', 'BOTH', 'btoa', 'BYTE',
     'cite', 'clip', 'code', 'cols', 'cues', 'data', 'DECR', 'DONE', 'face',
     'file', 'File', 'fill', 'find', 'font', 'form', 'gain', 'hash', 'head',
     'high', 'hint', 'host', 'href', 'HRTF', 'IDLE', 'INCR', 'info', 'INIT',
     'isId', 'item', 'KEEP', 'kind', 'knee', 'lang', 'left', 'LESS', 'line',
     'link', 'list', 'load', 'loop', 'mode', 'name', 'Node', 'None', 'NONE',
     'only', 'open', 'OPEN', 'ping', 'play', 'port', 'rect', 'Rect', 'refX',
     'refY', 'RGBA', 'root', 'rows', 'save', 'seed', 'seek', 'self', 'send',
     'show', 'SINE', 'size', 'span', 'stat', 'step', 'stop', 'tags', 'text',
     'Text', 'time', 'type', 'view', 'warn', 'wrap', 'ZERO'
   ];

   void reserveBackendNames() {
     for (String name in _reservedNativeProperties) {
       if (name.length < 2) {
         // Ensure the 1-letter names are disambiguated to the same name.
         String disambiguatedName = name;
         reservePublicMemberName(name, disambiguatedName);
       }
       instanceScope.registerUse(name);
       // Getter and setter names are autogenerated by prepending 'g' and 's' to
       // field names.  Therefore there are some field names we don't want to
       // use.  It is implicit in the next line that the banned prefix is
       // only one character.
       if (_hasBannedPrefix(name)) {
         instanceScope.registerUse(name.substring(1));
       }
     }

     // These popular names are present in most programs and deserve
     // single character minified names.  We could determine the popular names
     // individually per program, but that would mean that the output of the
     // minifier was less stable from version to version of the program being
     // minified.
     _populateSuggestedNames(instanceScope, const <String>[
       r'$add',
       r'add$1',
       r'$and',
       r'$or',
       r'current',
       r'$shr',
       r'$eq',
       r'$ne',
       r'$index',
       r'$indexSet',
       r'$xor',
       r'clone$0',
       r'iterator',
       r'length',
       r'$lt',
       r'$gt',
       r'$le',
       r'$ge',
       r'moveNext$0',
       r'node',
       r'on',
       r'$negate',
       r'push',
       r'self',
       r'start',
       r'target',
       r'$shl',
       r'value',
       r'width',
       r'style',
       r'noSuchMethod$1',
       r'$mul',
       r'$div',
       r'$sub',
       r'$not',
       r'$mod',
       r'$tdiv',
       r'toString$0'
     ]);

     _populateSuggestedNames(globalScope, const <String>[
       r'Object',
       'wrapException',
       r'$eq',
       r'S',
       r'ioore',
       r'UnsupportedError$',
       r'length',
       r'$sub',
       r'$add',
       r'$gt',
       r'$ge',
       r'$lt',
       r'$le',
       r'add',
       r'iae',
       r'ArgumentError$',
       r'BoundClosure',
       r'Closure',
       r'StateError$',
       r'getInterceptor',
       r'max',
       r'$mul',
       r'Map',
       r'Key_Key',
       r'$div',
       r'List_List$from',
       r'LinkedHashMap_LinkedHashMap$_empty',
       r'LinkedHashMap_LinkedHashMap$_literal',
       r'min',
       r'RangeError$value',
       r'JSString',
       r'JSNumber',
       r'JSArray',
       r'createInvocationMirror',
       r'String',
       r'setRuntimeTypeInfo',
       r'createRuntimeType'
     ]);
   }

   void _populateSuggestedNames(NamingScope scope, List<String> suggestions) {
     int c = $a - 1;
     String letter;
     for (String name in suggestions) {
       do {
         assert(c != $Z);
         c = (c == $z) ? $A : c + 1;
         letter = new String.fromCharCodes([c]);
       } while (_hasBannedPrefix(letter) || scope.isUsed(letter));
       assert(!scope.hasSuggestion(name));
       scope.addSuggestion(name, letter);
     }
   }

   // This gets a minified name based on a hash of the proposed name.  This
   // is slightly less efficient than just getting the next name in a series,
   // but it means that small changes in the input program will give smallish
   // changes in the output, which can be useful for diffing etc.
   String _getUnusedName(String proposedName, NamingScope scope) {
     int hash = _calculateHash(proposedName);
     // Avoid very small hashes that won't try many names.
     hash = hash < 1000 ? hash * 314159 : hash; // Yes, it's prime.

     // Try other n-character names based on the hash.  We try one to three
     // character identifiers.  For each length we try around 10 different names
     // in a predictable order determined by the proposed name.  This is in order
     // to make the renamer stable: small changes in the input should nornally
     // result in relatively small changes in the output.
     for (int n = 1; n <= 3; n++) {
       int h = hash;
       while (h > 10) {
         List<int> codes = <int>[_letterNumber(h)];
         int h2 = h ~/ ALPHABET_CHARACTERS;
         for (int i = 1; i < n; i++) {
           codes.add(_alphaNumericNumber(h2));
           h2 ~/= ALPHANUMERIC_CHARACTERS;
         }
         final candidate = new String.fromCharCodes(codes);
         if (scope.isUnused(candidate) &&
             !jsReserved.contains(candidate) &&
             !_hasBannedPrefix(candidate) &&
             (n != 1 || scope.isSuggestion(candidate))) {
           return candidate;
         }
         // Try again with a slightly different hash.  After around 10 turns
         // around this loop h is zero and we try a longer name.
         h ~/= 7;
       }
     }
     return _badName(hash, scope);
   }

   /// Instance members starting with g and s are reserved for getters and
   /// setters.
   static bool _hasBannedPrefix(String name) {
     int code = name.codeUnitAt(0);
     return code == $g || code == $s;
   }

   int _calculateHash(String name) {
     int h = 0;
     for (int i = 0; i < name.length; i++) {
       h += name.codeUnitAt(i);
       h &= 0xffffffff;
       h += h << 10;
       h &= 0xffffffff;
       h ^= h >> 6;
       h &= 0xffffffff;
     }
     return h;
   }

   /// Remember bad hashes to avoid using a the same character with long numbers
   /// for frequent hashes. For example, `closure` is a very common name.
   Map<int, int> _badNames = new Map<int, int>();

   /// If we can't find a hash based name in the three-letter space, then base
   /// the name on a letter and a counter.
   String _badName(int hash, NamingScope scope) {
     int count = _badNames.putIfAbsent(hash, () => 0);
     String startLetter =
         new String.fromCharCodes([_letterNumber(hash + count)]);
     _badNames[hash] = count + 1;
     String name;
     int i = 0;
     do {
       name = "$startLetter${i++}";
     } while (scope.isUsed(name));
     // We don't need to check for banned prefix because the name is in the form
     // xnnn, where nnn is a number.  There can be no getter or setter called
     // gnnn since that would imply a numeric field name.
     return name;
   }

   int _letterNumber(int x) {
     if (x >= ALPHABET_CHARACTERS) x %= ALPHABET_CHARACTERS;
     if (x < 26) return $a + x;
     return $A + x - 26;
   }

   int _alphaNumericNumber(int x) {
     if (x >= ALPHANUMERIC_CHARACTERS) x %= ALPHANUMERIC_CHARACTERS;
     if (x < 26) return $a + x;
     if (x < 52) return $A + x - 26;
     return $0 + x - 52;
   }

   @override
   jsAst.Name instanceFieldPropertyName(FieldEntity element) {
     jsAst.Name proposed = _minifiedInstanceFieldPropertyName(element);
     if (proposed != null) {
       return proposed;
     }
     return super.instanceFieldPropertyName(element);
   }
 }

 /// Implements naming for constructor bodies.
 ///
 /// Constructor bodies are only called in settings where the target is
 /// statically known. Therefore, we can share their names between classes.
 /// However, to support calling the constructor body of a super constructor,
 /// each level in the inheritance tree has to use its own names.
 ///
 /// This class implements a naming scheme by counting the distance from
 /// a given constructor to [Object], where distance is the number of
 /// constructors declared along the inheritance chain.
 class _ConstructorBodyNamingScope {
   final int _startIndex;
   final List<ConstructorEntity> _constructors;
   int get numberOfConstructors => _constructors.length;

   _ConstructorBodyNamingScope.rootScope(
       ClassEntity cls, ElementEnvironment environment)
       : _startIndex = 0,
         _constructors = _getConstructorList(cls, environment);

   _ConstructorBodyNamingScope.forClass(ClassEntity cls,
       _ConstructorBodyNamingScope superScope, ElementEnvironment environment)
       : _startIndex = superScope._startIndex + superScope.numberOfConstructors,
         _constructors = _getConstructorList(cls, environment);

   // Mixin Applications have constructors but we never generate code for them,
   // so they do not count in the inheritance chain.
   _ConstructorBodyNamingScope.forMixinApplication(
       ClassEntity cls, _ConstructorBodyNamingScope superScope)
       : _startIndex = superScope._startIndex + superScope.numberOfConstructors,
         _constructors = const [];

   factory _ConstructorBodyNamingScope(
       ClassEntity cls,
       Map<ClassEntity, _ConstructorBodyNamingScope> registry,
       ElementEnvironment environment) {
     return registry.putIfAbsent(cls, () {
       ClassEntity superclass = environment.getSuperClass(cls);
       if (superclass == null) {
         return new _ConstructorBodyNamingScope.rootScope(cls, environment);
       } else if (environment.isMixinApplication(cls)) {
         return new _ConstructorBodyNamingScope.forMixinApplication(cls,
             new _ConstructorBodyNamingScope(superclass, registry, environment));
       } else {
         return new _ConstructorBodyNamingScope.forClass(
             cls,
             new _ConstructorBodyNamingScope(superclass, registry, environment),
             environment);
       }
     });
   }

   String constructorBodyKeyFor(ConstructorBodyEntity body) {
     int position = _constructors.indexOf(body.constructor);
     assert(position >= 0, failedAt(body, "constructor body missing"));
     return "@constructorBody@${_startIndex + position}";
   }

   static List<ConstructorEntity> _getConstructorList(
       ClassEntity cls, ElementEnvironment environment) {
     var result = <ConstructorEntity>[];
     environment.forEachConstructor(cls, result.add);
     return result;
   }
 }

 abstract class _MinifyConstructorBodyNamer implements Namer {
   Map<ClassEntity, _ConstructorBodyNamingScope> _constructorBodyScopes =
       new Map<ClassEntity, _ConstructorBodyNamingScope>();

   @override
   jsAst.Name constructorBodyName(ConstructorBodyEntity method) {
     _ConstructorBodyNamingScope scope = new _ConstructorBodyNamingScope(
         method.enclosingClass, _constructorBodyScopes, elementEnvironment);
     String key = scope.constructorBodyKeyFor(method);
     return _disambiguateMemberByKey(
         key, () => _proposeNameForConstructorBody(method));
   }
 }

 abstract class _MinifiedOneShotInterceptorNamer implements Namer {
   /// Property name used for the one-shot interceptor method for the given
   /// [selector] and return-type specialization.
   @override
   jsAst.Name nameForGetOneShotInterceptor(
       Selector selector, Iterable<ClassEntity> classes) {
     String root = selector.isOperator
         ? operatorNameToIdentifier(selector.name)
         : privateName(selector.memberName);
     String prefix =
         selector.isGetter ? r"$get" : selector.isSetter ? r"$set" : "";
     String callSuffix = selector.isCall
         ? Namer.callSuffixForStructure(selector.callStructure).join()
         : "";
     String suffix = suffixForGetInterceptor(classes);
     String fullName = "\$intercepted$prefix\$$root$callSuffix\$$suffix";
     return _disambiguateInternalGlobal(fullName);
   }
 }
	// 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.namer;

	/**
	* Assigns JavaScript identifiers to Dart variables, class-names and members.
	*/
	class MinifyNamer extends Namer
	with
	_MinifiedFieldNamer,
	_MinifyConstructorBodyNamer,
	_MinifiedOneShotInterceptorNamer {
	MinifyNamer(JClosedWorld closedWorld, CodegenWorldBuilder codegenWorldBuilder)
	: super(closedWorld, codegenWorldBuilder) {
	reserveBackendNames();
	fieldRegistry = new _FieldNamingRegistry(this);
	}

	_FieldNamingRegistry fieldRegistry;

	String get isolateName => 'I';
	String get isolatePropertiesName => 'p';
	bool get shouldMinify => true;

	final String getterPrefix = 'g';
	final String setterPrefix = 's';
	final String callPrefix = ''; // this will create function names $<n>
	String get requiredParameterField => r'$R';
	String get defaultValuesField => r'$D';
	String get operatorSignature => r'$S';
	String get genericInstantiationPrefix => r'$I';

	final ALPHABET_CHARACTERS = 52; // a-zA-Z.
	final ALPHANUMERIC_CHARACTERS = 62; // a-zA-Z0-9.

	/// You can pass an invalid identifier to this and unlike its non-minifying
	/// counterpart it will never return the proposedName as the new fresh name.
	///
	/// [sanitizeForNatives] and [sanitizeForAnnotations] are ignored because the
	/// minified names will always avoid clashing with annotated names or natives.
	@override
	String _generateFreshStringForName(String proposedName, NamingScope scope,
	{bool sanitizeForNatives: false, bool sanitizeForAnnotations: false}) {
	String freshName;
	String suggestion = scope.suggestName(proposedName);
	if (suggestion != null && scope.isUnused(suggestion)) {
	freshName = suggestion;
	} else {
	freshName = _getUnusedName(proposedName, scope);
	}
	scope.registerUse(freshName);
	return freshName;
	}

	// From issue 7554. These should not be used on objects (as instance
	// variables) because they clash with names from the DOM. However, it is
	// OK to use them as fields, as we only access fields directly if we know
	// the receiver type.
	static const List<String> _reservedNativeProperties = const <String>[
	'a', 'b', 'c', 'd', 'e', 'f', 'r', 'x', 'y', 'z', 'Q',
	// 2-letter:
	'ch', 'cx', 'cy', 'db', 'dx', 'dy', 'fr', 'fx', 'fy', 'go', 'id', 'k1',
	'k2', 'k3', 'k4', 'r1', 'r2', 'rx', 'ry', 'x1', 'x2', 'y1', 'y2',
	// 3-letter:
	'add', 'all', 'alt', 'arc', 'CCW', 'cmp', 'dir', 'end', 'get', 'in1',
	'in2', 'INT', 'key', 'log', 'low', 'm11', 'm12', 'm13', 'm14', 'm21',
	'm22', 'm23', 'm24', 'm31', 'm32', 'm33', 'm34', 'm41', 'm42', 'm43',
	'm44', 'max', 'min', 'now', 'ONE', 'put', 'red', 'rel', 'rev', 'RGB',
	'sdp', 'set', 'src', 'tag', 'top', 'uid', 'uri', 'url', 'URL',
	// 4-letter:
	'abbr', 'atob', 'Attr', 'axes', 'axis', 'back', 'BACK', 'beta', 'bias',
	'Blob', 'blue', 'blur', 'BLUR', 'body', 'BOOL', 'BOTH', 'btoa', 'BYTE',
	'cite', 'clip', 'code', 'cols', 'cues', 'data', 'DECR', 'DONE', 'face',
	'file', 'File', 'fill', 'find', 'font', 'form', 'gain', 'hash', 'head',
	'high', 'hint', 'host', 'href', 'HRTF', 'IDLE', 'INCR', 'info', 'INIT',
	'isId', 'item', 'KEEP', 'kind', 'knee', 'lang', 'left', 'LESS', 'line',
	'link', 'list', 'load', 'loop', 'mode', 'name', 'Node', 'None', 'NONE',
	'only', 'open', 'OPEN', 'ping', 'play', 'port', 'rect', 'Rect', 'refX',
	'refY', 'RGBA', 'root', 'rows', 'save', 'seed', 'seek', 'self', 'send',
	'show', 'SINE', 'size', 'span', 'stat', 'step', 'stop', 'tags', 'text',
	'Text', 'time', 'type', 'view', 'warn', 'wrap', 'ZERO'
	];

	void reserveBackendNames() {
	for (String name in _reservedNativeProperties) {
	if (name.length < 2) {
	// Ensure the 1-letter names are disambiguated to the same name.
	String disambiguatedName = name;
	reservePublicMemberName(name, disambiguatedName);
	}
	instanceScope.registerUse(name);
	// Getter and setter names are autogenerated by prepending 'g' and 's' to
	// field names. Therefore there are some field names we don't want to
	// use. It is implicit in the next line that the banned prefix is
	// only one character.
	if (_hasBannedPrefix(name)) {
	instanceScope.registerUse(name.substring(1));
	}
	}

	// These popular names are present in most programs and deserve
	// single character minified names. We could determine the popular names
	// individually per program, but that would mean that the output of the
	// minifier was less stable from version to version of the program being
	// minified.
	_populateSuggestedNames(instanceScope, const <String>[
	r'$add',
	r'add$1',
	r'$and',
	r'$or',
	r'current',
	r'$shr',
	r'$eq',
	r'$ne',
	r'$index',
	r'$indexSet',
	r'$xor',
	r'clone$0',
	r'iterator',
	r'length',
	r'$lt',
	r'$gt',
	r'$le',
	r'$ge',
	r'moveNext$0',
	r'node',
	r'on',
	r'$negate',
	r'push',
	r'self',
	r'start',
	r'target',
	r'$shl',
	r'value',
	r'width',
	r'style',
	r'noSuchMethod$1',
	r'$mul',
	r'$div',
	r'$sub',
	r'$not',
	r'$mod',
	r'$tdiv',
	r'toString$0'
	]);

	_populateSuggestedNames(globalScope, const <String>[
	r'Object',
	'wrapException',
	r'$eq',
	r'S',
	r'ioore',
	r'UnsupportedError$',
	r'length',
	r'$sub',
	r'$add',
	r'$gt',
	r'$ge',
	r'$lt',
	r'$le',
	r'add',
	r'iae',
	r'ArgumentError$',
	r'BoundClosure',
	r'Closure',
	r'StateError$',
	r'getInterceptor',
	r'max',
	r'$mul',
	r'Map',
	r'Key_Key',
	r'$div',
	r'List_List$from',
	r'LinkedHashMap_LinkedHashMap$_empty',
	r'LinkedHashMap_LinkedHashMap$_literal',
	r'min',
	r'RangeError$value',
	r'JSString',
	r'JSNumber',
	r'JSArray',
	r'createInvocationMirror',
	r'String',
	r'setRuntimeTypeInfo',
	r'createRuntimeType'
	]);
	}

	void _populateSuggestedNames(NamingScope scope, List<String> suggestions) {
	int c = $a - 1;
	String letter;
	for (String name in suggestions) {
	do {
	assert(c != $Z);
	c = (c == $z) ? $A : c + 1;
	letter = new String.fromCharCodes([c]);
	} while (_hasBannedPrefix(letter) \|\| scope.isUsed(letter));
	assert(!scope.hasSuggestion(name));
	scope.addSuggestion(name, letter);
	}
	}

	// This gets a minified name based on a hash of the proposed name. This
	// is slightly less efficient than just getting the next name in a series,
	// but it means that small changes in the input program will give smallish
	// changes in the output, which can be useful for diffing etc.
	String _getUnusedName(String proposedName, NamingScope scope) {
	int hash = _calculateHash(proposedName);
	// Avoid very small hashes that won't try many names.
	hash = hash < 1000 ? hash * 314159 : hash; // Yes, it's prime.

	// Try other n-character names based on the hash. We try one to three
	// character identifiers. For each length we try around 10 different names
	// in a predictable order determined by the proposed name. This is in order
	// to make the renamer stable: small changes in the input should nornally
	// result in relatively small changes in the output.
	for (int n = 1; n <= 3; n++) {
	int h = hash;
	while (h > 10) {
	List<int> codes = <int>[_letterNumber(h)];
	int h2 = h ~/ ALPHABET_CHARACTERS;
	for (int i = 1; i < n; i++) {
	codes.add(_alphaNumericNumber(h2));
	h2 ~/= ALPHANUMERIC_CHARACTERS;
	}
	final candidate = new String.fromCharCodes(codes);
	if (scope.isUnused(candidate) &&
	!jsReserved.contains(candidate) &&
	!_hasBannedPrefix(candidate) &&
	(n != 1 \|\| scope.isSuggestion(candidate))) {
	return candidate;
	}
	// Try again with a slightly different hash. After around 10 turns
	// around this loop h is zero and we try a longer name.
	h ~/= 7;
	}
	}
	return _badName(hash, scope);
	}

	/// Instance members starting with g and s are reserved for getters and
	/// setters.
	static bool _hasBannedPrefix(String name) {
	int code = name.codeUnitAt(0);
	return code == $g \|\| code == $s;
	}

	int _calculateHash(String name) {
	int h = 0;
	for (int i = 0; i < name.length; i++) {
	h += name.codeUnitAt(i);
	h &= 0xffffffff;
	h += h << 10;
	h &= 0xffffffff;
	h ^= h >> 6;
	h &= 0xffffffff;
	}
	return h;
	}

	/// Remember bad hashes to avoid using a the same character with long numbers
	/// for frequent hashes. For example, `closure` is a very common name.
	Map<int, int> _badNames = new Map<int, int>();

	/// If we can't find a hash based name in the three-letter space, then base
	/// the name on a letter and a counter.
	String _badName(int hash, NamingScope scope) {
	int count = _badNames.putIfAbsent(hash, () => 0);
	String startLetter =
	new String.fromCharCodes([_letterNumber(hash + count)]);
	_badNames[hash] = count + 1;
	String name;
	int i = 0;
	do {
	name = "$startLetter${i++}";
	} while (scope.isUsed(name));
	// We don't need to check for banned prefix because the name is in the form
	// xnnn, where nnn is a number. There can be no getter or setter called
	// gnnn since that would imply a numeric field name.
	return name;
	}

	int _letterNumber(int x) {
	if (x >= ALPHABET_CHARACTERS) x %= ALPHABET_CHARACTERS;
	if (x < 26) return $a + x;
	return $A + x - 26;
	}

	int _alphaNumericNumber(int x) {
	if (x >= ALPHANUMERIC_CHARACTERS) x %= ALPHANUMERIC_CHARACTERS;
	if (x < 26) return $a + x;
	if (x < 52) return $A + x - 26;
	return $0 + x - 52;
	}

	@override
	jsAst.Name instanceFieldPropertyName(FieldEntity element) {
	jsAst.Name proposed = _minifiedInstanceFieldPropertyName(element);
	if (proposed != null) {
	return proposed;
	}
	return super.instanceFieldPropertyName(element);
	}
	}

	/// Implements naming for constructor bodies.
	///
	/// Constructor bodies are only called in settings where the target is
	/// statically known. Therefore, we can share their names between classes.
	/// However, to support calling the constructor body of a super constructor,
	/// each level in the inheritance tree has to use its own names.
	///
	/// This class implements a naming scheme by counting the distance from
	/// a given constructor to [Object], where distance is the number of
	/// constructors declared along the inheritance chain.
	class _ConstructorBodyNamingScope {
	final int _startIndex;
	final List<ConstructorEntity> _constructors;
	int get numberOfConstructors => _constructors.length;

	_ConstructorBodyNamingScope.rootScope(
	ClassEntity cls, ElementEnvironment environment)
	: _startIndex = 0,
	_constructors = _getConstructorList(cls, environment);

	_ConstructorBodyNamingScope.forClass(ClassEntity cls,
	_ConstructorBodyNamingScope superScope, ElementEnvironment environment)
	: _startIndex = superScope._startIndex + superScope.numberOfConstructors,
	_constructors = _getConstructorList(cls, environment);

	// Mixin Applications have constructors but we never generate code for them,
	// so they do not count in the inheritance chain.
	_ConstructorBodyNamingScope.forMixinApplication(
	ClassEntity cls, _ConstructorBodyNamingScope superScope)
	: _startIndex = superScope._startIndex + superScope.numberOfConstructors,
	_constructors = const [];

	factory _ConstructorBodyNamingScope(
	ClassEntity cls,
	Map<ClassEntity, _ConstructorBodyNamingScope> registry,
	ElementEnvironment environment) {
	return registry.putIfAbsent(cls, () {
	ClassEntity superclass = environment.getSuperClass(cls);
	if (superclass == null) {
	return new _ConstructorBodyNamingScope.rootScope(cls, environment);
	} else if (environment.isMixinApplication(cls)) {
	return new _ConstructorBodyNamingScope.forMixinApplication(cls,
	new _ConstructorBodyNamingScope(superclass, registry, environment));
	} else {
	return new _ConstructorBodyNamingScope.forClass(
	cls,
	new _ConstructorBodyNamingScope(superclass, registry, environment),
	environment);
	}
	});
	}

	String constructorBodyKeyFor(ConstructorBodyEntity body) {
	int position = _constructors.indexOf(body.constructor);
	assert(position >= 0, failedAt(body, "constructor body missing"));
	return "@constructorBody@${_startIndex + position}";
	}

	static List<ConstructorEntity> _getConstructorList(
	ClassEntity cls, ElementEnvironment environment) {
	var result = <ConstructorEntity>[];
	environment.forEachConstructor(cls, result.add);
	return result;
	}
	}

	abstract class _MinifyConstructorBodyNamer implements Namer {
	Map<ClassEntity, _ConstructorBodyNamingScope> _constructorBodyScopes =
	new Map<ClassEntity, _ConstructorBodyNamingScope>();

	@override
	jsAst.Name constructorBodyName(ConstructorBodyEntity method) {
	_ConstructorBodyNamingScope scope = new _ConstructorBodyNamingScope(
	method.enclosingClass, _constructorBodyScopes, elementEnvironment);
	String key = scope.constructorBodyKeyFor(method);
	return _disambiguateMemberByKey(
	key, () => _proposeNameForConstructorBody(method));
	}
	}

	abstract class _MinifiedOneShotInterceptorNamer implements Namer {
	/// Property name used for the one-shot interceptor method for the given
	/// [selector] and return-type specialization.
	@override
	jsAst.Name nameForGetOneShotInterceptor(
	Selector selector, Iterable<ClassEntity> classes) {
	String root = selector.isOperator
	? operatorNameToIdentifier(selector.name)
	: privateName(selector.memberName);
	String prefix =
	selector.isGetter ? r"$get" : selector.isSetter ? r"$set" : "";
	String callSuffix = selector.isCall
	? Namer.callSuffixForStructure(selector.callStructure).join()
	: "";
	String suffix = suffixForGetInterceptor(classes);
	String fullName = "\$intercepted$prefix\$$root$callSuffix\$$suffix";
	return _disambiguateInternalGlobal(fullName);
	}
	}