dart2js: Use an abstract Name class for names in the generated JavaScript ast.

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 304 matching lines @@
       _jsVariableReserved.addAll(reservedGlobalObjectNames);
       // 26 letters in the alphabet, 25 not counting I.
       assert(reservedGlobalObjectNames.length == 25);
       _jsVariableReserved.addAll(reservedGlobalHelperFunctions);
     }
     return _jsVariableReserved;
   }
 
   final String currentIsolate = r'$';
   final String getterPrefix = r'get$';
+  final String lazyGetterPrefix = r'$get$';
   final String setterPrefix = r'set$';
   final String superPrefix = r'super$';
   final String metadataField = '@';
   final String callPrefix = 'call';
   final String callCatchAllName = r'call*';
   final String callNameField = r'$callName';
   final String reflectableField = r'$reflectable';
   final String reflectionInfoField = r'$reflectionInfo';
   final String reflectionNameField = r'$reflectionName';
   final String metadataIndexField = r'$metadataIndex';
   final String defaultValuesField = r'$defaultValues';
   final String methodsWithOptionalArgumentsField =
       r'$methodsWithOptionalArguments';
   final String deferredAction = r'$deferredAction';
 
   final String classDescriptorProperty = r'^';
   final String requiredParameterField = r'$requiredArgCount';
 
   /// The non-minifying namer's [callPrefix] with a dollar after it.
   static const String _callPrefixDollar = r'call$';
 
+  static final jsAst.Name _literalSuper = new StringBackedName("super");
+  static final jsAst.Name _literalDollar = new StringBackedName(r'$');
+  static final jsAst.Name _literalUnderscore = new StringBackedName('_');
+  static final jsAst.Name literalPlus = new StringBackedName('+');
+  static final jsAst.Name _literalDynamic = new StringBackedName("dynamic");
+
+  jsAst.Name _literalGetterPrefix;
+  jsAst.Name _literalSetterPrefix;
+  jsAst.Name _literalLazyGetterPrefix;
+
   // Name of property in a class description for the native dispatch metadata.
   final String nativeSpecProperty = '%';
 
   static final RegExp IDENTIFIER = new RegExp(r'^[A-Za-z_$][A-Za-z0-9_$]*$');
   static final RegExp NON_IDENTIFIER_CHAR = new RegExp(r'[^A-Za-z_0-9$]');
 
   final Compiler compiler;
 
   /// Used disambiguated names in the global namespace, issued by
   /// [_disambiguateGlobal], and [_disambiguateInternalGlobal].
   ///
   /// Although global names are distributed across a number of global objects,
   /// (see [globalObjectFor]), we currently use a single namespace for all these
   /// names.
   final Set<String> usedGlobalNames = new Set<String>();
-  final Map<Element, String> userGlobals = <Element, String>{};
-  final Map<String, String> internalGlobals = <String, String>{};
+  final Map<Element, jsAst.Name> userGlobals =
+      new HashMap<Element, jsAst.Name>();
+  final Map<String, jsAst.Name> internalGlobals =
+      new HashMap<String, jsAst.Name>();
 
   /// Used disambiguated names in the instance namespace, issued by
   /// [_disambiguateMember], [_disambiguateInternalMember],
   /// [_disambiguateOperator], and [reservePublicMemberName].
   final Set<String> usedInstanceNames = new Set<String>();
-  final Map<String, String> userInstanceMembers = <String, String>{};
-  final Map<Element, String> internalInstanceMembers = <Element, String>{};
-  final Map<String, String> userInstanceOperators = <String, String>{};
+  final Map<String, jsAst.Name> userInstanceMembers =
+      new HashMap<String, jsAst.Name>();
+  final Map<Element, jsAst.Name> internalInstanceMembers =
+      new HashMap<Element, jsAst.Name>();
+  final Map<String, jsAst.Name> userInstanceOperators =
+      new HashMap<String, jsAst.Name>();
 
   final Map<String, int> popularNameCounters = <String, int>{};
 
-  final Map<ConstantValue, String> constantNames = <ConstantValue, String>{};
+  final Map<LibraryElement, String> libraryLongNames =
+      new HashMap<LibraryElement, String>();
+
+  final Map<ConstantValue, jsAst.Name> constantNames =
+      new HashMap<ConstantValue, jsAst.Name>();
   final Map<ConstantValue, String> constantLongNames =
       <ConstantValue, String>{};
   ConstantCanonicalHasher constantHasher;
 
   /// Maps private names to a library that may use that name without prefixing
   /// itself. Used for building proposed names.
   final Map<String, LibraryElement> shortPrivateNameOwners =
       <String, LibraryElement>{};
 
   /// 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> suggestedGlobalNames = <String, String>{};
   final Map<String, String> suggestedInstanceNames = <String, String>{};
 
