Johnni Winther
9cfab12d36
Change-Id: Ie958dbbf75f5cac20074b2a64a4eefb9de636116 Reviewed-on: https://dart-review.googlesource.com/c/85290 Commit-Queue: Johnni Winther <johnniwinther@google.com> Reviewed-by: Sigmund Cherem <sigmund@google.com>
2074 lines
71 KiB
Dart
2074 lines
71 KiB
Dart
// Copyright (c) 2017, 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.kernel.element_map;
|
|
|
|
import 'package:front_end/src/api_unstable/dart2js.dart' show Link, LinkBuilder;
|
|
import 'package:js_runtime/shared/embedded_names.dart';
|
|
import 'package:kernel/ast.dart' as ir;
|
|
import 'package:kernel/class_hierarchy.dart' as ir;
|
|
import 'package:kernel/core_types.dart' as ir;
|
|
import 'package:kernel/type_algebra.dart' as ir;
|
|
import 'package:kernel/type_environment.dart' as ir;
|
|
|
|
import '../common.dart';
|
|
import '../common/names.dart';
|
|
import '../common/resolution.dart';
|
|
import '../common_elements.dart';
|
|
import '../compile_time_constants.dart';
|
|
import '../constants/constant_system.dart';
|
|
import '../constants/constructors.dart';
|
|
import '../constants/evaluation.dart';
|
|
import '../constants/expressions.dart';
|
|
import '../constants/values.dart';
|
|
import '../elements/entities.dart';
|
|
import '../elements/indexed.dart';
|
|
import '../elements/names.dart';
|
|
import '../elements/types.dart';
|
|
import '../environment.dart';
|
|
import '../frontend_strategy.dart';
|
|
import '../ir/debug.dart';
|
|
import '../ir/element_map.dart';
|
|
import '../ir/scope.dart';
|
|
import '../ir/types.dart';
|
|
import '../ir/visitors.dart';
|
|
import '../ir/util.dart';
|
|
import '../js/js.dart' as js;
|
|
import '../js_backend/backend.dart' show JavaScriptBackend;
|
|
import '../js_backend/constant_system_javascript.dart';
|
|
import '../js_backend/namer.dart';
|
|
import '../js_backend/native_data.dart';
|
|
import '../js_backend/no_such_method_registry.dart';
|
|
import '../js_model/locals.dart';
|
|
import '../kernel/dart2js_target.dart';
|
|
import '../native/behavior.dart';
|
|
import '../native/resolver.dart';
|
|
import '../options.dart';
|
|
import '../ordered_typeset.dart';
|
|
import '../universe/call_structure.dart';
|
|
import '../universe/class_hierarchy.dart';
|
|
import '../universe/selector.dart';
|
|
|
|
import 'element_map.dart';
|
|
import 'env.dart';
|
|
import 'kelements.dart';
|
|
import 'kernel_impact.dart';
|
|
|
|
part 'native_basic_data.dart';
|
|
part 'no_such_method_resolver.dart';
|
|
|
|
/// Implementation of [KernelToElementMap] that only supports world
|
|
/// impact computation.
|
|
class KernelToElementMapImpl implements KernelToElementMap, IrToElementMap {
|
|
final CompilerOptions options;
|
|
final DiagnosticReporter reporter;
|
|
CommonElementsImpl _commonElements;
|
|
KernelElementEnvironment _elementEnvironment;
|
|
DartTypeConverter _typeConverter;
|
|
KernelConstantEnvironment _constantEnvironment;
|
|
KernelDartTypes _types;
|
|
ir.TypeEnvironment _typeEnvironment;
|
|
|
|
/// Library environment. Used for fast lookup.
|
|
KProgramEnv env = new KProgramEnv();
|
|
|
|
final EntityDataEnvMap<IndexedLibrary, KLibraryData, KLibraryEnv> libraries =
|
|
new EntityDataEnvMap<IndexedLibrary, KLibraryData, KLibraryEnv>();
|
|
final EntityDataEnvMap<IndexedClass, KClassData, KClassEnv> classes =
|
|
new EntityDataEnvMap<IndexedClass, KClassData, KClassEnv>();
|
|
final EntityDataMap<IndexedMember, KMemberData> members =
|
|
new EntityDataMap<IndexedMember, KMemberData>();
|
|
final EntityDataMap<IndexedTypeVariable, KTypeVariableData> typeVariables =
|
|
new EntityDataMap<IndexedTypeVariable, KTypeVariableData>();
|
|
final EntityDataMap<IndexedTypedef, KTypedefData> typedefs =
|
|
new EntityDataMap<IndexedTypedef, KTypedefData>();
|
|
|
|
/// Set to `true` before creating the J-World from the K-World to assert that
|
|
/// no entities are created late.
|
|
bool envIsClosed = false;
|
|
|
|
final Map<ir.Library, IndexedLibrary> libraryMap = {};
|
|
final Map<ir.Class, IndexedClass> classMap = {};
|
|
final Map<ir.Typedef, IndexedTypedef> typedefMap = {};
|
|
|
|
/// Map from [ir.TypeParameter] nodes to the corresponding
|
|
/// [TypeVariableEntity].
|
|
///
|
|
/// Normally the type variables are [IndexedTypeVariable]s, but for type
|
|
/// parameters on local function (in the frontend) these are _not_ since
|
|
/// their type declaration is neither a class nor a member. In the backend,
|
|
/// these type parameters belong to the call-method and are therefore indexed.
|
|
final Map<ir.TypeParameter, TypeVariableEntity> typeVariableMap = {};
|
|
final Map<ir.Member, IndexedConstructor> constructorMap = {};
|
|
final Map<ir.Procedure, IndexedFunction> methodMap = {};
|
|
final Map<ir.Field, IndexedField> fieldMap = {};
|
|
final Map<ir.TreeNode, Local> localFunctionMap = {};
|
|
|
|
BehaviorBuilder _nativeBehaviorBuilder;
|
|
FrontendStrategy _frontendStrategy;
|
|
|
|
Map<KMember, Map<ir.TreeNode, ir.DartType>> staticTypeCacheForTesting;
|
|
|
|
KernelToElementMapImpl(this.reporter, Environment environment,
|
|
this._frontendStrategy, this.options) {
|
|
_elementEnvironment = new KernelElementEnvironment(this);
|
|
_commonElements = new CommonElementsImpl(_elementEnvironment);
|
|
_constantEnvironment = new KernelConstantEnvironment(this, environment);
|
|
_typeConverter = new DartTypeConverter(this);
|
|
_types = new KernelDartTypes(this);
|
|
}
|
|
|
|
DartTypes get types => _types;
|
|
|
|
KernelElementEnvironment get elementEnvironment => _elementEnvironment;
|
|
|
|
@override
|
|
CommonElementsImpl get commonElements => _commonElements;
|
|
|
|
FunctionEntity get _mainFunction {
|
|
return env.mainMethod != null ? getMethodInternal(env.mainMethod) : null;
|
|
}
|
|
|
|
LibraryEntity get _mainLibrary {
|
|
return env.mainMethod != null
|
|
? getLibraryInternal(env.mainMethod.enclosingLibrary)
|
|
: null;
|
|
}
|
|
|
|
SourceSpan getSourceSpan(Spannable spannable, Entity currentElement) {
|
|
SourceSpan fromSpannable(Spannable spannable) {
|
|
if (spannable is IndexedLibrary &&
|
|
spannable.libraryIndex < libraries.length) {
|
|
KLibraryEnv env = libraries.getEnv(spannable);
|
|
return computeSourceSpanFromTreeNode(env.library);
|
|
} else if (spannable is IndexedClass &&
|
|
spannable.classIndex < classes.length) {
|
|
KClassData data = classes.getData(spannable);
|
|
assert(data != null, "No data for $spannable in $this");
|
|
return computeSourceSpanFromTreeNode(data.node);
|
|
} else if (spannable is IndexedMember &&
|
|
spannable.memberIndex < members.length) {
|
|
KMemberData data = members.getData(spannable);
|
|
assert(data != null, "No data for $spannable in $this");
|
|
return computeSourceSpanFromTreeNode(data.node);
|
|
} else if (spannable is KLocalFunction) {
|
|
return getSourceSpan(spannable.memberContext, currentElement);
|
|
} else if (spannable is JLocal) {
|
|
return getSourceSpan(spannable.memberContext, currentElement);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
SourceSpan sourceSpan = fromSpannable(spannable);
|
|
sourceSpan ??= fromSpannable(currentElement);
|
|
return sourceSpan;
|
|
}
|
|
|
|
LibraryEntity lookupLibrary(Uri uri) {
|
|
KLibraryEnv libraryEnv = env.lookupLibrary(uri);
|
|
if (libraryEnv == null) return null;
|
|
return getLibraryInternal(libraryEnv.library, libraryEnv);
|
|
}
|
|
|
|
String _getLibraryName(IndexedLibrary library) {
|
|
assert(checkFamily(library));
|
|
KLibraryEnv libraryEnv = libraries.getEnv(library);
|
|
return libraryEnv.library.name ?? '';
|
|
}
|
|
|
|
MemberEntity lookupLibraryMember(IndexedLibrary library, String name,
|
|
{bool setter: false}) {
|
|
assert(checkFamily(library));
|
|
KLibraryEnv libraryEnv = libraries.getEnv(library);
|
|
ir.Member member = libraryEnv.lookupMember(name, setter: setter);
|
|
return member != null ? getMember(member) : null;
|
|
}
|
|
|
|
void _forEachLibraryMember(
|
|
IndexedLibrary library, void f(MemberEntity member)) {
|
|
assert(checkFamily(library));
|
|
KLibraryEnv libraryEnv = libraries.getEnv(library);
|
|
libraryEnv.forEachMember((ir.Member node) {
|
|
f(getMember(node));
|
|
});
|
|
}
|
|
|
|
ClassEntity lookupClass(IndexedLibrary library, String name) {
|
|
assert(checkFamily(library));
|
|
KLibraryEnv libraryEnv = libraries.getEnv(library);
|
|
KClassEnv classEnv = libraryEnv.lookupClass(name);
|
|
if (classEnv != null) {
|
|
return getClassInternal(classEnv.cls, classEnv);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void _forEachClass(IndexedLibrary library, void f(ClassEntity cls)) {
|
|
assert(checkFamily(library));
|
|
KLibraryEnv libraryEnv = libraries.getEnv(library);
|
|
libraryEnv.forEachClass((KClassEnv classEnv) {
|
|
if (!classEnv.isUnnamedMixinApplication) {
|
|
f(getClassInternal(classEnv.cls, classEnv));
|
|
}
|
|
});
|
|
}
|
|
|
|
void ensureClassMembers(ir.Class node) {
|
|
classes.getEnv(getClassInternal(node)).ensureMembers(this);
|
|
}
|
|
|
|
MemberEntity lookupClassMember(IndexedClass cls, String name,
|
|
{bool setter: false}) {
|
|
assert(checkFamily(cls));
|
|
KClassEnv classEnv = classes.getEnv(cls);
|
|
return classEnv.lookupMember(this, name, setter: setter);
|
|
}
|
|
|
|
ConstructorEntity lookupConstructor(IndexedClass cls, String name) {
|
|
assert(checkFamily(cls));
|
|
KClassEnv classEnv = classes.getEnv(cls);
|
|
return classEnv.lookupConstructor(this, name);
|
|
}
|
|
|
|
@override
|
|
InterfaceType createInterfaceType(
|
|
ir.Class cls, List<ir.DartType> typeArguments) {
|
|
return new InterfaceType(getClass(cls), getDartTypes(typeArguments));
|
|
}
|
|
|
|
LibraryEntity getLibrary(ir.Library node) => getLibraryInternal(node);
|
|
|
|
@override
|
|
ClassEntity getClass(ir.Class node) => getClassInternal(node);
|
|
|
|
InterfaceType getSuperType(IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
_ensureSupertypes(cls, data);
|
|
return data.supertype;
|
|
}
|
|
|
|
void _ensureThisAndRawType(ClassEntity cls, KClassData data) {
|
|
assert(checkFamily(cls));
|
|
if (data is KClassDataImpl && data.thisType == null) {
|
|
ir.Class node = data.node;
|
|
if (node.typeParameters.isEmpty) {
|
|
data.thisType =
|
|
data.rawType = new InterfaceType(cls, const <DartType>[]);
|
|
} else {
|
|
data.thisType = new InterfaceType(
|
|
cls,
|
|
new List<DartType>.generate(node.typeParameters.length,
|
|
(int index) {
|
|
return new TypeVariableType(
|
|
getTypeVariableInternal(node.typeParameters[index]));
|
|
}));
|
|
data.rawType = new InterfaceType(
|
|
cls,
|
|
new List<DartType>.filled(
|
|
node.typeParameters.length, const DynamicType()));
|
|
}
|
|
}
|
|
}
|
|
|
|
TypeVariableEntity getTypeVariable(ir.TypeParameter node) =>
|
|
getTypeVariableInternal(node);
|
|
|
|
void _ensureSupertypes(ClassEntity cls, KClassData data) {
|
|
assert(checkFamily(cls));
|
|
if (data is KClassDataImpl && data.orderedTypeSet == null) {
|
|
_ensureThisAndRawType(cls, data);
|
|
|
|
ir.Class node = data.node;
|
|
|
|
if (node.supertype == null) {
|
|
data.orderedTypeSet = new OrderedTypeSet.singleton(data.thisType);
|
|
data.isMixinApplication = false;
|
|
data.interfaces = const <InterfaceType>[];
|
|
} else {
|
|
InterfaceType processSupertype(ir.Supertype node) {
|
|
InterfaceType supertype = _typeConverter.visitSupertype(node);
|
|
IndexedClass superclass = supertype.element;
|
|
KClassData superdata = classes.getData(superclass);
|
|
_ensureSupertypes(superclass, superdata);
|
|
return supertype;
|
|
}
|
|
|
|
InterfaceType supertype;
|
|
LinkBuilder<InterfaceType> linkBuilder =
|
|
new LinkBuilder<InterfaceType>();
|
|
if (node.isMixinDeclaration) {
|
|
// A mixin declaration
|
|
//
|
|
// mixin M on A, B, C {}
|
|
//
|
|
// is encoded by CFE as
|
|
//
|
|
// abstract class M extends A implements B, C {}
|
|
// abstract class M extends A&B&C {}
|
|
//
|
|
// but we encode it as
|
|
//
|
|
// abstract class M extends Object implements A, B, C {}
|
|
//
|
|
// so we need get the superclasses from the on-clause, A, B, and C,
|
|
// through [superclassConstraints].
|
|
for (ir.Supertype constraint in node.superclassConstraints()) {
|
|
linkBuilder.addLast(processSupertype(constraint));
|
|
}
|
|
// Set superclass to `Object`.
|
|
supertype = _commonElements.objectType;
|
|
} else {
|
|
supertype = processSupertype(node.supertype);
|
|
}
|
|
if (supertype == _commonElements.objectType) {
|
|
ClassEntity defaultSuperclass =
|
|
_commonElements.getDefaultSuperclass(cls, nativeBasicData);
|
|
data.supertype = _elementEnvironment.getRawType(defaultSuperclass);
|
|
} else {
|
|
data.supertype = supertype;
|
|
}
|
|
if (node.mixedInType != null) {
|
|
data.isMixinApplication = true;
|
|
linkBuilder
|
|
.addLast(data.mixedInType = processSupertype(node.mixedInType));
|
|
} else {
|
|
data.isMixinApplication = false;
|
|
}
|
|
node.implementedTypes.forEach((ir.Supertype supertype) {
|
|
linkBuilder.addLast(processSupertype(supertype));
|
|
});
|
|
Link<InterfaceType> interfaces =
|
|
linkBuilder.toLink(const Link<InterfaceType>());
|
|
OrderedTypeSetBuilder setBuilder =
|
|
new KernelOrderedTypeSetBuilder(this, cls);
|
|
data.orderedTypeSet = setBuilder.createOrderedTypeSet(
|
|
data.supertype, interfaces.reverse(const Link<InterfaceType>()));
|
|
data.interfaces = new List<InterfaceType>.from(interfaces.toList());
|
|
}
|
|
}
|
|
}
|
|
|
|
@override
|
|
TypedefType getTypedefType(ir.Typedef node) {
|
|
IndexedTypedef typedef = getTypedefInternal(node);
|
|
return typedefs.getData(typedef).rawType;
|
|
}
|
|
|
|
@override
|
|
MemberEntity getMember(ir.Member node) {
|
|
if (node is ir.Field) {
|
|
return getFieldInternal(node);
|
|
} else if (node is ir.Constructor) {
|
|
return getConstructorInternal(node);
|
|
} else if (node is ir.Procedure) {
|
|
if (node.kind == ir.ProcedureKind.Factory) {
|
|
return getConstructorInternal(node);
|
|
} else {
|
|
return getMethodInternal(node);
|
|
}
|
|
}
|
|
throw new UnsupportedError("Unexpected member: $node");
|
|
}
|
|
|
|
MemberEntity getSuperMember(MemberEntity context, ir.Name name,
|
|
{bool setter: false}) {
|
|
// We can no longer trust the interface target of the super access since it
|
|
// might be a member that we have cloned.
|
|
ClassEntity cls = context.enclosingClass;
|
|
assert(
|
|
cls != null,
|
|
failedAt(context,
|
|
"No enclosing class for super member access in $context."));
|
|
IndexedClass superclass = getSuperType(cls)?.element;
|
|
while (superclass != null) {
|
|
KClassEnv env = classes.getEnv(superclass);
|
|
MemberEntity superMember =
|
|
env.lookupMember(this, name.name, setter: setter);
|
|
if (superMember != null) {
|
|
if (!superMember.isInstanceMember) return null;
|
|
if (!superMember.isAbstract) {
|
|
return superMember;
|
|
}
|
|
}
|
|
superclass = getSuperType(superclass)?.element;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@override
|
|
ConstructorEntity getConstructor(ir.Member node) =>
|
|
getConstructorInternal(node);
|
|
|
|
ConstructorEntity getSuperConstructor(
|
|
ir.Constructor sourceNode, ir.Member targetNode) {
|
|
ConstructorEntity source = getConstructor(sourceNode);
|
|
ClassEntity sourceClass = source.enclosingClass;
|
|
ConstructorEntity target = getConstructor(targetNode);
|
|
ClassEntity targetClass = target.enclosingClass;
|
|
IndexedClass superClass = getSuperType(sourceClass)?.element;
|
|
if (superClass == targetClass) {
|
|
return target;
|
|
}
|
|
KClassEnv env = classes.getEnv(superClass);
|
|
ConstructorEntity constructor = env.lookupConstructor(this, target.name);
|
|
if (constructor != null) {
|
|
return constructor;
|
|
}
|
|
throw failedAt(source, "Super constructor for $source not found.");
|
|
}
|
|
|
|
@override
|
|
FunctionEntity getMethod(ir.Procedure node) => getMethodInternal(node);
|
|
|
|
@override
|
|
FieldEntity getField(ir.Field node) => getFieldInternal(node);
|
|
|
|
@override
|
|
DartType getDartType(ir.DartType type) => _typeConverter.convert(type);
|
|
|
|
TypeVariableType getTypeVariableType(ir.TypeParameterType type) =>
|
|
getDartType(type);
|
|
|
|
List<DartType> getDartTypes(List<ir.DartType> types) {
|
|
List<DartType> list = <DartType>[];
|
|
types.forEach((ir.DartType type) {
|
|
list.add(getDartType(type));
|
|
});
|
|
return list;
|
|
}
|
|
|
|
InterfaceType getInterfaceType(ir.InterfaceType type) =>
|
|
_typeConverter.convert(type);
|
|
|
|
@override
|
|
FunctionType getFunctionType(ir.FunctionNode node) {
|
|
DartType returnType;
|
|
if (node.parent is ir.Constructor) {
|
|
// The return type on generative constructors is `void`, but we need
|
|
// `dynamic` type to match the element model.
|
|
returnType = const DynamicType();
|
|
} else {
|
|
returnType = getDartType(node.returnType);
|
|
}
|
|
List<DartType> parameterTypes = <DartType>[];
|
|
List<DartType> optionalParameterTypes = <DartType>[];
|
|
|
|
DartType getParameterType(ir.VariableDeclaration variable) {
|
|
if (variable.isCovariant || variable.isGenericCovariantImpl) {
|
|
// A covariant parameter has type `Object` in the method signature.
|
|
return commonElements.objectType;
|
|
}
|
|
return getDartType(variable.type);
|
|
}
|
|
|
|
for (ir.VariableDeclaration variable in node.positionalParameters) {
|
|
if (parameterTypes.length == node.requiredParameterCount) {
|
|
optionalParameterTypes.add(getParameterType(variable));
|
|
} else {
|
|
parameterTypes.add(getParameterType(variable));
|
|
}
|
|
}
|
|
List<String> namedParameters = <String>[];
|
|
List<DartType> namedParameterTypes = <DartType>[];
|
|
List<ir.VariableDeclaration> sortedNamedParameters =
|
|
node.namedParameters.toList()..sort((a, b) => a.name.compareTo(b.name));
|
|
for (ir.VariableDeclaration variable in sortedNamedParameters) {
|
|
namedParameters.add(variable.name);
|
|
namedParameterTypes.add(getParameterType(variable));
|
|
}
|
|
List<FunctionTypeVariable> typeVariables;
|
|
if (node.typeParameters.isNotEmpty) {
|
|
List<DartType> typeParameters = <DartType>[];
|
|
for (ir.TypeParameter typeParameter in node.typeParameters) {
|
|
typeParameters
|
|
.add(getDartType(new ir.TypeParameterType(typeParameter)));
|
|
}
|
|
typeVariables = new List<FunctionTypeVariable>.generate(
|
|
node.typeParameters.length,
|
|
(int index) => new FunctionTypeVariable(index));
|
|
|
|
DartType subst(DartType type) {
|
|
return type.subst(typeVariables, typeParameters);
|
|
}
|
|
|
|
returnType = subst(returnType);
|
|
parameterTypes = parameterTypes.map(subst).toList();
|
|
optionalParameterTypes = optionalParameterTypes.map(subst).toList();
|
|
namedParameterTypes = namedParameterTypes.map(subst).toList();
|
|
for (int index = 0; index < typeVariables.length; index++) {
|
|
typeVariables[index].bound =
|
|
subst(getDartType(node.typeParameters[index].bound));
|
|
}
|
|
} else {
|
|
typeVariables = const <FunctionTypeVariable>[];
|
|
}
|
|
|
|
return new FunctionType(returnType, parameterTypes, optionalParameterTypes,
|
|
namedParameters, namedParameterTypes, typeVariables);
|
|
}
|
|
|
|
ConstantValue computeConstantValue(
|
|
Spannable spannable, ConstantExpression constant,
|
|
{bool requireConstant: true, bool checkCasts: true}) {
|
|
return _constantEnvironment._getConstantValue(spannable, constant,
|
|
constantRequired: requireConstant, checkCasts: checkCasts);
|
|
}
|
|
|
|
DartType substByContext(DartType type, InterfaceType context) {
|
|
return type.subst(
|
|
context.typeArguments, getThisType(context.element).typeArguments);
|
|
}
|
|
|
|
/// Returns the type of the `call` method on 'type'.
|
|
///
|
|
/// If [type] doesn't have a `call` member `null` is returned. If [type] has
|
|
/// an invalid `call` member (non-method or a synthesized method with both
|
|
/// optional and named parameters) a [DynamicType] is returned.
|
|
DartType getCallType(InterfaceType type) {
|
|
IndexedClass cls = type.element;
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
if (data.callType != null) {
|
|
return substByContext(data.callType, type);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
InterfaceType getThisType(IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
_ensureThisAndRawType(cls, data);
|
|
return data.thisType;
|
|
}
|
|
|
|
InterfaceType _getRawType(IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
_ensureThisAndRawType(cls, data);
|
|
return data.rawType;
|
|
}
|
|
|
|
DartType _getFieldType(IndexedField field) {
|
|
assert(checkFamily(field));
|
|
KFieldData data = members.getData(field);
|
|
return data.getFieldType(this);
|
|
}
|
|
|
|
FunctionType _getFunctionType(IndexedFunction function) {
|
|
assert(checkFamily(function));
|
|
KFunctionData data = members.getData(function);
|
|
return data.getFunctionType(this);
|
|
}
|
|
|
|
List<TypeVariableType> _getFunctionTypeVariables(IndexedFunction function) {
|
|
assert(checkFamily(function));
|
|
KFunctionData data = members.getData(function);
|
|
return data.getFunctionTypeVariables(this);
|
|
}
|
|
|
|
DartType getTypeVariableBound(IndexedTypeVariable typeVariable) {
|
|
assert(checkFamily(typeVariable));
|
|
KTypeVariableData data = typeVariables.getData(typeVariable);
|
|
return data.getBound(this);
|
|
}
|
|
|
|
ClassEntity getAppliedMixin(IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
_ensureSupertypes(cls, data);
|
|
return data.mixedInType?.element;
|
|
}
|
|
|
|
bool _isMixinApplication(IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
_ensureSupertypes(cls, data);
|
|
return data.isMixinApplication;
|
|
}
|
|
|
|
bool _isUnnamedMixinApplication(IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
KClassEnv env = classes.getEnv(cls);
|
|
return env.isUnnamedMixinApplication;
|
|
}
|
|
|
|
void _forEachSupertype(IndexedClass cls, void f(InterfaceType supertype)) {
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
_ensureSupertypes(cls, data);
|
|
data.orderedTypeSet.supertypes.forEach(f);
|
|
}
|
|
|
|
void _forEachMixin(IndexedClass cls, void f(ClassEntity mixin)) {
|
|
assert(checkFamily(cls));
|
|
while (cls != null) {
|
|
KClassData data = classes.getData(cls);
|
|
_ensureSupertypes(cls, data);
|
|
if (data.mixedInType != null) {
|
|
f(data.mixedInType.element);
|
|
}
|
|
cls = data.supertype?.element;
|
|
}
|
|
}
|
|
|
|
void _forEachConstructor(IndexedClass cls, void f(ConstructorEntity member)) {
|
|
assert(checkFamily(cls));
|
|
KClassEnv env = classes.getEnv(cls);
|
|
env.forEachConstructor(this, f);
|
|
}
|
|
|
|
void _forEachLocalClassMember(IndexedClass cls, void f(MemberEntity member)) {
|
|
assert(checkFamily(cls));
|
|
KClassEnv env = classes.getEnv(cls);
|
|
env.forEachMember(this, (MemberEntity member) {
|
|
f(member);
|
|
});
|
|
}
|
|
|
|
void forEachInjectedClassMember(
|
|
IndexedClass cls, void f(MemberEntity member)) {
|
|
assert(checkFamily(cls));
|
|
throw new UnsupportedError(
|
|
'KernelToElementMapBase._forEachInjectedClassMember');
|
|
}
|
|
|
|
void _forEachClassMember(
|
|
IndexedClass cls, void f(ClassEntity cls, MemberEntity member)) {
|
|
assert(checkFamily(cls));
|
|
KClassEnv env = classes.getEnv(cls);
|
|
env.forEachMember(this, (MemberEntity member) {
|
|
f(cls, member);
|
|
});
|
|
KClassData data = classes.getData(cls);
|
|
_ensureSupertypes(cls, data);
|
|
if (data.supertype != null) {
|
|
_forEachClassMember(data.supertype.element, f);
|
|
}
|
|
}
|
|
|
|
ConstantConstructor _getConstructorConstant(IndexedConstructor constructor) {
|
|
assert(checkFamily(constructor));
|
|
KConstructorData data = members.getData(constructor);
|
|
return data.getConstructorConstant(this, constructor);
|
|
}
|
|
|
|
ConstantExpression _getFieldConstantExpression(IndexedField field) {
|
|
assert(checkFamily(field));
|
|
KFieldData data = members.getData(field);
|
|
return data.getFieldConstantExpression(this);
|
|
}
|
|
|
|
InterfaceType asInstanceOf(InterfaceType type, ClassEntity cls) {
|
|
assert(checkFamily(cls));
|
|
OrderedTypeSet orderedTypeSet = getOrderedTypeSet(type.element);
|
|
InterfaceType supertype =
|
|
orderedTypeSet.asInstanceOf(cls, getHierarchyDepth(cls));
|
|
if (supertype != null) {
|
|
supertype = substByContext(supertype, type);
|
|
}
|
|
return supertype;
|
|
}
|
|
|
|
OrderedTypeSet getOrderedTypeSet(IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
_ensureSupertypes(cls, data);
|
|
return data.orderedTypeSet;
|
|
}
|
|
|
|
int getHierarchyDepth(IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
_ensureSupertypes(cls, data);
|
|
return data.orderedTypeSet.maxDepth;
|
|
}
|
|
|
|
Iterable<InterfaceType> getInterfaces(IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
_ensureSupertypes(cls, data);
|
|
return data.interfaces;
|
|
}
|
|
|
|
ir.Member getMemberNode(covariant IndexedMember member) {
|
|
assert(checkFamily(member));
|
|
return members.getData(member).node;
|
|
}
|
|
|
|
ir.Class getClassNode(covariant IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
return classes.getData(cls).node;
|
|
}
|
|
|
|
ir.Typedef _getTypedefNode(covariant IndexedTypedef typedef) {
|
|
return typedefs.getData(typedef).node;
|
|
}
|
|
|
|
ImportEntity getImport(ir.LibraryDependency node) {
|
|
ir.Library library = node.parent;
|
|
KLibraryData data = libraries.getData(getLibraryInternal(library));
|
|
return data.imports[node];
|
|
}
|
|
|
|
ir.TypeEnvironment get typeEnvironment {
|
|
if (_typeEnvironment == null) {
|
|
_typeEnvironment ??= new ir.TypeEnvironment(
|
|
new ir.CoreTypes(env.mainComponent),
|
|
new ir.ClassHierarchy(env.mainComponent));
|
|
}
|
|
return _typeEnvironment;
|
|
}
|
|
|
|
DartType getStaticType(ir.Expression node) {
|
|
ir.TreeNode enclosingClass = node;
|
|
while (enclosingClass != null && enclosingClass is! ir.Class) {
|
|
enclosingClass = enclosingClass.parent;
|
|
}
|
|
try {
|
|
typeEnvironment.thisType =
|
|
enclosingClass is ir.Class ? enclosingClass.thisType : null;
|
|
return getDartType(node.getStaticType(typeEnvironment));
|
|
} catch (e) {
|
|
// The static type computation crashes on type errors. Use `dynamic`
|
|
// as static type.
|
|
return commonElements.dynamicType;
|
|
}
|
|
}
|
|
|
|
Name getName(ir.Name name) {
|
|
return new Name(
|
|
name.name, name.isPrivate ? getLibrary(name.library) : null);
|
|
}
|
|
|
|
CallStructure getCallStructure(ir.Arguments arguments) {
|
|
int argumentCount = arguments.positional.length + arguments.named.length;
|
|
List<String> namedArguments = arguments.named.map((e) => e.name).toList();
|
|
return new CallStructure(
|
|
argumentCount, namedArguments, arguments.types.length);
|
|
}
|
|
|
|
ParameterStructure getParameterStructure(ir.FunctionNode node,
|
|
// TODO(johnniwinther): Remove this when type arguments are passed to
|
|
// constructors like calling a generic method.
|
|
{bool includeTypeParameters: true}) {
|
|
// TODO(johnniwinther): Cache the computed function type.
|
|
int requiredParameters = node.requiredParameterCount;
|
|
int positionalParameters = node.positionalParameters.length;
|
|
int typeParameters = node.typeParameters.length;
|
|
List<String> namedParameters =
|
|
node.namedParameters.map((p) => p.name).toList()..sort();
|
|
return new ParameterStructure(requiredParameters, positionalParameters,
|
|
namedParameters, includeTypeParameters ? typeParameters : 0);
|
|
}
|
|
|
|
Selector getSelector(ir.Expression node) {
|
|
// TODO(efortuna): This is screaming for a common interface between
|
|
// PropertyGet and SuperPropertyGet (and same for *Get). Talk to kernel
|
|
// folks.
|
|
if (node is ir.PropertyGet) {
|
|
return getGetterSelector(node.name);
|
|
}
|
|
if (node is ir.SuperPropertyGet) {
|
|
return getGetterSelector(node.name);
|
|
}
|
|
if (node is ir.PropertySet) {
|
|
return getSetterSelector(node.name);
|
|
}
|
|
if (node is ir.SuperPropertySet) {
|
|
return getSetterSelector(node.name);
|
|
}
|
|
if (node is ir.InvocationExpression) {
|
|
return getInvocationSelector(node);
|
|
}
|
|
throw failedAt(
|
|
CURRENT_ELEMENT_SPANNABLE,
|
|
"Can only get the selector for a property get or an invocation: "
|
|
"${node}");
|
|
}
|
|
|
|
Selector getInvocationSelector(ir.InvocationExpression invocation) {
|
|
Name name = getName(invocation.name);
|
|
SelectorKind kind;
|
|
if (Selector.isOperatorName(name.text)) {
|
|
if (name == Names.INDEX_NAME || name == Names.INDEX_SET_NAME) {
|
|
kind = SelectorKind.INDEX;
|
|
} else {
|
|
kind = SelectorKind.OPERATOR;
|
|
}
|
|
} else {
|
|
kind = SelectorKind.CALL;
|
|
}
|
|
|
|
CallStructure callStructure = getCallStructure(invocation.arguments);
|
|
return new Selector(kind, name, callStructure);
|
|
}
|
|
|
|
Selector getGetterSelector(ir.Name irName) {
|
|
Name name = new Name(
|
|
irName.name, irName.isPrivate ? getLibrary(irName.library) : null);
|
|
return new Selector.getter(name);
|
|
}
|
|
|
|
Selector getSetterSelector(ir.Name irName) {
|
|
Name name = new Name(
|
|
irName.name, irName.isPrivate ? getLibrary(irName.library) : null);
|
|
return new Selector.setter(name);
|
|
}
|
|
|
|
/// Looks up [typeName] for use in the spec-string of a `JS` call.
|
|
// TODO(johnniwinther): Use this in [NativeBehavior] instead of calling
|
|
// the `ForeignResolver`.
|
|
TypeLookup typeLookup({bool resolveAsRaw: true}) {
|
|
return resolveAsRaw
|
|
? (_cachedTypeLookupRaw ??= _typeLookup(resolveAsRaw: true))
|
|
: (_cachedTypeLookupFull ??= _typeLookup(resolveAsRaw: false));
|
|
}
|
|
|
|
TypeLookup _cachedTypeLookupRaw;
|
|
TypeLookup _cachedTypeLookupFull;
|
|
|
|
TypeLookup _typeLookup({bool resolveAsRaw: true}) {
|
|
bool cachedMayLookupInMain;
|
|
bool mayLookupInMain() {
|
|
var mainUri = elementEnvironment.mainLibrary.canonicalUri;
|
|
// Tests permit lookup outside of dart: libraries.
|
|
return mainUri.path.contains('tests/compiler/dart2js_native') ||
|
|
mainUri.path.contains('tests/compiler/dart2js_extra');
|
|
}
|
|
|
|
DartType lookup(String typeName, {bool required}) {
|
|
DartType findInLibrary(LibraryEntity library) {
|
|
if (library != null) {
|
|
ClassEntity cls = elementEnvironment.lookupClass(library, typeName);
|
|
if (cls != null) {
|
|
// TODO(johnniwinther): Align semantics.
|
|
return resolveAsRaw
|
|
? elementEnvironment.getRawType(cls)
|
|
: elementEnvironment.getThisType(cls);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
DartType findIn(Uri uri) {
|
|
return findInLibrary(elementEnvironment.lookupLibrary(uri));
|
|
}
|
|
|
|
// TODO(johnniwinther): Narrow the set of lookups based on the depending
|
|
// library.
|
|
// TODO(johnniwinther): Cache more results to avoid redundant lookups?
|
|
DartType type;
|
|
if (cachedMayLookupInMain ??= mayLookupInMain()) {
|
|
type ??= findInLibrary(elementEnvironment.mainLibrary);
|
|
}
|
|
type ??= findIn(Uris.dart_core);
|
|
type ??= findIn(Uris.dart__js_helper);
|
|
type ??= findIn(Uris.dart__interceptors);
|
|
type ??= findIn(Uris.dart__native_typed_data);
|
|
type ??= findIn(Uris.dart_collection);
|
|
type ??= findIn(Uris.dart_math);
|
|
type ??= findIn(Uris.dart_html);
|
|
type ??= findIn(Uris.dart_html_common);
|
|
type ??= findIn(Uris.dart_svg);
|
|
type ??= findIn(Uris.dart_web_audio);
|
|
type ??= findIn(Uris.dart_web_gl);
|
|
type ??= findIn(Uris.dart_web_sql);
|
|
type ??= findIn(Uris.dart_indexed_db);
|
|
type ??= findIn(Uris.dart_typed_data);
|
|
type ??= findIn(Uris.dart_mirrors);
|
|
if (type == null && required) {
|
|
reporter.reportErrorMessage(CURRENT_ELEMENT_SPANNABLE,
|
|
MessageKind.GENERIC, {'text': "Type '$typeName' not found."});
|
|
}
|
|
return type;
|
|
}
|
|
|
|
return lookup;
|
|
}
|
|
|
|
String _getStringArgument(ir.StaticInvocation node, int index) {
|
|
return node.arguments.positional[index].accept(new Stringifier());
|
|
}
|
|
|
|
/// Computes the [NativeBehavior] for a call to the [JS] function.
|
|
// TODO(johnniwinther): Cache this for later use.
|
|
NativeBehavior getNativeBehaviorForJsCall(ir.StaticInvocation node) {
|
|
if (node.arguments.positional.length < 2 ||
|
|
node.arguments.named.isNotEmpty) {
|
|
reporter.reportErrorMessage(
|
|
CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS);
|
|
return new NativeBehavior();
|
|
}
|
|
String specString = _getStringArgument(node, 0);
|
|
if (specString == null) {
|
|
reporter.reportErrorMessage(
|
|
CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS_FIRST);
|
|
return new NativeBehavior();
|
|
}
|
|
|
|
String codeString = _getStringArgument(node, 1);
|
|
if (codeString == null) {
|
|
reporter.reportErrorMessage(
|
|
CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS_SECOND);
|
|
return new NativeBehavior();
|
|
}
|
|
|
|
return NativeBehavior.ofJsCall(
|
|
specString,
|
|
codeString,
|
|
typeLookup(resolveAsRaw: true),
|
|
CURRENT_ELEMENT_SPANNABLE,
|
|
reporter,
|
|
commonElements);
|
|
}
|
|
|
|
/// Computes the [NativeBehavior] for a call to the [JS_BUILTIN]
|
|
/// function.
|
|
// TODO(johnniwinther): Cache this for later use.
|
|
NativeBehavior getNativeBehaviorForJsBuiltinCall(ir.StaticInvocation node) {
|
|
if (node.arguments.positional.length < 1) {
|
|
reporter.internalError(
|
|
CURRENT_ELEMENT_SPANNABLE, "JS builtin expression has no type.");
|
|
return new NativeBehavior();
|
|
}
|
|
if (node.arguments.positional.length < 2) {
|
|
reporter.internalError(
|
|
CURRENT_ELEMENT_SPANNABLE, "JS builtin is missing name.");
|
|
return new NativeBehavior();
|
|
}
|
|
String specString = _getStringArgument(node, 0);
|
|
if (specString == null) {
|
|
reporter.internalError(
|
|
CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
|
|
return new NativeBehavior();
|
|
}
|
|
return NativeBehavior.ofJsBuiltinCall(
|
|
specString,
|
|
typeLookup(resolveAsRaw: true),
|
|
CURRENT_ELEMENT_SPANNABLE,
|
|
reporter,
|
|
commonElements);
|
|
}
|
|
|
|
/// Computes the [NativeBehavior] for a call to the
|
|
/// [JS_EMBEDDED_GLOBAL] function.
|
|
// TODO(johnniwinther): Cache this for later use.
|
|
NativeBehavior getNativeBehaviorForJsEmbeddedGlobalCall(
|
|
ir.StaticInvocation node) {
|
|
if (node.arguments.positional.length < 1) {
|
|
reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
|
|
"JS embedded global expression has no type.");
|
|
return new NativeBehavior();
|
|
}
|
|
if (node.arguments.positional.length < 2) {
|
|
reporter.internalError(
|
|
CURRENT_ELEMENT_SPANNABLE, "JS embedded global is missing name.");
|
|
return new NativeBehavior();
|
|
}
|
|
if (node.arguments.positional.length > 2 ||
|
|
node.arguments.named.isNotEmpty) {
|
|
reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
|
|
"JS embedded global has more than 2 arguments.");
|
|
return new NativeBehavior();
|
|
}
|
|
String specString = _getStringArgument(node, 0);
|
|
if (specString == null) {
|
|
reporter.internalError(
|
|
CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
|
|
return new NativeBehavior();
|
|
}
|
|
return NativeBehavior.ofJsEmbeddedGlobalCall(
|
|
specString,
|
|
typeLookup(resolveAsRaw: true),
|
|
CURRENT_ELEMENT_SPANNABLE,
|
|
reporter,
|
|
commonElements);
|
|
}
|
|
|
|
js.Name getNameForJsGetName(ConstantValue constant, Namer namer) {
|
|
int index = extractEnumIndexFromConstantValue(
|
|
constant, commonElements.jsGetNameEnum);
|
|
if (index == null) return null;
|
|
return namer.getNameForJsGetName(
|
|
CURRENT_ELEMENT_SPANNABLE, JsGetName.values[index]);
|
|
}
|
|
|
|
int extractEnumIndexFromConstantValue(
|
|
ConstantValue constant, ClassEntity classElement) {
|
|
if (constant is ConstructedConstantValue) {
|
|
if (constant.type.element == classElement) {
|
|
assert(constant.fields.length == 1 || constant.fields.length == 2);
|
|
ConstantValue indexConstant = constant.fields.values.first;
|
|
if (indexConstant is IntConstantValue) {
|
|
return indexConstant.intValue.toInt();
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
ConstantValue getConstantValue(ir.Expression node,
|
|
{bool requireConstant: true,
|
|
bool implicitNull: false,
|
|
bool checkCasts: true}) {
|
|
ConstantExpression constant;
|
|
if (node == null) {
|
|
if (!implicitNull) {
|
|
throw failedAt(
|
|
CURRENT_ELEMENT_SPANNABLE, 'No expression for constant.');
|
|
}
|
|
constant = new NullConstantExpression();
|
|
} else {
|
|
constant =
|
|
new Constantifier(this, requireConstant: requireConstant).visit(node);
|
|
}
|
|
if (constant == null) {
|
|
if (requireConstant) {
|
|
throw new UnsupportedError(
|
|
'No constant for ${DebugPrinter.prettyPrint(node)}');
|
|
}
|
|
return null;
|
|
}
|
|
ConstantValue value = computeConstantValue(
|
|
computeSourceSpanFromTreeNode(node), constant,
|
|
requireConstant: requireConstant, checkCasts: checkCasts);
|
|
if (!value.isConstant && !requireConstant) {
|
|
return null;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
/// Converts [annotations] into a list of [ConstantValue]s.
|
|
List<ConstantValue> getMetadata(List<ir.Expression> annotations) {
|
|
if (annotations.isEmpty) return const <ConstantValue>[];
|
|
List<ConstantValue> metadata = <ConstantValue>[];
|
|
annotations.forEach((ir.Expression node) {
|
|
// We skip the implicit cast checks for metadata to avoid circular
|
|
// dependencies in the js-interop class registration.
|
|
metadata.add(getConstantValue(node, checkCasts: false));
|
|
});
|
|
return metadata;
|
|
}
|
|
|
|
FunctionEntity getSuperNoSuchMethod(ClassEntity cls) {
|
|
while (cls != null) {
|
|
cls = elementEnvironment.getSuperClass(cls);
|
|
MemberEntity member = elementEnvironment.lookupLocalClassMember(
|
|
cls, Identifiers.noSuchMethod_);
|
|
if (member != null && !member.isAbstract) {
|
|
if (member.isFunction) {
|
|
FunctionEntity function = member;
|
|
if (function.parameterStructure.positionalParameters >= 1) {
|
|
return function;
|
|
}
|
|
}
|
|
// If [member] is not a valid `noSuchMethod` the target is
|
|
// `Object.superNoSuchMethod`.
|
|
break;
|
|
}
|
|
}
|
|
FunctionEntity function = elementEnvironment.lookupLocalClassMember(
|
|
commonElements.objectClass, Identifiers.noSuchMethod_);
|
|
assert(function != null,
|
|
failedAt(cls, "No super noSuchMethod found for class $cls."));
|
|
return function;
|
|
}
|
|
|
|
Iterable<LibraryEntity> get libraryListInternal {
|
|
if (env.length != libraryMap.length) {
|
|
// Create a [KLibrary] for each library.
|
|
env.forEachLibrary((KLibraryEnv env) {
|
|
getLibraryInternal(env.library, env);
|
|
});
|
|
}
|
|
return libraryMap.values;
|
|
}
|
|
|
|
LibraryEntity getLibraryInternal(ir.Library node, [KLibraryEnv libraryEnv]) {
|
|
return libraryMap[node] ??= _getLibraryCreate(node, libraryEnv);
|
|
}
|
|
|
|
LibraryEntity _getLibraryCreate(ir.Library node, KLibraryEnv libraryEnv) {
|
|
assert(
|
|
!envIsClosed,
|
|
"Environment of $this is closed. Trying to create "
|
|
"library for $node.");
|
|
Uri canonicalUri = node.importUri;
|
|
String name = node.name;
|
|
if (name == null) {
|
|
// Use the file name as script name.
|
|
String path = canonicalUri.path;
|
|
name = path.substring(path.lastIndexOf('/') + 1);
|
|
}
|
|
IndexedLibrary library = createLibrary(name, canonicalUri);
|
|
return libraries.register(library, new KLibraryData(node),
|
|
libraryEnv ?? env.lookupLibrary(canonicalUri));
|
|
}
|
|
|
|
ClassEntity getClassInternal(ir.Class node, [KClassEnv classEnv]) {
|
|
return classMap[node] ??= _getClassCreate(node, classEnv);
|
|
}
|
|
|
|
ClassEntity _getClassCreate(ir.Class node, KClassEnv classEnv) {
|
|
assert(
|
|
!envIsClosed,
|
|
"Environment of $this is closed. Trying to create "
|
|
"class for $node.");
|
|
KLibrary library = getLibraryInternal(node.enclosingLibrary);
|
|
if (classEnv == null) {
|
|
classEnv = libraries.getEnv(library).lookupClass(node.name);
|
|
}
|
|
IndexedClass cls =
|
|
createClass(library, node.name, isAbstract: node.isAbstract);
|
|
return classes.register(cls, new KClassDataImpl(node), classEnv);
|
|
}
|
|
|
|
TypedefEntity getTypedefInternal(ir.Typedef node) {
|
|
return typedefMap[node] ??= _getTypedefCreate(node);
|
|
}
|
|
|
|
TypedefEntity _getTypedefCreate(ir.Typedef node) {
|
|
assert(
|
|
!envIsClosed,
|
|
"Environment of $this is closed. Trying to create "
|
|
"typedef for $node.");
|
|
IndexedLibrary library = getLibraryInternal(node.enclosingLibrary);
|
|
IndexedTypedef typedef = createTypedef(library, node.name);
|
|
TypedefType typedefType = new TypedefType(
|
|
typedef,
|
|
new List<DartType>.filled(
|
|
node.typeParameters.length, const DynamicType()),
|
|
getDartType(node.type));
|
|
return typedefs.register(
|
|
typedef, new KTypedefData(node, typedef, typedefType));
|
|
}
|
|
|
|
TypeVariableEntity getTypeVariableInternal(ir.TypeParameter node) {
|
|
return typeVariableMap[node] ??= _getTypeVariableCreate(node);
|
|
}
|
|
|
|
TypeVariableEntity _getTypeVariableCreate(ir.TypeParameter node) {
|
|
assert(
|
|
!envIsClosed,
|
|
"Environment of $this is closed. Trying to create "
|
|
"type variable for $node.");
|
|
if (node.parent is ir.Class) {
|
|
ir.Class cls = node.parent;
|
|
int index = cls.typeParameters.indexOf(node);
|
|
return typeVariables.register(
|
|
createTypeVariable(getClassInternal(cls), node.name, index),
|
|
new KTypeVariableData(node));
|
|
}
|
|
if (node.parent is ir.FunctionNode) {
|
|
ir.FunctionNode func = node.parent;
|
|
int index = func.typeParameters.indexOf(node);
|
|
if (func.parent is ir.Constructor) {
|
|
ir.Constructor constructor = func.parent;
|
|
ir.Class cls = constructor.enclosingClass;
|
|
return getTypeVariableInternal(cls.typeParameters[index]);
|
|
} else if (func.parent is ir.Procedure) {
|
|
ir.Procedure procedure = func.parent;
|
|
if (procedure.kind == ir.ProcedureKind.Factory) {
|
|
ir.Class cls = procedure.enclosingClass;
|
|
return getTypeVariableInternal(cls.typeParameters[index]);
|
|
} else {
|
|
return typeVariables.register(
|
|
createTypeVariable(
|
|
getMethodInternal(procedure), node.name, index),
|
|
new KTypeVariableData(node));
|
|
}
|
|
} else if (func.parent is ir.FunctionDeclaration ||
|
|
func.parent is ir.FunctionExpression) {
|
|
// Ensure that local function type variables have been created.
|
|
getLocalFunction(func.parent);
|
|
return typeVariableMap[node];
|
|
} else {
|
|
throw new UnsupportedError('Unsupported function type parameter parent '
|
|
'node ${func.parent}.');
|
|
}
|
|
}
|
|
throw new UnsupportedError('Unsupported type parameter type node $node.');
|
|
}
|
|
|
|
ConstructorEntity getConstructorInternal(ir.Member node) {
|
|
return constructorMap[node] ??= _getConstructorCreate(node);
|
|
}
|
|
|
|
ConstructorEntity _getConstructorCreate(ir.Member node) {
|
|
assert(
|
|
!envIsClosed,
|
|
"Environment of $this is closed. Trying to create "
|
|
"constructor for $node.");
|
|
ir.FunctionNode functionNode;
|
|
ClassEntity enclosingClass = getClassInternal(node.enclosingClass);
|
|
Name name = getName(node.name);
|
|
bool isExternal = node.isExternal;
|
|
|
|
IndexedConstructor constructor;
|
|
if (node is ir.Constructor) {
|
|
functionNode = node.function;
|
|
constructor = createGenerativeConstructor(enclosingClass, name,
|
|
getParameterStructure(functionNode, includeTypeParameters: false),
|
|
isExternal: isExternal, isConst: node.isConst);
|
|
} else if (node is ir.Procedure) {
|
|
functionNode = node.function;
|
|
bool isFromEnvironment = isExternal &&
|
|
name.text == 'fromEnvironment' &&
|
|
const ['int', 'bool', 'String'].contains(enclosingClass.name);
|
|
constructor = createFactoryConstructor(enclosingClass, name,
|
|
getParameterStructure(functionNode, includeTypeParameters: false),
|
|
isExternal: isExternal,
|
|
isConst: node.isConst,
|
|
isFromEnvironmentConstructor: isFromEnvironment);
|
|
} else {
|
|
// TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
|
|
throw failedAt(
|
|
NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
|
|
}
|
|
return members.register<IndexedConstructor, KConstructorData>(
|
|
constructor, new KConstructorDataImpl(node, functionNode));
|
|
}
|
|
|
|
FunctionEntity getMethodInternal(ir.Procedure node) {
|
|
// [_getMethodCreate] inserts the created function in [methodMap] so we
|
|
// don't need to use ??= here.
|
|
return methodMap[node] ?? _getMethodCreate(node);
|
|
}
|
|
|
|
FunctionEntity _getMethodCreate(ir.Procedure node) {
|
|
assert(
|
|
!envIsClosed,
|
|
"Environment of $this is closed. Trying to create "
|
|
"function for $node.");
|
|
FunctionEntity function;
|
|
LibraryEntity library;
|
|
ClassEntity enclosingClass;
|
|
if (node.enclosingClass != null) {
|
|
enclosingClass = getClassInternal(node.enclosingClass);
|
|
library = enclosingClass.library;
|
|
} else {
|
|
library = getLibraryInternal(node.enclosingLibrary);
|
|
}
|
|
Name name = getName(node.name);
|
|
bool isStatic = node.isStatic;
|
|
bool isExternal = node.isExternal;
|
|
// TODO(johnniwinther): Remove `&& !node.isExternal` when #31233 is fixed.
|
|
bool isAbstract = node.isAbstract && !node.isExternal;
|
|
AsyncMarker asyncMarker = getAsyncMarker(node.function);
|
|
switch (node.kind) {
|
|
case ir.ProcedureKind.Factory:
|
|
throw new UnsupportedError("Cannot create method from factory.");
|
|
case ir.ProcedureKind.Getter:
|
|
function = createGetter(library, enclosingClass, name, asyncMarker,
|
|
isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
|
|
break;
|
|
case ir.ProcedureKind.Method:
|
|
case ir.ProcedureKind.Operator:
|
|
function = createMethod(library, enclosingClass, name,
|
|
getParameterStructure(node.function), asyncMarker,
|
|
isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
|
|
break;
|
|
case ir.ProcedureKind.Setter:
|
|
assert(asyncMarker == AsyncMarker.SYNC);
|
|
function = createSetter(library, enclosingClass, name.setter,
|
|
isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
|
|
break;
|
|
}
|
|
members.register<IndexedFunction, KFunctionData>(
|
|
function, new KFunctionDataImpl(node, node.function));
|
|
// We need to register the function before creating the type variables.
|
|
methodMap[node] = function;
|
|
for (ir.TypeParameter typeParameter in node.function.typeParameters) {
|
|
getTypeVariable(typeParameter);
|
|
}
|
|
return function;
|
|
}
|
|
|
|
FieldEntity getFieldInternal(ir.Field node) {
|
|
return fieldMap[node] ??= _getFieldCreate(node);
|
|
}
|
|
|
|
FieldEntity _getFieldCreate(ir.Field node) {
|
|
assert(
|
|
!envIsClosed,
|
|
"Environment of $this is closed. Trying to create "
|
|
"field for $node.");
|
|
LibraryEntity library;
|
|
ClassEntity enclosingClass;
|
|
if (node.enclosingClass != null) {
|
|
enclosingClass = getClassInternal(node.enclosingClass);
|
|
library = enclosingClass.library;
|
|
} else {
|
|
library = getLibraryInternal(node.enclosingLibrary);
|
|
}
|
|
Name name = getName(node.name);
|
|
bool isStatic = node.isStatic;
|
|
IndexedField field = createField(library, enclosingClass, name,
|
|
isStatic: isStatic,
|
|
isAssignable: node.isMutable,
|
|
isConst: node.isConst);
|
|
return members.register<IndexedField, KFieldData>(
|
|
field, new KFieldDataImpl(node));
|
|
}
|
|
|
|
bool checkFamily(Entity entity) {
|
|
assert(
|
|
'$entity'.startsWith(kElementPrefix),
|
|
failedAt(entity,
|
|
"Unexpected entity $entity, expected family $kElementPrefix."));
|
|
return true;
|
|
}
|
|
|
|
/// NativeBasicData is need for computation of the default super class.
|
|
NativeBasicData get nativeBasicData => _frontendStrategy.nativeBasicData;
|
|
|
|
/// Adds libraries in [component] to the set of libraries.
|
|
///
|
|
/// The main method of the first component is used as the main method for the
|
|
/// compilation.
|
|
void addComponent(ir.Component component) {
|
|
env.addComponent(component);
|
|
}
|
|
|
|
BehaviorBuilder get nativeBehaviorBuilder =>
|
|
_nativeBehaviorBuilder ??= new KernelBehaviorBuilder(elementEnvironment,
|
|
commonElements, nativeBasicData, reporter, options);
|
|
|
|
ResolutionImpact computeWorldImpact(
|
|
KMember member, VariableScopeModel variableScopeModel) {
|
|
ir.Member node = members.getData(member).node;
|
|
KernelImpactBuilder builder = new KernelImpactBuilder(
|
|
this, member, reporter, options, variableScopeModel);
|
|
node.accept(builder);
|
|
if (retainDataForTesting) {
|
|
staticTypeCacheForTesting ??= {};
|
|
staticTypeCacheForTesting[member] = builder.staticTypeCacheForTesting;
|
|
}
|
|
return builder.impactBuilder;
|
|
}
|
|
|
|
ScopeModel computeScopeModel(KMember member) {
|
|
ir.Member node = members.getData(member).node;
|
|
return ScopeModel.computeScopeModel(node);
|
|
}
|
|
|
|
/// Returns the kernel [ir.Procedure] node for the [method].
|
|
ir.Procedure _lookupProcedure(KFunction method) {
|
|
return members.getData(method).node;
|
|
}
|
|
|
|
@override
|
|
ir.Library getLibraryNode(LibraryEntity library) {
|
|
return libraries.getData(library).library;
|
|
}
|
|
|
|
@override
|
|
Local getLocalFunction(ir.TreeNode node) {
|
|
assert(
|
|
node is ir.FunctionDeclaration || node is ir.FunctionExpression,
|
|
failedAt(
|
|
CURRENT_ELEMENT_SPANNABLE, 'Invalid local function node: $node'));
|
|
KLocalFunction localFunction = localFunctionMap[node];
|
|
if (localFunction == null) {
|
|
MemberEntity memberContext;
|
|
Entity executableContext;
|
|
ir.TreeNode parent = node.parent;
|
|
while (parent != null) {
|
|
if (parent is ir.Member) {
|
|
executableContext = memberContext = getMember(parent);
|
|
break;
|
|
}
|
|
if (parent is ir.FunctionDeclaration ||
|
|
parent is ir.FunctionExpression) {
|
|
KLocalFunction localFunction = getLocalFunction(parent);
|
|
executableContext = localFunction;
|
|
memberContext = localFunction.memberContext;
|
|
break;
|
|
}
|
|
parent = parent.parent;
|
|
}
|
|
String name;
|
|
ir.FunctionNode function;
|
|
if (node is ir.FunctionDeclaration) {
|
|
name = node.variable.name;
|
|
function = node.function;
|
|
} else if (node is ir.FunctionExpression) {
|
|
function = node.function;
|
|
}
|
|
localFunction = localFunctionMap[node] =
|
|
new KLocalFunction(name, memberContext, executableContext, node);
|
|
int index = 0;
|
|
List<KLocalTypeVariable> typeVariables = <KLocalTypeVariable>[];
|
|
for (ir.TypeParameter typeParameter in function.typeParameters) {
|
|
typeVariables.add(typeVariableMap[typeParameter] =
|
|
new KLocalTypeVariable(localFunction, typeParameter.name, index));
|
|
index++;
|
|
}
|
|
index = 0;
|
|
for (ir.TypeParameter typeParameter in function.typeParameters) {
|
|
typeVariables[index].bound = getDartType(typeParameter.bound);
|
|
typeVariables[index].defaultType =
|
|
getDartType(typeParameter.defaultType);
|
|
index++;
|
|
}
|
|
localFunction.functionType = getFunctionType(function);
|
|
}
|
|
return localFunction;
|
|
}
|
|
|
|
bool _implementsFunction(IndexedClass cls) {
|
|
assert(checkFamily(cls));
|
|
KClassData data = classes.getData(cls);
|
|
OrderedTypeSet orderedTypeSet = data.orderedTypeSet;
|
|
InterfaceType supertype = orderedTypeSet.asInstanceOf(
|
|
commonElements.functionClass,
|
|
getHierarchyDepth(commonElements.functionClass));
|
|
if (supertype != null) {
|
|
return true;
|
|
}
|
|
return data.callType is FunctionType;
|
|
}
|
|
|
|
@override
|
|
ir.Typedef getTypedefNode(TypedefEntity typedef) {
|
|
return _getTypedefNode(typedef);
|
|
}
|
|
|
|
/// Returns the element type of a async/sync*/async* function.
|
|
@override
|
|
DartType getFunctionAsyncOrSyncStarElementType(ir.FunctionNode functionNode) {
|
|
DartType returnType = getDartType(functionNode.returnType);
|
|
switch (functionNode.asyncMarker) {
|
|
case ir.AsyncMarker.SyncStar:
|
|
return elementEnvironment.getAsyncOrSyncStarElementType(
|
|
AsyncMarker.SYNC_STAR, returnType);
|
|
case ir.AsyncMarker.Async:
|
|
return elementEnvironment.getAsyncOrSyncStarElementType(
|
|
AsyncMarker.ASYNC, returnType);
|
|
case ir.AsyncMarker.AsyncStar:
|
|
return elementEnvironment.getAsyncOrSyncStarElementType(
|
|
AsyncMarker.ASYNC_STAR, returnType);
|
|
default:
|
|
failedAt(CURRENT_ELEMENT_SPANNABLE,
|
|
"Unexpected ir.AsyncMarker: ${functionNode.asyncMarker}");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// Returns `true` is [node] has a `@Native(...)` annotation.
|
|
// TODO(johnniwinther): Cache this for later use.
|
|
bool isNativeClass(ir.Class node) {
|
|
for (ir.Expression annotation in node.annotations) {
|
|
if (annotation is ir.ConstructorInvocation) {
|
|
FunctionEntity target = getConstructor(annotation.target);
|
|
if (target.enclosingClass == commonElements.nativeAnnotationClass) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Compute the kind of foreign helper function called by [node], if any.
|
|
ForeignKind getForeignKind(ir.StaticInvocation node) {
|
|
if (commonElements.isForeignHelper(getMember(node.target))) {
|
|
switch (node.target.name.name) {
|
|
case JavaScriptBackend.JS:
|
|
return ForeignKind.JS;
|
|
case JavaScriptBackend.JS_BUILTIN:
|
|
return ForeignKind.JS_BUILTIN;
|
|
case JavaScriptBackend.JS_EMBEDDED_GLOBAL:
|
|
return ForeignKind.JS_EMBEDDED_GLOBAL;
|
|
case JavaScriptBackend.JS_INTERCEPTOR_CONSTANT:
|
|
return ForeignKind.JS_INTERCEPTOR_CONSTANT;
|
|
}
|
|
}
|
|
return ForeignKind.NONE;
|
|
}
|
|
|
|
/// Computes the [InterfaceType] referenced by a call to the
|
|
/// [JS_INTERCEPTOR_CONSTANT] function, if any.
|
|
InterfaceType getInterfaceTypeForJsInterceptorCall(ir.StaticInvocation node) {
|
|
if (node.arguments.positional.length != 1 ||
|
|
node.arguments.named.isNotEmpty) {
|
|
reporter.reportErrorMessage(CURRENT_ELEMENT_SPANNABLE,
|
|
MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
|
|
}
|
|
ir.Node argument = node.arguments.positional.first;
|
|
if (argument is ir.TypeLiteral && argument.type is ir.InterfaceType) {
|
|
return getInterfaceType(argument.type);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// Computes the native behavior for reading the native [field].
|
|
// TODO(johnniwinther): Cache this for later use.
|
|
NativeBehavior getNativeBehaviorForFieldLoad(ir.Field field,
|
|
{bool isJsInterop}) {
|
|
DartType type = getDartType(field.type);
|
|
List<ConstantValue> metadata = getMetadata(field.annotations);
|
|
return nativeBehaviorBuilder.buildFieldLoadBehavior(
|
|
type, metadata, typeLookup(resolveAsRaw: false),
|
|
isJsInterop: isJsInterop);
|
|
}
|
|
|
|
/// Computes the native behavior for writing to the native [field].
|
|
// TODO(johnniwinther): Cache this for later use.
|
|
NativeBehavior getNativeBehaviorForFieldStore(ir.Field field) {
|
|
DartType type = getDartType(field.type);
|
|
return nativeBehaviorBuilder.buildFieldStoreBehavior(type);
|
|
}
|
|
|
|
/// Computes the native behavior for calling [member].
|
|
// TODO(johnniwinther): Cache this for later use.
|
|
NativeBehavior getNativeBehaviorForMethod(ir.Member member,
|
|
{bool isJsInterop}) {
|
|
DartType type;
|
|
if (member is ir.Procedure) {
|
|
type = getFunctionType(member.function);
|
|
} else if (member is ir.Constructor) {
|
|
type = getFunctionType(member.function);
|
|
} else {
|
|
failedAt(CURRENT_ELEMENT_SPANNABLE, "Unexpected method node $member.");
|
|
}
|
|
List<ConstantValue> metadata = getMetadata(member.annotations);
|
|
return nativeBehaviorBuilder.buildMethodBehavior(
|
|
type, metadata, typeLookup(resolveAsRaw: false),
|
|
isJsInterop: isJsInterop);
|
|
}
|
|
|
|
IndexedLibrary createLibrary(String name, Uri canonicalUri) {
|
|
return new KLibrary(name, canonicalUri);
|
|
}
|
|
|
|
IndexedClass createClass(LibraryEntity library, String name,
|
|
{bool isAbstract}) {
|
|
return new KClass(library, name, isAbstract: isAbstract);
|
|
}
|
|
|
|
IndexedTypedef createTypedef(LibraryEntity library, String name) {
|
|
return new KTypedef(library, name);
|
|
}
|
|
|
|
TypeVariableEntity createTypeVariable(
|
|
Entity typeDeclaration, String name, int index) {
|
|
return new KTypeVariable(typeDeclaration, name, index);
|
|
}
|
|
|
|
IndexedConstructor createGenerativeConstructor(ClassEntity enclosingClass,
|
|
Name name, ParameterStructure parameterStructure,
|
|
{bool isExternal, bool isConst}) {
|
|
return new KGenerativeConstructor(enclosingClass, name, parameterStructure,
|
|
isExternal: isExternal, isConst: isConst);
|
|
}
|
|
|
|
IndexedConstructor createFactoryConstructor(ClassEntity enclosingClass,
|
|
Name name, ParameterStructure parameterStructure,
|
|
{bool isExternal, bool isConst, bool isFromEnvironmentConstructor}) {
|
|
return new KFactoryConstructor(enclosingClass, name, parameterStructure,
|
|
isExternal: isExternal,
|
|
isConst: isConst,
|
|
isFromEnvironmentConstructor: isFromEnvironmentConstructor);
|
|
}
|
|
|
|
IndexedFunction createGetter(LibraryEntity library,
|
|
ClassEntity enclosingClass, Name name, AsyncMarker asyncMarker,
|
|
{bool isStatic, bool isExternal, bool isAbstract}) {
|
|
return new KGetter(library, enclosingClass, name, asyncMarker,
|
|
isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
|
|
}
|
|
|
|
IndexedFunction createMethod(
|
|
LibraryEntity library,
|
|
ClassEntity enclosingClass,
|
|
Name name,
|
|
ParameterStructure parameterStructure,
|
|
AsyncMarker asyncMarker,
|
|
{bool isStatic,
|
|
bool isExternal,
|
|
bool isAbstract}) {
|
|
return new KMethod(
|
|
library, enclosingClass, name, parameterStructure, asyncMarker,
|
|
isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
|
|
}
|
|
|
|
IndexedFunction createSetter(
|
|
LibraryEntity library, ClassEntity enclosingClass, Name name,
|
|
{bool isStatic, bool isExternal, bool isAbstract}) {
|
|
return new KSetter(library, enclosingClass, name,
|
|
isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
|
|
}
|
|
|
|
IndexedField createField(
|
|
LibraryEntity library, ClassEntity enclosingClass, Name name,
|
|
{bool isStatic, bool isAssignable, bool isConst}) {
|
|
return new KField(library, enclosingClass, name,
|
|
isStatic: isStatic, isAssignable: isAssignable, isConst: isConst);
|
|
}
|
|
}
|
|
|
|
class KernelElementEnvironment extends ElementEnvironment
|
|
implements KElementEnvironment {
|
|
final KernelToElementMapImpl elementMap;
|
|
|
|
KernelElementEnvironment(this.elementMap);
|
|
|
|
@override
|
|
DartType get dynamicType => const DynamicType();
|
|
|
|
@override
|
|
LibraryEntity get mainLibrary => elementMap._mainLibrary;
|
|
|
|
@override
|
|
FunctionEntity get mainFunction => elementMap._mainFunction;
|
|
|
|
@override
|
|
Iterable<LibraryEntity> get libraries => elementMap.libraryListInternal;
|
|
|
|
@override
|
|
String getLibraryName(LibraryEntity library) {
|
|
return elementMap._getLibraryName(library);
|
|
}
|
|
|
|
@override
|
|
InterfaceType getThisType(ClassEntity cls) {
|
|
return elementMap.getThisType(cls);
|
|
}
|
|
|
|
@override
|
|
InterfaceType getRawType(ClassEntity cls) {
|
|
return elementMap._getRawType(cls);
|
|
}
|
|
|
|
@override
|
|
bool isGenericClass(ClassEntity cls) {
|
|
return getThisType(cls).typeArguments.isNotEmpty;
|
|
}
|
|
|
|
@override
|
|
bool isMixinApplication(ClassEntity cls) {
|
|
return elementMap._isMixinApplication(cls);
|
|
}
|
|
|
|
@override
|
|
bool isUnnamedMixinApplication(ClassEntity cls) {
|
|
return elementMap._isUnnamedMixinApplication(cls);
|
|
}
|
|
|
|
@override
|
|
DartType getTypeVariableBound(TypeVariableEntity typeVariable) {
|
|
if (typeVariable is KLocalTypeVariable) return typeVariable.bound;
|
|
return elementMap.getTypeVariableBound(typeVariable);
|
|
}
|
|
|
|
@override
|
|
InterfaceType createInterfaceType(
|
|
ClassEntity cls, List<DartType> typeArguments) {
|
|
return new InterfaceType(cls, typeArguments);
|
|
}
|
|
|
|
@override
|
|
FunctionType getFunctionType(FunctionEntity function) {
|
|
return elementMap._getFunctionType(function);
|
|
}
|
|
|
|
@override
|
|
List<TypeVariableType> getFunctionTypeVariables(FunctionEntity function) {
|
|
return elementMap._getFunctionTypeVariables(function);
|
|
}
|
|
|
|
@override
|
|
DartType getFunctionAsyncOrSyncStarElementType(FunctionEntity function) {
|
|
// TODO(sra): Should be getting the DartType from the node.
|
|
DartType returnType = getFunctionType(function).returnType;
|
|
return getAsyncOrSyncStarElementType(function.asyncMarker, returnType);
|
|
}
|
|
|
|
@override
|
|
DartType getAsyncOrSyncStarElementType(
|
|
AsyncMarker asyncMarker, DartType returnType) {
|
|
switch (asyncMarker) {
|
|
case AsyncMarker.SYNC:
|
|
return returnType;
|
|
case AsyncMarker.SYNC_STAR:
|
|
if (returnType is InterfaceType) {
|
|
if (returnType.element == elementMap.commonElements.iterableClass) {
|
|
return returnType.typeArguments.first;
|
|
}
|
|
}
|
|
return dynamicType;
|
|
case AsyncMarker.ASYNC:
|
|
if (returnType is FutureOrType) return returnType.typeArgument;
|
|
if (returnType is InterfaceType) {
|
|
if (returnType.element == elementMap.commonElements.futureClass) {
|
|
return returnType.typeArguments.first;
|
|
}
|
|
}
|
|
return dynamicType;
|
|
case AsyncMarker.ASYNC_STAR:
|
|
if (returnType is InterfaceType) {
|
|
if (returnType.element == elementMap.commonElements.streamClass) {
|
|
return returnType.typeArguments.first;
|
|
}
|
|
}
|
|
return dynamicType;
|
|
}
|
|
assert(false, 'Unexpected marker ${asyncMarker}');
|
|
return null;
|
|
}
|
|
|
|
@override
|
|
DartType getFieldType(FieldEntity field) {
|
|
return elementMap._getFieldType(field);
|
|
}
|
|
|
|
@override
|
|
FunctionType getLocalFunctionType(covariant KLocalFunction function) {
|
|
return function.functionType;
|
|
}
|
|
|
|
@override
|
|
ConstantExpression getFieldConstantForTesting(FieldEntity field) {
|
|
return elementMap._getFieldConstantExpression(field);
|
|
}
|
|
|
|
@override
|
|
DartType getUnaliasedType(DartType type) => type;
|
|
|
|
@override
|
|
ConstructorEntity lookupConstructor(ClassEntity cls, String name,
|
|
{bool required: false}) {
|
|
ConstructorEntity constructor = elementMap.lookupConstructor(cls, name);
|
|
if (constructor == null && required) {
|
|
throw failedAt(
|
|
CURRENT_ELEMENT_SPANNABLE,
|
|
"The constructor '$name' was not found in class '${cls.name}' "
|
|
"in library ${cls.library.canonicalUri}.");
|
|
}
|
|
return constructor;
|
|
}
|
|
|
|
@override
|
|
MemberEntity lookupLocalClassMember(ClassEntity cls, String name,
|
|
{bool setter: false, bool required: false}) {
|
|
MemberEntity member =
|
|
elementMap.lookupClassMember(cls, name, setter: setter);
|
|
if (member == null && required) {
|
|
throw failedAt(CURRENT_ELEMENT_SPANNABLE,
|
|
"The member '$name' was not found in ${cls.name}.");
|
|
}
|
|
return member;
|
|
}
|
|
|
|
@override
|
|
ClassEntity getSuperClass(ClassEntity cls,
|
|
{bool skipUnnamedMixinApplications: false}) {
|
|
assert(elementMap.checkFamily(cls));
|
|
ClassEntity superclass = elementMap.getSuperType(cls)?.element;
|
|
if (skipUnnamedMixinApplications) {
|
|
while (superclass != null &&
|
|
elementMap._isUnnamedMixinApplication(superclass)) {
|
|
superclass = elementMap.getSuperType(superclass)?.element;
|
|
}
|
|
}
|
|
return superclass;
|
|
}
|
|
|
|
@override
|
|
void forEachSupertype(ClassEntity cls, void f(InterfaceType supertype)) {
|
|
elementMap._forEachSupertype(cls, f);
|
|
}
|
|
|
|
@override
|
|
void forEachMixin(ClassEntity cls, void f(ClassEntity mixin)) {
|
|
elementMap._forEachMixin(cls, f);
|
|
}
|
|
|
|
@override
|
|
void forEachLocalClassMember(ClassEntity cls, void f(MemberEntity member)) {
|
|
elementMap._forEachLocalClassMember(cls, f);
|
|
}
|
|
|
|
@override
|
|
void forEachClassMember(
|
|
ClassEntity cls, void f(ClassEntity declarer, MemberEntity member)) {
|
|
elementMap._forEachClassMember(cls, f);
|
|
}
|
|
|
|
@override
|
|
void forEachConstructor(
|
|
ClassEntity cls, void f(ConstructorEntity constructor)) {
|
|
elementMap._forEachConstructor(cls, f);
|
|
}
|
|
|
|
@override
|
|
void forEachLibraryMember(
|
|
LibraryEntity library, void f(MemberEntity member)) {
|
|
elementMap._forEachLibraryMember(library, f);
|
|
}
|
|
|
|
@override
|
|
MemberEntity lookupLibraryMember(LibraryEntity library, String name,
|
|
{bool setter: false, bool required: false}) {
|
|
MemberEntity member =
|
|
elementMap.lookupLibraryMember(library, name, setter: setter);
|
|
if (member == null && required) {
|
|
failedAt(CURRENT_ELEMENT_SPANNABLE,
|
|
"The member '${name}' was not found in library '${library.name}'.");
|
|
}
|
|
return member;
|
|
}
|
|
|
|
@override
|
|
ClassEntity lookupClass(LibraryEntity library, String name,
|
|
{bool required: false}) {
|
|
ClassEntity cls = elementMap.lookupClass(library, name);
|
|
if (cls == null && required) {
|
|
failedAt(CURRENT_ELEMENT_SPANNABLE,
|
|
"The class '$name' was not found in library '${library.name}'.");
|
|
}
|
|
return cls;
|
|
}
|
|
|
|
@override
|
|
void forEachClass(LibraryEntity library, void f(ClassEntity cls)) {
|
|
elementMap._forEachClass(library, f);
|
|
}
|
|
|
|
@override
|
|
LibraryEntity lookupLibrary(Uri uri, {bool required: false}) {
|
|
LibraryEntity library = elementMap.lookupLibrary(uri);
|
|
if (library == null && required) {
|
|
failedAt(CURRENT_ELEMENT_SPANNABLE, "The library '$uri' was not found.");
|
|
}
|
|
return library;
|
|
}
|
|
|
|
@override
|
|
bool isDeferredLoadLibraryGetter(MemberEntity member) {
|
|
// The front-end generates the getter of loadLibrary explicitly as code
|
|
// so there is no implicit representation based on a "loadLibrary" member.
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
Iterable<ConstantValue> getLibraryMetadata(covariant IndexedLibrary library) {
|
|
assert(elementMap.checkFamily(library));
|
|
KLibraryData libraryData = elementMap.libraries.getData(library);
|
|
return libraryData.getMetadata(elementMap);
|
|
}
|
|
|
|
@override
|
|
Iterable<ImportEntity> getImports(covariant IndexedLibrary library) {
|
|
assert(elementMap.checkFamily(library));
|
|
KLibraryData libraryData = elementMap.libraries.getData(library);
|
|
return libraryData.getImports(elementMap);
|
|
}
|
|
|
|
@override
|
|
Iterable<ConstantValue> getClassMetadata(covariant IndexedClass cls) {
|
|
assert(elementMap.checkFamily(cls));
|
|
KClassData classData = elementMap.classes.getData(cls);
|
|
return classData.getMetadata(elementMap);
|
|
}
|
|
|
|
@override
|
|
Iterable<ConstantValue> getMemberMetadata(covariant IndexedMember member,
|
|
{bool includeParameterMetadata: false}) {
|
|
// TODO(redemption): Support includeParameterMetadata.
|
|
assert(elementMap.checkFamily(member));
|
|
KMemberData memberData = elementMap.members.getData(member);
|
|
return memberData.getMetadata(elementMap);
|
|
}
|
|
|
|
@override
|
|
bool isEnumClass(ClassEntity cls) {
|
|
assert(elementMap.checkFamily(cls));
|
|
KClassData classData = elementMap.classes.getData(cls);
|
|
return classData.isEnumClass;
|
|
}
|
|
}
|
|
|
|
/// [BehaviorBuilder] for kernel based elements.
|
|
class KernelBehaviorBuilder extends BehaviorBuilder {
|
|
final ElementEnvironment elementEnvironment;
|
|
final CommonElements commonElements;
|
|
final DiagnosticReporter reporter;
|
|
final NativeBasicData nativeBasicData;
|
|
final CompilerOptions _options;
|
|
|
|
KernelBehaviorBuilder(this.elementEnvironment, this.commonElements,
|
|
this.nativeBasicData, this.reporter, this._options);
|
|
|
|
@override
|
|
bool get trustJSInteropTypeAnnotations =>
|
|
_options.trustJSInteropTypeAnnotations;
|
|
}
|
|
|
|
/// Constant environment mapping [ConstantExpression]s to [ConstantValue]s using
|
|
/// [_EvaluationEnvironment] for the evaluation.
|
|
class KernelConstantEnvironment implements ConstantEnvironment {
|
|
final KernelToElementMapImpl _elementMap;
|
|
final Environment _environment;
|
|
|
|
Map<ConstantExpression, ConstantValue> _valueMap =
|
|
<ConstantExpression, ConstantValue>{};
|
|
|
|
KernelConstantEnvironment(this._elementMap, this._environment);
|
|
|
|
@override
|
|
ConstantSystem get constantSystem => JavaScriptConstantSystem.only;
|
|
|
|
ConstantValue _getConstantValue(
|
|
Spannable spannable, ConstantExpression expression,
|
|
{bool constantRequired, bool checkCasts: true}) {
|
|
return _valueMap.putIfAbsent(expression, () {
|
|
return expression.evaluate(
|
|
new KernelEvaluationEnvironment(_elementMap, _environment, spannable,
|
|
constantRequired: constantRequired, checkCasts: checkCasts),
|
|
constantSystem);
|
|
});
|
|
}
|
|
}
|
|
|
|
/// Evaluation environment used for computing [ConstantValue]s for
|
|
/// kernel based [ConstantExpression]s.
|
|
class KernelEvaluationEnvironment extends EvaluationEnvironmentBase {
|
|
final KernelToElementMapImpl _elementMap;
|
|
final Environment _environment;
|
|
final bool checkCasts;
|
|
|
|
KernelEvaluationEnvironment(
|
|
this._elementMap, this._environment, Spannable spannable,
|
|
{bool constantRequired, this.checkCasts: true})
|
|
: super(spannable, constantRequired: constantRequired);
|
|
|
|
@override
|
|
CommonElements get commonElements => _elementMap.commonElements;
|
|
|
|
@override
|
|
DartTypes get types => _elementMap.types;
|
|
|
|
@override
|
|
DartType substByContext(DartType base, InterfaceType target) {
|
|
return _elementMap.substByContext(base, target);
|
|
}
|
|
|
|
@override
|
|
ConstantConstructor getConstructorConstant(ConstructorEntity constructor) {
|
|
return _elementMap._getConstructorConstant(constructor);
|
|
}
|
|
|
|
@override
|
|
ConstantExpression getFieldConstant(FieldEntity field) {
|
|
return _elementMap._getFieldConstantExpression(field);
|
|
}
|
|
|
|
@override
|
|
ConstantExpression getLocalConstant(Local local) {
|
|
throw new UnimplementedError("_EvaluationEnvironment.getLocalConstant");
|
|
}
|
|
|
|
@override
|
|
String readFromEnvironment(String name) {
|
|
return _environment.valueOf(name);
|
|
}
|
|
|
|
@override
|
|
DiagnosticReporter get reporter => _elementMap.reporter;
|
|
|
|
@override
|
|
bool get enableAssertions => _elementMap.options.enableUserAssertions;
|
|
}
|
|
|
|
class KernelNativeMemberResolver extends NativeMemberResolverBase {
|
|
final KernelToElementMap elementMap;
|
|
final NativeBasicData nativeBasicData;
|
|
final NativeDataBuilder nativeDataBuilder;
|
|
|
|
KernelNativeMemberResolver(
|
|
this.elementMap, this.nativeBasicData, this.nativeDataBuilder);
|
|
|
|
@override
|
|
KElementEnvironment get elementEnvironment => elementMap.elementEnvironment;
|
|
|
|
@override
|
|
CommonElements get commonElements => elementMap.commonElements;
|
|
|
|
@override
|
|
NativeBehavior computeNativeFieldStoreBehavior(covariant KField field) {
|
|
ir.Field node = elementMap.getMemberNode(field);
|
|
return elementMap.getNativeBehaviorForFieldStore(node);
|
|
}
|
|
|
|
@override
|
|
NativeBehavior computeNativeFieldLoadBehavior(covariant KField field,
|
|
{bool isJsInterop}) {
|
|
ir.Field node = elementMap.getMemberNode(field);
|
|
return elementMap.getNativeBehaviorForFieldLoad(node,
|
|
isJsInterop: isJsInterop);
|
|
}
|
|
|
|
@override
|
|
NativeBehavior computeNativeMethodBehavior(covariant KFunction function,
|
|
{bool isJsInterop}) {
|
|
ir.Member node = elementMap.getMemberNode(function);
|
|
return elementMap.getNativeBehaviorForMethod(node,
|
|
isJsInterop: isJsInterop);
|
|
}
|
|
|
|
@override
|
|
bool isNativeMethod(covariant KFunction function) {
|
|
if (!maybeEnableNative(function.library.canonicalUri)) return false;
|
|
ir.Member node = elementMap.getMemberNode(function);
|
|
return node.annotations.any((ir.Expression expression) {
|
|
return expression is ir.ConstructorInvocation &&
|
|
elementMap.getInterfaceType(expression.constructedType) ==
|
|
commonElements.externalNameType;
|
|
});
|
|
}
|
|
|
|
@override
|
|
bool isJsInteropMember(MemberEntity element) {
|
|
return nativeBasicData.isJsInteropMember(element);
|
|
}
|
|
}
|
|
|
|
class KernelClassQueries extends ClassQueries {
|
|
final KernelToElementMapImpl elementMap;
|
|
|
|
KernelClassQueries(this.elementMap);
|
|
|
|
@override
|
|
ClassEntity getDeclaration(ClassEntity cls) {
|
|
return cls;
|
|
}
|
|
|
|
@override
|
|
Iterable<InterfaceType> getSupertypes(ClassEntity cls) {
|
|
return elementMap.getOrderedTypeSet(cls).supertypes;
|
|
}
|
|
|
|
@override
|
|
ClassEntity getSuperClass(ClassEntity cls) {
|
|
return elementMap.getSuperType(cls)?.element;
|
|
}
|
|
|
|
@override
|
|
bool implementsFunction(ClassEntity cls) {
|
|
return elementMap._implementsFunction(cls);
|
|
}
|
|
|
|
@override
|
|
int getHierarchyDepth(ClassEntity cls) {
|
|
return elementMap.getHierarchyDepth(cls);
|
|
}
|
|
|
|
@override
|
|
ClassEntity getAppliedMixin(ClassEntity cls) {
|
|
return elementMap.getAppliedMixin(cls);
|
|
}
|
|
}
|