Clean up naming scheme for reflection names.

sdk/lib/_internal/compiler/js_lib/js_mirrors.dart

 // Copyright (c) 2013, 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 dart._js_mirrors;
 
 import 'dart:_js_embedded_names' show
     JsGetName,
     ALL_CLASSES,
     LAZIES,
@@ skipping 973 matching lines @@
   String _computeReflectiveName(Symbol symbolName, int type,
                                 List positionalArguments,
                                 Map<Symbol, dynamic> namedArguments) {
     String name = n(symbolName);
     switch (type) {
       case JSInvocationMirror.GETTER: return name;
       case JSInvocationMirror.SETTER: return '$name=';
       case JSInvocationMirror.METHOD:
         if (namedArguments.isNotEmpty) return '$name*';
         int nbArgs = positionalArguments.length as int;
-        return "$name:$nbArgs:0";
+        return "$name:$nbArgs";
     }
     throw new RuntimeError("Could not compute reflective name for $name");
   }
 
   /**
    * Returns a `CachedInvocation` or `CachedNoSuchMethodInvocation` for the
    * given member.
    *
    * Caches the result.
    */
@@ skipping 673 matching lines @@
     var result = <JsMethodMirror>[];
     for (String key in keys) {
       if (isReflectiveDataInPrototype(key)) continue;
       String simpleName = mangledNames[key];
       // [simpleName] can be null if [key] represents an implementation
       // detail, for example, a bailout method, or runtime type support.
       // It might also be null if the user has limited what is reified for
       // reflection with metadata.
       if (simpleName == null) continue;
       var function = JS('', '#[#]', prototype, key);
-      if (isNoSuchMethodStub(function)) continue;
+      if (!isOrdinaryReflectableMethod(function)) continue;
       if (isAliasedSuperMethod(function, key)) continue;
       var mirror =
           new JsMethodMirror.fromUnmangledName(
               simpleName, function, false, false);
       result.add(mirror);
       mirror._owner = methodOwner;
     }
 
     var statics = JS_EMBEDDED_GLOBAL('', STATICS);
     keys = extractKeys(JS('', '#[#]', statics, _mangledName));
@@ skipping 625 matching lines @@
     int optionalParameterCount = 0;
     bool isGetter = false;
     if (info.length == 1) {
       if (isSetter) {
         requiredParameterCount = 1;
       } else {
         isGetter = true;
         requiredParameterCount = 0;
       }
     } else {
-      requiredParameterCount = int.parse(info[1]);
-      optionalParameterCount = int.parse(info[2]);
+      ReflectionInfo reflectionInfo = new ReflectionInfo(jsFunction);
+      requiredParameterCount = reflectionInfo.requiredParameterCount;
+      optionalParameterCount = reflectionInfo.optionalParameterCount;
+      assert(int.parse(info[1]) == requiredParameterCount
+          + optionalParameterCount);
     }
     return new JsMethodMirror(
         s(name), jsFunction, requiredParameterCount, optionalParameterCount,
         isGetter, isSetter, isStatic, isConstructor, isOperator);
   }
 
   String get _prettyName => 'MethodMirror';
 
   int get _parameterCount => _requiredParameterCount + _optionalParameterCount;
 
@@ skipping 606 matching lines @@
 /// method.
 bool isReflectiveDataInPrototype(String key) {
   if (key == JS_GET_NAME(JsGetName.CLASS_DESCRIPTOR_PROPERTY) ||
       key == METHODS_WITH_OPTIONAL_ARGUMENTS) {
     return true;
   }
   String firstChar = key[0];
   return firstChar == '*' || firstChar == '+';
 }
 
-bool isNoSuchMethodStub(var jsFunction) {
-  return JS('bool', r'#.$reflectable == 2', jsFunction);
+/// Returns `true` if [jsFunction] is an ordinary reflectable method and
+/// not a (potentially reflectable) stub or otherwise non-reflectable method.
+bool isOrdinaryReflectableMethod(var jsFunction) {
+  return JS('bool', r'#.$reflectable === 1', jsFunction);
 }
 
 /// Returns true if [key] is only an aliased entry for [function] in the
 /// prototype.
 bool isAliasedSuperMethod(var jsFunction, String key) {
   var stubName = JS('String|Null', r'#.$stubName', jsFunction);
   return stubName != null && key != stubName;
 }
 
 class NoSuchStaticMethodError extends Error implements NoSuchMethodError {
@@ skipping 59 matching lines @@
   // have a part (following a '.') that starts with '_'.
   const int UNDERSCORE = 0x5f;
   if (name.isEmpty) return true;
   int index = -1;
   do {
     if (name.codeUnitAt(index + 1) == UNDERSCORE) return false;
     index = name.indexOf('.', index + 1);
   } while (index >= 0 && index + 1 < name.length);
   return true;
 }