Refactor BackendHelpers to make 'find' methods private.

pkg/compiler/lib/src/js_backend/backend_helpers.dart

 // Copyright (c) 2015, 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 dart2js.js_backend.helpers;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Uris;
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../core_types.dart' show CommonElements;
 import '../elements/elements.dart'
     show
         AbstractFieldElement,
         ClassElement,
         ConstructorElement,
         Element,
         EnumClassElement,
         FunctionElement,
         LibraryElement,
         MemberElement,
         MethodElement,
         Name,
         PublicName;
 import '../library_loader.dart' show LoadedLibraries;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
+import 'constant_system_javascript.dart';
 import 'js_backend.dart';
 
 /// Helper classes and functions for the JavaScript backend.
 class BackendHelpers {
   static final Uri DART_JS_HELPER = new Uri(scheme: 'dart', path: '_js_helper');
   static final Uri DART_INTERCEPTORS =
       new Uri(scheme: 'dart', path: '_interceptors');
   static final Uri DART_FOREIGN_HELPER =
       new Uri(scheme: 'dart', path: '_foreign_helper');
   static final Uri DART_JS_MIRRORS =
@@ skipping 136 matching lines @@
   FunctionElement requiresPreambleMarker;
 
   /// Holds the class for the [JsGetName] enum.
   EnumClassElement jsGetNameEnum;
 
   /// Holds the class for the [JsBuiltins] enum.
   EnumClassElement jsBuiltinEnum;
 
   ClassElement _symbolImplementationClass;
   ClassElement get symbolImplementationClass {
-    return _symbolImplementationClass ??= find(internalLibrary, 'Symbol');
+    return _symbolImplementationClass ??= _find(internalLibrary, 'Symbol');
   }
 
   final Selector symbolValidatedConstructorSelector =
       new Selector.call(const PublicName('validated'), CallStructure.ONE_ARG);
 
   ConstructorElement _symbolValidatedConstructor;
 
   bool isSymbolValidatedConstructor(Element element) {
     if (_symbolValidatedConstructor != null) {
       return element == _symbolValidatedConstructor;
     }
     return false;
   }
 
   ConstructorElement get symbolValidatedConstructor {
     return _symbolValidatedConstructor ??= _findConstructor(
         symbolImplementationClass, symbolValidatedConstructorSelector.name);
   }
 
   // TODO(johnniwinther): Make these private.
-  // TODO(johnniwinther): Split into findHelperFunction and findHelperClass and
+  // TODO(johnniwinther): Split into _findHelperFunction and _findHelperClass and
   // add a check that the element has the expected kind.
-  Element findHelper(String name) => find(jsHelperLibrary, name);
-  Element findAsyncHelper(String name) => find(asyncLibrary, name);
-  Element findInterceptor(String name) => find(interceptorsLibrary, name);
-  Element find(LibraryElement library, String name) {
+  Element _findHelper(String name) => _find(jsHelperLibrary, name);
+  FunctionElement _findHelperFunction(String name) =>
+      _find(jsHelperLibrary, name);
+  Element _findAsyncHelper(String name) => _find(asyncLibrary, name);
+  Element _findInterceptor(String name) => _find(interceptorsLibrary, name);
+  Element _find(LibraryElement library, String name) {
     Element element = library.implementation.findLocal(name);
     assert(invariant(library, element != null,
         message: "Element '$name' not found in '${library.canonicalUri}'."));
     return element;
   }
 
   Element findCoreHelper(String name) =>
       compiler.commonElements.coreLibrary.implementation.localLookup(name);
 
   ConstructorElement _findConstructor(ClassElement cls, String name) {
@@ skipping 17 matching lines @@
     } else if (uri == DART_FOREIGN_HELPER) {
       foreignLibrary = library;
     } else if (uri == DART_ISOLATE_HELPER) {
       isolateHelperLibrary = library;
     }
   }
 
   void initializeHelperClasses(DiagnosticReporter reporter) {
     final List missingHelperClasses = [];
     ClassElement lookupHelperClass(String name) {
-      ClassElement result = findHelper(name);
+      ClassElement result = _findHelper(name);
       if (result == null) {
         missingHelperClasses.add(name);
       }
       return result;
     }
 
     jsInvocationMirrorClass = lookupHelperClass('JSInvocationMirror');
     boundClosureClass = lookupHelperClass('BoundClosure');
     closureClass = lookupHelperClass('Closure');
     if (!missingHelperClasses.isEmpty) {
       reporter.internalError(
           jsHelperLibrary,
           'dart:_js_helper library does not contain required classes: '
           '$missingHelperClasses');
     }
   }
 
   void onLibraryScanned(LibraryElement library) {
     Uri uri = library.canonicalUri;
 
     FunctionElement findMethod(String name) {
-      return find(library, name);
+      return _find(library, name);
     }
 
     ClassElement findClass(String name) {
-      return find(library, name);
+      return _find(library, name);
     }
 
     if (uri == DART_INTERCEPTORS) {
       getInterceptorMethod = findMethod('getInterceptor');
       getNativeInterceptorMethod = findMethod('getNativeInterceptor');
       jsInterceptorClass = findClass('Interceptor');
       jsStringClass = findClass('JSString');
       jsArrayClass = findClass('JSArray');
       // The int class must be before the double class, because the
       // emitter relies on this list for the order of type checks.
@@ skipping 10 matching lines @@
       jsExtendableArrayClass = findClass('JSExtendableArray');
       jsUnmodifiableArrayClass = findClass('JSUnmodifiableArray');
       jsPlainJavaScriptObjectClass = findClass('PlainJavaScriptObject');
       jsJavaScriptObjectClass = findClass('JavaScriptObject');
       jsJavaScriptFunctionClass = findClass('JavaScriptFunction');
       jsUnknownJavaScriptObjectClass = findClass('UnknownJavaScriptObject');
       jsIndexableClass = findClass('JSIndexable');
       jsMutableIndexableClass = findClass('JSMutableIndexable');
     } else if (uri == DART_JS_HELPER) {
       initializeHelperClasses(reporter);
-      assertTest = findHelper('assertTest');
-      assertThrow = findHelper('assertThrow');
-      assertHelper = findHelper('assertHelper');
-      assertUnreachableMethod = findHelper('assertUnreachable');
+      assertTest = _findHelper('assertTest');
+      assertThrow = _findHelper('assertThrow');
+      assertHelper = _findHelper('assertHelper');
+      assertUnreachableMethod = _findHelper('assertUnreachable');
 
       typeLiteralClass = findClass('TypeImpl');
       constMapLiteralClass = findClass('ConstantMap');
       typeVariableClass = findClass('TypeVariable');
 
       jsIndexingBehaviorInterface = findClass('JavaScriptIndexingBehavior');
 
       noSideEffectsClass = findClass('NoSideEffects');
       noThrowsClass = findClass('NoThrows');
       noInlineClass = findClass('NoInline');
       forceInlineClass = findClass('ForceInline');
       irRepresentationClass = findClass('IrRepresentation');
 
       getIsolateAffinityTagMarker = findMethod('getIsolateAffinityTag');
 
       requiresPreambleMarker = findMethod('requiresPreamble');
     } else if (uri == DART_JS_MIRRORS) {
-      disableTreeShakingMarker = find(library, 'disableTreeShaking');
-      preserveMetadataMarker = find(library, 'preserveMetadata');
-      preserveUrisMarker = find(library, 'preserveUris');
-      preserveLibraryNamesMarker = find(library, 'preserveLibraryNames');
+      disableTreeShakingMarker = _find(library, 'disableTreeShaking');
+      preserveMetadataMarker = _find(library, 'preserveMetadata');
+      preserveUrisMarker = _find(library, 'preserveUris');
+      preserveLibraryNamesMarker = _find(library, 'preserveLibraryNames');
     } else if (uri == DART_JS_NAMES) {
-      preserveNamesMarker = find(library, 'preserveNames');
+      preserveNamesMarker = _find(library, 'preserveNames');
     } else if (uri == DART_EMBEDDED_NAMES) {
-      jsGetNameEnum = find(library, 'JsGetName');
-      jsBuiltinEnum = find(library, 'JsBuiltin');
+      jsGetNameEnum = _find(library, 'JsGetName');
+      jsBuiltinEnum = _find(library, 'JsBuiltin');
     } else if (uri == Uris.dart__native_typed_data) {
       typedArrayClass = findClass('NativeTypedArray');
       typedArrayOfIntClass = findClass('NativeTypedArrayOfInt');
     } else if (uri == PACKAGE_JS) {
-      jsAnnotationClass = find(library, 'JS');
-      jsAnonymousClass = find(library, '_Anonymous');
+      jsAnnotationClass = _find(library, 'JS');
+      jsAnonymousClass = _find(library, '_Anonymous');
     }
   }
 
   void onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     assert(loadedLibraries.containsLibrary(Uris.dart_core));
     assert(loadedLibraries.containsLibrary(DART_INTERCEPTORS));
     assert(loadedLibraries.containsLibrary(DART_JS_HELPER));
 
     if (jsInvocationMirrorClass != null) {
       jsInvocationMirrorClass.ensureResolved(resolution);
@@ skipping 105 matching lines @@
       return element;
     }
 
     _mapLiteralConstructor = getFactory('_literal', 1);
     _mapLiteralConstructorEmpty = getFactory('_empty', 0);
     _mapLiteralUntypedMaker = getMember('_makeLiteral');
     _mapLiteralUntypedEmptyMaker = getMember('_makeEmpty');
   }
 
   Element get badMain {
-    return findHelper('badMain');
+    return _findHelper('badMain');
   }
 
   Element get missingMain {
-    return findHelper('missingMain');
+    return _findHelper('missingMain');
   }
 
   Element get mainHasTooManyParameters {
-    return findHelper('mainHasTooManyParameters');
+    return _findHelper('mainHasTooManyParameters');
   }
 
   MethodElement get loadLibraryWrapper {
-    return findHelper("_loadLibraryWrapper");
+    return _findHelper("_loadLibraryWrapper");
   }
 
   Element get boolConversionCheck {
-    return findHelper('boolConversionCheck');
+    return _findHelper('boolConversionCheck');
   }
 
   MethodElement _traceHelper;
 
   MethodElement get traceHelper {
     return _traceHelper ??= JavaScriptBackend.TRACE_METHOD == 'console'
         ? _consoleTraceHelper
         : _postTraceHelper;
   }
 
   MethodElement get _consoleTraceHelper {
-    return findHelper('consoleTraceHelper');
+    return _findHelper('consoleTraceHelper');
   }
 
   MethodElement get _postTraceHelper {
-    return findHelper('postTraceHelper');
+    return _findHelper('postTraceHelper');
   }
 
   FunctionElement get closureFromTearOff {
-    return findHelper('closureFromTearOff');
+    return _findHelper('closureFromTearOff');
   }
 
   Element get isJsIndexable {
-    return findHelper('isJsIndexable');
+    return _findHelper('isJsIndexable');
   }
 
   Element get throwIllegalArgumentException {
-    return findHelper('iae');
+    return _findHelper('iae');
   }
 
   Element get throwIndexOutOfRangeException {
-    return findHelper('ioore');
+    return _findHelper('ioore');
   }
 
   Element get exceptionUnwrapper {
-    return findHelper('unwrapException');
+    return _findHelper('unwrapException');
   }
 
   Element get throwRuntimeError {
-    return findHelper('throwRuntimeError');
+    return _findHelper('throwRuntimeError');
   }
 
   Element get throwTypeError {
-    return findHelper('throwTypeError');
+    return _findHelper('throwTypeError');
   }
 
   Element get throwAbstractClassInstantiationError {
-    return findHelper('throwAbstractClassInstantiationError');
+    return _findHelper('throwAbstractClassInstantiationError');
   }
 
   Element get checkConcurrentModificationError {
     if (cachedCheckConcurrentModificationError == null) {
       cachedCheckConcurrentModificationError =
-          findHelper('checkConcurrentModificationError');
+          _findHelper('checkConcurrentModificationError');
     }
     return cachedCheckConcurrentModificationError;
   }
 
   Element get throwConcurrentModificationError {
-    return findHelper('throwConcurrentModificationError');
+    return _findHelper('throwConcurrentModificationError');
   }
 
