blob: 8e021a9d721bb05a818e76d8c08c33dba7b912b6 [file] [log] [blame]
// Copyright (c) 2014, 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 dart2js.js_emitter.runtime_type_generator;
import '../closure.dart' show ClosureClassMap, ClosureFieldElement;
import '../common.dart';
import '../common/names.dart' show Identifiers;
import '../compiler.dart' show Compiler;
import '../common_elements.dart' show CommonElements;
import '../elements/resolution_types.dart'
show ResolutionDartType, ResolutionFunctionType, ResolutionTypeVariableType;
import '../elements/elements.dart'
import '../js/js.dart' as jsAst;
import '../js/js.dart' show js;
import '../js_backend/js_backend.dart'
import '../util/util.dart' show Setlet;
import 'code_emitter_task.dart' show CodeEmitterTask;
import 'model.dart';
import 'type_test_registry.dart' show TypeTestRegistry;
// Function signatures used in the generation of runtime type information.
typedef void FunctionTypeSignatureEmitter(
Element method, ResolutionFunctionType methodType);
typedef void SubstitutionEmitter(Element element, {bool emitNull});
class TypeTestProperties {
/// The index of the function type into the metadata.
/// If the class doesn't have a function type this field is `null`.
/// If the is tests were generated with `storeFunctionTypeInMetadata` set to
/// `false`, this field is `null`, and the [properties] contain a property
/// that encodes the function type.
jsAst.Expression functionTypeIndex;
/// The properties that must be installed on the prototype of the
/// JS constructor of the [ClassElement] for which the is checks were
/// generated.
final Map<jsAst.Name, jsAst.Node> properties = <jsAst.Name, jsAst.Node>{};
class RuntimeTypeGenerator {
final Compiler compiler;
final CodeEmitterTask emitterTask;
final Namer namer;
RuntimeTypeGenerator(this.compiler, this.emitterTask, this.namer);
JavaScriptBackend get backend => compiler.backend;
TypeTestRegistry get typeTestRegistry => emitterTask.typeTestRegistry;
CommonElements get commonElements => compiler.commonElements;
Set<ClassElement> get checkedClasses => typeTestRegistry.checkedClasses;
Iterable<ClassElement> get classesUsingTypeVariableTests =>
Set<ResolutionFunctionType> get checkedFunctionTypes =>
/// Generates all properties necessary for is-checks on the [classElement].
/// Returns an instance of [TypeTestProperties] that contains the properties
/// that must be installed on the prototype of the JS constructor of the
/// [classElement].
/// If [storeFunctionTypeInMetadata] is `true`, stores the reified function
/// type (if class has one) in the metadata object and stores its index in
/// the result. This is only possible for function types that do not contain
/// type variables.
TypeTestProperties generateIsTests(ClassElement classElement,
{bool storeFunctionTypeInMetadata: true}) {
assert(invariant(classElement, classElement.isDeclaration));
TypeTestProperties result = new TypeTestProperties();
/// Generates an is-test if the test is not inherited from a superclass
/// This assumes that for every class an is-tests is generated
/// dynamically at runtime. We also always generate tests against
/// native classes.
/// TODO(herhut): Generate tests for native classes dynamically, as well.
void generateIsTest(ClassElement other) {
if (backend.nativeData.isNativeClass(classElement) ||
!classElement.isSubclassOf(other)) {[namer.operatorIs(other)] = js('1');
void generateFunctionTypeSignature(
FunctionElement method, ResolutionFunctionType type) {
jsAst.Expression thisAccess = new jsAst.This();
if (!method.isAbstract) {
ClosureClassMap closureData = compiler.closureToClassMapper
if (closureData != null) {
ClosureFieldElement thisLocal =
if (thisLocal != null) {
jsAst.Name thisName = namer.instanceFieldPropertyName(thisLocal);
thisAccess = js('this.#', thisName);
if (storeFunctionTypeInMetadata && !type.containsTypeVariables) {
result.functionTypeIndex =
} else {
RuntimeTypesEncoder rtiEncoder = backend.rtiEncoder;
jsAst.Expression encoding =
rtiEncoder.getSignatureEncoding(type, thisAccess);
jsAst.Name operatorSignature = namer.asName(namer.operatorSignature);[operatorSignature] = encoding;
void generateSubstitution(ClassElement cls, {bool emitNull: false}) {
if (cls.typeVariables.isEmpty) return;
RuntimeTypesSubstitutions rtiSubstitutions = backend.rtiSubstitutions;
RuntimeTypesEncoder rtiEncoder = backend.rtiEncoder;
jsAst.Expression expression;
bool needsNativeCheck =
Substitution substitution =
rtiSubstitutions.getSubstitution(classElement, cls);
if (substitution != null) {
expression = rtiEncoder.getSubstitutionCode(substitution);
if (expression == null && (emitNull || needsNativeCheck)) {
expression = new jsAst.LiteralNull();
if (expression != null) {[namer.substitutionName(cls)] = expression;
void generateTypeCheck(TypeCheck check) {
ClassElement checkedClass = check.cls;
Substitution substitution = check.substitution;
if (substitution != null) {
jsAst.Expression body =
backend.rtiEncoder.getSubstitutionCode(substitution);[namer.substitutionName(checkedClass)] = body;
_generateIsTestsOn(classElement, generateIsTest,
generateFunctionTypeSignature, generateSubstitution, generateTypeCheck);
if (classElement == backend.helpers.jsJavaScriptFunctionClass) {
var type = backend.jsInteropAnalysis.buildJsFunctionType();
if (type != null) {
jsAst.Expression thisAccess = new jsAst.This();
RuntimeTypesEncoder rtiEncoder = backend.rtiEncoder;
jsAst.Expression encoding =
rtiEncoder.getSignatureEncoding(type, thisAccess);
jsAst.Name operatorSignature = namer.asName(namer.operatorSignature);[operatorSignature] = encoding;
return result;
* Generate "is tests" for [cls] itself, and the "is tests" for the
* classes it implements and type argument substitution functions for these
* tests. We don't need to add the "is tests" of the super class because
* they will be inherited at runtime, but we may need to generate the
* substitutions, because they may have changed.
void _generateIsTestsOn(
ClassElement cls,
void generateIsTest(Element element),
FunctionTypeSignatureEmitter generateFunctionTypeSignature,
SubstitutionEmitter generateSubstitution,
void emitTypeCheck(TypeCheck check)) {
Setlet<Element> generated = new Setlet<Element>();
if (checkedClasses.contains(cls)) {
// Precomputed is checks.
TypeChecks typeChecks = backend.rtiChecks.requiredChecks;
Iterable<TypeCheck> classChecks = typeChecks[cls];
if (classChecks != null) {
for (TypeCheck check in classChecks) {
if (!generated.contains(check.cls)) {
ClassElement superclass = cls.superclass;
bool haveSameTypeVariables(ClassElement a, ClassElement b) {
if (a.isClosure) return true;
return backend.rtiSubstitutions.isTrivialSubstitution(a, b);
bool supertypesNeedSubstitutions = false;
if (superclass != null &&
superclass != commonElements.objectClass &&
!haveSameTypeVariables(cls, superclass)) {
// We cannot inherit the generated substitutions, because the type
// variable layout for this class is different. Instead we generate
// substitutions for all checks and make emitSubstitution a NOP for the
// rest of this function.
// TODO(karlklose): move the computation of these checks to
// RuntimeTypeInformation.
while (superclass != null) {
if (backend.rtiNeed.classNeedsRti(superclass)) {
generateSubstitution(superclass, emitNull: true);
superclass = superclass.superclass;
supertypesNeedSubstitutions = true;
if (cls is MixinApplicationElement) {
supertypesNeedSubstitutions = true;
if (supertypesNeedSubstitutions) {
for (ResolutionDartType supertype in cls.allSupertypes) {
ClassElement superclass = supertype.element;
if (generated.contains(superclass)) continue;
if (classesUsingTypeVariableTests.contains(superclass) ||
backend.rtiNeed.classUsesTypeVariableExpression(superclass) ||
checkedClasses.contains(superclass)) {
// Generate substitution. If no substitution is necessary, emit
// `null` to overwrite a (possibly) existing substitution from the
// super classes.
generateSubstitution(superclass, emitNull: true);
void emitNothing(_, {emitNull}) {}
generateSubstitution = emitNothing;
// A class that defines a `call` method implicitly implements
// [Function] and needs checks for all typedefs that are used in is-checks.
if (checkedClasses.contains(commonElements.functionClass) ||
checkedFunctionTypes.isNotEmpty) {
Element call = cls.lookupLocalMember(;
if (call == null) {
// If [cls] is a closure, it has a synthetic call operator method.
call = cls.lookupBackendMember(;
if (call != null && call.isFunction) {
FunctionElement callFunction = call;
// A superclass might already implement the Function interface. In such
// a case, we can avoid emiting the is test here.
if (!cls.superclass.implementsFunction(commonElements)) {
generateIsTest, generateSubstitution, generated);
ResolutionFunctionType callType =
generateFunctionTypeSignature(callFunction, callType);
for (ResolutionDartType interfaceType in cls.interfaces) {
_generateInterfacesIsTests(interfaceType.element, generateIsTest,
generateSubstitution, generated);
* Generate "is tests" where [cls] is being implemented.
void _generateInterfacesIsTests(
ClassElement cls,
void generateIsTest(ClassElement element),
SubstitutionEmitter generateSubstitution,
Set<Element> alreadyGenerated) {
void tryEmitTest(ClassElement check) {
if (!alreadyGenerated.contains(check) && checkedClasses.contains(check)) {
for (ResolutionDartType interfaceType in cls.interfaces) {
Element element = interfaceType.element;
element, generateIsTest, generateSubstitution, alreadyGenerated);
// We need to also emit "is checks" for the superclass and its supertypes.
ClassElement superclass = cls.superclass;
if (superclass != null) {
superclass, generateIsTest, generateSubstitution, alreadyGenerated);