blob: 7f92ce9cf296fada7085e3013f95df9ab1ba3ec0 [file] [log] [blame]
// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
library kernel.transformations.mixin_full_resolution;
import '../ast.dart';
import '../class_hierarchy.dart';
import '../clone.dart';
import '../core_types.dart';
import '../type_algebra.dart';
Program transformProgram(Program program) {
new MixinFullResolution().transform(program);
return program;
/// Replaces all mixin applications with regular classes, cloning all fields
/// and procedures from the mixed-in class, cloning all constructors from the
/// base class.
/// Super calls (as well as super initializer invocations) are also resolved
/// to their targets in this pass.
class MixinFullResolution {
ClassHierarchy hierarchy;
CoreTypes coreTypes;
void transform(Program program) {
var transformedClasses = new Set<Class>();
// Desugar all mixin application classes by copying in fields/methods from
// the mixin and constructors from the base class.
var processedClasses = new Set<Class>();
for (var library in program.libraries) {
if (library.isExternal) continue;
for (var class_ in library.classes) {
transformClass(processedClasses, transformedClasses, class_);
hierarchy = new ClassHierarchy(program);
coreTypes = new CoreTypes(program);
// Resolve all super call expressions and super initializers.
for (var library in program.libraries) {
if (library.isExternal) continue;
for (var class_ in library.classes) {
final bool hasTransformedSuperclass =
for (var procedure in class_.procedures) {
if (procedure.containsSuperCalls) {
new SuperCallResolutionTransformer(
hierarchy, coreTypes, class_.superclass)
for (var constructor in class_.constructors) {
if (constructor.containsSuperCalls) {
new SuperCallResolutionTransformer(
hierarchy, coreTypes, class_.superclass)
if (hasTransformedSuperclass && constructor.initializers.length > 0) {
new SuperInitializerResolutionTransformer(class_.superclass)
transformClass(Set<Class> processedClasses, Set<Class> transformedClasses,
Class class_) {
// If this class was already handled then so were all classes up to the
// [Object] class.
if (!processedClasses.add(class_)) return;
// Ensure super classes have been transformed before this class.
if (class_.superclass != null &&
class_.superclass.level.index >= ClassLevel.Mixin.index) {
transformClass(processedClasses, transformedClasses, class_.superclass);
// If this is not a mixin application we don't need to make forwarding
// constructors in this class.
if (!class_.isMixinApplication) return;
if (class_.mixedInClass.level.index < ClassLevel.Mixin.index) {
throw new Exception(
'Class "${}" mixes in "${}" from'
' an external library. Did you forget --link?');
// Clone fields and methods from the mixin class.
var substitution = getSubstitutionMap(class_.mixedInType);
var cloner = new CloneVisitor(typeSubstitution: substitution);
for (var field in class_.mixin.fields) {
for (var procedure in class_.mixin.procedures) {
// For each generative constructor in the superclass we make a
// corresponding forwarding constructor in the subclass.
// Named mixin applications already have constructors, so only build the
// constructors for anonymous mixin applications.
if (class_.constructors.isEmpty) {
var superclassSubstitution = getSubstitutionMap(class_.supertype);
var superclassCloner =
new CloneVisitor(typeSubstitution: superclassSubstitution);
for (var superclassConstructor in class_.superclass.constructors) {
var forwardingConstructor =
buildForwardingConstructor(superclassCloner, superclassConstructor);
// This class implements the mixin type.
// This class is now a normal class.
class_.mixedInType = null;
Constructor buildForwardingConstructor(
CloneVisitor cloner, Constructor superclassConstructor) {
var superFunction = superclassConstructor.function;
// We keep types and default values for the parameters but always mark the
// parameters as final (since we just forward them to the super
// constructor).
VariableDeclaration cloneVariable(VariableDeclaration variable) {
VariableDeclaration clone = cloner.clone(variable);
clone.isFinal = true;
return clone;
// Build a [FunctionNode] which has the same parameters as the one in the
// superclass constructor.
var positionalParameters =;
var namedParameters =;
var function = new FunctionNode(new EmptyStatement(),
positionalParameters: positionalParameters,
namedParameters: namedParameters,
requiredParameterCount: superFunction.requiredParameterCount,
returnType: const VoidType());
// Build a [SuperInitializer] which takes all positional/named parameters
// and forward them to the super class constructor.
var positionalArguments = <Expression>[];
for (var variable in positionalParameters) {
positionalArguments.add(new VariableGet(variable));
var namedArguments = <NamedExpression>[];
for (var variable in namedParameters) {
.add(new NamedExpression(, new VariableGet(variable)));
var superInitializer = new SuperInitializer(superclassConstructor,
new Arguments(positionalArguments, named: namedArguments));
// Assemble the constructor.
return new Constructor(function,
initializers: <Initializer>[superInitializer]);
class SuperCallResolutionTransformer extends Transformer {
final ClassHierarchy hierarchy;
final CoreTypes coreTypes;
final Class lookupClass;
Constructor _invocationMirrorConstructor; // cached
Procedure _listFrom; // cached
this.hierarchy, this.coreTypes, this.lookupClass);
TreeNode visit(TreeNode node) => node.accept(this);
visitSuperPropertyGet(SuperPropertyGet node) {
Member target = hierarchy.getDispatchTarget(lookupClass,;
if (target != null) {
return new DirectPropertyGet(new ThisExpression(), target);
} else {
return _callNoSuchMethod(, new Arguments.empty(), node,
isGetter: true, isSuper: true);
visitSuperPropertySet(SuperPropertySet node) {
Member target =
hierarchy.getDispatchTarget(lookupClass,, setter: true);
if (target != null) {
return new DirectPropertySet(
new ThisExpression(), target, visit(node.value));
} else {
// Call has to return right-hand-side.
VariableDeclaration rightHandSide =
new VariableDeclaration.forValue(visit(node.value));
Expression result = _callNoSuchMethod(, new Arguments([new VariableGet(rightHandSide)]), node,
isSetter: true, isSuper: true);
VariableDeclaration call = new VariableDeclaration.forValue(result);
return new Let(
rightHandSide, new Let(call, new VariableGet(rightHandSide)));
visitSuperMethodInvocation(SuperMethodInvocation node) {
Member target = hierarchy.getDispatchTarget(lookupClass,;
Arguments visitedArguments = visit(node.arguments);
if (target is Procedure &&
!target.isAccessor &&
_callIsLegal(target.function, visitedArguments)) {
return new DirectMethodInvocation(
new ThisExpression(), target, visitedArguments)
..fileOffset = node.fileOffset;
} else if (target == null || (target is Procedure && !target.isAccessor)) {
// Target not found at all, or call was illegal.
return _callNoSuchMethod(, visitedArguments, node,
isSuper: true);
} else if (target != null) {
return new MethodInvocation(
new DirectPropertyGet(new ThisExpression(), target),
new Name('call'),
visitedArguments)..fileOffset = node.fileOffset;
/// Create a call to no such method.
Expression _callNoSuchMethod(
String methodName, Arguments methodArguments, TreeNode node,
{isSuper: false, isGetter: false, isSetter: false}) {
Member noSuchMethod =
hierarchy.getDispatchTarget(lookupClass, new Name("noSuchMethod"));
String methodNameUsed = (isGetter)
? "get:$methodName"
: (isSetter) ? "set:$methodName" : methodName;
if (noSuchMethod != null &&
noSuchMethod.function.positionalParameters.length == 1 &&
noSuchMethod.function.namedParameters.isEmpty) {
// We have a correct noSuchMethod method.
ConstructorInvocation invocation = _createInvocation(
methodNameUsed, methodArguments, isSuper, new ThisExpression());
return new DirectMethodInvocation(
new ThisExpression(), noSuchMethod, new Arguments([invocation]))
..fileOffset = node.fileOffset;
} else {
// Incorrect noSuchMethod method: Call noSuchMethod on Object
// with Invocation of noSuchMethod as the method that did not exist.
noSuchMethod = hierarchy.getDispatchTarget(
hierarchy.rootClass, new Name("noSuchMethod"));
ConstructorInvocation invocation = _createInvocation(
methodNameUsed, methodArguments, isSuper, new ThisExpression());
ConstructorInvocation invocationPrime = _createInvocation("noSuchMethod",
new Arguments([invocation]), false, new ThisExpression());
return new DirectMethodInvocation(
new ThisExpression(), noSuchMethod, new Arguments([invocationPrime]))
..fileOffset = node.fileOffset;
/// Creates an "new _InvocationMirror(...)" invocation.
ConstructorInvocation _createInvocation(String methodName,
Arguments callArguments, bool isSuperInvocation, Expression receiver) {
if (_invocationMirrorConstructor == null) {
Class clazz = coreTypes.getClass('dart:core', '_InvocationMirror');
_invocationMirrorConstructor = clazz.constructors[0];
// The _InvocationMirror constructor takes the following arguments:
// * Method name (a string).
// * An arguments descriptor - a list consisting of:
// - number of arguments (including receiver).
// - number of positional arguments (including receiver).
// - pairs (2 entries in the list) of
// * named arguments name.
// * index of named argument in arguments list.
// * A list of arguments, where the first ones are the positional arguments.
// * Whether it's a super invocation or not.
int numPositionalArguments = callArguments.positional.length + 1;
int numArguments = numPositionalArguments + callArguments.named.length;
List<Expression> argumentsDescriptor = [
new IntLiteral(numArguments),
new IntLiteral(numPositionalArguments)
List<Expression> arguments = [];
for (Expression pos in callArguments.positional) {
for (NamedExpression named in callArguments.named) {
argumentsDescriptor.add(new StringLiteral(;
argumentsDescriptor.add(new IntLiteral(arguments.length));
return new ConstructorInvocation(
new Arguments([
new StringLiteral(methodName),
new BoolLiteral(isSuperInvocation)
/// Create a fixed length list containing given expressions.
Expression _fixedLengthList(List<Expression> list) {
_listFrom ??= coreTypes.getMember('dart:core', 'List', 'from');
return new StaticInvocation(
new Arguments([new ListLiteral(list)],
named: [new NamedExpression("growable", new BoolLiteral(false))],
types: [const DynamicType()]));
/// Check that a call to the targetFunction is legal given the arguments.
/// I.e. check that the number of positional parameters and the names of the
/// given named parameters represents a valid call to the function.
bool _callIsLegal(FunctionNode targetFunction, Arguments arguments) {
if ((targetFunction.requiredParameterCount > arguments.positional.length) ||
(targetFunction.positionalParameters.length <
arguments.positional.length)) {
// Given too few or too many positional arguments
return false;
// Do we give named that we don't take?
Set<String> givenNamed = =>;
Set<String> takenNamed = =>;
return givenNamed.isEmpty;
class SuperInitializerResolutionTransformer extends InitializerVisitor {
final Class lookupClass;
transformInitializers(List<Initializer> initializers) {
for (var initializer in initializers) {
visitSuperInitializer(SuperInitializer node) {
Constructor constructor =;
if (constructor.enclosingClass != lookupClass) {
// If [node] refers to a constructor target which is not directly the
// superclass but some indirect base class then this is because classes in
// the middle are mixin applications. These mixin applications will have
// received a forwarding constructor which we are required to use instead.
for (var replacement in lookupClass.constructors) {
if ( == { = replacement;
return null;
throw new Exception(
'Could not find a generative constructor named "${}" '
'in lookup class "${}"!');