| Index: pkg/compiler/lib/src/enqueue.dart
|
| diff --git a/pkg/compiler/lib/src/enqueue.dart b/pkg/compiler/lib/src/enqueue.dart
|
| index 38c02bf9d235533193f90615711ffc7ad57cc5fd..ff3c21c35f92ca5b897bb6600fbe7542832af69a 100644
|
| --- a/pkg/compiler/lib/src/enqueue.dart
|
| +++ b/pkg/compiler/lib/src/enqueue.dart
|
| @@ -4,66 +4,44 @@
|
|
|
| library dart2js.enqueue;
|
|
|
| -import 'dart:collection' show
|
| - Queue;
|
| +import 'dart:collection' show Queue;
|
|
|
| import 'common.dart';
|
| -import 'common/names.dart' show
|
| - Identifiers;
|
| -import 'common/resolution.dart' show
|
| - Resolution;
|
| -import 'common/work.dart' show
|
| - ItemCompilationContext,
|
| - WorkItem;
|
| -import 'common/tasks.dart' show
|
| - CompilerTask,
|
| - DeferredAction,
|
| - DeferredTask;
|
| -import 'common/codegen.dart' show
|
| - CodegenWorkItem;
|
| -import 'common/resolution.dart' show
|
| - ResolutionWorkItem;
|
| -import 'compiler.dart' show
|
| - Compiler;
|
| -import 'dart_types.dart' show
|
| - DartType,
|
| - InterfaceType;
|
| -import 'elements/elements.dart' show
|
| - AnalyzableElement,
|
| - AstElement,
|
| - ClassElement,
|
| - ConstructorElement,
|
| - Element,
|
| - Elements,
|
| - FunctionElement,
|
| - LibraryElement,
|
| - LocalFunctionElement,
|
| - Member,
|
| - MemberElement,
|
| - MethodElement,
|
| - Name,
|
| - TypedElement,
|
| - TypedefElement;
|
| +import 'common/names.dart' show Identifiers;
|
| +import 'common/resolution.dart' show Resolution;
|
| +import 'common/work.dart' show ItemCompilationContext, WorkItem;
|
| +import 'common/tasks.dart' show CompilerTask, DeferredAction, DeferredTask;
|
| +import 'common/codegen.dart' show CodegenWorkItem;
|
| +import 'common/resolution.dart' show ResolutionWorkItem;
|
| +import 'compiler.dart' show Compiler;
|
| +import 'dart_types.dart' show DartType, InterfaceType;
|
| +import 'elements/elements.dart'
|
| + show
|
| + AnalyzableElement,
|
| + AstElement,
|
| + ClassElement,
|
| + ConstructorElement,
|
| + Element,
|
| + Elements,
|
| + FunctionElement,
|
| + LibraryElement,
|
| + LocalFunctionElement,
|
| + Member,
|
| + MemberElement,
|
| + MethodElement,
|
| + Name,
|
| + TypedElement,
|
| + TypedefElement;
|
| import 'js/js.dart' as js;
|
| import 'native/native.dart' as native;
|
| -import 'types/types.dart' show
|
| - TypeMaskStrategy;
|
| -import 'universe/selector.dart' show
|
| - Selector;
|
| +import 'types/types.dart' show TypeMaskStrategy;
|
| +import 'universe/selector.dart' show Selector;
|
| import 'universe/universe.dart';
|
| -import 'universe/use.dart' show
|
| - DynamicUse,
|
| - StaticUse,
|
| - StaticUseKind,
|
| - TypeUse,
|
| - TypeUseKind;
|
| -import 'universe/world_impact.dart' show
|
| - ImpactUseCase,
|
| - WorldImpact,
|
| - WorldImpactVisitor;
|
| -import 'util/util.dart' show
|
| - Link,
|
| - Setlet;
|
| +import 'universe/use.dart'
|
| + show DynamicUse, StaticUse, StaticUseKind, TypeUse, TypeUseKind;
|
| +import 'universe/world_impact.dart'
|
| + show ImpactUseCase, WorldImpact, WorldImpactVisitor;
|
| +import 'util/util.dart' show Link, Setlet;
|
|
|
| typedef ItemCompilationContext ItemCompilationContextCreator();
|
|
|
| @@ -74,14 +52,17 @@ class EnqueueTask extends CompilerTask {
|
| String get name => 'Enqueue';
|
|
|
| EnqueueTask(Compiler compiler)
|
| - : resolution = new ResolutionEnqueuer(
|
| - compiler, compiler.backend.createItemCompilationContext,
|
| - compiler.options.analyzeOnly && compiler.options.analyzeMain
|
| - ? const EnqueuerStrategy() : const TreeShakingEnqueuerStrategy()),
|
| - codegen = new CodegenEnqueuer(
|
| - compiler, compiler.backend.createItemCompilationContext,
|
| - const TreeShakingEnqueuerStrategy()),
|
| - super(compiler) {
|
| + : resolution = new ResolutionEnqueuer(
|
| + compiler,
|
| + compiler.backend.createItemCompilationContext,
|
| + compiler.options.analyzeOnly && compiler.options.analyzeMain
|
| + ? const EnqueuerStrategy()
|
| + : const TreeShakingEnqueuerStrategy()),
|
| + codegen = new CodegenEnqueuer(
|
| + compiler,
|
| + compiler.backend.createItemCompilationContext,
|
| + const TreeShakingEnqueuerStrategy()),
|
| + super(compiler) {
|
| codegen.task = this;
|
| resolution.task = this;
|
|
|
| @@ -101,10 +82,10 @@ abstract class Enqueuer {
|
| final Compiler compiler; // TODO(ahe): Remove this dependency.
|
| final EnqueuerStrategy strategy;
|
| final ItemCompilationContextCreator itemCompilationContextCreator;
|
| - final Map<String, Set<Element>> instanceMembersByName
|
| - = new Map<String, Set<Element>>();
|
| - final Map<String, Set<Element>> instanceFunctionsByName
|
| - = new Map<String, Set<Element>>();
|
| + final Map<String, Set<Element>> instanceMembersByName =
|
| + new Map<String, Set<Element>>();
|
| + final Map<String, Set<Element>> instanceFunctionsByName =
|
| + new Map<String, Set<Element>>();
|
| final Set<ClassElement> _processedClasses = new Set<ClassElement>();
|
| Set<ClassElement> recentClasses = new Setlet<ClassElement>();
|
| final Universe universe = new Universe(const TypeMaskStrategy());
|
| @@ -114,17 +95,15 @@ abstract class Enqueuer {
|
|
|
| bool queueIsClosed = false;
|
| EnqueueTask task;
|
| - native.NativeEnqueuer nativeEnqueuer; // Set by EnqueueTask
|
| + native.NativeEnqueuer nativeEnqueuer; // Set by EnqueueTask
|
|
|
| bool hasEnqueuedReflectiveElements = false;
|
| bool hasEnqueuedReflectiveStaticFields = false;
|
|
|
| WorldImpactVisitor impactVisitor;
|
|
|
| - Enqueuer(this.name,
|
| - this.compiler,
|
| - this.itemCompilationContextCreator,
|
| - this.strategy) {
|
| + Enqueuer(this.name, this.compiler, this.itemCompilationContextCreator,
|
| + this.strategy) {
|
| impactVisitor = new _EnqueuerImpactVisitor(this);
|
| }
|
|
|
| @@ -160,8 +139,8 @@ abstract class Enqueuer {
|
| if (internalAddToWorkList(element) && compiler.options.dumpInfo) {
|
| // TODO(sigmund): add other missing dependencies (internals, selectors
|
| // enqueued after allocations), also enable only for the codegen enqueuer.
|
| - compiler.dumpInfoTask.registerDependency(
|
| - compiler.currentElement, element);
|
| + compiler.dumpInfoTask
|
| + .registerDependency(compiler.currentElement, element);
|
| }
|
| }
|
|
|
| @@ -174,23 +153,20 @@ abstract class Enqueuer {
|
|
|
| /// Apply the [worldImpact] of processing [element] to this enqueuer.
|
| void applyImpact(Element element, WorldImpact worldImpact) {
|
| - compiler.impactStrategy.visitImpact(
|
| - element, worldImpact, impactVisitor, impactUse);
|
| + compiler.impactStrategy
|
| + .visitImpact(element, worldImpact, impactVisitor, impactUse);
|
| }
|
|
|
| - void registerInstantiatedType(InterfaceType type,
|
| - {bool mirrorUsage: false}) {
|
| + void registerInstantiatedType(InterfaceType type, {bool mirrorUsage: false}) {
|
| task.measure(() {
|
| ClassElement cls = type.element;
|
| cls.ensureResolved(resolution);
|
| bool isNative = compiler.backend.isNative(cls);
|
| - universe.registerTypeInstantiation(
|
| - type,
|
| + universe.registerTypeInstantiation(type,
|
| isNative: isNative,
|
| - byMirrors: mirrorUsage,
|
| - onImplemented: (ClassElement cls) {
|
| - compiler.backend.registerImplementedClass(
|
| - cls, this, compiler.globalDependencies);
|
| + byMirrors: mirrorUsage, onImplemented: (ClassElement cls) {
|
| + compiler.backend
|
| + .registerImplementedClass(cls, this, compiler.globalDependencies);
|
| });
|
| // TODO(johnniwinther): Share this reasoning with [Universe].
|
| if (!cls.isAbstract || isNative || mirrorUsage) {
|
| @@ -260,8 +236,7 @@ abstract class Enqueuer {
|
| if (function.name == Identifiers.noSuchMethod_) {
|
| registerNoSuchMethod(function);
|
| }
|
| - if (function.name == Identifiers.call &&
|
| - !cls.typeVariables.isEmpty) {
|
| + if (function.name == Identifiers.call && !cls.typeVariables.isEmpty) {
|
| registerCallMethodWithFreeTypeVariables(function);
|
| }
|
| // If there is a property access with the same name as a method we
|
| @@ -273,7 +248,8 @@ abstract class Enqueuer {
|
| }
|
| // Store the member in [instanceFunctionsByName] to catch
|
| // getters on the function.
|
| - instanceFunctionsByName.putIfAbsent(memberName, () => new Set<Element>())
|
| + instanceFunctionsByName
|
| + .putIfAbsent(memberName, () => new Set<Element>())
|
| .add(member);
|
| if (universe.hasInvocation(function, compiler.world)) {
|
| addToWorkList(function);
|
| @@ -303,7 +279,8 @@ abstract class Enqueuer {
|
|
|
| // The element is not yet used. Add it to the list of instance
|
| // members to still be processed.
|
| - instanceMembersByName.putIfAbsent(memberName, () => new Set<Element>())
|
| + instanceMembersByName
|
| + .putIfAbsent(memberName, () => new Set<Element>())
|
| .add(member);
|
| }
|
|
|
| @@ -368,7 +345,7 @@ abstract class Enqueuer {
|
| * The actual implementation depends on the current compiler phase.
|
| */
|
| bool shouldIncludeElementDueToMirrors(Element element,
|
| - {bool includedEnclosing});
|
| + {bool includedEnclosing});
|
|
|
| void logEnqueueReflectiveAction(action, [msg = ""]) {
|
| if (TRACE_MIRROR_ENQUEUING) {
|
| @@ -380,16 +357,14 @@ abstract class Enqueuer {
|
| ///
|
| /// [enclosingWasIncluded] provides a hint whether the enclosing element was
|
| /// needed for reflection.
|
| - void enqueueReflectiveConstructor(ConstructorElement ctor,
|
| - bool enclosingWasIncluded) {
|
| + void enqueueReflectiveConstructor(
|
| + ConstructorElement ctor, bool enclosingWasIncluded) {
|
| if (shouldIncludeElementDueToMirrors(ctor,
|
| includedEnclosing: enclosingWasIncluded)) {
|
| logEnqueueReflectiveAction(ctor);
|
| ClassElement cls = ctor.declaration.enclosingClass;
|
| compiler.backend.registerInstantiatedType(
|
| - cls.rawType,
|
| - this,
|
| - compiler.mirrorDependencies,
|
| + cls.rawType, this, compiler.mirrorDependencies,
|
| mirrorUsage: true);
|
| registerStaticUse(new StaticUse.foreignUse(ctor.declaration));
|
| }
|
| @@ -401,7 +376,7 @@ abstract class Enqueuer {
|
| /// needed for reflection.
|
| void enqueueReflectiveMember(Element element, bool enclosingWasIncluded) {
|
| if (shouldIncludeElementDueToMirrors(element,
|
| - includedEnclosing: enclosingWasIncluded)) {
|
| + includedEnclosing: enclosingWasIncluded)) {
|
| logEnqueueReflectiveAction(element);
|
| if (element.isTypedef) {
|
| TypedefElement typedef = element;
|
| @@ -413,13 +388,14 @@ abstract class Enqueuer {
|
| // We need to enqueue all members matching this one in subclasses, as
|
| // well.
|
| // TODO(herhut): Use TypedSelector.subtype for enqueueing
|
| - DynamicUse dynamicUse = new DynamicUse(
|
| - new Selector.fromElement(element), null);
|
| + DynamicUse dynamicUse =
|
| + new DynamicUse(new Selector.fromElement(element), null);
|
| registerDynamicUse(dynamicUse);
|
| if (element.isField) {
|
| DynamicUse dynamicUse = new DynamicUse(
|
| - new Selector.setter(new Name(
|
| - element.name, element.library, isSetter: true)), null);
|
| + new Selector.setter(
|
| + new Name(element.name, element.library, isSetter: true)),
|
| + null);
|
| registerDynamicUse(dynamicUse);
|
| }
|
| }
|
| @@ -431,8 +407,7 @@ abstract class Enqueuer {
|
| /// [enclosingWasIncluded] provides a hint whether the enclosing element was
|
| /// needed for reflection.
|
| void enqueueReflectiveElementsInClass(ClassElement cls,
|
| - Iterable<ClassElement> recents,
|
| - bool enclosingWasIncluded) {
|
| + Iterable<ClassElement> recents, bool enclosingWasIncluded) {
|
| if (cls.library.isInternalLibrary || cls.isInjected) return;
|
| bool includeClass = shouldIncludeElementDueToMirrors(cls,
|
| includedEnclosing: enclosingWasIncluded);
|
| @@ -441,9 +416,7 @@ abstract class Enqueuer {
|
| ClassElement decl = cls.declaration;
|
| decl.ensureResolved(resolution);
|
| compiler.backend.registerInstantiatedType(
|
| - decl.rawType,
|
| - this,
|
| - compiler.mirrorDependencies,
|
| + decl.rawType, this, compiler.mirrorDependencies,
|
| mirrorUsage: true);
|
| }
|
| // If the class is never instantiated, we know nothing of it can possibly
|
| @@ -475,9 +448,7 @@ abstract class Enqueuer {
|
| logEnqueueReflectiveAction(cls);
|
| cls.ensureResolved(resolution);
|
| compiler.backend.registerInstantiatedType(
|
| - cls.rawType,
|
| - this,
|
| - compiler.mirrorDependencies,
|
| + cls.rawType, this, compiler.mirrorDependencies,
|
| mirrorUsage: true);
|
| }
|
| }
|
| @@ -485,10 +456,10 @@ abstract class Enqueuer {
|
|
|
| /// Enqeue all local members of the library [lib] if they are required for
|
| /// reflection.
|
| - void enqueueReflectiveElementsInLibrary(LibraryElement lib,
|
| - Iterable<ClassElement> recents) {
|
| - bool includeLibrary = shouldIncludeElementDueToMirrors(lib,
|
| - includedEnclosing: false);
|
| + void enqueueReflectiveElementsInLibrary(
|
| + LibraryElement lib, Iterable<ClassElement> recents) {
|
| + bool includeLibrary =
|
| + shouldIncludeElementDueToMirrors(lib, includedEnclosing: false);
|
| lib.forEachLocalMember((Element member) {
|
| if (member.isClass) {
|
| enqueueReflectiveElementsInClass(member, recents, includeLibrary);
|
| @@ -522,7 +493,9 @@ abstract class Enqueuer {
|
| // Keep looking at new classes until fixpoint is reached.
|
| logEnqueueReflectiveAction("!START enqueueRecents");
|
| recents.forEach((ClassElement cls) {
|
| - enqueueReflectiveElementsInClass(cls, recents,
|
| + enqueueReflectiveElementsInClass(
|
| + cls,
|
| + recents,
|
| shouldIncludeElementDueToMirrors(cls.library,
|
| includedEnclosing: false));
|
| });
|
| @@ -541,9 +514,7 @@ abstract class Enqueuer {
|
| }
|
|
|
| void processSet(
|
| - Map<String, Set<Element>> map,
|
| - String memberName,
|
| - bool f(Element e)) {
|
| + Map<String, Set<Element>> map, String memberName, bool f(Element e)) {
|
| Set<Element> members = map[memberName];
|
| if (members == null) return;
|
| // [f] might add elements to [: map[memberName] :] during the loop below
|
| @@ -577,7 +548,8 @@ abstract class Enqueuer {
|
| if (member.isFunction && selector.isGetter) {
|
| registerClosurizedMember(member);
|
| }
|
| - if (member.isField && compiler.backend.isNative(member.enclosingClass)) {
|
| + if (member.isField &&
|
| + compiler.backend.isNative(member.enclosingClass)) {
|
| if (selector.isGetter || selector.isCall) {
|
| nativeEnqueuer.registerFieldLoad(member);
|
| // We have to also handle storing to the field because we only get
|
| @@ -677,8 +649,7 @@ abstract class Enqueuer {
|
| // Even in checked mode, type annotations for return type and argument
|
| // types do not imply type checks, so there should never be a check
|
| // against the type variable of a typedef.
|
| - assert(!type.isTypeVariable ||
|
| - !type.element.enclosingElement.isTypedef);
|
| + assert(!type.isTypeVariable || !type.element.enclosingElement.isTypedef);
|
| }
|
|
|
| void registerCallMethodWithFreeTypeVariables(Element element) {
|
| @@ -748,17 +719,17 @@ class ResolutionEnqueuer extends Enqueuer {
|
| */
|
| final Queue<DeferredTask> deferredTaskQueue;
|
|
|
| - static const ImpactUseCase IMPACT_USE = const ImpactUseCase('ResolutionEnqueuer');
|
| + static const ImpactUseCase IMPACT_USE =
|
| + const ImpactUseCase('ResolutionEnqueuer');
|
|
|
| ImpactUseCase get impactUse => IMPACT_USE;
|
|
|
| - ResolutionEnqueuer(Compiler compiler,
|
| - ItemCompilationContext itemCompilationContextCreator(),
|
| - EnqueuerStrategy strategy)
|
| - : super('resolution enqueuer',
|
| - compiler,
|
| - itemCompilationContextCreator,
|
| - strategy),
|
| + ResolutionEnqueuer(
|
| + Compiler compiler,
|
| + ItemCompilationContext itemCompilationContextCreator(),
|
| + EnqueuerStrategy strategy)
|
| + : super('resolution enqueuer', compiler, itemCompilationContextCreator,
|
| + strategy),
|
| processedElements = new Set<AstElement>(),
|
| queue = new Queue<ResolutionWorkItem>(),
|
| deferredTaskQueue = new Queue<DeferredTask>();
|
| @@ -786,8 +757,9 @@ class ResolutionEnqueuer extends Enqueuer {
|
| * yet.
|
| */
|
| bool shouldIncludeElementDueToMirrors(Element element,
|
| - {bool includedEnclosing}) {
|
| - return includedEnclosing || compiler.backend.requiredByMirrorSystem(element);
|
| + {bool includedEnclosing}) {
|
| + return includedEnclosing ||
|
| + compiler.backend.requiredByMirrorSystem(element);
|
| }
|
|
|
| bool internalAddToWorkList(Element element) {
|
| @@ -797,22 +769,21 @@ class ResolutionEnqueuer extends Enqueuer {
|
| message: 'Element $element is not analyzable.'));
|
| if (hasBeenProcessed(element)) return false;
|
| if (queueIsClosed) {
|
| - throw new SpannableAssertionFailure(element,
|
| - "Resolution work list is closed. Trying to add $element.");
|
| + throw new SpannableAssertionFailure(
|
| + element, "Resolution work list is closed. Trying to add $element.");
|
| }
|
|
|
| compiler.world.registerUsedElement(element);
|
|
|
| - ResolutionWorkItem workItem = compiler.resolution.createWorkItem(
|
| - element, itemCompilationContextCreator());
|
| + ResolutionWorkItem workItem = compiler.resolution
|
| + .createWorkItem(element, itemCompilationContextCreator());
|
| queue.add(workItem);
|
|
|
| // Enable isolate support if we start using something from the isolate
|
| // library, or timers for the async library. We exclude constant fields,
|
| // which are ending here because their initializing expression is compiled.
|
| LibraryElement library = element.library;
|
| - if (!compiler.hasIsolateSupport &&
|
| - (!element.isField || !element.isConst)) {
|
| + if (!compiler.hasIsolateSupport && (!element.isField || !element.isConst)) {
|
| String uri = library.canonicalUri.toString();
|
| if (uri == 'dart:isolate') {
|
| enableIsolateSupport();
|
| @@ -861,7 +832,8 @@ class ResolutionEnqueuer extends Enqueuer {
|
| */
|
| void addDeferredAction(Element element, DeferredAction action) {
|
| if (queueIsClosed) {
|
| - throw new SpannableAssertionFailure(element,
|
| + throw new SpannableAssertionFailure(
|
| + element,
|
| "Resolution work list is closed. "
|
| "Trying to add deferred action for $element");
|
| }
|
| @@ -901,18 +873,20 @@ class CodegenEnqueuer extends Enqueuer {
|
|
|
| bool enabledNoSuchMethod = false;
|
|
|
| - static const ImpactUseCase IMPACT_USE = const ImpactUseCase('CodegenEnqueuer');
|
| + static const ImpactUseCase IMPACT_USE =
|
| + const ImpactUseCase('CodegenEnqueuer');
|
|
|
| ImpactUseCase get impactUse => IMPACT_USE;
|
|
|
| - CodegenEnqueuer(Compiler compiler,
|
| - ItemCompilationContext itemCompilationContextCreator(),
|
| - EnqueuerStrategy strategy)
|
| + CodegenEnqueuer(
|
| + Compiler compiler,
|
| + ItemCompilationContext itemCompilationContextCreator(),
|
| + EnqueuerStrategy strategy)
|
| : queue = new Queue<CodegenWorkItem>(),
|
| newlyEnqueuedElements = compiler.cacheStrategy.newSet(),
|
| newlySeenSelectors = compiler.cacheStrategy.newSet(),
|
| super('codegen enqueuer', compiler, itemCompilationContextCreator,
|
| - strategy);
|
| + strategy);
|
|
|
| bool isProcessed(Element member) =>
|
| member.isAbstract || generatedCode.containsKey(member);
|
| @@ -925,7 +899,7 @@ class CodegenEnqueuer extends Enqueuer {
|
| * subtyping constraints into account.
|
| */
|
| bool shouldIncludeElementDueToMirrors(Element element,
|
| - {bool includedEnclosing}) {
|
| + {bool includedEnclosing}) {
|
| return compiler.backend.isAccessibleByReflection(element);
|
| }
|
|
|
| @@ -936,8 +910,8 @@ class CodegenEnqueuer extends Enqueuer {
|
| // Codegen inlines field initializers. It only needs to generate
|
| // code for checked setters.
|
| if (element.isField && element.isInstanceMember) {
|
| - if (!compiler.options.enableTypeAssertions
|
| - || element.enclosingElement.isClosure) {
|
| + if (!compiler.options.enableTypeAssertions ||
|
| + element.enclosingElement.isClosure) {
|
| return false;
|
| }
|
| }
|
| @@ -947,11 +921,11 @@ class CodegenEnqueuer extends Enqueuer {
|
| }
|
|
|
| if (queueIsClosed) {
|
| - throw new SpannableAssertionFailure(element,
|
| - "Codegen work list is closed. Trying to add $element");
|
| + throw new SpannableAssertionFailure(
|
| + element, "Codegen work list is closed. Trying to add $element");
|
| }
|
| - CodegenWorkItem workItem = new CodegenWorkItem(
|
| - compiler, element, itemCompilationContextCreator());
|
| + CodegenWorkItem workItem =
|
| + new CodegenWorkItem(compiler, element, itemCompilationContextCreator());
|
| queue.add(workItem);
|
| return true;
|
| }
|
| @@ -992,11 +966,11 @@ class QueueFilter {
|
| bool checkNoEnqueuedInvokedInstanceMethods(Enqueuer enqueuer) {
|
| enqueuer.task.measure(() {
|
| // Run through the classes and see if we need to compile methods.
|
| - for (ClassElement classElement in
|
| - enqueuer.universe.directlyInstantiatedClasses) {
|
| + for (ClassElement classElement
|
| + in enqueuer.universe.directlyInstantiatedClasses) {
|
| for (ClassElement currentClass = classElement;
|
| - currentClass != null;
|
| - currentClass = currentClass.superclass) {
|
| + currentClass != null;
|
| + currentClass = currentClass.superclass) {
|
| enqueuer.processInstantiatedClassMembers(currentClass);
|
| }
|
| }
|
|
|
Chromium Code Reviews
