Add ConstructorBodyEntity

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;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../diagnostics/invariant.dart' show DEBUG_MODE;
 import '../elements/elements.dart'
     show
         ClassElement,
-        ConstructorBodyElement,
         Element,
         Elements,
         FieldElement,
-        FormalElement,
-        FunctionElement,
-        FunctionSignature,
         MemberElement,
         TypeDeclarationElement,
         MixinApplicationElement,
         TypedefElement;
 import '../elements/entities.dart';
 import '../elements/entity_utils.dart' as utils;
 import '../elements/jumps.dart';
 import '../elements/names.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
@@ skipping 725 matching lines @@
       // 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 and as the library
       // name itself might clash.
       String libraryName = _proposeNameForLibrary(library);
       return "_$libraryName\$$text";
     }
   }
 
-  String _proposeNameForConstructorBody(ConstructorBodyElement method) {
+  String _proposeNameForConstructorBody(ConstructorBodyEntity 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);
+    List<String> suffix = callSuffixForSignature(method.parameterStructure);
     return '$name\$${suffix.join(r'$')}';
   }
 
   /// Name for a constructor body.
-  jsAst.Name constructorBodyName(ConstructorBodyElement ctor) {
+  jsAst.Name constructorBodyName(ConstructorBodyEntity ctor) {
     return _disambiguateInternalMember(
         ctor, () => _proposeNameForConstructorBody(ctor));
   }
 
   /// Annotated name for [method] encoding arity and named parameters.
   jsAst.Name instanceMethodName(FunctionEntity method) {
-    // TODO(redemption): Avoid the use of [ConstructorBodyElement]. The
+    // TODO(johnniwinther): Avoid the use of [ConstructorBodyEntity]. The
     // codegen model should be explicit about its constructor body elements.
-    if (method is ConstructorBodyElement) {
+    if (method is ConstructorBodyEntity) {
       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 15 matching lines @@
     suffixes.addAll(callStructure.getOrderedNamedArguments());
     return suffixes;
   }
 
   /// 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> callSuffixForSignature(FunctionSignature sig) {
-    List<String> suffixes = ['${sig.parameterCount}'];
-    if (sig.optionalParametersAreNamed) {
-      for (FormalElement param in sig.orderedOptionalParameters) {
-        suffixes.add(param.name);
-      }
-    }
+  List<String> callSuffixForSignature(ParameterStructure parameterStructure) {
+    List<String> suffixes = ['${parameterStructure.totalParameters}'];
+    suffixes.addAll(parameterStructure.namedParameters);
     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);
         return deriveGetterName(disambiguatedName);
 
@@ skipping 1404 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);
   }
 }