+  /// Used to store unique keys for library names. Keys are not used as names,
+  /// nor are they visible in the output. The only serve as an internal
+  /// key into maps.
+  final Map<LibraryElement, String> _libraryKeys =
+      new HashMap<LibraryElement, String>();
+
   Namer(Compiler compiler)
       : compiler = compiler,
         constantHasher = new ConstantCanonicalHasher(compiler),
-        functionTypeNamer = new FunctionTypeNamer(compiler);
+        functionTypeNamer = new FunctionTypeNamer(compiler) {
+    _literalGetterPrefix = new StringBackedName(getterPrefix);
+    _literalSetterPrefix = new StringBackedName(setterPrefix);
+    _literalLazyGetterPrefix = new StringBackedName(lazyGetterPrefix);
+  }
 
   JavaScriptBackend get backend => compiler.backend;
 
   String get deferredTypesName => 'deferredTypes';
   String get isolateName => 'Isolate';
   String get isolatePropertiesName => r'$isolateProperties';
-  String get noSuchMethodName => publicInstanceMethodNameByArity(
+  jsAst.Name get noSuchMethodName => publicInstanceMethodNameByArity(
       Compiler.NO_SUCH_METHOD, Compiler.NO_SUCH_METHOD_ARG_COUNT);
   /**
    * 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 => Compiler.CALL_OPERATOR_NAME;
   bool get shouldMinify => false;
 
   /// Returns the string that is to be used as the result of a call to
   /// [JS_GET_NAME] at [node] with argument [name].
-  String getNameForJsGetName(Node node, JsGetName name) {
+  jsAst.Name getNameForJsGetName(Node node, JsGetName name) {
     switch (name) {
-      case JsGetName.GETTER_PREFIX: return getterPrefix;
-      case JsGetName.SETTER_PREFIX: return setterPrefix;
-      case JsGetName.CALL_PREFIX: return callPrefix;
-      case JsGetName.CALL_PREFIX0: return '${callPrefix}\$0';
-      case JsGetName.CALL_PREFIX1: return '${callPrefix}\$1';
-      case JsGetName.CALL_PREFIX2: return '${callPrefix}\$2';
-      case JsGetName.CALL_PREFIX3: return '${callPrefix}\$3';
-      case JsGetName.CALL_CATCH_ALL: return callCatchAllName;
-      case JsGetName.REFLECTABLE: return 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 classDescriptorProperty;
+        return asName(classDescriptorProperty);
       case JsGetName.REQUIRED_PARAMETER_PROPERTY:
-        return requiredParameterField;
-      case JsGetName.DEFAULT_VALUES_PROPERTY: return defaultValuesField;
-      case JsGetName.CALL_NAME_PROPERTY: return callNameField;
-      case JsGetName.DEFERRED_ACTION_PROPERTY: return deferredAction;
-      case JsGetName.OPERATOR_AS_PREFIX: return operatorAsPrefix;
-      case JsGetName.SIGNATURE_NAME: return operatorSignature;
-      case JsGetName.TYPEDEF_TAG: return typedefTag;
+        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.FUNCTION_TYPE_VOID_RETURN_TAG:
-        return functionTypeVoidReturnTag;
+        return asName(functionTypeVoidReturnTag);
       case JsGetName.FUNCTION_TYPE_RETURN_TYPE_TAG:
-        return functionTypeReturnTypeTag;
+        return asName(functionTypeReturnTypeTag);
       case JsGetName.FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG:
-        return functionTypeRequiredParametersTag;
+        return asName(functionTypeRequiredParametersTag);
       case JsGetName.FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG:
-        return functionTypeOptionalParametersTag;
+        return asName(functionTypeOptionalParametersTag);
       case JsGetName.FUNCTION_TYPE_NAMED_PARAMETERS_TAG:
-        return functionTypeNamedParametersTag;
+        return asName(functionTypeNamedParametersTag);
       case JsGetName.IS_INDEXABLE_FIELD_NAME:
         Element cls = backend.findHelper('JavaScriptIndexingBehavior');
         return operatorIs(cls);
+      case JsGetName.NULL_CLASS_TYPE_NAME:
+        return runtimeTypeName(compiler.nullClass);
+      case JsGetName.OBJECT_CLASS_TYPE_NAME:
+        return runtimeTypeName(compiler.objectClass);
+      case JsGetName.FUNCTION_CLASS_TYPE_NAME:
+        return runtimeTypeName(compiler.functionClass);
       default:
         compiler.reportError(
           node, MessageKind.GENERIC,
           {'text': 'Error: Namer has no name for "$name".'});
-        return 'BROKEN';
+        return asName('BROKEN');
     }
   }
 
   /// Disambiguated name for [constant].
   ///
   /// Unique within the global-member namespace.
-  String constantName(ConstantValue constant) {
+  jsAst.Name constantName(ConstantValue constant) {
     // In the current implementation it doesn't make sense to give names to
     // function constants since the function-implementation itself serves as
     // constant and can be accessed directly.
     assert(!constant.isFunction);
-    String result = constantNames[constant];
+    jsAst.Name result = constantNames[constant];
     if (result == null) {
       String longName = constantLongName(constant);
       result = getFreshName(longName, usedGlobalNames, suggestedGlobalNames);
       constantNames[constant] = result;
     }
     return result;
   }
 
   /// Proposed name for [constant].
   String constantLongName(ConstantValue constant) {
@@ skipping 46 matching lines @@
     // The first library asking for a short private name wins.
     LibraryElement owner =
         shortPrivateNameOwners.putIfAbsent(text, () => library);
 
     if (owner == library) {
       return text;
     } else {
       // Make sure to return a private name that starts with _ so it
       // cannot clash with any public names.
       // The name is still not guaranteed to be unique, since both the library
-      // name and originalName could contain $ symbols.
-      String libraryName = _disambiguateGlobal(library);
-      return '_$libraryName\$${text}';
+      // name and originalName could contain $ symbols and as the library
+      // name itself might clash.
+      String libraryName = _proposeNameForGlobal(library);
+      return "_$libraryName\$$text";
     }
   }
 
   String _proposeNameForConstructorBody(ConstructorBodyElement method) {
     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'$')}';
   }
 
   /// Annotated name for [method] encoding arity and named parameters.
-  String instanceMethodName(FunctionElement method) {
+  jsAst.Name instanceMethodName(FunctionElement method) {
     if (method.isGenerativeConstructorBody) {
       return _disambiguateInternalMember(method,
           () => _proposeNameForConstructorBody(method));
     }
     return invocationName(new Selector.fromElement(method));
   }
 
   /// Annotated name for a public method with the given [originalName]
   /// and [arity] and no named parameters.
-  String publicInstanceMethodNameByArity(String originalName, int arity) {
+  jsAst.Name publicInstanceMethodNameByArity(String originalName,
+                                             int arity) {
     return invocationName(new Selector.call(originalName, null, arity));
   }
 
   /// Returns the annotated name for a variant of `call`.
   /// The result has the form:
   ///
   ///     call$<N>$namedParam1...$namedParam<M>
   ///
   /// This name cannot be minified because it is generated by string
   /// concatenation at runtime, by applyFunction in js_helper.dart.
-  String deriveCallMethodName(List<String> suffix) {
+  jsAst.Name deriveCallMethodName(List<String> suffix) {
     // TODO(asgerf): Avoid clashes when named parameters contain $ symbols.
-    return '$callPrefix\$${suffix.join(r'$')}';
+    return new StringBackedName('$callPrefix\$${suffix.join(r'$')}');
   }
 
   /// The suffix list for the pattern:
   ///
   ///     $<N>$namedParam1...$namedParam<M>
   ///
   /// This is used for the annotated names of `call`, and for the proposed name
   /// for other instance methods.
   List<String> callSuffixForStructure(CallStructure callStructure) {
     List<String> suffixes = ['${callStructure.argumentCount}'];
@@ skipping 11 matching lines @@
     List<String> suffixes = ['${sig.parameterCount}'];
     if (sig.optionalParametersAreNamed) {
       for (FormalElement param in sig.orderedOptionalParameters) {
         suffixes.add(param.name);
       }
     }
     return suffixes;
   }
 
   /// Annotated name for the member being invoked by [selector].
-  String invocationName(Selector selector) {
+  jsAst.Name invocationName(Selector selector) {
     switch (selector.kind) {
       case SelectorKind.GETTER:
-        String disambiguatedName = _disambiguateMember(selector.memberName);
+        jsAst.Name disambiguatedName =
+            _disambiguateMember(selector.memberName);
         return deriveGetterName(disambiguatedName);
 
       case SelectorKind.SETTER:
-        String disambiguatedName = _disambiguateMember(selector.memberName);
+        jsAst.Name disambiguatedName =
+            _disambiguateMember(selector.memberName);
         return deriveSetterName(disambiguatedName);
 
       case SelectorKind.OPERATOR:
       case SelectorKind.INDEX:
         String operatorIdentifier = operatorNameToIdentifier(selector.name);
-        String disambiguatedName = _disambiguateOperator(operatorIdentifier);
+        jsAst.Name disambiguatedName =
+            _disambiguateOperator(operatorIdentifier);
         return disambiguatedName; // Operators are not annotated.
 
       case SelectorKind.CALL:
         List<String> suffix = callSuffixForStructure(selector.callStructure);
         if (selector.name == Compiler.CALL_OPERATOR_NAME) {
           // Derive the annotated name for this variant of 'call'.
           return deriveCallMethodName(suffix);
         }
-        String disambiguatedName =
+        jsAst.Name disambiguatedName =
             _disambiguateMember(selector.memberName, suffix);
         return disambiguatedName; // Methods other than call are not annotated.
 
       default:
         compiler.internalError(compiler.currentElement,
             'Unexpected selector kind: ${selector.kind}');
         return null;
     }
   }
 
   /**
    * Returns the internal name used for an invocation mirror of this selector.
    */
-  String invocationMirrorInternalName(Selector selector)
+  jsAst.Name invocationMirrorInternalName(Selector selector)
       => invocationName(selector);
 
   /**
    * Returns the disambiguated name for the given field, used for constructing
    * the getter and setter names.
    */
-  String fieldAccessorName(FieldElement element) {
+  jsAst.Name fieldAccessorName(FieldElement element) {
     return element.isInstanceMember
         ? _disambiguateMember(element.memberName)
         : _disambiguateGlobal(element);
   }
 
   /**
    * Returns name of the JavaScript property used to store a static or instance
    * field.
    */
-  String fieldPropertyName(FieldElement element) {
+  jsAst.Name fieldPropertyName(FieldElement element) {
     return element.isInstanceMember
         ? instanceFieldPropertyName(element)
         : _disambiguateGlobal(element);
   }
 
   /**
    * Returns name of the JavaScript property used to store the
    * `readTypeVariable` function for the given type variable.
    */
-  String nameForReadTypeVariable(TypeVariableElement element) {
+  jsAst.Name nameForReadTypeVariable(TypeVariableElement element) {
     return _disambiguateInternalMember(element, () => element.name);
   }
 
   /**
    * Returns a JavaScript property name used to store [element] on one
    * of the global objects.
    *
    * Should be used together with [globalObjectFor], which denotes the object
    * on which the returned property name should be used.
    */
-  String globalPropertyName(Element element) {
+  jsAst.Name globalPropertyName(Element element) {
     return _disambiguateGlobal(element);
   }
 
   /**
    * Returns the JavaScript property name used to store an instance field.
    */
-  String instanceFieldPropertyName(FieldElement element) {
+  jsAst.Name instanceFieldPropertyName(FieldElement element) {
     ClassElement enclosingClass = element.enclosingClass;
 
     if (element.hasFixedBackendName) {
       // Certain native fields must be given a specific name. Native names must
       // not contain '$'. We rely on this to avoid clashes.
       assert(enclosingClass.isNative &&
              !element.fixedBackendName.contains(r'$'));
 
-      return element.fixedBackendName;
+      return new StringBackedName(element.fixedBackendName);
     }
 
     // Instances of BoxFieldElement are special. They are already created with
     // a unique and safe 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. We still do not mark the name as a
     // fixedBackendName, as we want to allow other namers to do something more
     // clever with them.
     if (element is BoxFieldElement) {
-      return element.name;
+      return new StringBackedName(element.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 14 matching lines @@
     return element.enclosingClass.hasFieldShadowedBy(element);
   }
 
   /// True if [class_] is a non-native class that inherits from a native class.
   bool _isUserClassExtendingNative(ClassElement class_) {
     return !class_.isNative &&
            Elements.isNativeOrExtendsNative(class_.superclass);
   }
 
   /// Annotated name for the setter of [element].
-  String setterForElement(MemberElement 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.
-    String name = _disambiguateMember(element.memberName);
+    jsAst.Name name = _disambiguateMember(element.memberName);
     return deriveSetterName(name);
   }
 
   /// Annotated name for the setter of any member with [disambiguatedName].
-  String deriveSetterName(String disambiguatedName) {
+  jsAst.Name deriveSetterName(jsAst.Name disambiguatedName) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
-    return '$setterPrefix$disambiguatedName';
+    return new SetterName(_literalSetterPrefix, disambiguatedName);
   }
 
   /// Annotated name for the setter of any member with [disambiguatedName].
-  String deriveGetterName(String disambiguatedName) {
+  jsAst.Name deriveGetterName(jsAst.Name disambiguatedName) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
-    return '$getterPrefix$disambiguatedName';
+    return new GetterName(_literalGetterPrefix, disambiguatedName);
   }
 
   /// Annotated name for the getter of [element].
-  String getterForElement(MemberElement element) {
+  jsAst.Name getterForElement(MemberElement element) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
-    String name = _disambiguateMember(element.memberName);
+    jsAst.Name name = _disambiguateMember(element.memberName);
     return deriveGetterName(name);
   }
 
   /// Property name for the getter of an instance member with [originalName].
-  String getterForMember(Name originalName) {
-    String disambiguatedName = _disambiguateMember(originalName);
+  jsAst.Name getterForMember(Name originalName) {
+    jsAst.Name disambiguatedName = _disambiguateMember(originalName);
     return deriveGetterName(disambiguatedName);
   }
 
   /// Disambiguated name for a compiler-owned global variable.
   ///
   /// The resulting name is unique within the global-member namespace.
-  String _disambiguateInternalGlobal(String name) {
-    String newName = internalGlobals[name];
+  jsAst.Name _disambiguateInternalGlobal(String name) {
+    jsAst.Name newName = internalGlobals[name];
     if (newName == null) {
       newName = getFreshName(name, usedGlobalNames, suggestedGlobalNames);
       internalGlobals[name] = newName;
     }
     return newName;
   }
 
   /// Returns the property name to use for a compiler-owner global variable,
   /// i.e. one that does not correspond to any element but is used as a utility
   /// global by code generation.
   ///
   /// [name] functions as both the proposed name for the global, and as a key
   /// identifying the global. The [name] must not contain `$` symbols, since
   /// the [Namer] uses those names internally.
   ///
   /// This provides an easy mechanism of avoiding a name-clash with user-space
   /// globals, although the callers of must still take care not to accidentally
   /// pass in the same [name] for two different internal globals.
-  String internalGlobal(String name) {
+  jsAst.Name internalGlobal(String name) {
     assert(!name.contains(r'$'));
     return _disambiguateInternalGlobal(name);
   }
 
+  /// 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++}";
+      }
+      return key;
+    });
+  }
+
   /// Returns the disambiguated name for a top-level or static element.
   ///
   /// The resulting name is unique within the global-member namespace.
-  String _disambiguateGlobal(Element element) {
+  jsAst.Name _disambiguateGlobal(Element element) {
     // TODO(asgerf): We can reuse more short names if we disambiguate with
     // a separate namespace for each of the global holder objects.
     element = element.declaration;
-    String newName = userGlobals[element];
+    jsAst.Name newName = userGlobals[element];
     if (newName == null) {
       String proposedName = _proposeNameForGlobal(element);
       newName = getFreshName(proposedName, usedGlobalNames,
                              suggestedGlobalNames);
       userGlobals[element] = newName;
     }
     return newName;
   }
 
   /// Returns the disambiguated name for an instance method or field
   /// with [originalName] in [library].
   ///
   /// [library] may be `null` if [originalName] is known to be public.
   ///
   /// This is the name used for deriving property names of accessors (getters
   /// and setters) and as property name for storing methods and method stubs.
   ///
   /// [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.
-  String _disambiguateMember(Name originalName,
-                             [List<String> suffixes = const []]) {
+  jsAst.Name _disambiguateMember(Name originalName,
+                                 [List<String> suffixes = const []]) {
     // Build a string encoding the library name, if the name is private.
     String libraryKey = originalName.isPrivate
-            ? _disambiguateGlobal(originalName.library)
+            ? _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('@')}';
-    String newName = userInstanceMembers[key];
+    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(proposedName,
                              usedInstanceNames, suggestedInstanceNames,
                              sanitizeForAnnotations: true);
@@ skipping 11 matching lines @@
   /// Using [_disambiguateMember] with the given [originalName] and no suffixes
   /// will subsequently return [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(!usedInstanceNames.contains(disambiguatedName));
-    userInstanceMembers[key] = disambiguatedName;
+    userInstanceMembers[key] = new StringBackedName(disambiguatedName);
     usedInstanceNames.add(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.
-  String _disambiguateInternalMember(Element element, String proposeName()) {
-    String newName = internalInstanceMembers[element];
+  jsAst.Name _disambiguateInternalMember(Element element,
+                                         String proposeName()) {
+    jsAst.Name newName = internalInstanceMembers[element];
     if (newName == null) {
       String name = proposeName();
       bool mayClashNative = _isUserClassExtendingNative(element.enclosingClass);
       newName = getFreshName(name,
                              usedInstanceNames, suggestedInstanceNames,
                              sanitizeForAnnotations: true,
                              sanitizeForNatives: mayClashNative);
       internalInstanceMembers[element] = newName;
     }
     return 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.
-  String _disambiguateOperator(String operatorIdentifier) {
-    String newName = userInstanceOperators[operatorIdentifier];
+  jsAst.Name _disambiguateOperator(String operatorIdentifier) {
+    jsAst.Name newName = userInstanceOperators[operatorIdentifier];
     if (newName == null) {
       newName = getFreshName(operatorIdentifier, usedInstanceNames,
                              suggestedInstanceNames);
       userInstanceOperators[operatorIdentifier] = newName;
     }
     return newName;
   }
 
   /// Returns an unused name.
   ///
   /// [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.
-  String getFreshName(String proposedName,
-                      Set<String> usedNames,
-                      Map<String, String> suggestedNames,
-                      {bool sanitizeForAnnotations: false,
-                       bool sanitizeForNatives: false}) {
+  jsAst.Name getFreshName(String proposedName,
+                          Set<String> usedNames,
+                          Map<String, String> suggestedNames,
+                          {bool sanitizeForAnnotations: false,
+                           bool sanitizeForNatives: false}) {
     if (sanitizeForAnnotations) {
       proposedName = _sanitizeForAnnotations(proposedName);
     }
     if (sanitizeForNatives) {
       proposedName = _sanitizeForNatives(proposedName);
     }
     proposedName = _sanitizeForKeywords(proposedName);
     String candidate;
     if (!usedNames.contains(proposedName)) {
       candidate = proposedName;
     } else {
       int counter = popularNameCounters[proposedName];
       int i = (counter == null) ? 0 : counter;
       while (usedNames.contains("$proposedName$i")) {
         i++;
       }
       popularNameCounters[proposedName] = i + 1;
       candidate = "$proposedName$i";
     }
     usedNames.add(candidate);
-    return candidate;
+    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 45 matching lines @@
     } else if (Elements.isStaticOrTopLevel(element)) {
       if (element.isClassMember) {
         ClassElement enclosingClass = element.enclosingClass;
         name = "${enclosingClass.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.getLibraryOrScriptName();
       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.
           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;
+      for (int c = 0; libraryLongNames.containsValue(disambiguated); c++) {
+        disambiguated = "$name$c";
+      }
+      libraryLongNames[library] = disambiguated;
+      name = disambiguated;
     } else {
       name = element.name;
     }
     return name;
   }
 
   String suffixForGetInterceptor(Iterable<ClassElement> classes) {
     String abbreviate(ClassElement cls) {
       if (cls == compiler.objectClass) return "o";
       if (cls == backend.jsStringClass) return "s";
@@ skipping 14 matching lines @@
     if (classes.any((cls) => Elements.isNativeOrExtendsNative(cls))) {
       names.add("x");
     }
     // Sort the names of the classes after abbreviating them to ensure
     // the suffix is stable and predictable for the suggested names.
     names.sort();
     return names.join();
   }
 
   /// Property name used for `getInterceptor` or one of its specializations.
-  String nameForGetInterceptor(Iterable<ClassElement> classes) {
+  jsAst.Name nameForGetInterceptor(Iterable<ClassElement> classes) {
     FunctionElement getInterceptor = backend.getInterceptorMethod;
     if (classes.contains(backend.jsInterceptorClass)) {
       // If the base Interceptor class is in the set of intercepted classes, we
       // need to go through the generic getInterceptorMethod, since any subclass
       // of the base Interceptor could match.
       // The unspecialized getInterceptor method can also be accessed through
       // 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.
-  String 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.
 
-    String root = invocationName(selector);
+    jsAst.Name root = invocationName(selector);
 
     if (classes.contains(backend.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.  To keep the name short, we add '$' only to
       // distinguish from internal globals requested from outside the Namer
       // with internalGlobal().
       // 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".
-      if (selector.isGetter || selector.isSetter) root = '$root\$';
-      return _disambiguateInternalGlobal(root);
+    if (selector.isGetter || selector.isSetter) {
+      return new CompoundName([root, _literalDollar]);
+    } else {
+      return root;
+    }
     } else {
       String suffix = suffixForGetInterceptor(classes);
-      return _disambiguateInternalGlobal("$root\$$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,
   /// then by convention, an underscore must also separate [operatorIsPrefix]
   /// from the type name.
-  String runtimeTypeName(TypeDeclarationElement element) {
-    if (element == null) return 'dynamic';
+  jsAst.Name runtimeTypeName(TypeDeclarationElement element) {
+    if (element == null) return _literalDynamic;
     // The returned name affects both the global and instance member namespaces:
     //
     // - If given a class, this must coincide with the class name, which
     //   is also the GLOBAL property name of its constructor.
     //
     // - The result is used to derive `$isX` and `$asX` names, which are used
     //   as INSTANCE property names.
     //
     // To prevent clashes in both namespaces at once, we disambiguate the name
     // as a global here, and in [_sanitizeForAnnotations] we ensure that
     // ordinary instance members cannot start with `$is` or `$as`.
     return _disambiguateGlobal(element);
   }
 
   /// Returns the disambiguated name of [class_].
   ///
   /// This is both the *runtime type* of the class (see [runtimeTypeName])
   /// and a global property name in which to store its JS constructor.
-  String className(ClassElement class_) => _disambiguateGlobal(class_);
+  jsAst.Name className(ClassElement class_) => _disambiguateGlobal(class_);
 
   /// Property name on which [member] can be accessed directly,
   /// without clashing with another JS property name.
   ///
   /// This is used for implementing super-calls, where ordinary dispatch
   /// semantics must be circumvented. For example:
   ///
   ///     class A { foo() }
   ///     class B extends A {
   ///         foo() { super.foo() }
   ///     }
   ///
   /// Example translation to JS:
   ///
   ///     A.prototype.super$A$foo = function() {...}
   ///     A.prototype.foo$0 = A.prototype.super$A$foo
   ///
   ///     B.prototype.foo$0 = function() {
   ///         this.super$A$foo(); // super.foo()
   ///     }
   ///
-  String aliasedSuperMemberPropertyName(Element member) {
+  jsAst.Name aliasedSuperMemberPropertyName(Element member) {
     assert(!member.isField); // Fields do not need super aliases.
-    String methodName = instanceMethodName(member);
-    return _disambiguateInternalMember(member,
-        () => 'super\$${member.enclosingClass.name}\$$methodName');
+    return _disambiguateInternalMember(member, () {
+      String invocationName = operatorNameToIdentifier(member.name);
+      return "super\$${member.enclosingClass.name}\$$invocationName";
+    });
   }
 
   /// Property name in which to store the given static or instance [method].
   /// For instance methods, this includes the suffix encoding arity and named
   /// parameters.
   ///
   /// The name is not necessarily unique to [method], since a static method
   /// may share its name with an instance method.
-  String methodPropertyName(Element method) {
+  jsAst.Name methodPropertyName(Element method) {
     return method.isInstanceMember
         ? instanceMethodName(method)
         : globalPropertyName(method);
   }
 
   /// Returns true if [element] is stored on current isolate ('$').  We intend
   /// to store only mutable static state in [currentIsolate], constants are
   /// stored in 'C', and functions, accessors, classes, etc. are stored in one
   /// of the other objects in [reservedGlobalObjectNames].
   bool isPropertyOfCurrentIsolate(Element element) {
@@ skipping 18 matching lines @@
     if (library == backend.interceptorsLibrary) return 'J';
     if (library.isInternalLibrary) return 'H';
     if (library.isPlatformLibrary) {
       if ('${library.canonicalUri}' == 'dart:html') return 'W';
       return 'P';
     }
     return userGlobalObjects[
         library.getLibraryOrScriptName().hashCode % userGlobalObjects.length];
   }
 
-  String lazyInitializerName(Element element) {
-    assert(Elements.isStaticOrTopLevelField(element));
-    String name = _disambiguateGlobal(element);
-    return _disambiguateInternalGlobal("$getterPrefix$name");
+  jsAst.Name deriveLazyInitializerName(jsAst.Name name) {
+    // These are not real dart getters, so do not use GetterName;
+    return new CompoundName([_literalLazyGetterPrefix, name]);
   }
 
-  String staticClosureName(Element element) {
+  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 name = _disambiguateGlobal(element);
-    return _disambiguateInternalGlobal("$name\$closure");
+    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.
-    return "${globalObjectFor(element)}.${globalPropertyName(element)}";
+    String library = _proposeNameForGlobal(element.library);
+    return "${library}.${element.name}";
   }
 
   String globalObjectForConstant(ConstantValue constant) => 'C';
 
   String get operatorIsPrefix => r'$is';
 
   String get operatorAsPrefix => r'$as';
 
   String get operatorSignature => r'$signature';
 
   String get typedefTag => r'typedef';
 
   String get functionTypeTag => r'func';
 
   String get functionTypeVoidReturnTag => r'void';
 
   String get functionTypeReturnTypeTag => r'ret';
 
   String get functionTypeRequiredParametersTag => r'args';
 
   String get functionTypeOptionalParametersTag => r'opt';
 
   String get functionTypeNamedParametersTag => r'named';
 
-  Map<FunctionType,String> functionTypeNameMap =
-      new Map<FunctionType,String>();
+  Map<FunctionType, jsAst.Name> functionTypeNameMap =
+      new HashMap<FunctionType, jsAst.Name>();
   final FunctionTypeNamer functionTypeNamer;
 
-  String getFunctionTypeName(FunctionType functionType) {
+  jsAst.Name getFunctionTypeName(FunctionType functionType) {
     return functionTypeNameMap.putIfAbsent(functionType, () {
       String proposedName = functionTypeNamer.computeName(functionType);
-      String freshName = getFreshName(proposedName, usedInstanceNames,
-                                      suggestedInstanceNames);
-      return freshName;
+      return getFreshName(proposedName, usedInstanceNames,
+                          suggestedInstanceNames);
     });
   }
 
-  String operatorIsType(DartType type) {
+  jsAst.Name operatorIsType(DartType type) {
     if (type.isFunctionType) {
       // TODO(erikcorry): Reduce from $isx to ix when we are minifying.
-      return '${operatorIsPrefix}_${getFunctionTypeName(type)}';
+      return new CompoundName([new StringBackedName(operatorIsPrefix),
+                               _literalUnderscore,
+                               getFunctionTypeName(type)]);
     }
     return operatorIs(type.element);
   }
 
-  String operatorIs(ClassElement element) {
+  jsAst.Name operatorIs(ClassElement element) {
     // TODO(erikcorry): Reduce from $isx to ix when we are minifying.
-    return '${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;
   }
 
-  String substitutionName(Element element) {
-    return '${operatorAsPrefix}${runtimeTypeName(element)}';
+  jsAst.Name substitutionName(Element 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)));
+    }
+    if (name.startsWith(setterPrefix) && name.length > setterPrefix.length) {
+      return new GetterName(_literalSetterPrefix,
+                            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.
   String safeVariableName(String name) {
     if (jsVariableReserved.contains(name) || name.startsWith(r'$')) {
       return '\$$name';
@@ skipping 48 matching lines @@
     }
   }
 
   String get incrementalHelperName => r'$dart_unsafe_incremental_support';
 
   jsAst.Expression get accessIncrementalHelper {
     return js('self.${incrementalHelperName}');
   }
 
   void forgetElement(Element element) {
-    String globalName = userGlobals[element];
+    jsAst.Name globalName = userGlobals[element];
     invariant(element, globalName != null, message: 'No global name.');
     usedGlobalNames.remove(globalName);
     userGlobals.remove(element);
   }
 }
 
+abstract class _NamerName extends jsAst.Name {
+  int get _kind;
+}
+
+class StringBackedName extends _NamerName {
+  final String name;
+  int get _kind => 1;
+  
+  StringBackedName(this.name);
+
+  toString() => throw new UnsupportedError("Cannot convert a name to a string");
+
+  operator==(other) {
+    if (identical(this, other)) return true;
+    return (other is StringBackedName) && other.name == name;
+  }
+
+  int get hashCode => name.hashCode;
+
+  int compareTo(_NamerName other) {
+    if (other._kind != _kind) return other._kind - _kind;
+    return name.compareTo(other.name);
+  }
+}
+
+abstract class _PrefixedName extends _NamerName {
+  final jsAst.Name prefix;
+  final jsAst.Name base;
+  int get _kind;
+
+  _PrefixedName(this.prefix, this.base);
+  
+  String get name => prefix.name + base.name;
+
+  toString() => throw new UnsupportedError("Cannot convert a name to a string");
+
+  bool operator==(other) {
+    if (identical(this, other)) return true;
+    if (other is! _PrefixedName) return false;
+    return other.base == base && other.prefix == prefix;
+  }
+
+  int get hashCode => base.hashCode * 13 + prefix.hashCode;
+
+  int compareTo(_NamerName other) {
+    if (other._kind != _kind) return other._kind - _kind;
+    _PrefixedName otherSameKind = other;
+    int result = prefix.compareTo(otherSameKind.prefix);
+    if (result == 0) {
+      result = name.compareTo(otherSameKind.name);
+    }
+    return result;
+  }
+}
+
+class GetterName extends _PrefixedName {
+  int get _kind => 2;
+
+  GetterName(jsAst.Name prefix, jsAst.Name base) : super(prefix, base);
+}
+
+class SetterName extends _PrefixedName {
+  int get _kind => 3;
+
+  SetterName(jsAst.Name prefix, jsAst.Name base) : super(prefix, base);
+}
+
+class CompoundName extends _NamerName {
+  final List<_NamerName> _parts;
+  int get _kind => 4;
+  String _cachedName;
+  int _cachedHashCode = -1;
+
+  CompoundName(this._parts);
+
+  String get name {
+    if (_cachedName == null) {
+      _cachedName = _parts.map((jsAst.Name name) => name.name).join();
+    }
+    return _cachedName;
+  }
+
+  toString() => throw new UnsupportedError("Cannot convert a name to a string");
+
+  bool operator==(other) {
+    if (identical(this, other)) return true;
+    if (other is! CompoundName) return false;
+    if (other._parts.length != _parts.length) return false;
+    for (int i = 0; i < _parts.length; ++i) {
+      if (other._parts[i] != _parts[i]) return false;
+    }
+    return true;
+  }
+
+  int get hashCode {
+    if (_cachedHashCode < 0) {
+      _cachedHashCode = 0;
+      for (jsAst.Name name in _parts) {
+        _cachedHashCode = (_cachedHashCode * 17) & 0x7fffffff;
+      }
+    }
+    return _cachedHashCode;
+  }
+
+  int compareTo(_NamerName other) {
+    if (other._kind != _kind) return other._kind - _kind;
+    CompoundName otherSameKind = other;
+    if (otherSameKind._parts.length != _parts.length) {
+      return otherSameKind._parts.length - _parts.length;
+    }
+    int result = 0;
+    for (int pos = 0; result == 0 && pos < _parts.length; pos++) {
+      result = _parts[pos].compareTo(otherSameKind._parts[pos]);
+    }
+    return result;
+  }
+}
+
 /**
  * Generator of names for [ConstantValue] values.
  *
  * The names are stable under perturbations of the source.  The name is either a
  * short sequence of words, if this can be found from the constant, or a type
  * followed by a hash tag.
  *
  *     List_imX                // A List, with hash tag.
  *     C_Sentinel              // const Sentinel(),  "C_" added to avoid clash
  *                             //   with class name.
@@ skipping 164 matching lines @@
 
   @override
   void visitSynthetic(SyntheticConstantValue constant, [_]) {
     switch (constant.kind) {
       case SyntheticConstantKind.DUMMY_INTERCEPTOR:
         add('dummy_receiver');
         break;
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
         add('type_variable_reference');
         break;
+      case SyntheticConstantKind.NAME:
+        add('name');
+        break;
       default:
         compiler.internalError(compiler.currentElement,
                                "Unexpected SyntheticConstantValue");
     }
   }
 
   @override
   void visitDeferred(DeferredConstantValue constant, [_]) {
     addRoot('Deferred');
   }
@@ skipping 228 matching lines @@
         if (!first) {
           sb.write('_');
         }
         sb.write('_');
         visit(parameter);
         first = true;
       }
     }
   }
 }