in pkg/compiler/lib/src/ir/impact_data.dart [697:1031]
void apply(ImpactRegistry registry) {
if (_superInitializers != null) {
for (_SuperInitializer data in _superInitializers) {
registry.registerSuperInitializer(
data.source,
data.target,
data.callStructure.positionalArguments,
data.callStructure.namedArguments,
data.callStructure.typeArguments);
}
}
if (_superSets != null) {
for (ir.Member data in _superSets) {
registry.registerSuperSet(data);
}
}
if (_superGets != null) {
for (ir.Member data in _superGets) {
registry.registerSuperGet(data);
}
}
if (_superInvocations != null) {
for (_SuperInvocation data in _superInvocations) {
registry.registerSuperInvocation(
data.target,
data.callStructure.positionalArguments,
data.callStructure.namedArguments,
data.callStructure.typeArguments);
}
}
if (_instanceSets != null) {
for (_InstanceAccess data in _instanceSets) {
registry.registerInstanceSet(
data.receiverType, data.classRelation, data.target);
}
}
if (_dynamicSets != null) {
for (_DynamicAccess data in _dynamicSets) {
registry.registerDynamicSet(
data.receiverType, data.classRelation, data.name);
}
}
if (_instanceGets != null) {
for (_InstanceAccess data in _instanceGets) {
registry.registerInstanceGet(
data.receiverType, data.classRelation, data.target);
}
}
if (_dynamicGets != null) {
for (_DynamicAccess data in _dynamicGets) {
registry.registerDynamicGet(
data.receiverType, data.classRelation, data.name);
}
}
if (_functionInvocations != null) {
for (_FunctionInvocation data in _functionInvocations) {
registry.registerFunctionInvocation(
data.receiverType,
data.callStructure.positionalArguments,
data.callStructure.namedArguments,
data.callStructure.typeArguments);
}
}
if (_instanceInvocations != null) {
for (_InstanceInvocation data in _instanceInvocations) {
registry.registerInstanceInvocation(
data.receiverType,
data.classRelation,
data.target,
data.callStructure.positionalArguments,
data.callStructure.namedArguments,
data.callStructure.typeArguments);
}
}
if (_dynamicInvocations != null) {
for (_DynamicInvocation data in _dynamicInvocations) {
registry.registerDynamicInvocation(
data.receiverType,
data.classRelation,
data.name,
data.callStructure.positionalArguments,
data.callStructure.namedArguments,
data.callStructure.typeArguments);
}
}
if (_localFunctionInvocations != null) {
for (_LocalFunctionInvocation data in _localFunctionInvocations) {
registry.registerLocalFunctionInvocation(
data.localFunction,
data.callStructure.positionalArguments,
data.callStructure.namedArguments,
data.callStructure.typeArguments);
}
}
if (_staticInvocations != null) {
for (_StaticInvocation data in _staticInvocations) {
registry.registerStaticInvocation(
data.target,
data.callStructure.positionalArguments,
data.callStructure.namedArguments,
data.callStructure.typeArguments,
data.import);
;
}
}
if (_constructorInvocations != null) {
for (_ConstructorInvocation data in _constructorInvocations) {
registry.registerNew(
data.constructor,
data.type,
data.callStructure.positionalArguments,
data.callStructure.namedArguments,
data.callStructure.typeArguments,
data.import,
isConst: data.isConst);
}
}
if (_constInstantiations != null) {
for (_ConstInstantiation data in _constInstantiations) {
registry.registerConstInstantiation(
data.cls, data.typeArguments, data.import);
}
}
if (_features != null) {
for (_Feature data in _features.iterable(_Feature.values)) {
switch (data) {
case _Feature.lazyField:
registry.registerLazyField();
break;
case _Feature.loadLibrary:
registry.registerLoadLibrary();
break;
case _Feature.stackTrace:
registry.registerStackTrace();
break;
case _Feature.catchClause:
registry.registerCatch();
break;
case _Feature.throwExpression:
registry.registerThrow();
break;
case _Feature.localWithoutInitializer:
registry.registerLocalWithoutInitializer();
break;
case _Feature.stringConcatenation:
registry.registerStringConcatenation();
break;
case _Feature.assertWithMessage:
registry.registerAssert(withMessage: true);
break;
case _Feature.assertWithoutMessage:
registry.registerAssert(withMessage: false);
break;
case _Feature.nullLiteral:
registry.registerNullLiteral();
break;
}
}
}
if (_typeUses != null) {
for (_TypeUse data in _typeUses) {
switch (data.kind) {
case _TypeUseKind.parameterCheck:
registry.registerParameterCheck(data.type);
break;
case _TypeUseKind.catchType:
registry.registerCatchType(data.type);
break;
case _TypeUseKind.asCast:
registry.registerAsCast(data.type);
break;
case _TypeUseKind.implicitCast:
registry.registerImplicitCast(data.type);
break;
case _TypeUseKind.isCheck:
registry.registerIsCheck(data.type);
break;
case _TypeUseKind.asyncStarMarker:
registry.registerAsyncStar(data.type);
break;
case _TypeUseKind.asyncMarker:
registry.registerAsync(data.type);
break;
case _TypeUseKind.syncStarMarker:
registry.registerSyncStar(data.type);
break;
}
}
}
if (_redirectingInitializers != null) {
for (_RedirectingInitializer data in _redirectingInitializers) {
registry.registerRedirectingInitializer(
data.constructor,
data.callStructure.positionalArguments,
data.callStructure.namedArguments,
data.callStructure.typeArguments);
}
}
if (_fieldInitializers != null) {
for (ir.Field data in _fieldInitializers) {
registry.registerFieldInitialization(data);
}
}
if (_fieldConstantInitializers != null) {
_fieldConstantInitializers
.forEach((ir.Field field, List<ConstantReference> constants) {
for (ConstantReference constant in constants) {
registry.registerFieldConstantInitialization(field, constant);
}
});
}
if (_typeLiterals != null) {
for (_TypeLiteral data in _typeLiterals) {
registry.registerTypeLiteral(data.type, data.import);
}
}
if (_localFunctions != null) {
for (ir.TreeNode data in _localFunctions) {
registry.registerLocalFunction(data);
}
}
if (_genericInstantiations != null) {
for (_GenericInstantiation data in _genericInstantiations) {
registry.registerGenericInstantiation(
data.expressionType, data.typeArguments);
}
}
if (_staticSets != null) {
for (_StaticAccess data in _staticSets) {
registry.registerStaticSet(data.target, data.import);
}
}
if (_staticGets != null) {
for (_StaticAccess data in _staticGets) {
registry.registerStaticGet(data.target, data.import);
}
}
if (_staticTearOffs != null) {
for (_StaticAccess data in _staticTearOffs) {
registry.registerStaticTearOff(data.target, data.import);
}
}
if (_mapLiterals != null) {
for (_MapLiteral data in _mapLiterals) {
registry.registerMapLiteral(data.keyType, data.valueType,
isConst: data.isConst, isEmpty: data.isEmpty);
}
}
if (_listLiterals != null) {
for (_ContainerLiteral data in _listLiterals) {
registry.registerListLiteral(data.elementType,
isConst: data.isConst, isEmpty: data.isEmpty);
}
}
if (_setLiterals != null) {
for (_ContainerLiteral data in _setLiterals) {
registry.registerSetLiteral(data.elementType,
isConst: data.isConst, isEmpty: data.isEmpty);
}
}
if (_symbolLiterals != null) {
for (String data in _symbolLiterals) {
registry.registerSymbolLiteral(data);
}
}
if (_stringLiterals != null) {
for (String data in _stringLiterals) {
registry.registerStringLiteral(data);
}
}
if (_boolLiterals != null) {
for (bool data in _boolLiterals) {
registry.registerBoolLiteral(data);
}
}
if (_doubleLiterals != null) {
for (double data in _doubleLiterals) {
registry.registerDoubleLiteral(data);
}
}
if (_intLiterals != null) {
for (int data in _intLiterals) {
registry.registerIntLiteral(data);
}
}
if (_runtimeTypeUses != null) {
for (_RuntimeTypeUse data in _runtimeTypeUses) {
registry.registerRuntimeTypeUse(
data.node, data.kind, data.receiverType, data.argumentType);
}
}
if (_forInData != null) {
for (_ForInData data in _forInData) {
if (data.isAsync) {
registry.registerAsyncForIn(
data.iterableType, data.iteratorType, data.iteratorClassRelation);
} else {
registry.registerSyncForIn(
data.iterableType, data.iteratorType, data.iteratorClassRelation);
}
}
}
// TODO(johnniwinther): Remove these when CFE provides constants.
if (_constructorNodes != null) {
for (ir.Constructor data in _constructorNodes) {
registry.registerConstructorNode(data);
}
}
if (_fieldNodes != null) {
for (ir.Field data in _fieldNodes) {
registry.registerFieldNode(data);
}
}
if (_procedureNodes != null) {
for (ir.Procedure data in _procedureNodes) {
registry.registerProcedureNode(data);
}
}
if (_switchStatementNodes != null) {
for (ir.SwitchStatement data in _switchStatementNodes) {
registry.registerSwitchStatementNode(data);
}
}
if (_staticInvocationNodes != null) {
for (ir.StaticInvocation data in _staticInvocationNodes) {
registry.registerStaticInvocationNode(data);
}
}
if (_constConstructorInvocationNodes != null) {
for (ir.ConstructorInvocation data in _constConstructorInvocationNodes) {
registry.registerConstConstructorInvocationNode(data);
}
}
}