Index: pkg/compiler/lib/src/js_backend/backend.dart |
diff --git a/pkg/compiler/lib/src/js_backend/backend.dart b/pkg/compiler/lib/src/js_backend/backend.dart |
index eb9a21f4fd990ee4e612ff17d24ec063a286b8e8..78f9a0aac11afb3f1fd7c18a1d0d235b0c88a2d8 100644 |
--- a/pkg/compiler/lib/src/js_backend/backend.dart |
+++ b/pkg/compiler/lib/src/js_backend/backend.dart |
@@ -1420,7 +1420,7 @@ class JavaScriptBackend extends Backend { |
} |
} |
- void registerRequiredType(DartType type) { |
+ void registerRequiredType(DartType type, Element enclosingElement) { |
// If [argument] has type variables or is a type variable, this method |
// registers a RTI dependency between the class where the type variable is |
// defined (that is the enclosing class of the current element being |
@@ -1428,6 +1428,7 @@ class JavaScriptBackend extends Backend { |
// then the class of the type variable does too. |
ClassElement contextClass = Types.getClassContext(type); |
if (contextClass != null) { |
+ assert(contextClass == enclosingElement.enclosingClass.declaration); |
rti.registerRtiDependency(type.element, contextClass); |
} |
} |
@@ -2426,13 +2427,13 @@ class JavaScriptBackend extends Backend { |
reflectableMembers.add(cls); |
// 2) its constructors (if resolved) |
cls.constructors.forEach((Element constructor) { |
- if (resolution.hasBeenProcessed(constructor)) { |
+ if (resolution.hasBeenResolved(constructor)) { |
reflectableMembers.add(constructor); |
} |
}); |
// 3) all members, including fields via getter/setters (if resolved) |
cls.forEachClassMember((Member member) { |
- if (resolution.hasBeenProcessed(member.element)) { |
+ if (resolution.hasBeenResolved(member.element)) { |
memberNames.add(member.name); |
reflectableMembers.add(member.element); |
} |
@@ -2444,8 +2445,8 @@ class JavaScriptBackend extends Backend { |
if (memberNames.contains(member.name)) { |
// TODO(20993): find out why this assertion fails. |
// assert(invariant(member.element, |
- // resolution.hasBeenProcessed(member.element))); |
- if (resolution.hasBeenProcessed(member.element)) { |
+ // resolution.hasBeenResolved(member.element))); |
+ if (resolution.hasBeenResolved(member.element)) { |
reflectableMembers.add(member.element); |
} |
} |
@@ -2461,13 +2462,13 @@ class JavaScriptBackend extends Backend { |
} else { |
// check members themselves |
cls.constructors.forEach((ConstructorElement element) { |
- if (!resolution.hasBeenProcessed(element)) return; |
+ if (!resolution.hasBeenResolved(element)) return; |
if (referencedFromMirrorSystem(element, false)) { |
reflectableMembers.add(element); |
} |
}); |
cls.forEachClassMember((Member member) { |
- if (!resolution.hasBeenProcessed(member.element)) return; |
+ if (!resolution.hasBeenResolved(member.element)) return; |
if (referencedFromMirrorSystem(member.element, false)) { |
reflectableMembers.add(member.element); |
} |
@@ -2492,7 +2493,7 @@ class JavaScriptBackend extends Backend { |
if (lib.isInternalLibrary) continue; |
lib.forEachLocalMember((Element member) { |
if (!member.isClass && |
- resolution.hasBeenProcessed(member) && |
+ resolution.hasBeenResolved(member) && |
referencedFromMirrorSystem(member)) { |
reflectableMembers.add(member); |
} |
@@ -2651,15 +2652,7 @@ class JavaScriptBackend extends Backend { |
reporter.log('Retaining metadata.'); |
compiler.libraryLoader.libraries.forEach(retainMetadataOf); |
- if (enqueuer.isResolutionQueue) { |
- for (Dependency dependency in metadataConstants) { |
- registerCompileTimeConstant( |
- dependency.constant, |
- new EagerRegistry(compiler, |
- dependency.annotatedElement.analyzableElement.treeElements), |
- addForEmission: false); |
- } |
- } else { |
+ if (!enqueuer.isResolutionQueue) { |
for (Dependency dependency in metadataConstants) { |
registerCompileTimeConstant( |
dependency.constant, |
@@ -2806,48 +2799,33 @@ class JavaScriptBackend extends Backend { |
Enqueuer enqueuer, |
Registry registry) { |
if (element.asyncMarker == AsyncMarker.ASYNC) { |
- _registerAsync(enqueuer, registry); |
+ enqueue(enqueuer, getAsyncHelper(), registry); |
+ enqueue(enqueuer, getSyncCompleterConstructor(), registry); |
+ enqueue(enqueuer, getStreamIteratorConstructor(), registry); |
+ enqueue(enqueuer, getWrapBody(), registry); |
} else if (element.asyncMarker == AsyncMarker.SYNC_STAR) { |
- _registerSyncStar(enqueuer, registry); |
+ ClassElement clsSyncStarIterable = getSyncStarIterable(); |
+ clsSyncStarIterable.ensureResolved(resolution); |
+ registerInstantiatedType(clsSyncStarIterable.rawType, enqueuer, registry); |
+ enqueue(enqueuer, getSyncStarIterableConstructor(), registry); |
+ enqueue(enqueuer, getEndOfIteration(), registry); |
+ enqueue(enqueuer, getYieldStar(), registry); |
+ enqueue(enqueuer, getSyncStarUncaughtError(), registry); |
} else if (element.asyncMarker == AsyncMarker.ASYNC_STAR) { |
- _registerAsyncStar(enqueuer, registry); |
+ ClassElement clsASyncStarController = getASyncStarController(); |
+ clsASyncStarController.ensureResolved(resolution); |
+ registerInstantiatedType( |
+ clsASyncStarController.rawType, enqueuer, registry); |
+ enqueue(enqueuer, getAsyncStarHelper(), registry); |
+ enqueue(enqueuer, getStreamOfController(), registry); |
+ enqueue(enqueuer, getYieldSingle(), registry); |
+ enqueue(enqueuer, getYieldStar(), registry); |
+ enqueue(enqueuer, getASyncStarControllerConstructor(), registry); |
+ enqueue(enqueuer, getStreamIteratorConstructor(), registry); |
+ enqueue(enqueuer, getWrapBody(), registry); |
} |
} |
- void _registerAsync(Enqueuer enqueuer, |
- Registry registry) { |
- enqueue(enqueuer, getAsyncHelper(), registry); |
- enqueue(enqueuer, getSyncCompleterConstructor(), registry); |
- enqueue(enqueuer, getStreamIteratorConstructor(), registry); |
- enqueue(enqueuer, getWrapBody(), registry); |
- } |
- |
- void _registerSyncStar(Enqueuer enqueuer, |
- Registry registry) { |
- ClassElement clsSyncStarIterable = getSyncStarIterable(); |
- clsSyncStarIterable.ensureResolved(compiler.resolution); |
- registerInstantiatedType(clsSyncStarIterable.rawType, enqueuer, registry); |
- enqueue(enqueuer, getSyncStarIterableConstructor(), registry); |
- enqueue(enqueuer, getEndOfIteration(), registry); |
- enqueue(enqueuer, getYieldStar(), registry); |
- enqueue(enqueuer, getSyncStarUncaughtError(), registry); |
- } |
- |
- void _registerAsyncStar(Enqueuer enqueuer, |
- Registry registry) { |
- ClassElement clsASyncStarController = getASyncStarController(); |
- clsASyncStarController.ensureResolved(compiler.resolution); |
- registerInstantiatedType( |
- clsASyncStarController.rawType, enqueuer, registry); |
- enqueue(enqueuer, getAsyncStarHelper(), registry); |
- enqueue(enqueuer, getStreamOfController(), registry); |
- enqueue(enqueuer, getYieldSingle(), registry); |
- enqueue(enqueuer, getYieldStar(), registry); |
- enqueue(enqueuer, getASyncStarControllerConstructor(), registry); |
- enqueue(enqueuer, getStreamIteratorConstructor(), registry); |
- enqueue(enqueuer, getWrapBody(), registry); |
- } |
- |
@override |
bool enableDeferredLoadingIfSupported(Spannable node, Registry registry) { |
registerCheckDeferredIsLoaded(registry); |
@@ -3006,132 +2984,6 @@ class JavaScriptResolutionCallbacks extends ResolutionCallbacks { |
JavaScriptResolutionCallbacks(this.backend); |
- WorldImpact transformImpact(ResolutionWorldImpact worldImpact) { |
- TransformedWorldImpact transformed = |
- new TransformedWorldImpact(worldImpact); |
- for (Feature feature in worldImpact.features) { |
- switch (feature) { |
- case Feature.ABSTRACT_CLASS_INSTANTIATION: |
- onAbstractClassInstantiation(transformed); |
- break; |
- case Feature.ASSERT: |
- onAssert(false, transformed); |
- break; |
- case Feature.ASSERT_WITH_MESSAGE: |
- onAssert(true, transformed); |
- break; |
- case Feature.ASYNC: |
- backend._registerAsync( |
- backend.compiler.enqueuer.resolution, transformed); |
- break; |
- case Feature.ASYNC_FOR_IN: |
- onAsyncForIn(null, transformed); |
- break; |
- case Feature.ASYNC_STAR: |
- backend._registerAsyncStar( |
- backend.compiler.enqueuer.resolution, transformed); |
- break; |
- case Feature.CATCH_STATEMENT: |
- onCatchStatement(transformed); |
- break; |
- case Feature.COMPILE_TIME_ERROR: |
- onCompileTimeError(transformed, null); |
- break; |
- case Feature.FALL_THROUGH_ERROR: |
- onFallThroughError(transformed); |
- break; |
- case Feature.INC_DEC_OPERATION: |
- onIncDecOperation(transformed); |
- break; |
- case Feature.LAZY_FIELD: |
- onLazyField(transformed); |
- break; |
- case Feature.NEW_SYMBOL: |
- backend.registerNewSymbol(transformed); |
- break; |
- case Feature.STACK_TRACE_IN_CATCH: |
- onStackTraceInCatch(transformed); |
- break; |
- case Feature.STRING_INTERPOLATION: |
- onStringInterpolation(transformed); |
- break; |
- case Feature.SUPER_NO_SUCH_METHOD: |
- onSuperNoSuchMethod(transformed); |
- break; |
- case Feature.SYMBOL_CONSTRUCTOR: |
- onSymbolConstructor(transformed); |
- break; |
- case Feature.SYNC_FOR_IN: |
- onSyncForIn(transformed); |
- break; |
- case Feature.SYNC_STAR: |
- backend._registerSyncStar( |
- backend.compiler.enqueuer.resolution, transformed); |
- break; |
- case Feature.THROW_EXPRESSION: |
- onThrowExpression(transformed); |
- break; |
- case Feature.THROW_NO_SUCH_METHOD: |
- onThrowNoSuchMethod(transformed); |
- break; |
- case Feature.THROW_RUNTIME_ERROR: |
- onThrowRuntimeError(transformed); |
- break; |
- case Feature.TYPE_VARIABLE_BOUNDS_CHECK: |
- onTypeVariableBoundCheck(transformed); |
- break; |
- } |
- } |
- for (DartType type in worldImpact.isChecks) { |
- onIsCheck(type, transformed); |
- } |
- for (DartType type in worldImpact.asCasts) { |
- onIsCheck(type, transformed); |
- onAsCheck(type, transformed); |
- } |
- if (backend.compiler.enableTypeAssertions) { |
- for (DartType type in worldImpact.checkedModeChecks) { |
- onIsCheck(type, transformed); |
- } |
- } |
- for (DartType requiredType in worldImpact.requiredTypes) { |
- backend.registerRequiredType(requiredType); |
- } |
- for (MapLiteralUse mapLiteralUse in worldImpact.mapLiterals) { |
- // TODO(johnniwinther): Use the [isEmpty] property when factory |
- // constructors are registered directly. |
- onMapLiteral(transformed, mapLiteralUse.type, mapLiteralUse.isConstant); |
- } |
- for (ListLiteralUse listLiteralUse in worldImpact.listLiterals) { |
- // TODO(johnniwinther): Use the [isConstant] and [isEmpty] property when |
- // factory constructors are registered directly. |
- transformed.registerInstantiation(listLiteralUse.type); |
- } |
- for (DartType typeLiteral in worldImpact.typeLiterals) { |
- onTypeLiteral(typeLiteral, transformed); |
- transformed.registerInstantiation(backend.compiler.coreTypes.typeType); |
- if (typeLiteral.isTypeVariable) { |
- onTypeVariableExpression(transformed, typeLiteral.element); |
- } |
- } |
- for (String constSymbolName in worldImpact.constSymbolNames) { |
- backend.registerConstSymbol(constSymbolName, transformed); |
- } |
- for (LocalFunctionElement closure in worldImpact.closures) { |
- if (closure.computeType(backend.resolution).containsTypeVariables) { |
- backend.registerClosureWithFreeTypeVariables( |
- closure, backend.compiler.enqueuer.resolution, transformed); |
- } |
- } |
- // TODO(johnniwinther): Remove this when dependency tracking is done on |
- // the world impact itself. |
- for (InterfaceType instantiatedType in worldImpact.instantiatedTypes) { |
- transformed.registerInstantiation(instantiatedType); |
- } |
- |
- return transformed; |
- } |
- |
void registerBackendStaticInvocation(Element element, Registry registry) { |
registry.registerStaticInvocation(backend.registerBackendUse(element)); |
} |
@@ -3337,7 +3189,7 @@ class JavaScriptResolutionCallbacks extends ResolutionCallbacks { |
'Needed to encode the name of super.noSuchMethod.'); |
} |
- void onMapLiteral(Registry registry, |
+ void onMapLiteral(ResolutionRegistry registry, |
DartType type, |
bool isConstant) { |
assert(registry.isForResolution); |
@@ -3352,7 +3204,7 @@ class JavaScriptResolutionCallbacks extends ResolutionCallbacks { |
enqueue(JavaScriptMapConstant.DART_STRING_CLASS); |
enqueue(JavaScriptMapConstant.DART_GENERAL_CLASS); |
} else { |
- registry.registerInstantiation(type); |
+ registry.registerInstantiatedType(type); |
} |
} |