languages/dart-sdk
languages/dart-sdk
1
0
Fork 0
mirror of https://github.com/dart-lang/sdk synced 2024-10-14 16:26:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename Enqueuer.universe to worldBuilder.

Browse source 
R=sigmund@google.com

Review-Url: https://codereview.chromium.org/2625713002 .
This commit is contained in:
Johnni Winther 2017-01-12 13:26:59 +01:00
parent 9fb86fe21d
commit eac4142d42
41 changed files with 155 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
pkg/compiler/lib/src/compiler.dart
View file

@ -305,10 +305,9 @@ abstract class Compiler implements LibraryLoaderListener {
return new ResolverTask(resolution, backend.constantCompilerTask, measurer);
}
// TODO(johnniwinther): Rename these appropriately when unification of worlds/
// universes is complete.
ResolutionWorldBuilder get resolverWorld => enqueuer.resolution.universe;
CodegenWorldBuilder get codegenWorld => enqueuer.codegen.universe;
ResolutionWorldBuilder get resolutionWorldBuilder =>
enqueuer.resolution.worldBuilder;
CodegenWorldBuilder get codegenWorldBuilder => enqueuer.codegen.worldBuilder;
bool get analyzeAll => options.analyzeAll || compileAll;
@ -709,7 +708,7 @@ abstract class Compiler implements LibraryLoaderListener {
reporter.log('Compiling...');
phase = PHASE_COMPILING;
codegenWorld.open(closedWorld);
codegenWorldBuilder.open(closedWorld);
enqueuer.codegen.applyImpact(backend.onCodegenStart(closedWorld));
if (compileAll) {
libraryLoader.libraries.forEach((LibraryElement library) {
@ -736,7 +735,7 @@ abstract class Compiler implements LibraryLoaderListener {
ClosedWorldRefiner closeResolution() {
phase = PHASE_DONE_RESOLVING;
ClosedWorldImpl world = resolverWorld.closeWorld(reporter);
ClosedWorldImpl world = resolutionWorldBuilder.closeWorld(reporter);
// Compute whole-program-knowledge that the backend needs. (This might
// require the information computed in [world.closeWorld].)
backend.onResolutionComplete(world, world);
@ -1967,7 +1966,7 @@ class CompilerResolution implements Resolution {
@override
void registerClass(ClassElement cls) {
enqueuer.universe.registerClass(cls);
enqueuer.worldBuilder.registerClass(cls);
}
@override

9
pkg/compiler/lib/src/enqueue.dart
View file

@ -67,8 +67,7 @@ class EnqueueTask extends CompilerTask {
}
abstract class Enqueuer {
// TODO(johnniwinther): Rename to `worldBuilder`.
WorldBuilder get universe;
WorldBuilder get worldBuilder;
native.NativeEnqueuer get nativeEnqueuer;
void forgetEntity(Entity entity, Compiler compiler);
@ -168,7 +167,7 @@ class ResolutionEnqueuer extends EnqueuerImpl {
_impactVisitor = new EnqueuerImplImpactVisitor(this);
}
ResolutionWorldBuilder get universe => _universe;
ResolutionWorldBuilder get worldBuilder => _universe;
bool get queueIsEmpty => _queue.isEmpty;
@ -298,7 +297,7 @@ class ResolutionEnqueuer extends EnqueuerImpl {
break;
case TypeUseKind.TYPE_LITERAL:
if (type.isTypedef) {
universe.registerTypedef(type.element);
worldBuilder.registerTypedef(type.element);
}
break;
}
@ -483,7 +482,7 @@ class TreeShakingEnqueuerStrategy extends EnqueuerStrategy {
enqueuer.task.measure(() {
// Run through the classes and see if we need to enqueue more methods.
for (ClassElement classElement
in enqueuer.universe.directlyInstantiatedClasses) {
in enqueuer.worldBuilder.directlyInstantiatedClasses) {
for (ClassElement currentClass = classElement;
currentClass != null;
currentClass = currentClass.superclass) {

13
pkg/compiler/lib/src/js_backend/backend.dart
View file

@ -1292,7 +1292,7 @@ class JavaScriptBackend extends Backend {
}
computeMembersNeededForReflection(closedWorld);
rti.computeClassesNeedingRti(
compiler.enqueuer.resolution.universe, closedWorld);
compiler.enqueuer.resolution.worldBuilder, closedWorld);
_registeredMetadata.clear();
}
@ -2049,13 +2049,15 @@ class JavaScriptBackend extends Backend {
// can include the correct ones when including the class.
Map<ClassElement, List<LocalFunctionElement>> closureMap =
new Map<ClassElement, List<LocalFunctionElement>>();
for (LocalFunctionElement closure in compiler.resolverWorld.allClosures) {
for (LocalFunctionElement closure
in compiler.resolutionWorldBuilder.allClosures) {
closureMap.putIfAbsent(closure.enclosingClass, () => []).add(closure);
}
bool foundClosure = false;
Set<Element> reflectableMembers = new Set<Element>();
ResolutionEnqueuer resolution = compiler.enqueuer.resolution;
for (ClassElement cls in resolution.universe.directlyInstantiatedClasses) {
for (ClassElement cls
in resolution.worldBuilder.directlyInstantiatedClasses) {
// Do not process internal classes.
if (cls.library.isInternalLibrary || cls.isInjected) continue;
if (referencedFromMirrorSystem(cls)) {
@ -2158,7 +2160,8 @@ class JavaScriptBackend extends Backend {
if (foundClosure) {
reflectableMembers.add(helpers.closureClass);
}
Set<Element> closurizedMembers = compiler.resolverWorld.closurizedMembers;
Set<Element> closurizedMembers =
compiler.resolutionWorldBuilder.closurizedMembers;
if (closurizedMembers.any(reflectableMembers.contains)) {
reflectableMembers.add(helpers.boundClosureClass);
}
@ -2400,7 +2403,7 @@ class JavaScriptBackend extends Backend {
WorldImpact onCodegenStart(ClosedWorld closedWorld) {
_closedWorld = closedWorld;
_namer = determineNamer(_closedWorld, compiler.codegenWorld);
_namer = determineNamer(_closedWorld, compiler.codegenWorldBuilder);
tracer = new Tracer(_closedWorld, namer, compiler.outputProvider);
emitter.createEmitter(_namer, _closedWorld);
lookupMapAnalysis.onCodegenStart();

2
pkg/compiler/lib/src/js_backend/enqueuer.dart
View file

@ -72,7 +72,7 @@ class CodegenEnqueuer extends EnqueuerImpl {
_impactVisitor = new EnqueuerImplImpactVisitor(this);
}
CodegenWorldBuilder get universe => _universe;
CodegenWorldBuilder get worldBuilder => _universe;
bool get queueIsEmpty => _queue.isEmpty;

9
pkg/compiler/lib/src/js_backend/js_interop_analysis.dart
View file

@ -117,7 +117,10 @@ class JsInteropAnalysis {
// Skip classes that are completely unreachable. This should only happen
// when all of jsinterop types are unreachable from main.
if (!backend.compiler.resolverWorld.isImplemented(classElement)) return;
if (!backend.compiler.resolutionWorldBuilder
.isImplemented(classElement)) {
return;
}
if (!classElement.implementsInterface(helpers.jsJavaScriptObjectClass)) {
backend.reporter.reportErrorMessage(classElement,
@ -166,7 +169,7 @@ class JsInteropAnalysis {
jsAst.Statement buildJsInteropBootstrap() {
if (!enabledJsInterop) return null;
List<jsAst.Statement> statements = <jsAst.Statement>[];
backend.compiler.codegenWorld.forEachInvokedName(
backend.compiler.codegenWorldBuilder.forEachInvokedName(
(String name, Map<Selector, SelectorConstraints> selectors) {
selectors.forEach((Selector selector, SelectorConstraints constraints) {
if (selector.isClosureCall) {
@ -189,7 +192,7 @@ class JsInteropAnalysis {
}
ResolutionFunctionType buildJsFunctionType() {
// TODO(jacobr): consider using codegenWorld.isChecks to determine the
// TODO(jacobr): consider using codegenWorldBuilder.isChecks to determine the
// range of positional arguments that need to be supported by JavaScript
// function types.
return new ResolutionFunctionType.synthesized(

1
pkg/compiler/lib/src/js_backend/namer.dart
View file

@ -1787,6 +1787,7 @@ class ConstantNamingVisitor implements ConstantValueVisitor {
@override
void visitConstructed(ConstructedConstantValue constant, [_]) {
addRoot(constant.type.element.name);
// TODO(johnniwinther): This should be accessed from a codegen closed world.
codegenWorldBuilder.forEachInstanceField(constant.type.element,
(_, FieldElement field) {
if (failed) return;

45
pkg/compiler/lib/src/js_backend/runtime_types.dart
View file

@ -36,7 +36,7 @@ abstract class RuntimeTypes {
Set<ClassElement> getClassesUsedInSubstitutions(
JavaScriptBackend backend, TypeChecks checks);
void computeClassesNeedingRti(
ResolutionWorldBuilder resolverWorld, ClosedWorld closedWorld);
ResolutionWorldBuilder resolutionWorldBuilder, ClosedWorld closedWorld);
/// Compute the required type checkes and substitutions for the given
/// instantitated and checked classes.
@ -48,7 +48,7 @@ abstract class RuntimeTypes {
///
/// This function must be called after all is-checks have been registered.
void addImplicitChecks(
WorldBuilder universe, Iterable<ClassElement> classesUsingChecks);
WorldBuilder worldBuilder, Iterable<ClassElement> classesUsingChecks);
/// Return all classes that are referenced in the type of the function, i.e.,
/// in the return type or the argument types.
@ -173,18 +173,18 @@ class _RuntimeTypes implements RuntimeTypes {
*/
@override
void addImplicitChecks(
WorldBuilder universe, Iterable<ClassElement> classesUsingChecks) {
WorldBuilder worldBuilder, Iterable<ClassElement> classesUsingChecks) {
// If there are no classes that use their variables in checks, there is
// nothing to do.
if (classesUsingChecks.isEmpty) return;
Set<ResolutionDartType> instantiatedTypes = universe.instantiatedTypes;
Set<ResolutionDartType> instantiatedTypes = worldBuilder.instantiatedTypes;
if (cannotDetermineInstantiatedTypesPrecisely) {
for (ResolutionDartType type in instantiatedTypes) {
if (type.kind != ResolutionTypeKind.INTERFACE) continue;
ResolutionInterfaceType interface = type;
do {
for (ResolutionDartType argument in interface.typeArguments) {
universe.registerIsCheck(argument);
worldBuilder.registerIsCheck(argument);
}
interface = interface.element.supertype;
} while (interface != null && !instantiatedTypes.contains(interface));
@ -207,7 +207,7 @@ class _RuntimeTypes implements RuntimeTypes {
ResolutionInterfaceType instance = current.asInstanceOf(cls);
if (instance == null) break;
for (ResolutionDartType argument in instance.typeArguments) {
universe.registerIsCheck(argument);
worldBuilder.registerIsCheck(argument);
}
current = current.element.supertype;
} while (current != null && !instantiatedTypes.contains(current));
@ -218,7 +218,7 @@ class _RuntimeTypes implements RuntimeTypes {
@override
void computeClassesNeedingRti(
ResolutionWorldBuilder resolverWorld, ClosedWorld closedWorld) {
ResolutionWorldBuilder resolutionWorldBuilder, ClosedWorld closedWorld) {
// Find the classes that need runtime type information. Such
// classes are:
// (1) used in a is check with type variables,
@ -244,7 +244,7 @@ class _RuntimeTypes implements RuntimeTypes {
}
Set<ClassElement> classesUsingTypeVariableTests = new Set<ClassElement>();
resolverWorld.isChecks.forEach((ResolutionDartType type) {
resolutionWorldBuilder.isChecks.forEach((ResolutionDartType type) {
if (type.isTypeVariable) {
TypeVariableElement variable = type.element;
// GENERIC_METHODS: When generic method support is complete enough to
@ -256,7 +256,8 @@ class _RuntimeTypes implements RuntimeTypes {
}
});
// Add is-checks that result from classes using type variables in checks.
addImplicitChecks(compiler.resolverWorld, classesUsingTypeVariableTests);
addImplicitChecks(
compiler.resolutionWorldBuilder, classesUsingTypeVariableTests);
// Add the rti dependencies that are implicit in the way the backend
// generates code: when we create a new [List], we actually create
// a JSArray in the backend and we need to add type arguments to
@ -269,7 +270,7 @@ class _RuntimeTypes implements RuntimeTypes {
}
// Compute the set of all classes and methods that need runtime type
// information.
compiler.resolverWorld.isChecks.forEach((ResolutionDartType type) {
compiler.resolutionWorldBuilder.isChecks.forEach((ResolutionDartType type) {
if (type.isInterfaceType) {
ResolutionInterfaceType itf = type;
if (!itf.treatAsRaw) {
@ -294,9 +295,9 @@ class _RuntimeTypes implements RuntimeTypes {
}
}
compiler.resolverWorld.closuresWithFreeTypeVariables
compiler.resolutionWorldBuilder.closuresWithFreeTypeVariables
.forEach(analyzeMethod);
compiler.resolverWorld.callMethodsWithFreeTypeVariables
compiler.resolutionWorldBuilder.callMethodsWithFreeTypeVariables
.forEach(analyzeMethod);
}
}
@ -311,9 +312,9 @@ class _RuntimeTypes implements RuntimeTypes {
}
}
compiler.resolverWorld.closuresWithFreeTypeVariables
compiler.resolutionWorldBuilder.closuresWithFreeTypeVariables
.forEach(analyzeMethod);
compiler.resolverWorld.callMethodsWithFreeTypeVariables
compiler.resolutionWorldBuilder.callMethodsWithFreeTypeVariables
.forEach(analyzeMethod);
}
// Add the classes that need RTI because they use a type variable as
@ -358,10 +359,10 @@ class _RuntimeTypes implements RuntimeTypes {
}
void computeRequiredChecks() {
Set<ResolutionDartType> isChecks = compiler.codegenWorld.isChecks;
Set<ResolutionDartType> isChecks = compiler.codegenWorldBuilder.isChecks;
// These types are needed for is-checks against function types.
Set<ResolutionDartType> instantiatedTypesAndClosures =
computeInstantiatedTypesAndClosures(compiler.codegenWorld);
computeInstantiatedTypesAndClosures(compiler.codegenWorldBuilder);
computeInstantiatedArguments(instantiatedTypesAndClosures, isChecks);
computeCheckedArguments(instantiatedTypesAndClosures, isChecks);
cachedRequiredChecks =
@ -369,10 +370,11 @@ class _RuntimeTypes implements RuntimeTypes {
}
Set<ResolutionDartType> computeInstantiatedTypesAndClosures(
CodegenWorldBuilder universe) {
CodegenWorldBuilder worldBuilder) {
Set<ResolutionDartType> instantiatedTypes =
new Set<ResolutionDartType>.from(universe.instantiatedTypes);
for (ResolutionDartType instantiatedType in universe.instantiatedTypes) {
new Set<ResolutionDartType>.from(worldBuilder.instantiatedTypes);
for (ResolutionDartType instantiatedType
in worldBuilder.instantiatedTypes) {
if (instantiatedType.isInterfaceType) {
ResolutionInterfaceType interface = instantiatedType;
ResolutionFunctionType callType = interface.callType;
@ -381,14 +383,15 @@ class _RuntimeTypes implements RuntimeTypes {
}
}
}
for (FunctionElement element in universe.staticFunctionsNeedingGetter) {
for (FunctionElement element in worldBuilder.staticFunctionsNeedingGetter) {
instantiatedTypes.add(element.type);
}
// TODO(johnniwinther): We should get this information through the
// [neededClasses] computed in the emitter instead of storing it and pulling
// it from resolution, but currently it would introduce a cyclic dependency
// between [computeRequiredChecks] and [computeNeededClasses].
for (TypedElement element in compiler.resolverWorld.closurizedMembers) {
for (TypedElement element
in compiler.resolutionWorldBuilder.closurizedMembers) {
instantiatedTypes.add(element.type);
}
return instantiatedTypes;

12
pkg/compiler/lib/src/js_emitter/class_stub_generator.dart
View file

@ -7,12 +7,12 @@ part of dart2js.js_emitter;
class ClassStubGenerator {
final Namer namer;
final JavaScriptBackend backend;
final CodegenWorldBuilder codegenWorld;
final CodegenWorldBuilder worldBuilder;
final ClosedWorld closedWorld;
final bool enableMinification;
ClassStubGenerator(
this.namer, this.backend, this.codegenWorld, this.closedWorld,
this.namer, this.backend, this.worldBuilder, this.closedWorld,
{this.enableMinification});
jsAst.Expression generateClassConstructor(ClassElement classElement,
@ -130,7 +130,7 @@ class ClassStubGenerator {
Map<jsAst.Name, Selector> jsNames = <jsAst.Name, Selector>{};
// Do not generate no such method handlers if there is no class.
if (codegenWorld.directlyInstantiatedClasses.isEmpty) {
if (worldBuilder.directlyInstantiatedClasses.isEmpty) {
return jsNames;
}
@ -145,9 +145,9 @@ class ClassStubGenerator {
}
}
codegenWorld.forEachInvokedName(addNoSuchMethodHandlers);
codegenWorld.forEachInvokedGetter(addNoSuchMethodHandlers);
codegenWorld.forEachInvokedSetter(addNoSuchMethodHandlers);
worldBuilder.forEachInvokedName(addNoSuchMethodHandlers);
worldBuilder.forEachInvokedGetter(addNoSuchMethodHandlers);
worldBuilder.forEachInvokedSetter(addNoSuchMethodHandlers);
return jsNames;
}

2
pkg/compiler/lib/src/js_emitter/full_emitter/class_emitter.dart
View file

@ -10,7 +10,7 @@ class ClassEmitter extends CodeEmitterHelper {
ClassEmitter(this.closedWorld);
ClassStubGenerator get _stubGenerator =>
new ClassStubGenerator(namer, backend, codegenWorld, closedWorld,
new ClassStubGenerator(namer, backend, codegenWorldBuilder, closedWorld,
enableMinification: compiler.options.enableMinification);
/**

2
pkg/compiler/lib/src/js_emitter/full_emitter/code_emitter_helper.dart
View file

@ -19,7 +19,7 @@ class CodeEmitterHelper {
DiagnosticReporter get reporter => compiler.reporter;
CodegenWorldBuilder get codegenWorld => compiler.codegenWorld;
CodegenWorldBuilder get codegenWorldBuilder => compiler.codegenWorldBuilder;
String get n => emitter.n;

3
pkg/compiler/lib/src/js_emitter/full_emitter/emitter.dart
View file

@ -1889,7 +1889,8 @@ function(originalDescriptor, name, holder, isStatic, globalFunctionsAccess) {
// specific to the class. For now, not supported for native classes and
// native elements.
ClassElement cls = element.enclosingClassOrCompilationUnit.declaration;
if (compiler.codegenWorld.directlyInstantiatedClasses.contains(cls) &&
if (compiler.codegenWorldBuilder.directlyInstantiatedClasses
.contains(cls) &&
!backend.isNative(cls) &&
compiler.deferredLoadTask.outputUnitForElement(element) ==
compiler.deferredLoadTask.outputUnitForElement(cls)) {

2
pkg/compiler/lib/src/js_emitter/full_emitter/nsm_emitter.dart
View file

@ -23,7 +23,7 @@ class NsmEmitter extends CodeEmitterHelper {
void emitNoSuchMethodHandlers(AddPropertyFunction addProperty) {
ClassStubGenerator generator = new ClassStubGenerator(
namer, backend, codegenWorld, closedWorld,
namer, backend, codegenWorldBuilder, closedWorld,
enableMinification: compiler.options.enableMinification);
// Keep track of the JavaScript names we've already added so we

2
pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart
View file

@ -169,7 +169,7 @@ class InterceptorStubGenerator {
]));
} else {
ClassElement jsUnknown = helpers.jsUnknownJavaScriptObjectClass;
if (compiler.codegenWorld.directlyInstantiatedClasses
if (compiler.codegenWorldBuilder.directlyInstantiatedClasses
.contains(jsUnknown)) {
statements.add(js.statement('if (!(receiver instanceof #)) return #;', [
backend.emitter

6
pkg/compiler/lib/src/js_emitter/parameter_stub_generator.dart
View file

@ -20,7 +20,7 @@ class ParameterStubGenerator {
DiagnosticReporter get reporter => compiler.reporter;
bool needsSuperGetter(FunctionElement element) =>
compiler.codegenWorld.methodsNeedingSuperGetter.contains(element);
compiler.codegenWorldBuilder.methodsNeedingSuperGetter.contains(element);
/**
* Generates stubs to handle invocation of methods with optional
@ -214,12 +214,12 @@ class ParameterStubGenerator {
// Only instance members (not static methods) need stubs.
if (member.isInstanceMember) {
selectors = compiler.codegenWorld.invocationsByName(member.name);
selectors = compiler.codegenWorldBuilder.invocationsByName(member.name);
}
if (canTearOff) {
String call = namer.closureInvocationSelectorName;
callSelectors = compiler.codegenWorld.invocationsByName(call);
callSelectors = compiler.codegenWorldBuilder.invocationsByName(call);
}
assert(emptySelectorSet.isEmpty);

11
pkg/compiler/lib/src/js_emitter/program_builder/collector.dart
View file

@ -178,7 +178,10 @@ class Collector {
// Compute needed classes.
Set<ClassElement> instantiatedClasses = compiler
.codegenWorld.directlyInstantiatedClasses
// TODO(johnniwinther): This should be accessed from a codegen closed
// world.
.codegenWorldBuilder
.directlyInstantiatedClasses
.where(computeClassFilter())
.toSet();
@ -286,7 +289,11 @@ class Collector {
list.add(element);
}
Iterable<Element> fields = compiler.codegenWorld.allReferencedStaticFields
Iterable<Element> fields = compiler
// TODO(johnniwinther): This should be accessed from a codegen closed
// world.
.codegenWorldBuilder
.allReferencedStaticFields
.where((FieldElement field) {
if (!field.isConst) {
return field.isField &&

9
pkg/compiler/lib/src/js_emitter/program_builder/field_visitor.dart
View file

@ -72,8 +72,9 @@ class FieldVisitor {
// If the class is never instantiated we still need to set it up for
// inheritance purposes, but we can simplify its JavaScript constructor.
bool isInstantiated =
compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
bool isInstantiated = compiler
.codegenWorldBuilder.directlyInstantiatedClasses
.contains(element);
void visitField(Element holder, FieldElement field) {
assert(invariant(element, field.isDeclaration));
@ -141,7 +142,7 @@ class FieldVisitor {
if (fieldAccessNeverThrows(field)) return false;
if (backend.shouldRetainGetter(field)) return true;
return field.isClassMember &&
compiler.codegenWorld.hasInvokedGetter(field, closedWorld);
compiler.codegenWorldBuilder.hasInvokedGetter(field, closedWorld);
}
bool fieldNeedsSetter(VariableElement field) {
@ -150,7 +151,7 @@ class FieldVisitor {
if (field.isFinal || field.isConst) return false;
if (backend.shouldRetainSetter(field)) return true;
return field.isClassMember &&
compiler.codegenWorld.hasInvokedSetter(field, closedWorld);
compiler.codegenWorldBuilder.hasInvokedSetter(field, closedWorld);
}
static bool fieldAccessNeverThrows(VariableElement field) {

23
pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart
View file

@ -84,7 +84,7 @@ class ProgramBuilder {
JavaScriptBackend get backend => _compiler.backend;
BackendHelpers get helpers => backend.helpers;
CodegenWorldBuilder get universe => _compiler.codegenWorld;
CodegenWorldBuilder get worldBuilder => _compiler.codegenWorldBuilder;
/// Mapping from [ClassElement] to constructed [Class]. We need this to
/// update the superclass in the [Class].
@ -354,8 +354,7 @@ class ProgramBuilder {
backend.nativeData.getUnescapedJSInteropName(member.name);
if (!member.isInstanceMember) return;
if (member.isGetter || member.isField || member.isFunction) {
var selectors =
_compiler.codegenWorld.getterInvocationsByName(member.name);
var selectors = worldBuilder.getterInvocationsByName(member.name);
if (selectors != null && !selectors.isEmpty) {
for (var selector in selectors.keys) {
var stubName = namer.invocationName(selector);
@ -369,8 +368,7 @@ class ProgramBuilder {
}
if (member.isSetter || (member.isField && !member.isConst)) {
var selectors =
_compiler.codegenWorld.setterInvocationsByName(member.name);
var selectors = worldBuilder.setterInvocationsByName(member.name);
if (selectors != null && !selectors.isEmpty) {
var stubName = namer.setterForElement(member);
if (stubNames.add(stubName.key)) {
@ -423,8 +421,7 @@ class ProgramBuilder {
minArgs = 0;
maxArgs = 32767;
}
var selectors =
_compiler.codegenWorld.invocationsByName(member.name);
var selectors = worldBuilder.invocationsByName(member.name);
// Named arguments are not yet supported. In the future we
// may want to map named arguments to an object literal containing
// all named arguments.
@ -522,7 +519,7 @@ class ProgramBuilder {
List<StubMethod> callStubs = <StubMethod>[];
ClassStubGenerator classStubGenerator = new ClassStubGenerator(
namer, backend, universe, closedWorld,
namer, backend, worldBuilder, closedWorld,
enableMinification: _compiler.options.enableMinification);
RuntimeTypeGenerator runtimeTypeGenerator =
new RuntimeTypeGenerator(_compiler, _task, namer);
@ -538,7 +535,7 @@ class ProgramBuilder {
}
if (member.isGetter || member.isField) {
Map<Selector, SelectorConstraints> selectors =
_compiler.codegenWorld.invocationsByName(member.name);
worldBuilder.invocationsByName(member.name);
if (selectors != null && !selectors.isEmpty) {
Map<js.Name, js.Expression> callStubsForMember =
classStubGenerator.generateCallStubsForGetter(member, selectors);
@ -624,7 +621,7 @@ class ProgramBuilder {
// building a class.
Holder holder = _registry.registerHolder(holderName);
bool isInstantiated = !backend.isJsInterop(element) &&
_compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
worldBuilder.directlyInstantiatedClasses.contains(element);
Class result;
if (element.isMixinApplication && !onlyForRti) {
@ -741,10 +738,10 @@ class ProgramBuilder {
isClosureCallMethod = true;
} else {
// Careful with operators.
canTearOff = universe.hasInvokedGetter(element, closedWorld) ||
canTearOff = worldBuilder.hasInvokedGetter(element, closedWorld) ||
(canBeReflected && !element.isOperator);
assert(canTearOff ||
!universe.methodsNeedingSuperGetter.contains(element));
!worldBuilder.methodsNeedingSuperGetter.contains(element));
tearOffName = namer.getterForElement(element);
}
}
@ -935,7 +932,7 @@ class ProgramBuilder {
bool needsTearOff = isApplyTarget &&
(canBeReflected ||
universe.staticFunctionsNeedingGetter.contains(element));
worldBuilder.staticFunctionsNeedingGetter.contains(element));
js.Name tearOffName =
needsTearOff ? namer.staticClosureName(element) : null;

10
pkg/compiler/lib/src/js_emitter/type_test_registry.dart
View file

@ -28,7 +28,8 @@ class TypeTestRegistry {
Iterable<ClassElement> get classesUsingTypeVariableTests {
if (cachedClassesUsingTypeVariableTests == null) {
cachedClassesUsingTypeVariableTests = compiler.codegenWorld.isChecks
cachedClassesUsingTypeVariableTests = compiler
.codegenWorldBuilder.isChecks
.where((ResolutionDartType t) => t is ResolutionTypeVariableType)
.map((ResolutionTypeVariableType v) => v.element.enclosingClass)
.toList();
@ -106,7 +107,8 @@ class TypeTestRegistry {
return false;
} else if (function.isInstanceMember) {
if (!function.enclosingClass.isClosure) {
return compiler.codegenWorld.hasInvokedGetter(function, closedWorld);
return compiler.codegenWorldBuilder
.hasInvokedGetter(function, closedWorld);
}
}
return false;
@ -144,11 +146,11 @@ class TypeTestRegistry {
assert(checkedClasses == null && checkedFunctionTypes == null);
backend.rti.addImplicitChecks(
compiler.codegenWorld, classesUsingTypeVariableTests);
compiler.codegenWorldBuilder, classesUsingTypeVariableTests);
checkedClasses = new Set<ClassElement>();
checkedFunctionTypes = new Set<ResolutionFunctionType>();
compiler.codegenWorld.isChecks.forEach((ResolutionDartType t) {
compiler.codegenWorldBuilder.isChecks.forEach((ResolutionDartType t) {
if (t is ResolutionInterfaceType) {
checkedClasses.add(t.element);
} else if (t is ResolutionFunctionType) {

2
pkg/compiler/lib/src/resolution/resolution.dart
View file

@ -76,7 +76,7 @@ class ResolverTask extends CompilerTask {
ParsingContext get parsingContext => resolution.parsingContext;
CompilerOptions get options => resolution.options;
ResolutionEnqueuer get enqueuer => resolution.enqueuer;
OpenWorld get world => enqueuer.universe;
OpenWorld get world => enqueuer.worldBuilder;
ResolutionImpact resolve(Element element) {
return measure(() {

2
pkg/compiler/lib/src/ssa/optimize.dart
View file

@ -2317,7 +2317,7 @@ class SsaLoadElimination extends HBaseVisitor implements OptimizationPhase {
memorySet.registerAllocation(instruction);
if (shouldTrackInitialValues(instruction)) {
int argumentIndex = 0;
compiler.codegenWorld.forEachInstanceField(instruction.element,
compiler.codegenWorldBuilder.forEachInstanceField(instruction.element,
(_, FieldEntity member) {
if (compiler.elementHasCompileTimeError(member as Entity)) return;
memorySet.registerFieldValue(

6
pkg/compiler/lib/src/universe/world_builder.dart
View file

@ -159,8 +159,8 @@ abstract class WorldBuilder {
/// All types that are checked either through is, as or checked mode checks.
Iterable<ResolutionDartType> get isChecks;
/// Registers that [type] is checked in this universe. The unaliased type is
/// returned.
/// Registers that [type] is checked in this world builder. The unaliased type
/// is returned.
ResolutionDartType registerIsCheck(ResolutionDartType type);
/// All directly instantiated types, that is, the types of the directly
@ -1069,7 +1069,7 @@ class ResolutionWorldBuilderImpl implements ResolutionWorldBuilder {
return _closedWorldCache = new ClosedWorldImpl(
backend: _backend,
commonElements: commonElements,
resolverWorld: this,
resolutionWorldBuilder: this,
functionSetBuilder: _allFunctions,
allTypedefs: _allTypedefs,
mixinUses: _mixinUses,

4
pkg/compiler/lib/src/world.dart
View file

@ -424,7 +424,7 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
ClosedWorldImpl(
{JavaScriptBackend backend,
this.commonElements,
ResolutionWorldBuilder resolverWorld,
ResolutionWorldBuilder resolutionWorldBuilder,
FunctionSetBuilder functionSetBuilder,
Iterable<TypedefElement> allTypedefs,
Map<ClassElement, Set<MixinApplicationElement>> mixinUses,
@ -432,7 +432,7 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
Map<ClassElement, ClassHierarchyNode> classHierarchyNodes,
Map<ClassElement, ClassSet> classSets})
: this._backend = backend,
this._resolverWorld = resolverWorld,
this._resolverWorld = resolutionWorldBuilder,
this._allTypedefs = allTypedefs,
this._mixinUses = mixinUses,
this._typesImplementedBySubclasses = typesImplementedBySubclasses,

2
pkg/dart2js_incremental/lib/caching_compiler.dart
View file

@ -74,7 +74,7 @@ Future<CompilerImpl> reuseCompiler(
return compiler.libraryLoader.loadLibrary(core).then((_) {
// Likewise, always be prepared for runtimeType support.
// TODO(johnniwinther): Add global switch to force RTI.
compiler.resolverWorld.hasRuntimeTypeSupport = true;
compiler.resolutionWorldBuilder.hasRuntimeTypeSupport = true;
compiler.enqueuer.resolution.applyImpact(backend.registerRuntimeType());
return compiler;
});

3
tests/compiler/dart2js/assert_message_throw_test.dart
View file

@ -59,7 +59,8 @@ main() {
memorySourceFiles: {'main.dart': SOURCE},
options: [Flags.enableCheckedMode, Flags.enableAssertMessage]);
Compiler compiler = result.compiler;
ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
ClosedWorld closedWorld =
compiler.resolutionWorldBuilder.closedWorldForTesting;
void check(String methodName, TypeMask expectedReturnType) {
Element element = compiler.mainApp.find(methodName);

4
tests/compiler/dart2js/check_elements_invariants_test.dart
View file

@ -19,8 +19,8 @@ const List<String> DART2JS_OPTIONS = const <String>[
Iterable<ClassElement> computeLiveClasses(CompilerImpl compiler) {
return new Set<ClassElement>()
..addAll(compiler.resolverWorld.directlyInstantiatedClasses)
..addAll(compiler.codegenWorld.directlyInstantiatedClasses);
..addAll(compiler.resolutionWorldBuilder.directlyInstantiatedClasses)
..addAll(compiler.codegenWorldBuilder.directlyInstantiatedClasses);
}
void checkClassInvariants(ClassElement cls) {

9
tests/compiler/dart2js/concrete_type_inference_test.dart
View file

@ -20,7 +20,7 @@ void checkPrintType(String expression, checkType(closedWorld, type)) {
asyncTest(() => compileAndFind('main() { print($expression); }', 'print',
(compiler, printElement) {
var parameter = printElement.functionSignature.requiredParameters.first;
checkType(compiler.resolverWorld.closedWorldForTesting,
checkType(compiler.resolutionWorldBuilder.closedWorldForTesting,
_typeOf(compiler, parameter));
}));
@ -28,7 +28,7 @@ void checkPrintType(String expression, checkType(closedWorld, type)) {
compileAndFind('main() { var x = print; print($expression); }', 'print',
(compiler, printElement) {
var parameter = printElement.functionSignature.requiredParameters.first;
checkType(compiler.resolverWorld.closedWorldForTesting,
checkType(compiler.resolutionWorldBuilder.closedWorldForTesting,
_typeOf(compiler, parameter));
}));
@ -36,7 +36,7 @@ void checkPrintType(String expression, checkType(closedWorld, type)) {
'main() { print($expression); print($expression); }', 'print',
(compiler, printElement) {
var parameter = printElement.functionSignature.requiredParameters.first;
checkType(compiler.resolverWorld.closedWorldForTesting,
checkType(compiler.resolutionWorldBuilder.closedWorldForTesting,
_typeOf(compiler, parameter));
}));
}
@ -71,7 +71,8 @@ void testOptionalParameters() {
var firstParameter = fiskElement.functionSignature.requiredParameters[0];
var secondParameter = fiskElement.functionSignature.optionalParameters[0];
var thirdParameter = fiskElement.functionSignature.optionalParameters[1];
var commonMasks = compiler.resolverWorld.closedWorldForTesting.commonMasks;
var commonMasks =
compiler.resolutionWorldBuilder.closedWorldForTesting.commonMasks;
Expect.identical(commonMasks.uint31Type, _typeOf(compiler, firstParameter));
Expect.identical(commonMasks.nullType, _typeOf(compiler, secondParameter));
Expect.identical(commonMasks.nullType, _typeOf(compiler, thirdParameter));

3
tests/compiler/dart2js/dump_info_test.dart
View file

@ -104,7 +104,8 @@ jsonTest(String program, JsonTaking testFn) async {
var dumpTask = compiler.dumpInfoTask;
StringBuffer sb = new StringBuffer();
dumpTask.dumpInfoJson(sb, compiler.resolverWorld.closedWorldForTesting);
dumpTask.dumpInfoJson(
sb, compiler.resolutionWorldBuilder.closedWorldForTesting);
String json = sb.toString();
Map<String, dynamic> map = JSON.decode(json);

3
tests/compiler/dart2js/expect_annotations_test.dart
View file

@ -52,7 +52,8 @@ main() {
CompilationResult result =
await runCompiler(memorySourceFiles: MEMORY_SOURCE_FILES);
Compiler compiler = result.compiler;
ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
ClosedWorld closedWorld =
compiler.resolutionWorldBuilder.closedWorldForTesting;
Expect.isFalse(compiler.compilationFailed, 'Unsuccessful compilation');
JavaScriptBackend backend = compiler.backend;
Expect.isNotNull(backend.annotations.expectNoInlineClass,

2
tests/compiler/dart2js/gvn_dynamic_field_get_test.dart
View file

@ -36,7 +36,7 @@ main() {
var element = cls.lookupLocalMember(name);
Expect.isNotNull(element);
Selector selector = new Selector.getter(new PublicName(name));
Expect.isFalse(compiler.resolverWorld.closedWorldForTesting
Expect.isFalse(compiler.resolutionWorldBuilder.closedWorldForTesting
.hasAnyUserDefinedGetter(selector, null));
}));
}

2
tests/compiler/dart2js/instantiated_classes_test.dart
View file

@ -93,7 +93,7 @@ Future test(String source, List<String> directlyInstantiatedClasses,
Iterable<ClassElement> expectedClasses =
directlyInstantiatedClasses.map(env.getElement);
Iterable<ClassElement> actualClasses = env
.compiler.resolverWorld.directlyInstantiatedClasses
.compiler.resolutionWorldBuilder.directlyInstantiatedClasses
.where((c) => c.library == env.compiler.mainApp);
Expect.setEquals(expectedClasses, actualClasses);
});

10
tests/compiler/dart2js/kernel/closed_world_test.dart
View file

@ -76,11 +76,11 @@ main(List<String> args) {
Flags.enableAssertMessage
]);
ResolutionWorldBuilderImpl worldBuilder =
compiler.enqueuer.resolution.universe;
compiler.enqueuer.resolution.worldBuilder;
worldBuilder.useInstantiationMap = true;
compiler.resolution.retainCachesForTesting = true;
await compiler.run(entryPoint);
compiler.resolverWorld.closeWorld(compiler.reporter);
compiler.resolutionWorldBuilder.closeWorld(compiler.reporter);
JavaScriptBackend backend = compiler.backend;
// Create a new resolution enqueuer and feed it with the [WorldImpact]s
@ -114,7 +114,8 @@ main(List<String> args) {
.transformResolutionImpact(enqueuer, resolutionImpact);
enqueuer.applyImpact(worldImpact, impactSource: element);
});
ClosedWorld closedWorld = enqueuer.universe.closeWorld(compiler.reporter);
ClosedWorld closedWorld =
enqueuer.worldBuilder.closeWorld(compiler.reporter);
checkResolutionEnqueuers(compiler.enqueuer.resolution, enqueuer,
typeEquivalence: (ResolutionDartType a, ResolutionDartType b) {
@ -135,7 +136,8 @@ main(List<String> args) {
}
return true;
}, verbose: arguments.verbose);
checkClosedWorlds(compiler.resolverWorld.closedWorldForTesting, closedWorld,
checkClosedWorlds(
compiler.resolutionWorldBuilder.closedWorldForTesting, closedWorld,
verbose: arguments.verbose);
});
}

2
tests/compiler/dart2js/minimal_resolution_test.dart
View file

@ -25,7 +25,7 @@ main() {
void checkInstantiated(Compiler compiler, ClassElement cls, bool expected) {
ResolutionEnqueuer enqueuer = compiler.enqueuer.resolution;
bool isInstantiated =
enqueuer.universe.directlyInstantiatedClasses.contains(cls);
enqueuer.worldBuilder.directlyInstantiatedClasses.contains(cls);
bool isProcessed = enqueuer.processedClasses.contains(cls);
Expect.equals(expected, isInstantiated,
'Unexpected instantiation state of class $cls.');

2
tests/compiler/dart2js/patch_test.dart
View file

@ -974,7 +974,7 @@ Future testPatchAndSelector() async {
runCompiler: true,
analyzeOnly: true);
compiler.closeResolution();
ClosedWorld world = compiler.resolverWorld.closedWorldForTesting;
ClosedWorld world = compiler.resolutionWorldBuilder.closedWorldForTesting;
ClassElement cls = ensure(
compiler, "A", compiler.commonElements.coreLibrary.find,

3
tests/compiler/dart2js/related_types.dart
View file

@ -78,7 +78,8 @@ class RelatedTypesChecker
: this.resolvedAst = resolvedAst,
super(resolvedAst.elements);
ClosedWorld get world => compiler.resolverWorld.closedWorldForTesting;
ClosedWorld get world =>
compiler.resolutionWorldBuilder.closedWorldForTesting;
CommonElements get commonElements => compiler.commonElements;

19
tests/compiler/dart2js/serialization/model_test_helper.dart
View file

@ -98,8 +98,9 @@ Future checkModels(Uri entryPoint,
checkResolutionEnqueuers(compilerNormal.enqueuer.resolution,
compilerDeserialized.enqueuer.resolution,
verbose: verbose);
checkClosedWorlds(compilerNormal.resolverWorld.closedWorldForTesting,
compilerDeserialized.resolverWorld.closedWorldForTesting,
checkClosedWorlds(
compilerNormal.resolutionWorldBuilder.closedWorldForTesting,
compilerDeserialized.resolutionWorldBuilder.closedWorldForTesting,
verbose: verbose);
checkBackendInfo(compilerNormal, compilerDeserialized, verbose: verbose);
});
@ -115,8 +116,8 @@ void checkResolutionEnqueuers(
"Processed element mismatch", areElementsEquivalent,
elementFilter: elementFilter, verbose: verbose);
ResolutionWorldBuilderImpl worldBuilder1 = enqueuer1.universe;
ResolutionWorldBuilderImpl worldBuilder2 = enqueuer2.universe;
ResolutionWorldBuilderImpl worldBuilder1 = enqueuer1.worldBuilder;
ResolutionWorldBuilderImpl worldBuilder2 = enqueuer2.worldBuilder;
checkMaps(
worldBuilder1.getInstantiationMap(),
@ -127,20 +128,20 @@ void checkResolutionEnqueuers(
verbose: verbose);
checkSets(
enqueuer1.universe.directlyInstantiatedClasses,
enqueuer2.universe.directlyInstantiatedClasses,
enqueuer1.worldBuilder.directlyInstantiatedClasses,
enqueuer2.worldBuilder.directlyInstantiatedClasses,
"Directly instantiated classes mismatch",
areElementsEquivalent,
verbose: verbose);
checkSets(
enqueuer1.universe.instantiatedTypes,
enqueuer2.universe.instantiatedTypes,
enqueuer1.worldBuilder.instantiatedTypes,
enqueuer2.worldBuilder.instantiatedTypes,
"Instantiated types mismatch",
typeEquivalence,
verbose: verbose);
checkSets(enqueuer1.universe.isChecks, enqueuer2.universe.isChecks,
checkSets(enqueuer1.worldBuilder.isChecks, enqueuer2.worldBuilder.isChecks,
"Is-check mismatch", typeEquivalence,
verbose: verbose);

3
tests/compiler/dart2js/simple_inferrer_callers_test.dart
View file

@ -40,7 +40,8 @@ void main() {
var compiler = compilerFor(TEST, uri, analyzeOnly: true);
asyncTest(() => compiler.run(uri).then((_) {
ClosedWorldRefiner closedWorldRefiner = compiler.closeResolution();
ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
ClosedWorld closedWorld =
compiler.resolutionWorldBuilder.closedWorldForTesting;
var inferrer =
new MyInferrer(compiler, closedWorld, closedWorldRefiner);
compiler.globalInference.typesInferrerInternal = inferrer;

8
tests/compiler/dart2js/simple_inferrer_no_such_method_test.dart
View file

@ -174,7 +174,7 @@ test1() async {
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(TEST1, uri);
await compiler.run(uri);
var closedWorld = compiler.resolverWorld.closedWorldForTesting;
var closedWorld = compiler.resolutionWorldBuilder.closedWorldForTesting;
checkReturn(compiler, 'test1', closedWorld.commonMasks.uint31Type);
checkReturn(
compiler, 'test2', closedWorld.commonMasks.dynamicType.nonNullable());
@ -190,7 +190,7 @@ test2() async {
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(TEST2, uri);
await compiler.run(uri);
var closedWorld = compiler.resolverWorld.closedWorldForTesting;
var closedWorld = compiler.resolutionWorldBuilder.closedWorldForTesting;
checkReturn(compiler, 'test1', closedWorld.commonMasks.mapType.nonNullable());
checkReturn(compiler, 'test2', closedWorld.commonMasks.mapType);
checkReturn(compiler, 'test3', closedWorld.commonMasks.mapType);
@ -209,7 +209,7 @@ test3() async {
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(TEST3, uri);
await compiler.run(uri);
var closedWorld = compiler.resolverWorld.closedWorldForTesting;
var closedWorld = compiler.resolutionWorldBuilder.closedWorldForTesting;
checkReturn(compiler, 'test1', const TypeMask.nonNullEmpty());
checkReturn(compiler, 'test2', closedWorld.commonMasks.mapType);
checkReturn(compiler, 'test3', closedWorld.commonMasks.mapType);
@ -222,7 +222,7 @@ test4() async {
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(TEST4, uri);
await compiler.run(uri);
var closedWorld = compiler.resolverWorld.closedWorldForTesting;
var closedWorld = compiler.resolutionWorldBuilder.closedWorldForTesting;
checkReturn(compiler, 'test1', const TypeMask.nonNullEmpty());
checkReturn(compiler, 'test2', closedWorld.commonMasks.mapType);
checkReturn(compiler, 'test3', closedWorld.commonMasks.mapType);

12
tests/compiler/dart2js/type_combination_test.dart
View file

@ -102,7 +102,8 @@ class RuleSet {
}
void testUnion(MockCompiler compiler) {
ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
ClosedWorld closedWorld =
compiler.resolutionWorldBuilder.closedWorldForTesting;
RuleSet ruleSet = new RuleSet(
'union', (t1, t2) => simplify(t1.union(t2, closedWorld), closedWorld));
rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
@ -416,7 +417,8 @@ void testUnion(MockCompiler compiler) {
void testIntersection(MockCompiler compiler) {
JavaScriptBackend backend = compiler.backend;
BackendHelpers helpers = backend.helpers;
ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
ClosedWorld closedWorld =
compiler.resolutionWorldBuilder.closedWorldForTesting;
RuleSet ruleSet =
new RuleSet('intersection', (t1, t2) => t1.intersection(t2, closedWorld));
rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
@ -726,7 +728,8 @@ void testIntersection(MockCompiler compiler) {
}
void testRegressions(MockCompiler compiler) {
ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
ClosedWorld closedWorld =
compiler.resolutionWorldBuilder.closedWorldForTesting;
TypeMask nonNullPotentialString =
new TypeMask.nonNullSubtype(patternClass, closedWorld);
Expect.equals(potentialString,
@ -760,7 +763,8 @@ void main() {
.registerTypeUse(new TypeUse.instantiation(patternImplClass.rawType));
compiler.enqueuer.resolution.applyImpact(impactBuilder);
compiler.closeResolution();
ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
ClosedWorld closedWorld =
compiler.resolutionWorldBuilder.closedWorldForTesting;
// Grab hold of a supertype for String so we can produce potential
// string types.

2
tests/compiler/dart2js/type_mask_disjoint_test.dart
View file

@ -36,7 +36,7 @@ main() {
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(CODE, uri);
var world = compiler.resolverWorld.closedWorldForTesting;
var world = compiler.resolutionWorldBuilder.closedWorldForTesting;
main() {
asyncTest(() => compiler.run(uri).then((_) {

2
tests/compiler/dart2js/type_mask_test.dart
View file

@ -22,7 +22,7 @@ main() {
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(CODE, uri);
compiler.closeResolution();
var closedWorld = compiler.resolverWorld.closedWorldForTesting;
var closedWorld = compiler.resolutionWorldBuilder.closedWorldForTesting;
asyncTest(() => compiler.run(uri).then((_) {
var classA = findElement(compiler, 'A');

2
tests/compiler/dart2js/type_test_helper.dart
View file

@ -147,6 +147,6 @@ class TypeEnvironment {
}
ClosedWorld get closedWorld {
return compiler.resolverWorld.closedWorldForTesting;
return compiler.resolutionWorldBuilder.closedWorldForTesting;
}
}