-  Element get checkInt => _checkInt ??= findHelper('checkInt');
+  Element get checkInt => _checkInt ??= _findHelper('checkInt');
   Element _checkInt;
 
-  Element get checkNum => _checkNum ??= findHelper('checkNum');
+  Element get checkNum => _checkNum ??= _findHelper('checkNum');
   Element _checkNum;
 
-  Element get checkString => _checkString ??= findHelper('checkString');
+  Element get checkString => _checkString ??= _findHelper('checkString');
   Element _checkString;
 
   Element get stringInterpolationHelper {
-    return findHelper('S');
+    return _findHelper('S');
   }
 
   Element get wrapExceptionHelper {
-    return findHelper(r'wrapException');
+    return _findHelper(r'wrapException');
   }
 
   Element get throwExpressionHelper {
-    return findHelper('throwExpression');
+    return _findHelper('throwExpression');
   }
 
   Element get closureConverter {
-    return findHelper('convertDartClosureToJS');
+    return _findHelper('convertDartClosureToJS');
   }
 
   Element get traceFromException {
-    return findHelper('getTraceFromException');
+    return _findHelper('getTraceFromException');
   }
 
   Element get setRuntimeTypeInfo {
-    return findHelper('setRuntimeTypeInfo');
+    return _findHelper('setRuntimeTypeInfo');
   }
 
   Element get getRuntimeTypeInfo {
-    return findHelper('getRuntimeTypeInfo');
+    return _findHelper('getRuntimeTypeInfo');
   }
 
   Element get getTypeArgumentByIndex {
-    return findHelper('getTypeArgumentByIndex');
+    return _findHelper('getTypeArgumentByIndex');
   }
 
   Element get computeSignature {
-    return findHelper('computeSignature');
+    return _findHelper('computeSignature');
   }
 
   Element get getRuntimeTypeArguments {
-    return findHelper('getRuntimeTypeArguments');
+    return _findHelper('getRuntimeTypeArguments');
   }
 
   Element get getRuntimeTypeArgument {
-    return findHelper('getRuntimeTypeArgument');
+    return _findHelper('getRuntimeTypeArgument');
   }
 
   Element get runtimeTypeToString {
-    return findHelper('runtimeTypeToString');
+    return _findHelper('runtimeTypeToString');
   }
 
   Element get assertIsSubtype {
-    return findHelper('assertIsSubtype');
+    return _findHelper('assertIsSubtype');
   }
 
   Element get checkSubtype {
-    return findHelper('checkSubtype');
+    return _findHelper('checkSubtype');
   }
 
   Element get assertSubtype {
-    return findHelper('assertSubtype');
+    return _findHelper('assertSubtype');
   }
 
   Element get subtypeCast {
-    return findHelper('subtypeCast');
+    return _findHelper('subtypeCast');
   }
 
   Element get checkSubtypeOfRuntimeType {
-    return findHelper('checkSubtypeOfRuntimeType');
+    return _findHelper('checkSubtypeOfRuntimeType');
   }
 
   Element get assertSubtypeOfRuntimeType {
-    return findHelper('assertSubtypeOfRuntimeType');
+    return _findHelper('assertSubtypeOfRuntimeType');
   }
 
   Element get subtypeOfRuntimeTypeCast {
-    return findHelper('subtypeOfRuntimeTypeCast');
+    return _findHelper('subtypeOfRuntimeTypeCast');
   }
 
   Element get checkDeferredIsLoaded {
-    return findHelper('checkDeferredIsLoaded');
+    return _findHelper('checkDeferredIsLoaded');
   }
 
   Element get throwNoSuchMethod {
-    return findHelper('throwNoSuchMethod');
+    return _findHelper('throwNoSuchMethod');
   }
 
   Element get genericNoSuchMethod =>
       _genericNoSuchMethod ??= findCoreHelper('_genericNoSuchMethod');
   MethodElement _genericNoSuchMethod;
 
   Element get unresolvedConstructorError => _unresolvedConstructorError ??=
       findCoreHelper('_unresolvedConstructorError');
   MethodElement _unresolvedConstructorError;
 
   Element get malformedTypeError =>
       _malformedTypeError ??= findCoreHelper('_malformedTypeError');
   MethodElement _malformedTypeError;
 
   Element get createRuntimeType {
-    return findHelper('createRuntimeType');
+    return _findHelper('createRuntimeType');
   }
 
   Element get fallThroughError {
-    return findHelper("getFallThroughError");
+    return _findHelper("getFallThroughError");
   }
 
   Element get createInvocationMirror {
-    return findHelper('createInvocationMirror');
+    return _findHelper('createInvocationMirror');
   }
 
   Element get cyclicThrowHelper {
-    return findHelper("throwCyclicInit");
+    return _findHelper("throwCyclicInit");
   }
 
   Element get asyncHelper {
-    return findAsyncHelper("_asyncHelper");
+    return _findAsyncHelper("_asyncHelper");
   }
 
   Element get wrapBody {
-    return findAsyncHelper("_wrapJsFunctionForAsync");
+    return _findAsyncHelper("_wrapJsFunctionForAsync");
   }
 
   Element get yieldStar {
-    ClassElement classElement = findAsyncHelper("_IterationMarker");
+    ClassElement classElement = _findAsyncHelper("_IterationMarker");
     classElement.ensureResolved(resolution);
     return classElement.lookupLocalMember("yieldStar");
   }
 
   Element get yieldSingle {
-    ClassElement classElement = findAsyncHelper("_IterationMarker");
+    ClassElement classElement = _findAsyncHelper("_IterationMarker");
     classElement.ensureResolved(resolution);
     return classElement.lookupLocalMember("yieldSingle");
   }
 
   Element get syncStarUncaughtError {
-    ClassElement classElement = findAsyncHelper("_IterationMarker");
+    ClassElement classElement = _findAsyncHelper("_IterationMarker");
     classElement.ensureResolved(resolution);
     return classElement.lookupLocalMember("uncaughtError");
   }
 
   Element get asyncStarHelper {
-    return findAsyncHelper("_asyncStarHelper");
+    return _findAsyncHelper("_asyncStarHelper");
   }
 
   Element get streamOfController {
-    return findAsyncHelper("_streamOfController");
+    return _findAsyncHelper("_streamOfController");
   }
 
   Element get endOfIteration {
-    ClassElement classElement = findAsyncHelper("_IterationMarker");
+    ClassElement classElement = _findAsyncHelper("_IterationMarker");
     classElement.ensureResolved(resolution);
     return classElement.lookupLocalMember("endOfIteration");
   }
 
   Element get syncStarIterable {
-    ClassElement classElement = findAsyncHelper("_SyncStarIterable");
+    ClassElement classElement = _findAsyncHelper("_SyncStarIterable");
     classElement.ensureResolved(resolution);
     return classElement;
   }
 
   Element get futureImplementation {
-    ClassElement classElement = findAsyncHelper('_Future');
+    ClassElement classElement = _findAsyncHelper('_Future');
     classElement.ensureResolved(resolution);
     return classElement;
   }
 
   Element get controllerStream {
-    ClassElement classElement = findAsyncHelper("_ControllerStream");
+    ClassElement classElement = _findAsyncHelper("_ControllerStream");
     classElement.ensureResolved(resolution);
     return classElement;
   }
 
   Element get syncStarIterableConstructor {
     ClassElement classElement = syncStarIterable;
     classElement.ensureResolved(resolution);
     return classElement.lookupConstructor("");
   }
 
   Element get syncCompleterConstructor {
-    ClassElement classElement = find(asyncLibrary, "Completer");
+    ClassElement classElement = _find(asyncLibrary, "Completer");
     classElement.ensureResolved(resolution);
     return classElement.lookupConstructor("sync");
   }
 
   Element get asyncStarController {
-    ClassElement classElement = findAsyncHelper("_AsyncStarStreamController");
+    ClassElement classElement = _findAsyncHelper("_AsyncStarStreamController");
     classElement.ensureResolved(resolution);
     return classElement;
   }
 
   Element get asyncStarControllerConstructor {
     ClassElement classElement = asyncStarController;
     return classElement.lookupConstructor("");
   }
 
   Element get streamIteratorConstructor {
-    ClassElement classElement = find(asyncLibrary, "StreamIterator");
+    ClassElement classElement = _find(asyncLibrary, "StreamIterator");
     classElement.ensureResolved(resolution);
     return classElement.lookupConstructor("");
   }
 
   ClassElement get VoidRuntimeType {
-    return findHelper('VoidRuntimeType');
+    return _findHelper('VoidRuntimeType');
   }
 
   ClassElement get RuntimeType {
-    return findHelper('RuntimeType');
+    return _findHelper('RuntimeType');
   }
 
   ClassElement get RuntimeFunctionType {
-    return findHelper('RuntimeFunctionType');
+    return _findHelper('RuntimeFunctionType');
   }
 
   ClassElement get RuntimeTypePlain {
-    return findHelper('RuntimeTypePlain');
+    return _findHelper('RuntimeTypePlain');
   }
 
   ClassElement get RuntimeTypeGeneric {
-    return findHelper('RuntimeTypeGeneric');
+    return _findHelper('RuntimeTypeGeneric');
   }
 
   ClassElement get DynamicRuntimeType {
-    return findHelper('DynamicRuntimeType');
+    return _findHelper('DynamicRuntimeType');
+  }
+
+  MethodElement get getDynamicRuntimeType {
+    // TODO(johnniwinther): Support this in mocks.
+    return jsHelperLibrary.find('getDynamicRuntimeType');
+  }
+
+  MethodElement get getVoidRuntimeType {
+    // TODO(johnniwinther): Support this in mocks.
+    return jsHelperLibrary.find('getVoidRuntimeType');
+  }
+
+  MethodElement get buildInterfaceType {
+    // TODO(johnniwinther): Support this in mocks.
+    return jsHelperLibrary.find('buildInterfaceType');
+  }
+
+  MethodElement get buildFunctionType {
+    // TODO(johnniwinther): Support this in mocks.
+    return jsHelperLibrary.find('buildFunctionType');
+  }
+
+  MethodElement get buildNamedFunctionType {
+    // TODO(johnniwinther): Support this in mocks.
+    return jsHelperLibrary.find('buildNamedFunctionType');
   }
 
   MethodElement get functionTypeTestMetaHelper {
-    return findHelper('functionTypeTestMetaHelper');
+    return _findHelper('functionTypeTestMetaHelper');
   }
 
   MethodElement get defineProperty {
-    return findHelper('defineProperty');
+    return _findHelper('defineProperty');
   }
 
   Element get startRootIsolate {
-    return find(isolateHelperLibrary, START_ROOT_ISOLATE);
+    return _find(isolateHelperLibrary, START_ROOT_ISOLATE);
   }
 
   Element get currentIsolate {
-    return find(isolateHelperLibrary, '_currentIsolate');
+    return _find(isolateHelperLibrary, '_currentIsolate');
   }
 
   Element get callInIsolate {
-    return find(isolateHelperLibrary, '_callInIsolate');
+    return _find(isolateHelperLibrary, '_callInIsolate');
   }
 
   Element get findIndexForNativeSubclassType {
-    return findInterceptor('findIndexForNativeSubclassType');
+    return _findInterceptor('findIndexForNativeSubclassType');
   }
 
   Element get convertRtiToRuntimeType {
-    return findHelper('convertRtiToRuntimeType');
+    return _findHelper('convertRtiToRuntimeType');
   }
 
   ClassElement get stackTraceClass {
-    return findHelper('_StackTrace');
+    return _findHelper('_StackTrace');
   }
 
   MethodElement _objectNoSuchMethod;
 
   MethodElement get objectNoSuchMethod {
     if (_objectNoSuchMethod == null) {
       _objectNoSuchMethod = commonElements.objectClass
           .lookupLocalMember(Identifiers.noSuchMethod_);
     }
     return _objectNoSuchMethod;
   }
+
+  ClassElement get constantMapClass =>
+      _findHelper(JavaScriptMapConstant.DART_CLASS);
+  ClassElement get constantStringMapClass =>
+      _findHelper(JavaScriptMapConstant.DART_STRING_CLASS);
+  ClassElement get constantProtoMapClass =>
+      _findHelper(JavaScriptMapConstant.DART_PROTO_CLASS);
+  ClassElement get generalConstantMapClass =>
+      _findHelper(JavaScriptMapConstant.DART_GENERAL_CLASS);
+
+  ClassElement get annotationCreatesClass {
+    return _findHelper('Creates');
+  }
+
+  ClassElement get annotationReturnsClass {
+    return _findHelper('Returns');
+  }
+
+  ClassElement get annotationJSNameClass {
+    return _findHelper('JSName');
+  }
+
+  MethodElement get toStringForNativeObject {
+    return _findHelper('toStringForNativeObject');
+  }
+
+  MethodElement get hashCodeForNativeObject {
+    return _findHelper('hashCodeForNativeObject');
+  }
 }