Index: pkg/compiler/lib/src/js_model/elements.dart |
diff --git a/pkg/compiler/lib/src/js_model/elements.dart b/pkg/compiler/lib/src/js_model/elements.dart |
new file mode 100644 |
index 0000000000000000000000000000000000000000..3de8a1f312bb1e8ab5ceb4f169f4d0ed2e488f5d |
--- /dev/null |
+++ b/pkg/compiler/lib/src/js_model/elements.dart |
@@ -0,0 +1,1270 @@ |
+// 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); |
+} |