Index: pkg/compiler/lib/src/world.dart |
diff --git a/pkg/compiler/lib/src/world.dart b/pkg/compiler/lib/src/world.dart |
index 59e009558ed7f1ed8909992d296181d3814a5329..fa4c7978646560b642d79fb5fb3a0ccff141fe17 100644 |
--- a/pkg/compiler/lib/src/world.dart |
+++ b/pkg/compiler/lib/src/world.dart |
@@ -403,7 +403,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
final FunctionSet _allFunctions; |
- final Iterable<TypedefElement> _allTypedefs; |
+ final Set<TypedefElement> _allTypedefs; |
final Map<ClassEntity, Set<ClassEntity>> _mixinUses; |
Map<ClassEntity, List<ClassEntity>> _liveMixinUses; |
@@ -431,8 +431,12 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
final CommonElements commonElements; |
+ // TODO(johnniwinther): Avoid this. |
final ResolutionWorldBuilder _resolverWorld; |
+ // TODO(johnniwinther): Can this be derived from [ClassSet]s? |
+ final Set<ClassEntity> _implementedClasses; |
+ |
ClosedWorldBase( |
{this.commonElements, |
this.constantSystem, |
@@ -440,13 +444,15 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
this.interceptorData, |
this.backendUsage, |
ResolutionWorldBuilder resolutionWorldBuilder, |
+ Set<ClassEntity> implementedClasses, |
FunctionSet functionSet, |
- Iterable<TypedefElement> allTypedefs, |
+ Set<TypedefElement> allTypedefs, |
Map<ClassEntity, Set<ClassEntity>> mixinUses, |
Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses, |
Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes, |
Map<ClassEntity, ClassSet> classSets}) |
: this._resolverWorld = resolutionWorldBuilder, |
+ this._implementedClasses = implementedClasses, |
this._allFunctions = functionSet, |
this._allTypedefs = allTypedefs, |
this._mixinUses = mixinUses, |
@@ -474,55 +480,55 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
return cachedMasks.putIfAbsent(base, createMask); |
} |
- bool _checkEntity(Entity element); |
+ bool checkEntity(Entity element); |
- bool _checkClass(ClassEntity cls); |
+ bool checkClass(ClassEntity cls); |
- bool _checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true}); |
+ bool checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true}); |
- OrderedTypeSet _getOrderedTypeSet(ClassEntity cls); |
+ OrderedTypeSet getOrderedTypeSet(ClassEntity cls); |
- int _getHierarchyDepth(ClassEntity cls); |
+ int getHierarchyDepth(ClassEntity cls); |
- ClassEntity _getSuperClass(ClassEntity cls); |
+ ClassEntity getSuperClass(ClassEntity cls); |
- Iterable<ClassEntity> _getInterfaces(ClassEntity cls); |
+ Iterable<ClassEntity> getInterfaces(ClassEntity cls); |
- ClassEntity _getAppliedMixin(ClassEntity cls); |
+ ClassEntity getAppliedMixin(ClassEntity cls); |
- bool _isNamedMixinApplication(ClassEntity cls); |
+ bool isNamedMixinApplication(ClassEntity cls); |
@override |
bool isInstantiated(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode node = _classHierarchyNodes[cls]; |
return node != null && node.isInstantiated; |
} |
@override |
bool isDirectlyInstantiated(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode node = _classHierarchyNodes[cls]; |
return node != null && node.isDirectlyInstantiated; |
} |
@override |
bool isAbstractlyInstantiated(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode node = _classHierarchyNodes[cls]; |
return node != null && node.isAbstractlyInstantiated; |
} |
@override |
bool isExplicitlyInstantiated(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode node = _classHierarchyNodes[cls]; |
return node != null && node.isExplicitlyInstantiated; |
} |
@override |
bool isIndirectlyInstantiated(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode node = _classHierarchyNodes[cls]; |
return node != null && node.isIndirectlyInstantiated; |
} |
@@ -532,28 +538,28 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns `true` if [cls] is implemented by an instantiated class. |
bool isImplemented(ClassEntity cls) { |
- return _resolverWorld.isImplemented(cls); |
+ return _implementedClasses.contains(cls); |
} |
/// Returns `true` if [x] is a subtype of [y], that is, if [x] implements an |
/// instance of [y]. |
bool isSubtypeOf(ClassEntity x, ClassEntity y) { |
- assert(_checkInvariants(x)); |
- assert(_checkInvariants(y, mustBeInstantiated: false)); |
+ assert(checkInvariants(x)); |
+ assert(checkInvariants(y, mustBeInstantiated: false)); |
return _classSets[y].hasSubtype(_classHierarchyNodes[x]); |
} |
/// Return `true` if [x] is a (non-strict) subclass of [y]. |
bool isSubclassOf(ClassEntity x, ClassEntity y) { |
- assert(_checkInvariants(x)); |
- assert(_checkInvariants(y)); |
+ assert(checkInvariants(x)); |
+ assert(checkInvariants(y)); |
return _classHierarchyNodes[y].hasSubclass(_classHierarchyNodes[x]); |
} |
/// Returns an iterable over the directly instantiated classes that extend |
/// [cls] possibly including [cls] itself, if it is live. |
Iterable<ClassEntity> subclassesOf(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode hierarchy = _classHierarchyNodes[cls]; |
if (hierarchy == null) return const <ClassEntity>[]; |
return hierarchy |
@@ -563,7 +569,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns an iterable over the directly instantiated classes that extend |
/// [cls] _not_ including [cls] itself. |
Iterable<ClassEntity> strictSubclassesOf(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode subclasses = _classHierarchyNodes[cls]; |
if (subclasses == null) return const <ClassEntity>[]; |
return subclasses.subclassesByMask( |
@@ -574,7 +580,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns the number of live classes that extend [cls] _not_ |
/// including [cls] itself. |
int strictSubclassCount(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode subclasses = _classHierarchyNodes[cls]; |
if (subclasses == null) return 0; |
return subclasses.instantiatedSubclassCount; |
@@ -584,7 +590,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// itself. |
void forEachStrictSubclassOf( |
ClassEntity cls, IterationStep f(ClassEntity cls)) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode subclasses = _classHierarchyNodes[cls]; |
if (subclasses == null) return; |
subclasses.forEachSubclass(f, ClassHierarchyNode.EXPLICITLY_INSTANTIATED, |
@@ -594,7 +600,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns `true` if [predicate] applies to any live class that extend [cls] |
/// _not_ including [cls] itself. |
bool anyStrictSubclassOf(ClassEntity cls, bool predicate(ClassEntity cls)) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode subclasses = _classHierarchyNodes[cls]; |
if (subclasses == null) return false; |
return subclasses.anySubclass( |
@@ -605,7 +611,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns an iterable over the directly instantiated that implement [cls] |
/// possibly including [cls] itself, if it is live. |
Iterable<ClassEntity> subtypesOf(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassSet classSet = _classSets[cls]; |
if (classSet == null) { |
return const <ClassEntity>[]; |
@@ -618,7 +624,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns an iterable over the directly instantiated that implement [cls] |
/// _not_ including [cls]. |
Iterable<ClassEntity> strictSubtypesOf(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassSet classSet = _classSets[cls]; |
if (classSet == null) { |
return const <ClassEntity>[]; |
@@ -631,7 +637,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns the number of live classes that implement [cls] _not_ |
/// including [cls] itself. |
int strictSubtypeCount(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassSet classSet = _classSets[cls]; |
if (classSet == null) return 0; |
return classSet.instantiatedSubtypeCount; |
@@ -641,7 +647,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// itself. |
void forEachStrictSubtypeOf( |
ClassEntity cls, IterationStep f(ClassEntity cls)) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassSet classSet = _classSets[cls]; |
if (classSet == null) return; |
classSet.forEachSubtype(f, ClassHierarchyNode.EXPLICITLY_INSTANTIATED, |
@@ -651,7 +657,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns `true` if [predicate] applies to any live class that extend [cls] |
/// _not_ including [cls] itself. |
bool anyStrictSubtypeOf(ClassEntity cls, bool predicate(ClassEntity cls)) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassSet classSet = _classSets[cls]; |
if (classSet == null) return false; |
return classSet.anySubtype( |
@@ -661,8 +667,8 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns `true` if [a] and [b] have any known common subtypes. |
bool haveAnyCommonSubtypes(ClassEntity a, ClassEntity b) { |
- assert(_checkClass(a)); |
- assert(_checkClass(b)); |
+ assert(checkClass(a)); |
+ assert(checkClass(b)); |
ClassSet classSetA = _classSets[a]; |
ClassSet classSetB = _classSets[b]; |
if (classSetA == null || classSetB == null) return false; |
@@ -679,7 +685,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns `true` if any directly instantiated class other than [cls] extends |
/// [cls]. |
bool hasAnyStrictSubclass(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
ClassHierarchyNode subclasses = _classHierarchyNodes[cls]; |
if (subclasses == null) return false; |
return subclasses.isIndirectlyInstantiated; |
@@ -694,7 +700,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns `true` if all directly instantiated classes that implement [cls] |
/// extend it. |
bool hasOnlySubclasses(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
// TODO(johnniwinther): move this to ClassSet? |
if (cls == commonElements.objectClass) return true; |
ClassSet classSet = _classSets[cls]; |
@@ -707,7 +713,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
@override |
ClassEntity getLubOfInstantiatedSubclasses(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
if (nativeData.isJsInteropClass(cls)) { |
return commonElements.jsJavaScriptObjectClass; |
} |
@@ -719,7 +725,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
@override |
ClassEntity getLubOfInstantiatedSubtypes(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
if (nativeData.isJsInteropClass(cls)) { |
return commonElements.jsJavaScriptObjectClass; |
} |
@@ -763,8 +769,8 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns `true` if every subtype of [x] is a subclass of [y] or a subclass |
/// of a mixin application of [y]. |
bool everySubtypeIsSubclassOfOrMixinUseOf(ClassEntity x, ClassEntity y) { |
- assert(_checkClass(x)); |
- assert(_checkClass(y)); |
+ assert(checkClass(x)); |
+ assert(checkClass(y)); |
Map<ClassEntity, bool> secondMap = |
_subtypeCoveredByCache[x] ??= <ClassEntity, bool>{}; |
return secondMap[y] ??= subtypesOf(x).every((ClassEntity cls) => |
@@ -773,7 +779,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns `true` if any subclass of [superclass] implements [type]. |
bool hasAnySubclassThatImplements(ClassEntity superclass, ClassEntity type) { |
- assert(_checkClass(superclass)); |
+ assert(checkClass(superclass)); |
Set<ClassEntity> subclasses = _typesImplementedBySubclasses[superclass]; |
if (subclasses == null) return false; |
return subclasses.contains(type); |
@@ -838,16 +844,16 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
if (!iterator.moveNext()) return const <ClassEntity>[]; |
ClassEntity cls = iterator.current; |
- assert(_checkInvariants(cls)); |
- OrderedTypeSet typeSet = _getOrderedTypeSet(cls); |
+ assert(checkInvariants(cls)); |
+ OrderedTypeSet typeSet = getOrderedTypeSet(cls); |
if (!iterator.moveNext()) return typeSet.types.map((type) => type.element); |
int depth = typeSet.maxDepth; |
Link<OrderedTypeSet> otherTypeSets = const Link<OrderedTypeSet>(); |
do { |
ClassEntity otherClass = iterator.current; |
- assert(_checkInvariants(otherClass)); |
- OrderedTypeSet otherTypeSet = _getOrderedTypeSet(otherClass); |
+ assert(checkInvariants(otherClass)); |
+ OrderedTypeSet otherTypeSet = getOrderedTypeSet(otherClass); |
otherTypeSets = otherTypeSets.prepend(otherTypeSet); |
if (otherTypeSet.maxDepth < depth) { |
depth = otherTypeSet.maxDepth; |
@@ -863,7 +869,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
for (Link<OrderedTypeSet> link = otherTypeSets; |
!link.isEmpty; |
link = link.tail) { |
- if (link.head.asInstanceOf(cls, _getHierarchyDepth(cls)) == null) { |
+ if (link.head.asInstanceOf(cls, getHierarchyDepth(cls)) == null) { |
continue OUTER; |
} |
} |
@@ -884,7 +890,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
// that do not have a superclass or supertype that will be a |
// better candidate. |
return common.where((ClassEntity each) { |
- bool containsSuperclass = common.contains(_getSuperClass(each)); |
+ bool containsSuperclass = common.contains(getSuperClass(each)); |
// If the superclass is also a candidate, then we don't want to |
// deal with this class. If we're only looking for a subclass we |
// know we don't have to look at the list of interfaces because |
@@ -898,7 +904,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
// set contains the direct supertype of the class, we ignore the |
// the class because the supertype is a better candidate. |
- for (ClassEntity interface in _getInterfaces(each)) { |
+ for (ClassEntity interface in getInterfaces(each)) { |
if (common.contains(interface)) return false; |
} |
return true; |
@@ -915,7 +921,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
void addLiveUse(ClassEntity mixinApplication) { |
if (isInstantiated(mixinApplication)) { |
uses.add(mixinApplication); |
- } else if (_isNamedMixinApplication(mixinApplication)) { |
+ } else if (isNamedMixinApplication(mixinApplication)) { |
Set<ClassEntity> next = _mixinUses[mixinApplication]; |
if (next != null) { |
next.forEach(addLiveUse); |
@@ -943,14 +949,14 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// Returns `true` if [cls] or any superclass mixes in [mixin]. |
bool isSubclassOfMixinUseOf(ClassEntity cls, ClassEntity mixin) { |
- assert(_checkClass(cls)); |
- assert(_checkClass(mixin)); |
+ assert(checkClass(cls)); |
+ assert(checkClass(mixin)); |
if (isUsedAsMixin(mixin)) { |
ClassEntity current = cls; |
while (current != null) { |
- ClassEntity currentMixin = _getAppliedMixin(current); |
+ ClassEntity currentMixin = getAppliedMixin(current); |
if (currentMixin == mixin) return true; |
- current = _getSuperClass(current); |
+ current = getSuperClass(current); |
} |
} |
return false; |
@@ -962,7 +968,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// This method is only provided for testing. For queries on classes, use the |
/// methods defined in [ClosedWorld]. |
ClassHierarchyNode getClassHierarchyNode(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
return _classHierarchyNodes[cls]; |
} |
@@ -972,7 +978,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
/// This method is only provided for testing. For queries on classes, use the |
/// methods defined in [ClosedWorld]. |
ClassSet getClassSet(ClassEntity cls) { |
- assert(_checkClass(cls)); |
+ assert(checkClass(cls)); |
return _classSets[cls]; |
} |
@@ -1056,7 +1062,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
} |
SideEffects getSideEffectsOfElement(Entity element) { |
- assert(_checkEntity(element)); |
+ assert(checkEntity(element)); |
return _sideEffects.putIfAbsent(element, _makeSideEffects); |
} |
@@ -1068,29 +1074,29 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner { |
} |
void registerSideEffects(Entity element, SideEffects effects) { |
- assert(_checkEntity(element)); |
+ assert(checkEntity(element)); |
if (_sideEffectsFreeElements.contains(element)) return; |
_sideEffects[element] = effects; |
} |
void registerSideEffectsFree(Entity element) { |
- assert(_checkEntity(element)); |
+ assert(checkEntity(element)); |
_sideEffects[element] = new SideEffects.empty(); |
_sideEffectsFreeElements.add(element); |
} |
void addFunctionCalledInLoop(Entity element) { |
- assert(_checkEntity(element)); |
+ assert(checkEntity(element)); |
_functionsCalledInLoop.add(element); |
} |
bool isCalledInLoop(Entity element) { |
- assert(_checkEntity(element)); |
+ assert(checkEntity(element)); |
return _functionsCalledInLoop.contains(element); |
} |
void registerCannotThrow(Entity element) { |
- assert(_checkEntity(element)); |
+ assert(checkEntity(element)); |
_elementsThatCannotThrow.add(element); |
} |
@@ -1146,8 +1152,9 @@ class ClosedWorldImpl extends ClosedWorldBase { |
InterceptorData interceptorData, |
BackendUsage backendUsage, |
ResolutionWorldBuilder resolutionWorldBuilder, |
+ Set<ClassEntity> implementedClasses, |
FunctionSet functionSet, |
- Iterable<TypedefElement> allTypedefs, |
+ Set<TypedefElement> allTypedefs, |
Map<ClassEntity, Set<ClassEntity>> mixinUses, |
Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses, |
Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes, |
@@ -1159,6 +1166,7 @@ class ClosedWorldImpl extends ClosedWorldBase { |
interceptorData: interceptorData, |
backendUsage: backendUsage, |
resolutionWorldBuilder: resolutionWorldBuilder, |
+ implementedClasses: implementedClasses, |
functionSet: functionSet, |
allTypedefs: allTypedefs, |
mixinUses: mixinUses, |
@@ -1166,11 +1174,11 @@ class ClosedWorldImpl extends ClosedWorldBase { |
classHierarchyNodes: classHierarchyNodes, |
classSets: classSets); |
- bool _checkClass(ClassElement cls) => cls.isDeclaration; |
+ bool checkClass(ClassElement cls) => cls.isDeclaration; |
- bool _checkEntity(Element element) => element.isDeclaration; |
+ bool checkEntity(Element element) => element.isDeclaration; |
- bool _checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) { |
+ bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) { |
assert(cls.isDeclaration, failedAt(cls, '$cls must be the declaration.')); |
assert(cls.isResolved, failedAt(cls, '$cls must be resolved.')); |
@@ -1184,23 +1192,22 @@ class ClosedWorldImpl extends ClosedWorldBase { |
return true; |
} |
- OrderedTypeSet _getOrderedTypeSet(ClassElement cls) => |
+ OrderedTypeSet getOrderedTypeSet(ClassElement cls) => |
cls.allSupertypesAndSelf; |
- int _getHierarchyDepth(ClassElement cls) => cls.hierarchyDepth; |
+ int getHierarchyDepth(ClassElement cls) => cls.hierarchyDepth; |
- ClassEntity _getSuperClass(ClassElement cls) => cls.superclass; |
+ ClassEntity getSuperClass(ClassElement cls) => cls.superclass; |
- Iterable<ClassEntity> _getInterfaces(ClassElement cls) sync* { |
+ Iterable<ClassEntity> getInterfaces(ClassElement cls) sync* { |
for (Link link = cls.interfaces; !link.isEmpty; link = link.tail) { |
yield link.head.element; |
} |
} |
- bool _isNamedMixinApplication(ClassElement cls) => |
- cls.isNamedMixinApplication; |
+ bool isNamedMixinApplication(ClassElement cls) => cls.isNamedMixinApplication; |
- ClassEntity _getAppliedMixin(ClassElement cls) { |
+ ClassEntity getAppliedMixin(ClassElement cls) { |
if (cls.isMixinApplication) { |
MixinApplicationElement application = cls; |
return application.mixin; |
@@ -1290,8 +1297,9 @@ class KernelClosedWorld extends ClosedWorldBase { |
InterceptorData interceptorData, |
BackendUsage backendUsage, |
ResolutionWorldBuilder resolutionWorldBuilder, |
+ Set<ClassEntity> implementedClasses, |
FunctionSet functionSet, |
- Iterable<TypedefElement> allTypedefs, |
+ Set<TypedefElement> allTypedefs, |
Map<ClassEntity, Set<ClassEntity>> mixinUses, |
Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses, |
Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes, |
@@ -1303,6 +1311,7 @@ class KernelClosedWorld extends ClosedWorldBase { |
interceptorData: interceptorData, |
backendUsage: backendUsage, |
resolutionWorldBuilder: resolutionWorldBuilder, |
+ implementedClasses: implementedClasses, |
functionSet: functionSet, |
allTypedefs: allTypedefs, |
mixinUses: mixinUses, |
@@ -1317,44 +1326,44 @@ class KernelClosedWorld extends ClosedWorldBase { |
} |
@override |
- bool _isNamedMixinApplication(ClassEntity cls) { |
- throw new UnimplementedError('KernelClosedWorld._isNamedMixinApplication'); |
+ bool isNamedMixinApplication(ClassEntity cls) { |
+ throw new UnimplementedError('KernelClosedWorld.isNamedMixinApplication'); |
} |
@override |
- ClassEntity _getAppliedMixin(ClassEntity cls) { |
- throw new UnimplementedError('KernelClosedWorld._getAppliedMixin'); |
+ ClassEntity getAppliedMixin(ClassEntity cls) { |
+ throw new UnimplementedError('KernelClosedWorld.getAppliedMixin'); |
} |
@override |
- Iterable<ClassEntity> _getInterfaces(ClassEntity cls) { |
- throw new UnimplementedError('KernelClosedWorld._getInterfaces'); |
+ Iterable<ClassEntity> getInterfaces(ClassEntity cls) { |
+ throw new UnimplementedError('KernelClosedWorld.getInterfaces'); |
} |
@override |
- ClassEntity _getSuperClass(ClassEntity cls) { |
- throw new UnimplementedError('KernelClosedWorld._getSuperClass'); |
+ ClassEntity getSuperClass(ClassEntity cls) { |
+ throw new UnimplementedError('KernelClosedWorld.getSuperClass'); |
} |
@override |
- int _getHierarchyDepth(ClassEntity cls) { |
- throw new UnimplementedError('KernelClosedWorld._getHierarchyDepth'); |
+ int getHierarchyDepth(ClassEntity cls) { |
+ throw new UnimplementedError('KernelClosedWorld.getHierarchyDepth'); |
} |
@override |
- OrderedTypeSet _getOrderedTypeSet(ClassEntity cls) { |
- throw new UnimplementedError('KernelClosedWorld._getOrderedTypeSet'); |
+ OrderedTypeSet getOrderedTypeSet(ClassEntity cls) { |
+ throw new UnimplementedError('KernelClosedWorld.getOrderedTypeSet'); |
} |
@override |
- bool _checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true}) => |
+ bool checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true}) => |
true; |
@override |
- bool _checkClass(ClassEntity cls) => true; |
+ bool checkClass(ClassEntity cls) => true; |
@override |
- bool _checkEntity(Entity element) => true; |
+ bool checkEntity(Entity element) => true; |
@override |
void registerClosureClass(ClassElement cls) { |