It's alive!

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.
 
 library js_backend.namer;
 
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' show JsGetName;
 
@@ skipping 754 matching lines @@
     return '$name\$${suffix.join(r'$')}';
   }
 
   /// Name for a constructor body.
   jsAst.Name constructorBodyName(FunctionElement ctor) {
     return _disambiguateInternalMember(
         ctor, () => _proposeNameForConstructorBody(ctor));
   }
 
   /// Annotated name for [method] encoding arity and named parameters.
-  jsAst.Name instanceMethodName(MethodElement method) {
-    if (method.isGenerativeConstructorBody) {
+  jsAst.Name instanceMethodName(FunctionEntity method) {
+    // TODO(johnniwinther): Avoid the use of [ConstructorBodyElement]. The
+    // codegen model should be explicit about its constructor body elements.
+    if (method is ConstructorBodyElement) {
       return constructorBodyName(method);
     }
     return invocationName(new Selector.fromElement(method));
   }
 
   /// Returns the annotated name for a variant of `call`.
   /// The result has the form:
   ///
   ///     call$<N>$namedParam1...$namedParam<M>
   ///
@@ skipping 499 matching lines @@
     return element.name.replaceAll('+', '_');
   }
 
   String _proposeNameForConstructor(ConstructorEntity element) {
     String className = element.enclosingClass.name;
     if (element.isGenerativeConstructor) {
       return '${className}\$${element.name}';
     } else {
       // TODO(johnniwinther): Change factory name encoding as to not include
       // the class-name twice.
-      String constructorName;
-      if (element.name == '') {
-        constructorName = className;
-      } else {
-        constructorName = '${className}\$${element.name}';
-      }
-      return '${className}_${constructorName}';
+      return '${className}_${Elements.reconstructConstructorName(element)}';
     }
   }
 
   /**
    * Returns a proposed name for the given [LibraryElement].
    * The returned id is guaranteed to be a valid JavaScript identifier.
    */
   // TODO(sra): Pre-process libraries to assign [libraryLongNames] in a way that
   // is independent of the order of calls to namer.
   String _proposeNameForLibrary(LibraryEntity library) {
@@ skipping 101 matching lines @@
 
   /// 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.
-  jsAst.Name runtimeTypeName(TypeDeclarationElement element) {
+  jsAst.Name runtimeTypeName(Entity 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 _disambiguateGlobalType(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.
-  jsAst.Name className(ClassElement class_) => _disambiguateGlobalType(class_);
+  jsAst.Name className(ClassEntity class_) => _disambiguateGlobalType(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() }
@@ skipping 15 matching lines @@
       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.
-  jsAst.Name methodPropertyName(MethodElement method) {
+  jsAst.Name methodPropertyName(FunctionEntity method) {
     return method.isInstanceMember
         ? instanceMethodName(method)
         : globalPropertyNameForMember(method);
   }
 
   /// Returns true if [element] is stored in the static state holder
   /// ([staticStateHolder]).  We intend to store only mutable static state
   /// there, whereas constants are stored in 'C'. Functions, accessors,
   /// classes, etc. are stored in one of the other objects in
   /// [reservedGlobalObjectNames].
@@ skipping 12 matching lines @@
               !element.isClass &&
               !element.isTypedef &&
               !element.isConstructor &&
               !element.isFunction &&
               !element.isLibrary;
     }
     return element.isField;
   }
 
   /// Returns [staticStateHolder] or one of [reservedGlobalObjectNames].
-  // TODO(johnniwinther): Verify that the implementation can be changed to
-  // `globalObjectForLibrary(element.library)`.
-  String globalObjectForMethod(MethodElement element) =>
-      globalObjectForMember(element);
-
-  /// Returns [staticStateHolder] or one of [reservedGlobalObjectNames].
   String globalObjectForMember(MemberEntity element) {
     if (_isPropertyOfStaticStateHolder(element)) return staticStateHolder;
     return globalObjectForLibrary(element.library);
   }
 
   String globalObjectForClass(ClassEntity element) {
     return globalObjectForLibrary(element.library);
   }
 
   String globalObjectForType(Entity element) {
@@ skipping 20 matching lines @@
     return new CompoundName([_literalLazyGetterPrefix, name]);
   }
 
   jsAst.Name lazyInitializerName(FieldEntity element) {
     assert(element.isTopLevel || element.isStatic);
     jsAst.Name name = _disambiguateGlobalMember(element);
     // These are not real dart getters, so do not use GetterName;
     return deriveLazyInitializerName(name);
   }
 
-  jsAst.Name staticClosureName(Element element) {
-    assert(Elements.isStaticOrTopLevelFunction(element));
+  jsAst.Name staticClosureName(FunctionEntity element) {
+    assert(element.isTopLevel || element.isStatic);
     String enclosing =
         element.enclosingClass == null ? "" : element.enclosingClass.name;
     String library = _proposeNameForLibrary(element.library);
     return _disambiguateInternalGlobal(
         "${library}_${enclosing}_${element.name}\$closure");
   }
 
   // This name is used as part of the name of a TypeConstant
   String uniqueNameForTypeConstantElement(
       LibraryEntity library, Entity element) {
@@ skipping 44 matching lines @@
       return new CompoundName([
         new StringBackedName(operatorIsPrefix),
         _literalUnderscore,
         getFunctionTypeName(type)
       ]);
     }
     InterfaceType interfaceType = type;
     return operatorIs(interfaceType.element);
   }
 
-  jsAst.Name operatorIs(ClassElement element) {
+  jsAst.Name operatorIs(ClassEntity element) {
     // TODO(erikcorry): Reduce from $isx to ix when we are minifying.
     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(ClassElement element) {
+  jsAst.Name substitutionName(ClassEntity 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) {
@@ skipping 582 matching lines @@
   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);
   }
 }