dart2js: Make usage of names more consistent between compiler and runtime.

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 'shared/runtime_data.dart' as encoding;
 import 'shared/embedded_names.dart' show
     ALL_CLASSES,
     LAZIES,
     LIBRARIES,
     STATICS,
     TYPE_INFORMATION;
 
 import 'dart:collection' show
     UnmodifiableListView,
     UnmodifiableMapView;
 
 import 'dart:mirrors';
 
 import 'dart:_foreign_helper' show
     JS,
     JS_CURRENT_ISOLATE,
     JS_CURRENT_ISOLATE_CONTEXT,
     JS_EMBEDDED_GLOBAL,
-    JS_GET_NAME;
+    JS_GET_NAME,
+    JS_TYPEDEF_TAG,

[karlklose, 2014/11/28 10:19:00]

I think we should use JS_GET_NAME instead of having all these special cases.

[floitsch, 2014/11/28 10:40:16]

Added TODOs in the builder.

+    JS_FUNCTION_TYPE_TAG,
+    JS_FUNCTION_TYPE_RETURN_TYPE_TAG,
+    JS_FUNCTION_TYPE_VOID_RETURN_TAG,
+    JS_FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG,
+    JS_FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG,
+    JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG;
+
 
 import 'dart:_internal' as _symbol_dev;
 
 import 'dart:_js_helper' show
     BoundClosure,
     CachedInvocation,
     Closure,
     JSInvocationMirror,
     JsCache,
     Null,
@@ skipping 2558 matching lines @@
 class JsFunctionTypeMirror extends BrokenClassMirror
     implements FunctionTypeMirror {
   final _typeData;
   String _cachedToString;
   TypeMirror _cachedReturnType;
   UnmodifiableListView<ParameterMirror> _cachedParameters;
   DeclarationMirror owner;
 
   JsFunctionTypeMirror(this._typeData, this.owner);
 
-  bool get _hasReturnType => JS('bool', '"ret" in #', _typeData);
-  get _returnType => JS('', '#.ret', _typeData);
+  bool get _hasReturnType {
+    return JS('bool', '# in #', JS_FUNCTION_TYPE_RETURN_TYPE_TAG(), _typeData);
+  }
+  get _returnType {
+    return JS('', '#[#]', _typeData, JS_FUNCTION_TYPE_RETURN_TYPE_TAG());
+  }
 
-  bool get _isVoid => JS('bool', '!!#.void', _typeData);
+  bool get _isVoid {
+    return JS('bool', '!!#[#]', _typeData, JS_FUNCTION_TYPE_VOID_RETURN_TAG());
+  }
 
-  bool get _hasArguments => JS('bool', '"args" in #', _typeData);
-  List get _arguments => JS('JSExtendableArray', '#.args', _typeData);
+  bool get _hasArguments {
+    return JS('bool', '# in #',
+              JS_FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG(), _typeData);
+  }
+  List get _arguments {
+    return JS('JSExtendableArray', '#[#]',
+              _typeData, JS_FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG());
+  }
 
-  bool get _hasOptionalArguments => JS('bool', '"opt" in #', _typeData);
-  List get _optionalArguments => JS('JSExtendableArray', '#.opt', _typeData);
+  bool get _hasOptionalArguments {
+    return JS('bool', '# in #',
+              JS_FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG(), _typeData);
+  }
+  List get _optionalArguments {
+    return JS('JSExtendableArray', '#[#]',
+              _typeData, JS_FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG());
+  }
 
-  bool get _hasNamedArguments => JS('bool', '"named" in #', _typeData);
-  get _namedArguments => JS('=Object', '#.named', _typeData);
+  bool get _hasNamedArguments {
+    return JS('bool', '# in #',
+              JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG(), _typeData);
+  }
+  get _namedArguments {
+    return JS('=Object', '#[#]',
+              _typeData, JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG());
+  }
+
   bool get isOriginalDeclaration => true;
 
   bool get isAbstract => false;
 
   TypeMirror get returnType {
     if (_cachedReturnType != null) return _cachedReturnType;
     if (_isVoid) return _cachedReturnType = JsMirrorSystem._voidType;
     if (!_hasReturnType) return _cachedReturnType = JsMirrorSystem._dynamicType;
     return _cachedReturnType =
         typeMirrorFromRuntimeTypeRepresentation(owner, _returnType);
@@ skipping 164 matching lines @@
       }
       return typeArgument._mangledName;
     }
     representation =
         runtimeTypeToString(type, onTypeVariable: substituteTypeVariable);
   }
   if (representation != null) {
     return reflectClassByMangledName(
         getMangledTypeName(createRuntimeType(representation)));
   }
-  if (type != null && JS('', '#.typedef', type) != null) {
+  String typedefPropertyName = JS_TYPEDEF_TAG();
+  String functionTagPropertyName = JS_FUNCTION_TYPE_TAG();
+  if (type != null && JS('', '#[#]', type, typedefPropertyName) != null) {
     return typeMirrorFromRuntimeTypeRepresentation(
-        owner, JS('', '#.typedef', type));
-  } else if (type != null && JS('', '#.func', type) != null) {
+        owner, JS('', '#[#]', type, typedefPropertyName));
+  } else if (type != null &&
+             JS('', '#[#]', type, functionTagPropertyName) != null) {
     return new JsFunctionTypeMirror(type, owner);
   }
   return reflectClass(Function);
 }
 
 Symbol computeQualifiedName(DeclarationMirror owner, Symbol simpleName) {
   if (owner == null) return simpleName;
   String ownerName = n(owner.qualifiedName);
   return s('$ownerName.${n(simpleName)}');
 }
@@ skipping 162 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;
 }