| // Copyright (c) 2017, 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_model.elements; |
| |
| import '../common_elements.dart'; |
| import '../constants/constant_system.dart'; |
| import '../elements/elements.dart'; |
| import '../elements/entities.dart'; |
| import '../elements/types.dart'; |
| import '../js_backend/backend_usage.dart'; |
| import '../js_backend/interceptor_data.dart'; |
| import '../js_backend/native_data.dart'; |
| import '../native/behavior.dart'; |
| import '../ordered_typeset.dart'; |
| import '../universe/class_set.dart'; |
| import '../universe/function_set.dart'; |
| import '../universe/selector.dart'; |
| import '../universe/world_builder.dart'; |
| import '../world.dart'; |
| |
| /// Bidirectional map between 'frontend' and 'backend' elements. |
| /// |
| /// Frontend elements are what we read in, these typically represents concepts |
| /// in Dart. Backend elements are what we generate, these may include elements |
| /// that do not correspond to a Dart concept, such as closure classes. |
| /// |
| /// Querying for the frontend element for a backend-only element throws an |
| /// exception. |
| class JsToFrontendMap { |
| LibraryEntity toBackendLibrary(LibraryEntity library) => library; |
| LibraryEntity toFrontendLibrary(LibraryEntity library) => library; |
| |
| ClassEntity toBackendClass(ClassEntity cls) => cls; |
| ClassEntity toFrontendClass(ClassEntity cls) => cls; |
| |
| MemberEntity toBackendMember(MemberEntity member) => member; |
| MemberEntity toFrontendMember(MemberEntity member) => member; |
| |
| DartType toBackendType(DartType type) => type; |
| DartType fromFrontendType(DartType type) => type; |
| } |
| |
| class JsClosedWorld extends ClosedWorldBase { |
| JsClosedWorld( |
| {CommonElements commonElements, |
| ConstantSystem constantSystem, |
| NativeData nativeData, |
| InterceptorData interceptorData, |
| BackendUsage backendUsage, |
| ResolutionWorldBuilder resolutionWorldBuilder, |
| Set<ClassEntity> implementedClasses, |
| FunctionSet functionSet, |
| Set<TypedefElement> allTypedefs, |
| Map<ClassEntity, Set<ClassEntity>> mixinUses, |
| Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses, |
| Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes, |
| Map<ClassEntity, ClassSet> classSets}) |
| : super( |
| commonElements: commonElements, |
| constantSystem: constantSystem, |
| nativeData: nativeData, |
| interceptorData: interceptorData, |
| backendUsage: backendUsage, |
| resolutionWorldBuilder: resolutionWorldBuilder, |
| implementedClasses: implementedClasses, |
| functionSet: functionSet, |
| allTypedefs: allTypedefs, |
| mixinUses: mixinUses, |
| typesImplementedBySubclasses: typesImplementedBySubclasses, |
| classHierarchyNodes: classHierarchyNodes, |
| classSets: classSets); |
| |
| @override |
| bool hasConcreteMatch(ClassEntity cls, Selector selector, |
| {ClassEntity stopAtSuperclass}) { |
| throw new UnimplementedError('JsClosedWorld.hasConcreteMatch'); |
| } |
| |
| @override |
| void registerClosureClass(ClassElement cls) { |
| throw new UnimplementedError('JsClosedWorld.registerClosureClass'); |
| } |
| |
| @override |
| bool hasElementIn(ClassEntity cls, Selector selector, Entity element) { |
| throw new UnimplementedError('JsClosedWorld.hasElementIn'); |
| } |
| |
| @override |
| bool checkEntity(Entity element) => true; |
| |
| @override |
| bool checkClass(ClassEntity cls) => true; |
| |
| @override |
| bool checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true}) { |
| return true; |
| } |
| |
| @override |
| OrderedTypeSet getOrderedTypeSet(ClassEntity cls) { |
| throw new UnimplementedError('JsClosedWorld.getOrderedTypeSet'); |
| } |
| |
| @override |
| int getHierarchyDepth(ClassEntity cls) { |
| throw new UnimplementedError('JsClosedWorld.getHierarchyDepth'); |
| } |
| |
| @override |
| ClassEntity getSuperClass(ClassEntity cls) { |
| throw new UnimplementedError('JsClosedWorld.getSuperClass'); |
| } |
| |
| @override |
| Iterable<ClassEntity> getInterfaces(ClassEntity cls) { |
| throw new UnimplementedError('JsClosedWorld.getInterfaces'); |
| } |
| |
| @override |
| ClassEntity getAppliedMixin(ClassEntity cls) { |
| throw new UnimplementedError('JsClosedWorld.getAppliedMixin'); |
| } |
| |
| @override |
| bool isNamedMixinApplication(ClassEntity cls) { |
| throw new UnimplementedError('JsClosedWorld.isNamedMixinApplication'); |
| } |
| } |
| |
| class JsNativeData implements NativeData { |
| final JsToFrontendMap _map; |
| final NativeData _nativeData; |
| |
| JsNativeData(this._map, this._nativeData); |
| |
| @override |
| bool isNativeClass(ClassEntity element) { |
| return _nativeData.isNativeClass(_map.toFrontendClass(element)); |
| } |
| |
| @override |
| String computeUnescapedJSInteropName(String name) { |
| return _nativeData.computeUnescapedJSInteropName(name); |
| } |
| |
| @override |
| String getJsInteropMemberName(MemberEntity element) { |
| return _nativeData.getJsInteropMemberName(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| String getJsInteropClassName(ClassEntity element) { |
| return _nativeData.getJsInteropClassName(_map.toFrontendClass(element)); |
| } |
| |
| @override |
| bool isAnonymousJsInteropClass(ClassEntity element) { |
| return _nativeData.isAnonymousJsInteropClass(_map.toFrontendClass(element)); |
| } |
| |
| @override |
| String getJsInteropLibraryName(LibraryEntity element) { |
| return _nativeData.getJsInteropLibraryName(_map.toFrontendLibrary(element)); |
| } |
| |
| @override |
| bool isJsInteropMember(MemberEntity element) { |
| return _nativeData.isJsInteropMember(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| String getFixedBackendMethodPath(FunctionEntity element) { |
| return _nativeData |
| .getFixedBackendMethodPath(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| String getFixedBackendName(MemberEntity element) { |
| return _nativeData.getFixedBackendName(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| bool hasFixedBackendName(MemberEntity element) { |
| return _nativeData.hasFixedBackendName(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| NativeBehavior getNativeFieldStoreBehavior(FieldEntity field) { |
| return _nativeData |
| .getNativeFieldStoreBehavior(_map.toFrontendMember(field)); |
| } |
| |
| @override |
| NativeBehavior getNativeFieldLoadBehavior(FieldEntity field) { |
| return _nativeData.getNativeFieldLoadBehavior(_map.toFrontendMember(field)); |
| } |
| |
| @override |
| NativeBehavior getNativeMethodBehavior(FunctionEntity method) { |
| return _nativeData.getNativeMethodBehavior(_map.toFrontendMember(method)); |
| } |
| |
| @override |
| bool isNativeMember(MemberEntity element) { |
| return _nativeData.isNativeMember(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| bool isJsInteropClass(ClassEntity element) { |
| return _nativeData.isJsInteropClass(_map.toFrontendClass(element)); |
| } |
| |
| @override |
| bool isJsInteropLibrary(LibraryEntity element) { |
| return _nativeData.isJsInteropLibrary(_map.toFrontendLibrary(element)); |
| } |
| |
| @override |
| bool get isJsInteropUsed { |
| return _nativeData.isJsInteropUsed; |
| } |
| |
| @override |
| bool isNativeOrExtendsNative(ClassEntity element) { |
| return _nativeData.isNativeOrExtendsNative(_map.toFrontendClass(element)); |
| } |
| |
| @override |
| bool hasNativeTagsForcedNonLeaf(ClassEntity cls) { |
| return _nativeData.hasNativeTagsForcedNonLeaf(_map.toFrontendClass(cls)); |
| } |
| |
| @override |
| List<String> getNativeTagsOfClass(ClassEntity cls) { |
| return _nativeData.getNativeTagsOfClass(_map.toFrontendClass(cls)); |
| } |
| } |
| |
| class JsBackendUsage implements BackendUsage { |
| final JsToFrontendMap _map; |
| final BackendUsage _backendUsage; |
| |
| @override |
| bool needToInitializeIsolateAffinityTag; |
| @override |
| bool needToInitializeDispatchProperty; |
| |
| JsBackendUsage(this._map, this._backendUsage) { |
| needToInitializeIsolateAffinityTag = |
| _backendUsage.needToInitializeIsolateAffinityTag; |
| needToInitializeDispatchProperty = |
| _backendUsage.needToInitializeDispatchProperty; |
| } |
| |
| @override |
| bool isFunctionUsedByBackend(FunctionEntity element) { |
| return _backendUsage |
| .isFunctionUsedByBackend(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| bool isFieldUsedByBackend(FieldEntity element) { |
| return _backendUsage.isFieldUsedByBackend(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| Iterable<FunctionEntity> get globalFunctionDependencies { |
| return _backendUsage.globalFunctionDependencies.map(_map.toBackendMember); |
| } |
| |
| @override |
| Iterable<ClassEntity> get globalClassDependencies { |
| return _backendUsage.globalClassDependencies.map(_map.toBackendClass); |
| } |
| |
| @override |
| bool get requiresPreamble => _backendUsage.requiresPreamble; |
| |
| @override |
| bool get isInvokeOnUsed => _backendUsage.isInvokeOnUsed; |
| |
| @override |
| bool get isRuntimeTypeUsed => _backendUsage.isRuntimeTypeUsed; |
| |
| @override |
| bool get isIsolateInUse => _backendUsage.isIsolateInUse; |
| |
| @override |
| bool get isFunctionApplyUsed => _backendUsage.isFunctionApplyUsed; |
| |
| @override |
| bool get isNoSuchMethodUsed => _backendUsage.isNoSuchMethodUsed; |
| } |
| |
| class JsCommonElements implements CommonElements { |
| final JsToFrontendMap _map; |
| final CommonElements _commonElements; |
| |
| JsCommonElements(this._map, this._commonElements); |
| |
| @override |
| ClassEntity get objectClass => |
| _map.toBackendClass(_commonElements.objectClass); |
| |
| @override |
| ClassEntity get expectAssumeDynamicClass => |
| _map.toBackendClass(_commonElements.expectAssumeDynamicClass); |
| |
| @override |
| ClassEntity get expectTrustTypeAnnotationsClass => |
| _map.toBackendClass(_commonElements.expectTrustTypeAnnotationsClass); |
| |
| @override |
| ClassEntity get expectNoInlineClass => |
| _map.toBackendClass(_commonElements.expectNoInlineClass); |
| |
| @override |
| FunctionEntity get callInIsolate => |
| _map.toBackendMember(_commonElements.callInIsolate); |
| |
| @override |
| FunctionEntity get currentIsolate => |
| _map.toBackendMember(_commonElements.currentIsolate); |
| |
| @override |
| FunctionEntity get startRootIsolate => |
| _map.toBackendMember(_commonElements.startRootIsolate); |
| |
| @override |
| ClassEntity get jsBuiltinEnum => |
| _map.toBackendClass(_commonElements.jsBuiltinEnum); |
| |
| @override |
| ClassEntity get jsGetNameEnum => |
| _map.toBackendClass(_commonElements.jsGetNameEnum); |
| |
| @override |
| ClassEntity get typedArrayOfIntClass => |
| _map.toBackendClass(_commonElements.typedArrayOfIntClass); |
| |
| @override |
| ClassEntity get typedArrayClass => |
| _map.toBackendClass(_commonElements.typedArrayClass); |
| |
| @override |
| bool isSymbolValidatedConstructor(ConstructorEntity element) => |
| _commonElements |
| .isSymbolValidatedConstructor(_map.toFrontendMember(element)); |
| |
| @override |
| FieldEntity get symbolImplementationField => |
| _map.toBackendMember(_commonElements.symbolImplementationField); |
| |
| @override |
| ConstructorEntity get symbolValidatedConstructor => |
| _map.toBackendMember(_commonElements.symbolValidatedConstructor); |
| |
| @override |
| final Selector symbolValidatedConstructorSelector = null; |
| |
| @override |
| ClassEntity get symbolImplementationClass => |
| _map.toBackendClass(_commonElements.symbolImplementationClass); |
| |
| @override |
| FunctionEntity get hashCodeForNativeObject => |
| _map.toBackendMember(_commonElements.hashCodeForNativeObject); |
| |
| @override |
| FunctionEntity get toStringForNativeObject => |
| _map.toBackendMember(_commonElements.toStringForNativeObject); |
| |
| @override |
| FunctionEntity get convertRtiToRuntimeType => |
| _map.toBackendMember(_commonElements.convertRtiToRuntimeType); |
| |
| @override |
| FunctionEntity get defineProperty => |
| _map.toBackendMember(_commonElements.defineProperty); |
| |
| @override |
| FunctionEntity get cyclicThrowHelper => |
| _map.toBackendMember(_commonElements.cyclicThrowHelper); |
| |
| @override |
| FunctionEntity get createInvocationMirror => |
| _map.toBackendMember(_commonElements.createInvocationMirror); |
| |
| @override |
| FunctionEntity get fallThroughError => |
| _map.toBackendMember(_commonElements.fallThroughError); |
| |
| @override |
| FunctionEntity get createRuntimeType => |
| _map.toBackendMember(_commonElements.createRuntimeType); |
| |
| @override |
| FunctionEntity get throwNoSuchMethod => |
| _map.toBackendMember(_commonElements.throwNoSuchMethod); |
| |
| @override |
| FunctionEntity get checkDeferredIsLoaded => |
| _map.toBackendMember(_commonElements.checkDeferredIsLoaded); |
| |
| @override |
| FunctionEntity get subtypeOfRuntimeTypeCast => |
| _map.toBackendMember(_commonElements.subtypeOfRuntimeTypeCast); |
| |
| @override |
| FunctionEntity get assertSubtypeOfRuntimeType => |
| _map.toBackendMember(_commonElements.assertSubtypeOfRuntimeType); |
| |
| @override |
| FunctionEntity get checkSubtypeOfRuntimeType => |
| _map.toBackendMember(_commonElements.checkSubtypeOfRuntimeType); |
| |
| @override |
| FunctionEntity get functionTypeTest => |
| _map.toBackendMember(_commonElements.functionTypeTest); |
| |
| @override |
| FunctionEntity get subtypeCast => |
| _map.toBackendMember(_commonElements.subtypeCast); |
| |
| @override |
| FunctionEntity get assertSubtype => |
| _map.toBackendMember(_commonElements.assertSubtype); |
| |
| @override |
| FunctionEntity get checkSubtype => |
| _map.toBackendMember(_commonElements.checkSubtype); |
| |
| @override |
| FunctionEntity get assertIsSubtype => |
| _map.toBackendMember(_commonElements.assertIsSubtype); |
| |
| @override |
| FunctionEntity get runtimeTypeToString => |
| _map.toBackendMember(_commonElements.runtimeTypeToString); |
| |
| @override |
| FunctionEntity get getRuntimeTypeArgument => |
| _map.toBackendMember(_commonElements.getRuntimeTypeArgument); |
| |
| @override |
| FunctionEntity get getRuntimeTypeArguments => |
| _map.toBackendMember(_commonElements.getRuntimeTypeArguments); |
| |
| @override |
| FunctionEntity get computeSignature => |
| _map.toBackendMember(_commonElements.computeSignature); |
| |
| @override |
| FunctionEntity get getTypeArgumentByIndex => |
| _map.toBackendMember(_commonElements.getTypeArgumentByIndex); |
| |
| @override |
| FunctionEntity get getRuntimeTypeInfo => |
| _map.toBackendMember(_commonElements.getRuntimeTypeInfo); |
| |
| @override |
| FunctionEntity get setRuntimeTypeInfo => |
| _map.toBackendMember(_commonElements.setRuntimeTypeInfo); |
| |
| @override |
| FunctionEntity get traceFromException => |
| _map.toBackendMember(_commonElements.traceFromException); |
| |
| @override |
| FunctionEntity get closureConverter => |
| _map.toBackendMember(_commonElements.closureConverter); |
| |
| @override |
| FunctionEntity get throwExpressionHelper => |
| _map.toBackendMember(_commonElements.throwExpressionHelper); |
| |
| @override |
| FunctionEntity get wrapExceptionHelper => |
| _map.toBackendMember(_commonElements.wrapExceptionHelper); |
| |
| @override |
| FunctionEntity get stringInterpolationHelper => |
| _map.toBackendMember(_commonElements.stringInterpolationHelper); |
| |
| @override |
| FunctionEntity get checkString => |
| _map.toBackendMember(_commonElements.checkString); |
| |
| @override |
| FunctionEntity get checkNum => _map.toBackendMember(_commonElements.checkNum); |
| |
| @override |
| FunctionEntity get checkInt => _map.toBackendMember(_commonElements.checkInt); |
| |
| @override |
| FunctionEntity get throwConcurrentModificationError => |
| _map.toBackendMember(_commonElements.throwConcurrentModificationError); |
| |
| @override |
| FunctionEntity get checkConcurrentModificationError => |
| _map.toBackendMember(_commonElements.checkConcurrentModificationError); |
| |
| @override |
| FunctionEntity get throwAbstractClassInstantiationError => _map |
| .toBackendMember(_commonElements.throwAbstractClassInstantiationError); |
| |
| @override |
| FunctionEntity get throwTypeError => |
| _map.toBackendMember(_commonElements.throwTypeError); |
| |
| @override |
| FunctionEntity get throwRuntimeError => |
| _map.toBackendMember(_commonElements.throwRuntimeError); |
| |
| @override |
| FunctionEntity get exceptionUnwrapper => |
| _map.toBackendMember(_commonElements.exceptionUnwrapper); |
| |
| @override |
| FunctionEntity get throwIndexOutOfRangeException => |
| _map.toBackendMember(_commonElements.throwIndexOutOfRangeException); |
| |
| @override |
| FunctionEntity get throwIllegalArgumentException => |
| _map.toBackendMember(_commonElements.throwIllegalArgumentException); |
| |
| @override |
| FunctionEntity get isJsIndexable => |
| _map.toBackendMember(_commonElements.isJsIndexable); |
| |
| @override |
| FunctionEntity get closureFromTearOff => |
| _map.toBackendMember(_commonElements.closureFromTearOff); |
| |
| @override |
| FunctionEntity get traceHelper => |
| _map.toBackendMember(_commonElements.traceHelper); |
| |
| @override |
| FunctionEntity get boolConversionCheck => |
| _map.toBackendMember(_commonElements.boolConversionCheck); |
| |
| @override |
| FunctionEntity get loadLibraryWrapper => |
| _map.toBackendMember(_commonElements.loadLibraryWrapper); |
| |
| @override |
| FunctionEntity get mainHasTooManyParameters => |
| _map.toBackendMember(_commonElements.mainHasTooManyParameters); |
| |
| @override |
| FunctionEntity get missingMain => |
| _map.toBackendMember(_commonElements.missingMain); |
| |
| @override |
| FunctionEntity get badMain => _map.toBackendMember(_commonElements.badMain); |
| |
| @override |
| FunctionEntity get requiresPreambleMarker => |
| _map.toBackendMember(_commonElements.requiresPreambleMarker); |
| |
| @override |
| FunctionEntity get getIsolateAffinityTagMarker => |
| _map.toBackendMember(_commonElements.getIsolateAffinityTagMarker); |
| |
| @override |
| FunctionEntity get assertUnreachableMethod => |
| _map.toBackendMember(_commonElements.assertUnreachableMethod); |
| |
| @override |
| FunctionEntity get assertHelper => |
| _map.toBackendMember(_commonElements.assertHelper); |
| |
| @override |
| FunctionEntity get assertThrow => |
| _map.toBackendMember(_commonElements.assertThrow); |
| |
| @override |
| FunctionEntity get assertTest => |
| _map.toBackendMember(_commonElements.assertTest); |
| |
| @override |
| FunctionEntity get invokeOnMethod => |
| _map.toBackendMember(_commonElements.invokeOnMethod); |
| |
| @override |
| ConstructorEntity get typeVariableConstructor => |
| _map.toBackendMember(_commonElements.typeVariableConstructor); |
| |
| @override |
| ClassEntity get nativeAnnotationClass => |
| _map.toBackendClass(_commonElements.nativeAnnotationClass); |
| |
| @override |
| ClassEntity get patchAnnotationClass => |
| _map.toBackendClass(_commonElements.patchAnnotationClass); |
| |
| @override |
| ClassEntity get annotationJSNameClass => |
| _map.toBackendClass(_commonElements.annotationJSNameClass); |
| |
| @override |
| ClassEntity get annotationReturnsClass => |
| _map.toBackendClass(_commonElements.annotationReturnsClass); |
| |
| @override |
| ClassEntity get annotationCreatesClass => |
| _map.toBackendClass(_commonElements.annotationCreatesClass); |
| |
| @override |
| ClassEntity get generalConstantMapClass => |
| _map.toBackendClass(_commonElements.generalConstantMapClass); |
| |
| @override |
| ClassEntity get constantProtoMapClass => |
| _map.toBackendClass(_commonElements.constantProtoMapClass); |
| |
| @override |
| ClassEntity get constantStringMapClass => |
| _map.toBackendClass(_commonElements.constantStringMapClass); |
| |
| @override |
| ClassEntity get constantMapClass => |
| _map.toBackendClass(_commonElements.constantMapClass); |
| |
| @override |
| ClassEntity get stackTraceHelperClass => |
| _map.toBackendClass(_commonElements.stackTraceHelperClass); |
| |
| @override |
| ClassEntity get VoidRuntimeType => |
| _map.toBackendClass(_commonElements.VoidRuntimeType); |
| |
| @override |
| ClassEntity get jsIndexingBehaviorInterface => |
| _map.toBackendClass(_commonElements.jsIndexingBehaviorInterface); |
| |
| @override |
| ClassEntity get jsInvocationMirrorClass => |
| _map.toBackendClass(_commonElements.jsInvocationMirrorClass); |
| |
| @override |
| ClassEntity get irRepresentationClass => |
| _map.toBackendClass(_commonElements.irRepresentationClass); |
| |
| @override |
| ClassEntity get forceInlineClass => |
| _map.toBackendClass(_commonElements.forceInlineClass); |
| |
| @override |
| ClassEntity get noInlineClass => |
| _map.toBackendClass(_commonElements.noInlineClass); |
| |
| @override |
| ClassEntity get noThrowsClass => |
| _map.toBackendClass(_commonElements.noThrowsClass); |
| |
| @override |
| ClassEntity get noSideEffectsClass => |
| _map.toBackendClass(_commonElements.noSideEffectsClass); |
| |
| @override |
| ClassEntity get typeVariableClass => |
| _map.toBackendClass(_commonElements.typeVariableClass); |
| |
| @override |
| ClassEntity get constMapLiteralClass => |
| _map.toBackendClass(_commonElements.constMapLiteralClass); |
| |
| @override |
| ClassEntity get typeLiteralClass => |
| _map.toBackendClass(_commonElements.typeLiteralClass); |
| |
| @override |
| ClassEntity get boundClosureClass => |
| _map.toBackendClass(_commonElements.boundClosureClass); |
| |
| @override |
| ClassEntity get closureClass => |
| _map.toBackendClass(_commonElements.closureClass); |
| |
| @override |
| FunctionEntity findHelperFunction(String name) { |
| return _map.toBackendMember(_commonElements.findHelperFunction(name)); |
| } |
| |
| @override |
| ClassEntity get jsAnonymousClass => |
| _map.toBackendClass(_commonElements.jsAnonymousClass); |
| |
| @override |
| ClassEntity get jsAnnotationClass => |
| _map.toBackendClass(_commonElements.jsAnnotationClass); |
| |
| @override |
| FunctionEntity get jsStringOperatorAdd => |
| _map.toBackendMember(_commonElements.jsStringOperatorAdd); |
| |
| @override |
| FunctionEntity get jsStringToString => |
| _map.toBackendMember(_commonElements.jsStringToString); |
| |
| @override |
| FunctionEntity get jsStringSplit => |
| _map.toBackendMember(_commonElements.jsStringSplit); |
| |
| @override |
| FunctionEntity get jsArrayAdd => |
| _map.toBackendMember(_commonElements.jsArrayAdd); |
| |
| @override |
| FunctionEntity get jsArrayRemoveLast => |
| _map.toBackendMember(_commonElements.jsArrayRemoveLast); |
| |
| @override |
| ConstructorEntity get jsArrayTypedConstructor => |
| _map.toBackendMember(_commonElements.jsArrayTypedConstructor); |
| |
| @override |
| MemberEntity get jsIndexableLength => |
| _map.toBackendMember(_commonElements.jsIndexableLength); |
| |
| @override |
| FunctionEntity get getNativeInterceptorMethod => |
| _map.toBackendMember(_commonElements.getNativeInterceptorMethod); |
| |
| @override |
| FunctionEntity get getInterceptorMethod => |
| _map.toBackendMember(_commonElements.getInterceptorMethod); |
| |
| @override |
| FunctionEntity get findIndexForNativeSubclassType => |
| _map.toBackendMember(_commonElements.findIndexForNativeSubclassType); |
| |
| @override |
| ClassEntity get jsUInt31Class => |
| _map.toBackendClass(_commonElements.jsUInt31Class); |
| |
| @override |
| ClassEntity get jsUInt32Class => |
| _map.toBackendClass(_commonElements.jsUInt32Class); |
| |
| @override |
| ClassEntity get jsPositiveIntClass => |
| _map.toBackendClass(_commonElements.jsPositiveIntClass); |
| |
| @override |
| ClassEntity get jsUnmodifiableArrayClass => |
| _map.toBackendClass(_commonElements.jsUnmodifiableArrayClass); |
| |
| @override |
| ClassEntity get jsExtendableArrayClass => |
| _map.toBackendClass(_commonElements.jsExtendableArrayClass); |
| |
| @override |
| ClassEntity get jsFixedArrayClass => |
| _map.toBackendClass(_commonElements.jsFixedArrayClass); |
| |
| @override |
| ClassEntity get jsMutableArrayClass => |
| _map.toBackendClass(_commonElements.jsMutableArrayClass); |
| |
| @override |
| ClassEntity get jsMutableIndexableClass => |
| _map.toBackendClass(_commonElements.jsMutableIndexableClass); |
| |
| @override |
| ClassEntity get jsIndexableClass => |
| _map.toBackendClass(_commonElements.jsIndexableClass); |
| |
| @override |
| ClassEntity get jsJavaScriptObjectClass => |
| _map.toBackendClass(_commonElements.jsJavaScriptObjectClass); |
| |
| @override |
| ClassEntity get jsJavaScriptFunctionClass => |
| _map.toBackendClass(_commonElements.jsJavaScriptFunctionClass); |
| |
| @override |
| ClassEntity get jsUnknownJavaScriptObjectClass => |
| _map.toBackendClass(_commonElements.jsUnknownJavaScriptObjectClass); |
| |
| @override |
| ClassEntity get jsPlainJavaScriptObjectClass => |
| _map.toBackendClass(_commonElements.jsPlainJavaScriptObjectClass); |
| |
| @override |
| ClassEntity get jsBoolClass => |
| _map.toBackendClass(_commonElements.jsBoolClass); |
| |
| @override |
| ClassEntity get jsNullClass => |
| _map.toBackendClass(_commonElements.jsNullClass); |
| |
| @override |
| ClassEntity get jsDoubleClass => |
| _map.toBackendClass(_commonElements.jsDoubleClass); |
| |
| @override |
| ClassEntity get jsIntClass => _map.toBackendClass(_commonElements.jsIntClass); |
| |
| @override |
| ClassEntity get jsNumberClass => |
| _map.toBackendClass(_commonElements.jsNumberClass); |
| |
| @override |
| ClassEntity get jsArrayClass => |
| _map.toBackendClass(_commonElements.jsArrayClass); |
| |
| @override |
| ClassEntity get jsStringClass => |
| _map.toBackendClass(_commonElements.jsStringClass); |
| |
| @override |
| ClassEntity get jsInterceptorClass => |
| _map.toBackendClass(_commonElements.jsInterceptorClass); |
| |
| @override |
| ClassEntity get jsConstClass => |
| _map.toBackendClass(_commonElements.jsConstClass); |
| |
| @override |
| FunctionEntity get preserveLibraryNamesMarker => |
| _map.toBackendMember(_commonElements.preserveLibraryNamesMarker); |
| |
| @override |
| FunctionEntity get preserveUrisMarker => |
| _map.toBackendMember(_commonElements.preserveUrisMarker); |
| |
| @override |
| FunctionEntity get preserveMetadataMarker => |
| _map.toBackendMember(_commonElements.preserveMetadataMarker); |
| |
| @override |
| FunctionEntity get preserveNamesMarker => |
| _map.toBackendMember(_commonElements.preserveNamesMarker); |
| |
| @override |
| FunctionEntity get disableTreeShakingMarker => |
| _map.toBackendMember(_commonElements.disableTreeShakingMarker); |
| |
| @override |
| ConstructorEntity get streamIteratorConstructor => |
| _map.toBackendMember(_commonElements.streamIteratorConstructor); |
| |
| @override |
| ConstructorEntity get asyncStarControllerConstructor => |
| _map.toBackendMember(_commonElements.asyncStarControllerConstructor); |
| |
| @override |
| ClassEntity get asyncStarController => |
| _map.toBackendClass(_commonElements.asyncStarController); |
| |
| @override |
| ConstructorEntity get syncCompleterConstructor => |
| _map.toBackendMember(_commonElements.syncCompleterConstructor); |
| |
| @override |
| ConstructorEntity get syncStarIterableConstructor => |
| _map.toBackendMember(_commonElements.syncStarIterableConstructor); |
| |
| @override |
| ClassEntity get controllerStream => |
| _map.toBackendClass(_commonElements.controllerStream); |
| |
| @override |
| ClassEntity get futureImplementation => |
| _map.toBackendClass(_commonElements.futureImplementation); |
| |
| @override |
| ClassEntity get syncStarIterable => |
| _map.toBackendClass(_commonElements.syncStarIterable); |
| |
| @override |
| FunctionEntity get endOfIteration => |
| _map.toBackendMember(_commonElements.endOfIteration); |
| |
| @override |
| FunctionEntity get streamOfController => |
| _map.toBackendMember(_commonElements.streamOfController); |
| |
| @override |
| FunctionEntity get asyncStarHelper => |
| _map.toBackendMember(_commonElements.asyncStarHelper); |
| |
| @override |
| FunctionEntity get syncStarUncaughtError => |
| _map.toBackendMember(_commonElements.syncStarUncaughtError); |
| |
| @override |
| FunctionEntity get yieldSingle => |
| _map.toBackendMember(_commonElements.yieldSingle); |
| |
| @override |
| FunctionEntity get yieldStar => |
| _map.toBackendMember(_commonElements.yieldStar); |
| |
| @override |
| FunctionEntity get wrapBody => _map.toBackendMember(_commonElements.wrapBody); |
| |
| @override |
| FunctionEntity get asyncHelperAwait => |
| _map.toBackendMember(_commonElements.asyncHelperAwait); |
| |
| @override |
| FunctionEntity get asyncHelperRethrow => |
| _map.toBackendMember(_commonElements.asyncHelperRethrow); |
| |
| @override |
| FunctionEntity get asyncHelperReturn => |
| _map.toBackendMember(_commonElements.asyncHelperReturn); |
| |
| @override |
| FunctionEntity get asyncHelperStart => |
| _map.toBackendMember(_commonElements.asyncHelperStart); |
| |
| @override |
| bool isDefaultNoSuchMethodImplementation(FunctionEntity element) { |
| return _commonElements |
| .isDefaultNoSuchMethodImplementation(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| FunctionEntity get objectNoSuchMethod => |
| _map.toBackendMember(_commonElements.objectNoSuchMethod); |
| |
| @override |
| FunctionEntity get mapLiteralUntypedEmptyMaker => |
| _map.toBackendMember(_commonElements.mapLiteralUntypedEmptyMaker); |
| |
| @override |
| FunctionEntity get mapLiteralUntypedMaker => |
| _map.toBackendMember(_commonElements.mapLiteralUntypedMaker); |
| |
| @override |
| ConstructorEntity get mapLiteralConstructorEmpty => |
| _map.toBackendMember(_commonElements.mapLiteralConstructorEmpty); |
| |
| @override |
| ConstructorEntity get mapLiteralConstructor => |
| _map.toBackendMember(_commonElements.mapLiteralConstructor); |
| |
| @override |
| ClassEntity get mapLiteralClass => |
| _map.toBackendClass(_commonElements.mapLiteralClass); |
| |
| @override |
| FunctionEntity get objectEquals => |
| _map.toBackendMember(_commonElements.objectEquals); |
| |
| @override |
| FunctionEntity get unresolvedTopLevelMethodError => |
| _map.toBackendMember(_commonElements.unresolvedTopLevelMethodError); |
| |
| @override |
| FunctionEntity get unresolvedTopLevelSetterError => |
| _map.toBackendMember(_commonElements.unresolvedTopLevelSetterError); |
| |
| @override |
| FunctionEntity get unresolvedTopLevelGetterError => |
| _map.toBackendMember(_commonElements.unresolvedTopLevelGetterError); |
| |
| @override |
| FunctionEntity get unresolvedStaticMethodError => |
| _map.toBackendMember(_commonElements.unresolvedStaticMethodError); |
| |
| @override |
| FunctionEntity get unresolvedStaticSetterError => |
| _map.toBackendMember(_commonElements.unresolvedStaticSetterError); |
| |
| @override |
| FunctionEntity get unresolvedStaticGetterError => |
| _map.toBackendMember(_commonElements.unresolvedStaticGetterError); |
| |
| @override |
| FunctionEntity get unresolvedConstructorError => |
| _map.toBackendMember(_commonElements.unresolvedConstructorError); |
| |
| @override |
| FunctionEntity get genericNoSuchMethod => |
| _map.toBackendMember(_commonElements.genericNoSuchMethod); |
| |
| @override |
| FunctionEntity get malformedTypeError => |
| _map.toBackendMember(_commonElements.malformedTypeError); |
| |
| @override |
| bool isDefaultEqualityImplementation(MemberEntity element) { |
| return _commonElements |
| .isDefaultEqualityImplementation(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| InterfaceType get symbolImplementationType { |
| return _map.fromFrontendType(_commonElements.symbolImplementationType); |
| } |
| |
| @override |
| FieldEntity get symbolField => |
| _map.toBackendMember(_commonElements.symbolField); |
| |
| @override |
| InterfaceType getConstantMapTypeFor(InterfaceType sourceType, |
| {bool hasProtoKey: false, bool onlyStringKeys: false}) { |
| return _map.fromFrontendType(_commonElements.getConstantMapTypeFor( |
| _map.toBackendType(sourceType), |
| hasProtoKey: hasProtoKey, |
| onlyStringKeys: onlyStringKeys)); |
| } |
| |
| @override |
| bool isListSupertype(ClassEntity element) { |
| return _commonElements.isListSupertype(_map.toFrontendClass(element)); |
| } |
| |
| @override |
| bool isStringOnlySupertype(ClassEntity element) { |
| return _commonElements.isStringOnlySupertype(_map.toFrontendClass(element)); |
| } |
| |
| @override |
| bool isNumberOrStringSupertype(ClassEntity element) { |
| return _commonElements |
| .isNumberOrStringSupertype(_map.toFrontendClass(element)); |
| } |
| |
| @override |
| InterfaceType streamType([DartType elementType]) { |
| return _map.fromFrontendType( |
| _commonElements.streamType(_map.toBackendType(elementType))); |
| } |
| |
| @override |
| InterfaceType futureType([DartType elementType]) { |
| return _map.fromFrontendType( |
| _commonElements.futureType(_map.toBackendType(elementType))); |
| } |
| |
| @override |
| InterfaceType iterableType([DartType elementType]) { |
| return _map.fromFrontendType( |
| _commonElements.iterableType(_map.toBackendType(elementType))); |
| } |
| |
| @override |
| InterfaceType mapType([DartType keyType, DartType valueType]) { |
| return _map.fromFrontendType(_commonElements.mapType( |
| _map.toBackendType(keyType), _map.toBackendType(valueType))); |
| } |
| |
| @override |
| InterfaceType listType([DartType elementType]) { |
| return _map.fromFrontendType( |
| _commonElements.listType(_map.toBackendType(elementType))); |
| } |
| |
| @override |
| InterfaceType get stackTraceType => |
| _map.fromFrontendType(_commonElements.stackTraceType); |
| |
| @override |
| InterfaceType get typeLiteralType => |
| _map.fromFrontendType(_commonElements.typeLiteralType); |
| |
| @override |
| InterfaceType get typeType => _map.fromFrontendType(_commonElements.typeType); |
| |
| @override |
| InterfaceType get nullType => _map.fromFrontendType(_commonElements.nullType); |
| |
| @override |
| InterfaceType get functionType => |
| _map.fromFrontendType(_commonElements.functionType); |
| |
| @override |
| InterfaceType get symbolType => |
| _map.fromFrontendType(_commonElements.symbolType); |
| |
| @override |
| InterfaceType get stringType => |
| _map.fromFrontendType(_commonElements.stringType); |
| |
| @override |
| InterfaceType get resourceType => |
| _map.fromFrontendType(_commonElements.resourceType); |
| |
| @override |
| InterfaceType get doubleType => |
| _map.fromFrontendType(_commonElements.doubleType); |
| |
| @override |
| InterfaceType get intType => _map.fromFrontendType(_commonElements.intType); |
| |
| @override |
| InterfaceType get numType => _map.fromFrontendType(_commonElements.numType); |
| |
| @override |
| InterfaceType get boolType => _map.fromFrontendType(_commonElements.boolType); |
| |
| @override |
| InterfaceType get objectType => |
| _map.fromFrontendType(_commonElements.objectType); |
| |
| @override |
| DynamicType get dynamicType => |
| _map.fromFrontendType(_commonElements.dynamicType); |
| |
| @override |
| bool isFilledListConstructor(ConstructorEntity element) { |
| return _commonElements |
| .isFilledListConstructor(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| bool isUnnamedListConstructor(ConstructorEntity element) { |
| return _commonElements |
| .isUnnamedListConstructor(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| bool isFunctionApplyMethod(MemberEntity element) { |
| return _commonElements |
| .isFunctionApplyMethod(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| FunctionEntity get functionApplyMethod => |
| _map.toBackendMember(_commonElements.functionApplyMethod); |
| |
| @override |
| FunctionEntity get identicalFunction => |
| _map.toBackendMember(_commonElements.identicalFunction); |
| |
| @override |
| ClassEntity get deferredLibraryClass => |
| _map.toBackendClass(_commonElements.deferredLibraryClass); |
| |
| @override |
| bool isMirrorsUsedConstructor(ConstructorEntity element) { |
| return _commonElements |
| .isMirrorsUsedConstructor(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| ClassEntity get mirrorsUsedClass => |
| _map.toBackendClass(_commonElements.mirrorsUsedClass); |
| |
| @override |
| bool isMirrorSystemGetNameFunction(MemberEntity element) { |
| return _commonElements |
| .isMirrorSystemGetNameFunction(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| ClassEntity get mirrorSystemClass => |
| _map.toBackendClass(_commonElements.mirrorSystemClass); |
| |
| @override |
| bool isSymbolConstructor(ConstructorEntity element) { |
| return _commonElements.isSymbolConstructor(_map.toFrontendMember(element)); |
| } |
| |
| @override |
| ConstructorEntity get symbolConstructorTarget => |
| _map.toBackendMember(_commonElements.symbolConstructorTarget); |
| |
| @override |
| ClassEntity get typedDataClass => |
| _map.toBackendClass(_commonElements.typedDataClass); |
| |
| @override |
| LibraryEntity get internalLibrary => |
| _map.toBackendLibrary(_commonElements.internalLibrary); |
| |
| @override |
| LibraryEntity get isolateHelperLibrary => |
| _map.toBackendLibrary(_commonElements.isolateHelperLibrary); |
| |
| @override |
| LibraryEntity get foreignLibrary => |
| _map.toBackendLibrary(_commonElements.foreignLibrary); |
| |
| @override |
| LibraryEntity get interceptorsLibrary => |
| _map.toBackendLibrary(_commonElements.interceptorsLibrary); |
| |
| @override |
| LibraryEntity get jsHelperLibrary => |
| _map.toBackendLibrary(_commonElements.jsHelperLibrary); |
| |
| @override |
| LibraryEntity get typedDataLibrary => |
| _map.toBackendLibrary(_commonElements.typedDataLibrary); |
| |
| @override |
| LibraryEntity get mirrorsLibrary => |
| _map.toBackendLibrary(_commonElements.mirrorsLibrary); |
| |
| @override |
| LibraryEntity get asyncLibrary => |
| _map.toBackendLibrary(_commonElements.asyncLibrary); |
| |
| @override |
| LibraryEntity get coreLibrary => |
| _map.toBackendLibrary(_commonElements.coreLibrary); |
| |
| @override |
| ClassEntity get streamClass => |
| _map.toBackendClass(_commonElements.streamClass); |
| |
| @override |
| ClassEntity get futureClass => |
| _map.toBackendClass(_commonElements.futureClass); |
| |
| @override |
| ClassEntity get iterableClass => |
| _map.toBackendClass(_commonElements.iterableClass); |
| |
| @override |
| ClassEntity get mapClass => _map.toBackendClass(_commonElements.mapClass); |
| |
| @override |
| ClassEntity get listClass => _map.toBackendClass(_commonElements.listClass); |
| |
| @override |
| ClassEntity get stackTraceClass => |
| _map.toBackendClass(_commonElements.stackTraceClass); |
| |
| @override |
| ClassEntity get typeClass => _map.toBackendClass(_commonElements.typeClass); |
| |
| @override |
| ClassEntity get nullClass => _map.toBackendClass(_commonElements.nullClass); |
| |
| @override |
| ClassEntity get symbolClass => |
| _map.toBackendClass(_commonElements.symbolClass); |
| |
| @override |
| ClassEntity get resourceClass => |
| _map.toBackendClass(_commonElements.resourceClass); |
| |
| @override |
| ClassEntity get functionClass => |
| _map.toBackendClass(_commonElements.functionClass); |
| |
| @override |
| ClassEntity get stringClass => |
| _map.toBackendClass(_commonElements.stringClass); |
| |
| @override |
| ClassEntity get doubleClass => |
| _map.toBackendClass(_commonElements.doubleClass); |
| |
| @override |
| ClassEntity get intClass => _map.toBackendClass(_commonElements.intClass); |
| |
| @override |
| ClassEntity get numClass => _map.toBackendClass(_commonElements.numClass); |
| |
| @override |
| ClassEntity get boolClass => _map.toBackendClass(_commonElements.boolClass); |
| |
| @override |
| FunctionEntity get throwUnsupportedError => |
| _map.toBackendMember(_commonElements.throwUnsupportedError); |
| } |