Combine override checks and override-based inference in one phase
Change-Id: I2760f72f4eaa44bd192747179e843f017db30874
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/97301
Commit-Queue: Peter von der Ahé <ahe@google.com>
Reviewed-by: Dmitry Stefantsov <dmitryas@google.com>
diff --git a/pkg/front_end/lib/src/fasta/builder/library_builder.dart b/pkg/front_end/lib/src/fasta/builder/library_builder.dart
index 9dbca65..0276dfc 100644
--- a/pkg/front_end/lib/src/fasta/builder/library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/library_builder.dart
@@ -27,6 +27,7 @@
show
ClassBuilder,
Declaration,
+ FieldBuilder,
ModifierBuilder,
NameIterator,
PrefixBuilder,
@@ -235,6 +236,8 @@
}
void recordAccess(int charOffset, int length, Uri fileUri) {}
+
+ List<FieldBuilder> takeImplicitlyTypedFields() => null;
}
class LibraryLocalDeclarationIterator implements Iterator<Declaration> {
diff --git a/pkg/front_end/lib/src/fasta/builder/member_builder.dart b/pkg/front_end/lib/src/fasta/builder/member_builder.dart
index 827fe5f..6724f15 100644
--- a/pkg/front_end/lib/src/fasta/builder/member_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/member_builder.dart
@@ -4,6 +4,8 @@
library fasta.member_builder;
+import '../problems.dart' show unsupported;
+
import 'builder.dart'
show ClassBuilder, Declaration, LibraryBuilder, ModifierBuilder;
@@ -39,4 +41,10 @@
@override
String get fullNameForErrors => name;
+
+ void inferType() => unsupported("inferType", charOffset, fileUri);
+
+ void inferCopiedType(covariant Object other) {
+ unsupported("inferType", charOffset, fileUri);
+ }
}
diff --git a/pkg/front_end/lib/src/fasta/fasta_codes_generated.dart b/pkg/front_end/lib/src/fasta/fasta_codes_generated.dart
index b26fdac..3939f16 100644
--- a/pkg/front_end/lib/src/fasta/fasta_codes_generated.dart
+++ b/pkg/front_end/lib/src/fasta/fasta_codes_generated.dart
@@ -563,6 +563,36 @@
tip: r"""Try specifying the file explicitly with the --packages option.""");
// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<Message Function(String name)>
+ templateCantInferReturnTypeDueToInconsistentOverrides =
+ const Template<Message Function(String name)>(
+ messageTemplate:
+ r"""Can't infer a return type for '#name' as some of the inherited members have different types.""",
+ tipTemplate: r"""Try adding an explicit type.""",
+ withArguments:
+ _withArgumentsCantInferReturnTypeDueToInconsistentOverrides);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name)>
+ codeCantInferReturnTypeDueToInconsistentOverrides =
+ const Code<Message Function(String name)>(
+ "CantInferReturnTypeDueToInconsistentOverrides",
+ templateCantInferReturnTypeDueToInconsistentOverrides,
+ analyzerCodes: <String>["INVALID_METHOD_OVERRIDE"]);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsCantInferReturnTypeDueToInconsistentOverrides(
+ String name) {
+ if (name.isEmpty) throw 'No name provided';
+ name = demangleMixinApplicationName(name);
+ return new Message(codeCantInferReturnTypeDueToInconsistentOverrides,
+ message:
+ """Can't infer a return type for '${name}' as some of the inherited members have different types.""",
+ tip: """Try adding an explicit type.""",
+ arguments: {'name': name});
+}
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
const Template<
Message Function(
String
@@ -733,6 +763,38 @@
tip: r"""Try replacing the colon with the keyword 'in'.""");
// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+ Message Function(
+ String name,
+ String
+ name2)> templateCombinedMemberSignatureFailed = const Template<
+ Message Function(String name, String name2)>(
+ messageTemplate:
+ r"""Class '#name' inherits multiple members named '#name2' with incompatible signatures.""",
+ tipTemplate: r"""Try adding a declaration of '#name2' to '#name'.""",
+ withArguments: _withArgumentsCombinedMemberSignatureFailed);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name, String name2)>
+ codeCombinedMemberSignatureFailed =
+ const Code<Message Function(String name, String name2)>(
+ "CombinedMemberSignatureFailed", templateCombinedMemberSignatureFailed,
+ analyzerCodes: <String>["INCONSISTENT_INHERITANCE"]);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsCombinedMemberSignatureFailed(String name, String name2) {
+ if (name.isEmpty) throw 'No name provided';
+ name = demangleMixinApplicationName(name);
+ if (name2.isEmpty) throw 'No name provided';
+ name2 = demangleMixinApplicationName(name2);
+ return new Message(codeCombinedMemberSignatureFailed,
+ message:
+ """Class '${name}' inherits multiple members named '${name2}' with incompatible signatures.""",
+ tip: """Try adding a declaration of '${name2}' to '${name}'.""",
+ arguments: {'name': name, 'name2': name2});
+}
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
const Template<Message Function(String name)> templateConflictsWithConstructor =
const Template<Message Function(String name)>(
messageTemplate: r"""Conflicts with constructor '#name'.""",
diff --git a/pkg/front_end/lib/src/fasta/kernel/class_hierarchy_builder.dart b/pkg/front_end/lib/src/fasta/kernel/class_hierarchy_builder.dart
index 2593336..41a9d01 100644
--- a/pkg/front_end/lib/src/fasta/kernel/class_hierarchy_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/class_hierarchy_builder.dart
@@ -8,14 +8,19 @@
show
Class,
DartType,
+ Field,
+ FunctionNode,
InterfaceType,
- TypeParameter,
+ InvalidType,
Library,
Member,
Name,
Procedure,
ProcedureKind,
- Supertype;
+ Supertype,
+ TypeParameter,
+ TypeParameterType,
+ VariableDeclaration;
import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
@@ -23,6 +28,8 @@
import 'package:kernel/type_algebra.dart' show Substitution;
+import '../dill/dill_member_builder.dart' show DillMemberBuilder;
+
import '../loader.dart' show Loader;
import '../messages.dart'
@@ -36,15 +43,23 @@
messageInheritedMembersConflictCause2,
messageStaticAndInstanceConflict,
messageStaticAndInstanceConflictCause,
+ templateCantInferReturnTypeDueToInconsistentOverrides,
+ templateCantInferTypeDueToInconsistentOverrides,
+ templateCombinedMemberSignatureFailed,
templateDuplicatedDeclaration,
templateDuplicatedDeclarationCause,
+ templateDuplicatedDeclarationUse,
templateMissingImplementationCause,
templateMissingImplementationNotAbstract;
import '../names.dart' show noSuchMethodName;
+import '../problems.dart' show unhandled;
+
import '../scope.dart' show Scope;
+import '../source/source_loader.dart' show SourceLoader;
+
import '../type_inference/standard_bounds.dart' show StandardBounds;
import '../type_inference/type_constraint_gatherer.dart'
@@ -56,18 +71,35 @@
import '../type_inference/type_schema_environment.dart' show TypeConstraint;
+import 'forwarding_node.dart' show ForwardingNode;
+
import 'kernel_builder.dart'
show
Declaration,
+ FormalParameterBuilder,
+ ImplicitFieldType,
KernelClassBuilder,
+ KernelFieldBuilder,
+ KernelLibraryBuilder,
KernelNamedTypeBuilder,
+ KernelProcedureBuilder,
KernelTypeBuilder,
+ KernelTypeVariableBuilder,
LibraryBuilder,
+ MemberBuilder,
TypeBuilder,
TypeVariableBuilder;
import 'types.dart' show Types;
+const DebugLogger debug =
+ const bool.fromEnvironment("debug.hierarchy") ? const DebugLogger() : null;
+
+class DebugLogger {
+ const DebugLogger();
+ void log(Object message) => print(message);
+}
+
int compareDeclarations(Declaration a, Declaration b) {
return ClassHierarchy.compareMembers(a.target, b.target);
}
@@ -94,6 +126,7 @@
if (b.isField) return !(a.isField || a.isGetter || a.isSetter);
if (a.isSetter) return !(b.isGetter || b.isSetter);
if (b.isSetter) return !(a.isGetter || a.isSetter);
+ if (a is InterfaceConflict || b is InterfaceConflict) return false;
return true;
}
@@ -101,6 +134,68 @@
return declaration.isField && !(declaration.isFinal || declaration.isConst);
}
+bool hasSameSignature(FunctionNode a, FunctionNode b) {
+ List<TypeParameter> aTypeParameters = a.typeParameters;
+ List<TypeParameter> bTypeParameters = b.typeParameters;
+ int typeParameterCount = aTypeParameters.length;
+ if (typeParameterCount != bTypeParameters.length) return false;
+ Substitution substitution;
+ if (typeParameterCount != 0) {
+ List<DartType> types = new List<DartType>(typeParameterCount);
+ for (int i = 0; i < typeParameterCount; i++) {
+ types[i] = new TypeParameterType(aTypeParameters[i]);
+ }
+ substitution = Substitution.fromPairs(bTypeParameters, types);
+ for (int i = 0; i < typeParameterCount; i++) {
+ DartType aBound = aTypeParameters[i].bound;
+ DartType bBound = substitution.substituteType(bTypeParameters[i].bound);
+ if (aBound != bBound) return false;
+ }
+ }
+
+ if (a.requiredParameterCount != b.requiredParameterCount) return false;
+ List<VariableDeclaration> aPositionalParameters = a.positionalParameters;
+ List<VariableDeclaration> bPositionalParameters = b.positionalParameters;
+ if (aPositionalParameters.length != bPositionalParameters.length) {
+ return false;
+ }
+ for (int i = 0; i < aPositionalParameters.length; i++) {
+ VariableDeclaration aParameter = aPositionalParameters[i];
+ VariableDeclaration bParameter = bPositionalParameters[i];
+ if (aParameter.isCovariant != bParameter.isCovariant) return false;
+ DartType aType = aParameter.type;
+ DartType bType = bParameter.type;
+ if (substitution != null) {
+ bType = substitution.substituteType(bType);
+ }
+ if (aType != bType) return false;
+ }
+
+ List<VariableDeclaration> aNamedParameters = a.namedParameters;
+ List<VariableDeclaration> bNamedParameters = b.namedParameters;
+ if (aNamedParameters.length != bNamedParameters.length) return false;
+ for (int i = 0; i < aNamedParameters.length; i++) {
+ VariableDeclaration aParameter = aNamedParameters[i];
+ VariableDeclaration bParameter = bNamedParameters[i];
+ if (aParameter.isCovariant != bParameter.isCovariant) return false;
+ if (aParameter.name != bParameter.name) return false;
+ DartType aType = aParameter.type;
+ DartType bType = bParameter.type;
+ if (substitution != null) {
+ bType = substitution.substituteType(bType);
+ }
+ if (aType != bType) return false;
+ }
+
+ DartType aReturnType = a.returnType;
+ DartType bReturnType = b.returnType;
+ if (substitution != null) {
+ bReturnType = substitution.substituteType(bReturnType);
+ }
+
+ return aReturnType == bReturnType;
+}
+
class ClassHierarchyBuilder {
final Map<Class, ClassHierarchyNode> nodes = <Class, ClassHierarchyNode>{};
@@ -118,6 +213,10 @@
final Class nullKernelClass;
+ final List<DelayedOverrideCheck> overrideChecks = <DelayedOverrideCheck>[];
+
+ final List<DelayedMember> delayedMemberChecks = <DelayedMember>[];
+
// TODO(ahe): Remove this.
final CoreTypes coreTypes;
@@ -138,10 +237,8 @@
}
ClassHierarchyNode getNodeFromType(KernelTypeBuilder type) {
- Declaration declaration = type.declaration;
- return declaration is KernelClassBuilder
- ? getNodeFromClass(declaration)
- : null;
+ KernelClassBuilder cls = getClass(type);
+ return cls == null ? null : getNodeFromClass(cls);
}
ClassHierarchyNode getNodeFromKernelClass(Class cls) {
@@ -190,7 +287,9 @@
}
KernelNamedTypeBuilder supertype = asSupertypeOf(kernelClass, superclass);
if (supertype == null) return null;
- if (supertype.arguments == null) return superclass.rawType;
+ if (supertype.arguments == null && superclass.typeParameters.isEmpty) {
+ return superclass.rawType;
+ }
return Substitution.fromInterfaceType(type)
.substituteType(supertype.build(null));
}
@@ -232,17 +331,54 @@
return objectKernelClass.rawType;
}
+ Member getInterfaceMemberKernel(Class cls, Name name, bool isSetter) {
+ return getNodeFromKernelClass(cls)
+ .getInterfaceMember(name, isSetter)
+ ?.target;
+ }
+
+ Member getDispatchTargetKernel(Class cls, Name name, bool isSetter) {
+ return getNodeFromKernelClass(cls)
+ .getDispatchTarget(name, isSetter)
+ ?.target;
+ }
+
+ Member getCombinedMemberSignatureKernel(Class cls, Name name, bool isSetter,
+ int charOffset, KernelLibraryBuilder library) {
+ Declaration declaration =
+ getNodeFromKernelClass(cls).getInterfaceMember(name, isSetter);
+ if (declaration?.isStatic ?? true) return null;
+ if (declaration.next != null) {
+ library?.addProblem(
+ templateDuplicatedDeclarationUse.withArguments(name.name),
+ charOffset,
+ name.name.length,
+ library.fileUri);
+ return null;
+ }
+ if (declaration is DelayedMember) {
+ return declaration.check(this);
+ } else {
+ return declaration.target;
+ }
+ }
+
static ClassHierarchyBuilder build(
KernelClassBuilder objectClass,
List<KernelClassBuilder> classes,
- Loader<Object> loader,
+ SourceLoader loader,
CoreTypes coreTypes) {
ClassHierarchyBuilder hierarchy =
new ClassHierarchyBuilder(objectClass, loader, coreTypes);
for (int i = 0; i < classes.length; i++) {
KernelClassBuilder cls = classes[i];
- hierarchy.nodes[cls.target] =
- new ClassHierarchyNodeBuilder(hierarchy, cls).build();
+ if (!cls.isPatch) {
+ hierarchy.nodes[cls.target] =
+ new ClassHierarchyNodeBuilder(hierarchy, cls).build();
+ } else {
+ // TODO(ahe): Merge the injected members of patch into the hierarchy
+ // node of `cls.origin`.
+ }
}
return hierarchy;
}
@@ -261,6 +397,8 @@
KernelClassBuilder get objectClass => hierarchy.objectClass;
+ final Map<Class, Substitution> substitutions = <Class, Substitution>{};
+
/// When merging `aList` and `bList`, [a] (from `aList`) and [b] (from
/// `bList`) each have the same name.
///
@@ -271,44 +409,552 @@
///
/// If [mergeKind] is `MergeKind.supertypes`, [a] should implement [b], and
/// [b] is implicitly abstract.
- Declaration handleMergeConflict(KernelClassBuilder cls, Declaration a,
- Declaration b, MergeKind mergeKind) {
+ Declaration handleMergeConflict(
+ Declaration a, Declaration b, MergeKind mergeKind) {
+ debug?.log(
+ "handleMergeConflict: ${fullName(a)} ${fullName(b)} ${mergeKind}");
+ // TODO(ahe): Enable this optimization, but be careful about abstract
+ // methods overriding concrete methods.
+ // if (cls is DillClassBuilder) return a;
if (a == b) return a;
if (a.next != null || b.next != null) {
// Don't check overrides involving duplicated members.
return a;
}
- if (isInheritanceConflict(a, b)) {
- reportInheritanceConflict(cls, a, b);
- }
- Declaration result = a;
- if (mergeKind == MergeKind.accessors) {
- } else if (mergeKind == MergeKind.interfaces) {
- // TODO(ahe): Combine the signatures of a and b. See the section named
- // "Combined Member Signatures" in [Dart Programming Language
- // Specification](
- // ../../../../../../docs/language/dartLangSpec.tex#combinedMemberSignatures).
- } else if (a.target.isAbstract) {
- if (mergeKind == MergeKind.superclass && !b.target.isAbstract) {
- // An abstract method doesn't override an implemention inherited from a
- // superclass.
- result = b;
- } else {
- (abstractMembers ??= <Declaration>[]).add(a);
- }
- }
+ Declaration result = checkInheritanceConflict(a, b);
+ if (result != null) return result;
+ result = a;
+ switch (mergeKind) {
+ case MergeKind.superclassMembers:
+ case MergeKind.superclassSetters:
+ // [a] is a method declared in [cls]. This means it defines the
+ // interface of this class regardless if its abstract.
+ debug?.log(
+ "superclass: checkValidOverride(${cls.fullNameForErrors}, ${fullName(a)}, ${fullName(b)})");
+ checkValidOverride(
+ a, AbstractMemberOverridingImplementation.selectAbstract(b));
- if (mergeKind == MergeKind.superclass &&
- result.fullNameForErrors == noSuchMethodName.name &&
- result.parent != objectClass) {
- hasNoSuchMethod = true;
+ if (isAbstract(a)) {
+ if (isAbstract(b)) {
+ recordAbstractMember(a);
+ } else {
+ if (!cls.isAbstract) {
+ // The interface of this class is [a]. But the implementation is
+ // [b]. So [b] must implement [a], unless [cls] is abstract.
+ checkValidOverride(b, a);
+ }
+ result = new AbstractMemberOverridingImplementation(
+ cls,
+ a,
+ AbstractMemberOverridingImplementation.selectConcrete(b),
+ mergeKind == MergeKind.superclassSetters);
+ hierarchy.delayedMemberChecks.add(result);
+ }
+ }
+
+ Member target = result.target;
+ if (target.enclosingClass != objectClass.cls &&
+ target.name == noSuchMethodName) {
+ hasNoSuchMethod = true;
+ }
+ break;
+
+ case MergeKind.membersWithSetters:
+ case MergeKind.settersWithMembers:
+ if (a.parent == cls && b.parent != cls) {
+ if (a is KernelFieldBuilder) {
+ if (a.isFinal && b.isSetter) {
+ hierarchy.overrideChecks.add(new DelayedOverrideCheck(cls, a, b));
+ } else {
+ if (!inferFieldTypes(a, b)) {
+ hierarchy.overrideChecks
+ .add(new DelayedOverrideCheck(cls, a, b));
+ }
+ }
+ } else if (a is KernelProcedureBuilder) {
+ if (!inferMethodTypes(a, b)) {
+ hierarchy.overrideChecks.add(new DelayedOverrideCheck(cls, a, b));
+ }
+ }
+ }
+ break;
+
+ case MergeKind.interfacesMembers:
+ result = InterfaceConflict.combined(cls, a, b, false);
+ break;
+
+ case MergeKind.interfacesSetters:
+ result = InterfaceConflict.combined(cls, a, b, true);
+ break;
+
+ case MergeKind.supertypesMembers:
+ case MergeKind.supertypesSetters:
+ // [b] is inherited from an interface so it is implicitly abstract.
+
+ a = AbstractMemberOverridingImplementation.selectAbstract(a);
+ b = AbstractMemberOverridingImplementation.selectAbstract(b);
+
+ // If [a] is declared in this class, it defines the interface.
+ if (a.parent == cls) {
+ debug?.log(
+ "supertypes: checkValidOverride(${cls.fullNameForErrors}, ${fullName(a)}, ${fullName(b)})");
+ checkValidOverride(a, b);
+ } else {
+ if (isAbstract(a)) {
+ result = InterfaceConflict.combined(
+ cls, a, b, mergeKind == MergeKind.supertypesSetters);
+ } else {
+ result = InheritedImplementationInterfaceConflict.combined(
+ cls, a, b, mergeKind == MergeKind.supertypesSetters);
+ }
+ debug?.log("supertypes: ${result}");
+ if (result is DelayedMember) {
+ hierarchy.delayedMemberChecks.add(result);
+ }
+ }
+ break;
}
return result;
}
- void reportInheritanceConflict(
- KernelClassBuilder cls, Declaration a, Declaration b) {
+ Declaration checkInheritanceConflict(Declaration a, Declaration b) {
+ if (a is DelayedMember) {
+ Declaration result;
+ for (int i = 0; i < a.declarations.length; i++) {
+ Declaration d = checkInheritanceConflict(a.declarations[i], b);
+ result ??= d;
+ }
+ return result;
+ }
+ if (b is DelayedMember) {
+ Declaration result;
+ for (int i = 0; i < b.declarations.length; i++) {
+ Declaration d = checkInheritanceConflict(a, b.declarations[i]);
+ result ??= d;
+ }
+ return result;
+ }
+ if (isInheritanceConflict(a, b)) {
+ reportInheritanceConflict(a, b);
+ return a;
+ }
+ return null;
+ }
+
+ bool inferMethodTypes(KernelProcedureBuilder a, Declaration b) {
+ debug?.log(
+ "Trying to infer types for ${fullName(a)} based on ${fullName(b)}");
+ if (b is DelayedMember) {
+ bool hasSameSignature = true;
+ List<Declaration> declarations = b.declarations;
+ for (int i = 0; i < declarations.length; i++) {
+ if (!inferMethodTypes(a, declarations[i])) {
+ hasSameSignature = false;
+ }
+ }
+ return hasSameSignature;
+ }
+ if (a.isGetter) {
+ return inferGetterType(a, b);
+ } else if (a.isSetter) {
+ return inferSetterType(a, b);
+ }
+ bool hadTypesInferred = a.hadTypesInferred;
+ KernelClassBuilder aCls = a.parent;
+ Substitution aSubstitution;
+ if (cls != aCls) {
+ assert(substitutions.containsKey(aCls.target),
+ "${cls.fullNameForErrors} ${aCls.fullNameForErrors}");
+ aSubstitution = substitutions[aCls.target];
+ debug?.log(
+ "${cls.fullNameForErrors} -> ${aCls.fullNameForErrors} $aSubstitution");
+ }
+ KernelClassBuilder bCls = b.parent;
+ Substitution bSubstitution;
+ if (cls != bCls) {
+ assert(substitutions.containsKey(bCls.target),
+ "${cls.fullNameForErrors} ${bCls.fullNameForErrors}");
+ bSubstitution = substitutions[bCls.target];
+ debug?.log(
+ "${cls.fullNameForErrors} -> ${bCls.fullNameForErrors} $bSubstitution");
+ }
+ Procedure aProcedure = a.target;
+ if (b.target is! Procedure) {
+ debug?.log("Giving up 1");
+ return false;
+ }
+ Procedure bProcedure = b.target;
+ FunctionNode aFunction = aProcedure.function;
+ FunctionNode bFunction = bProcedure.function;
+
+ List<TypeParameter> aTypeParameters = aFunction.typeParameters;
+ List<TypeParameter> bTypeParameters = bFunction.typeParameters;
+ int typeParameterCount = aTypeParameters.length;
+ if (typeParameterCount != bTypeParameters.length) {
+ debug?.log("Giving up 2");
+ return false;
+ }
+ Substitution substitution;
+ if (typeParameterCount != 0) {
+ List<DartType> types = new List<DartType>(typeParameterCount);
+ for (int i = 0; i < typeParameterCount; i++) {
+ types[i] = new TypeParameterType(aTypeParameters[i]);
+ }
+ substitution = Substitution.fromPairs(bTypeParameters, types);
+ for (int i = 0; i < typeParameterCount; i++) {
+ DartType aBound = aTypeParameters[i].bound;
+ DartType bBound = substitution.substituteType(bTypeParameters[i].bound);
+ if (aBound != bBound) {
+ debug?.log("Giving up 3");
+ return false;
+ }
+ }
+ }
+
+ DartType aReturnType = aFunction.returnType;
+ if (aSubstitution != null) {
+ aReturnType = aSubstitution.substituteType(aReturnType);
+ }
+ DartType bReturnType = bFunction.returnType;
+ if (bSubstitution != null) {
+ bReturnType = bSubstitution.substituteType(bReturnType);
+ }
+ if (substitution != null) {
+ bReturnType = substitution.substituteType(bReturnType);
+ }
+ bool result = true;
+ if (aFunction.requiredParameterCount > bFunction.requiredParameterCount) {
+ debug?.log("Giving up 4");
+ return false;
+ }
+ List<VariableDeclaration> aPositional = aFunction.positionalParameters;
+ List<VariableDeclaration> bPositional = bFunction.positionalParameters;
+ if (aPositional.length < bPositional.length) {
+ debug?.log("Giving up 5");
+ return false;
+ }
+
+ if (aReturnType != bReturnType) {
+ if (a.parent == cls && a.returnType == null) {
+ result =
+ inferReturnType(cls, a, bReturnType, hadTypesInferred, hierarchy);
+ } else {
+ debug?.log("Giving up 6");
+ result = false;
+ }
+ }
+
+ for (int i = 0; i < bPositional.length; i++) {
+ VariableDeclaration aParameter = aPositional[i];
+ VariableDeclaration bParameter = bPositional[i];
+ copyParameterCovariance(a.parent, aParameter, bParameter);
+ DartType aType = aParameter.type;
+ if (aSubstitution != null) {
+ aType = aSubstitution.substituteType(aType);
+ }
+ DartType bType = bParameter.type;
+ if (bSubstitution != null) {
+ bType = bSubstitution.substituteType(bType);
+ }
+ if (substitution != null) {
+ bType = substitution.substituteType(bType);
+ }
+ if (aType != bType) {
+ if (a.parent == cls && a.formals[i].type == null) {
+ result = inferParameterType(
+ cls, a, a.formals[i], bType, hadTypesInferred, hierarchy);
+ } else {
+ debug?.log("Giving up 8");
+ result = false;
+ }
+ }
+ }
+
+ List<VariableDeclaration> aNamed = aFunction.namedParameters;
+ List<VariableDeclaration> bNamed = bFunction.namedParameters;
+ named:
+ if (aNamed.isNotEmpty || bNamed.isNotEmpty) {
+ if (aPositional.length != bPositional.length) {
+ debug?.log("Giving up 9");
+ result = false;
+ break named;
+ }
+ if (aFunction.requiredParameterCount !=
+ bFunction.requiredParameterCount) {
+ debug?.log("Giving up 10");
+ result = false;
+ break named;
+ }
+
+ aNamed = aNamed.toList()..sort(compareNamedParameters);
+ bNamed = bNamed.toList()..sort(compareNamedParameters);
+ int aCount = 0;
+ for (int bCount = 0; bCount < bNamed.length; bCount++) {
+ String name = bNamed[bCount].name;
+ for (; aCount < aNamed.length; aCount++) {
+ if (aNamed[aCount].name == name) break;
+ }
+ if (aCount == aNamed.length) {
+ debug?.log("Giving up 11");
+ result = false;
+ break named;
+ }
+ VariableDeclaration aParameter = aNamed[aCount];
+ VariableDeclaration bParameter = bNamed[bCount];
+ copyParameterCovariance(a.parent, aParameter, bParameter);
+ DartType aType = aParameter.type;
+ DartType bType = bParameter.type;
+ if (substitution != null) {
+ bType = substitution.substituteType(bType);
+ }
+ if (aType != bType) {
+ FormalParameterBuilder<KernelTypeBuilder> parameter =
+ a.formals[aPositional.length + aCount];
+ if (a.parent == cls && parameter.type == null) {
+ result = inferParameterType(
+ cls, a, parameter, bType, hadTypesInferred, hierarchy);
+ } else {
+ debug?.log("Giving up 12");
+ result = false;
+ }
+ }
+ }
+ }
+ debug?.log("Inferring types for ${fullName(a)} based on ${fullName(b)} " +
+ (result ? "succeeded." : "failed."));
+ return result;
+ }
+
+ bool inferGetterType(KernelProcedureBuilder a, Declaration b) {
+ debug?.log(
+ "Inferring getter types for ${fullName(a)} based on ${fullName(b)}");
+ Member bTarget = b.target;
+ DartType bType;
+ if (bTarget is Field) {
+ bType = bTarget.type;
+ } else if (bTarget is Procedure) {
+ if (b.isSetter) {
+ VariableDeclaration bParameter =
+ bTarget.function.positionalParameters.single;
+ bType = bParameter.type;
+ if (!hasExplictlyTypedFormalParameter(b, 0)) {
+ debug?.log("Giving up (type may be inferred)");
+ return false;
+ }
+ } else if (b.isGetter) {
+ bType = bTarget.function.returnType;
+ if (!hasExplicitReturnType(b)) {
+ debug?.log("Giving up (return type may be inferred)");
+ return false;
+ }
+ } else {
+ debug?.log("Giving up (not accessor: ${bTarget.kind})");
+ return false;
+ }
+ } else {
+ debug?.log("Giving up (not field/procedure: ${bTarget.runtimeType})");
+ return false;
+ }
+ return a.target.function.returnType == bType;
+ }
+
+ bool inferSetterType(KernelProcedureBuilder a, Declaration b) {
+ debug?.log(
+ "Inferring getter types for ${fullName(a)} based on ${fullName(b)}");
+ Member bTarget = b.target;
+ Procedure aProcedure = a.target;
+ VariableDeclaration aParameter =
+ aProcedure.function.positionalParameters.single;
+ DartType bType;
+ if (bTarget is Field) {
+ bType = bTarget.type;
+ copyParameterCovarianceFromField(a.parent, aParameter, bTarget);
+ }
+ if (bTarget is Procedure) {
+ if (b.isSetter) {
+ VariableDeclaration bParameter =
+ bTarget.function.positionalParameters.single;
+ bType = bParameter.type;
+ copyParameterCovariance(a.parent, aParameter, bParameter);
+ if (!hasExplictlyTypedFormalParameter(b, 0)) {
+ debug?.log("Giving up (type may be inferred)");
+ return false;
+ }
+ } else if (b.isGetter) {
+ bType = bTarget.function.returnType;
+ if (!hasExplicitReturnType(b)) {
+ debug?.log("Giving up (return type may be inferred)");
+ return false;
+ }
+ } else {
+ debug?.log("Giving up (not accessor: ${bTarget.kind})");
+ return false;
+ }
+ } else {
+ debug?.log("Giving up (not field/procedure: ${bTarget.runtimeType})");
+ return false;
+ }
+ return aParameter.type == bType;
+ }
+
+ void checkValidOverride(Declaration a, Declaration b) {
+ debug?.log(
+ "checkValidOverride(${fullName(a)}, ${fullName(b)}) ${a.runtimeType}");
+ if (a is KernelProcedureBuilder) {
+ if (inferMethodTypes(a, b)) return;
+ } else if (a.isField) {
+ if (inferFieldTypes(a, b)) return;
+ }
+ Member aTarget = a.target;
+ Member bTarget = b.target;
+ if (aTarget is Procedure && !aTarget.isAccessor && bTarget is Procedure) {
+ if (hasSameSignature(aTarget.function, bTarget.function)) return;
+ }
+
+ if (b is DelayedMember) {
+ for (int i = 0; i < b.declarations.length; i++) {
+ hierarchy.overrideChecks
+ .add(new DelayedOverrideCheck(cls, a, b.declarations[i]));
+ }
+ } else {
+ hierarchy.overrideChecks.add(new DelayedOverrideCheck(cls, a, b));
+ }
+ }
+
+ bool inferFieldTypes(MemberBuilder a, Declaration b) {
+ debug?.log(
+ "Trying to infer field types for ${fullName(a)} based on ${fullName(b)}");
+ if (b is DelayedMember) {
+ bool hasSameSignature = true;
+ List<Declaration> declarations = b.declarations;
+ for (int i = 0; i < declarations.length; i++) {
+ if (!inferFieldTypes(a, declarations[i])) {
+ hasSameSignature = false;
+ }
+ }
+ return hasSameSignature;
+ }
+ Member bTarget = b.target;
+ DartType inheritedType;
+ if (bTarget is Procedure) {
+ if (bTarget.isSetter) {
+ VariableDeclaration parameter =
+ bTarget.function.positionalParameters.single;
+ // inheritedType = parameter.type;
+ copyFieldCovarianceFromParameter(a.parent, a.target, parameter);
+ if (!hasExplictlyTypedFormalParameter(b, 0)) {
+ debug?.log("Giving up (type may be inferred)");
+ return false;
+ }
+ } else if (bTarget.isGetter) {
+ if (!hasExplicitReturnType(b)) return false;
+ inheritedType = bTarget.function.returnType;
+ }
+ } else if (bTarget is Field) {
+ copyFieldCovariance(a.parent, a.target, bTarget);
+ inheritedType = bTarget.type;
+ }
+ if (inheritedType == null) {
+ debug?.log("Giving up (inheritedType == null)\n${StackTrace.current}");
+ return false;
+ }
+ KernelClassBuilder aCls = a.parent;
+ Substitution aSubstitution;
+ if (cls != aCls) {
+ assert(substitutions.containsKey(aCls.target),
+ "${cls.fullNameForErrors} ${aCls.fullNameForErrors}");
+ aSubstitution = substitutions[aCls.target];
+ debug?.log(
+ "${cls.fullNameForErrors} -> ${aCls.fullNameForErrors} $aSubstitution");
+ }
+ KernelClassBuilder bCls = b.parent;
+ Substitution bSubstitution;
+ if (cls != bCls) {
+ assert(substitutions.containsKey(bCls.target),
+ "${cls.fullNameForErrors} ${bCls.fullNameForErrors}");
+ bSubstitution = substitutions[bCls.target];
+ debug?.log(
+ "${cls.fullNameForErrors} -> ${bCls.fullNameForErrors} $bSubstitution");
+ }
+ if (bSubstitution != null) {
+ inheritedType = bSubstitution.substituteType(inheritedType);
+ }
+
+ DartType declaredType = a.target.type;
+ if (aSubstitution != null) {
+ declaredType = aSubstitution.substituteType(declaredType);
+ }
+ if (declaredType == inheritedType) return true;
+
+ bool result = false;
+ if (a is KernelFieldBuilder) {
+ if (a.parent == cls && a.type == null) {
+ if (a.hadTypesInferred) {
+ reportCantInferFieldType(cls, a);
+ inheritedType = const InvalidType();
+ } else {
+ result = true;
+ a.hadTypesInferred = true;
+ }
+ if (inheritedType is ImplicitFieldType) {
+ KernelLibraryBuilder library = cls.library;
+ (library.implicitlyTypedFields ??= <KernelFieldBuilder>[]).add(a);
+ }
+ a.target.type = inheritedType;
+ }
+ }
+ return result;
+ }
+
+ void copyParameterCovariance(Declaration parent,
+ VariableDeclaration aParameter, VariableDeclaration bParameter) {
+ if (parent == cls) {
+ if (bParameter.isCovariant) {
+ aParameter.isCovariant = true;
+ }
+ if (bParameter.isGenericCovariantImpl) {
+ aParameter.isGenericCovariantImpl = true;
+ }
+ }
+ }
+
+ void copyParameterCovarianceFromField(
+ Declaration parent, VariableDeclaration aParameter, Field bField) {
+ if (parent == cls) {
+ if (bField.isCovariant) {
+ aParameter.isCovariant = true;
+ }
+ if (bField.isGenericCovariantImpl) {
+ aParameter.isGenericCovariantImpl = true;
+ }
+ }
+ }
+
+ void copyFieldCovariance(Declaration parent, Field aField, Field bField) {
+ if (parent == cls) {
+ if (bField.isCovariant) {
+ aField.isCovariant = true;
+ }
+ if (bField.isGenericCovariantImpl) {
+ aField.isGenericCovariantImpl = true;
+ }
+ }
+ }
+
+ void copyFieldCovarianceFromParameter(
+ Declaration parent, Field aField, VariableDeclaration bParameter) {
+ if (parent == cls) {
+ if (bParameter.isCovariant) {
+ aField.isCovariant = true;
+ }
+ if (bParameter.isGenericCovariantImpl) {
+ aField.isGenericCovariantImpl = true;
+ }
+ }
+ }
+
+ void reportInheritanceConflict(Declaration a, Declaration b) {
String name = a.fullNameForErrors;
if (a.parent != b.parent) {
if (a.parent == cls) {
@@ -374,8 +1020,13 @@
/// If [mergeKind] is `MergeKind.supertypes`, [member] isn't
/// implementing/overriding anything.
void handleOnlyA(Declaration member, MergeKind mergeKind) {
- if (mergeKind == MergeKind.superclass && member.target.isAbstract) {
- (abstractMembers ??= <Declaration>[]).add(member);
+ // TODO(ahe): Enable this optimization:
+ // if (cls is DillClassBuilder) return;
+ // assert(mergeKind == MergeKind.interfaces || member is! InterfaceConflict);
+ if ((mergeKind == MergeKind.superclassMembers ||
+ mergeKind == MergeKind.superclassSetters) &&
+ isAbstract(member)) {
+ recordAbstractMember(member);
}
}
@@ -388,30 +1039,45 @@
///
/// If [mergeKind] is `MergeKind.supertypes`, [member] is implicitly
/// abstract, and not implemented.
- void handleOnlyB(
- KernelClassBuilder cls, Declaration member, MergeKind mergeKind) {
+ Declaration handleOnlyB(Declaration member, MergeKind mergeKind) {
+ // TODO(ahe): Enable this optimization:
+ // if (cls is DillClassBuilder) return member;
Member target = member.target;
- if (mergeKind == MergeKind.supertypes ||
- (mergeKind == MergeKind.superclass && target.isAbstract)) {
+ if ((mergeKind == MergeKind.supertypesMembers ||
+ mergeKind == MergeKind.supertypesSetters) ||
+ ((mergeKind == MergeKind.superclassMembers ||
+ mergeKind == MergeKind.superclassSetters) &&
+ target.isAbstract)) {
if (isNameVisibleIn(target.name, cls.library)) {
- (abstractMembers ??= <Declaration>[]).add(member);
+ recordAbstractMember(member);
}
}
- if (member.parent != objectClass &&
- target.name == noSuchMethodName &&
- !target.isAbstract) {
+ if (mergeKind == MergeKind.superclassMembers &&
+ target.enclosingClass != objectClass.cls &&
+ target.name == noSuchMethodName) {
hasNoSuchMethod = true;
}
+ if (mergeKind != MergeKind.membersWithSetters &&
+ mergeKind != MergeKind.settersWithMembers &&
+ member is DelayedMember) {
+ hierarchy.delayedMemberChecks.add(member.withParent(cls));
+ }
+ return member;
+ }
+
+ void recordAbstractMember(Declaration member) {
+ abstractMembers ??= <Declaration>[];
+ if (member is DelayedMember) {
+ abstractMembers.addAll(member.declarations);
+ } else {
+ abstractMembers.add(member);
+ }
}
ClassHierarchyNode build() {
- if (cls.isPatch) {
- // TODO(ahe): What about patch classes. Have we injected patched members
- // into the class-builder's scope?
- return null;
- }
+ assert(!cls.isPatch);
ClassHierarchyNode supernode;
- if (objectClass != cls) {
+ if (objectClass != cls.origin) {
supernode = hierarchy.getNodeFromType(cls.supertype);
if (supernode == null) {
supernode = hierarchy.getNodeFromClass(objectClass);
@@ -423,8 +1089,10 @@
if (cls.isMixinApplication) {
Declaration mixin = cls.mixedInType.declaration;
inferMixinApplication();
+ // recordSupertype(cls.mixedInType);
while (mixin.isNamedMixinApplication) {
KernelClassBuilder named = mixin;
+ // recordSupertype(named.mixedInType);
mixin = named.mixedInType.declaration;
}
if (mixin is KernelClassBuilder) {
@@ -443,7 +1111,7 @@
..sort(compareDeclarations);
// Add implied setters from fields in [localMembers].
- localSetters = mergeAccessors(cls, localMembers, localSetters);
+ localSetters = mergeAccessors(localMembers, localSetters);
/// Members (excluding setters) declared in [cls] or its superclasses. This
/// includes static methods of [cls], but not its superclasses.
@@ -482,23 +1150,9 @@
new List<KernelTypeBuilder>(supernode.superclasses.length + 1);
superclasses.setRange(0, superclasses.length - 1,
substSupertypes(cls.supertype, supernode.superclasses));
- superclasses[superclasses.length - 1] = cls.supertype;
+ superclasses[superclasses.length - 1] = recordSupertype(cls.supertype);
- classMembers = merge(
- cls, localMembers, supernode.classMembers, MergeKind.superclass);
- classSetters = merge(
- cls, localSetters, supernode.classSetters, MergeKind.superclass);
-
- // Check if local members conflict with inherited setters. This check has
- // already been performed in the superclass, so we only need to check the
- // local members.
- merge(cls, localMembers, classSetters, MergeKind.accessors);
-
- // Check if local setters conflict with inherited members. As above, we
- // only need to check the local setters.
- merge(cls, localSetters, classMembers, MergeKind.accessors);
-
- List<KernelTypeBuilder> directInterfaces = cls.interfaces;
+ List<KernelTypeBuilder> directInterfaces = ignoreFunction(cls.interfaces);
if (cls.isMixinApplication) {
if (directInterfaces == null) {
directInterfaces = <KernelTypeBuilder>[cls.mixedInType];
@@ -508,15 +1162,29 @@
}
}
if (directInterfaces != null) {
- MergeResult result = mergeInterfaces(cls, supernode, directInterfaces);
+ for (int i = 0; i < directInterfaces.length; i++) {
+ recordSupertype(directInterfaces[i]);
+ }
+ }
+ List<KernelTypeBuilder> superclassInterfaces = supernode.interfaces;
+ if (superclassInterfaces != null) {
+ superclassInterfaces =
+ substSupertypes(cls.supertype, superclassInterfaces);
+ }
+
+ classMembers = merge(
+ localMembers, supernode.classMembers, MergeKind.superclassMembers);
+ classSetters = merge(
+ localSetters, supernode.classSetters, MergeKind.superclassSetters);
+
+ if (directInterfaces != null) {
+ MergeResult result = mergeInterfaces(supernode, directInterfaces);
interfaceMembers = result.mergedMembers;
interfaceSetters = result.mergedSetters;
interfaces = <KernelTypeBuilder>[];
- if (supernode.interfaces != null) {
- List<KernelTypeBuilder> types =
- substSupertypes(cls.supertype, supernode.interfaces);
- for (int i = 0; i < types.length; i++) {
- addInterface(interfaces, superclasses, types[i]);
+ if (superclassInterfaces != null) {
+ for (int i = 0; i < superclassInterfaces.length; i++) {
+ addInterface(interfaces, superclasses, superclassInterfaces[i]);
}
}
for (int i = 0; i < directInterfaces.length; i++) {
@@ -546,30 +1214,41 @@
} else {
interfaceMembers = supernode.interfaceMembers;
interfaceSetters = supernode.interfaceSetters;
- interfaces = substSupertypes(cls.supertype, supernode.interfaces);
+ interfaces = superclassInterfaces;
}
+
+ // Check if local members conflict with inherited setters. This check has
+ // already been performed in the superclass, so we only need to check the
+ // local members. These checks have to occur late to enable inferring
+ // types between setters and getters, or from a setter to a final field.
+ merge(localMembers, classSetters, MergeKind.membersWithSetters);
+
+ // Check if local setters conflict with inherited members. As above, we
+ // only need to check the local setters.
+ merge(localSetters, classMembers, MergeKind.settersWithMembers);
+
if (interfaceMembers != null) {
interfaceMembers =
- merge(cls, classMembers, interfaceMembers, MergeKind.supertypes);
+ merge(classMembers, interfaceMembers, MergeKind.supertypesMembers);
// Check if class setters conflict with members inherited from
// interfaces.
- merge(cls, classSetters, interfaceMembers, MergeKind.accessors);
+ merge(classSetters, interfaceMembers, MergeKind.settersWithMembers);
}
if (interfaceSetters != null) {
interfaceSetters =
- merge(cls, classSetters, interfaceSetters, MergeKind.supertypes);
+ merge(classSetters, interfaceSetters, MergeKind.supertypesSetters);
// Check if class members conflict with setters inherited from
// interfaces.
- merge(cls, classMembers, interfaceSetters, MergeKind.accessors);
+ merge(classMembers, interfaceSetters, MergeKind.membersWithSetters);
}
}
if (abstractMembers != null && !cls.isAbstract) {
if (!hasNoSuchMethod) {
- reportMissingMembers(cls);
+ reportMissingMembers();
} else {
- installNsmHandlers(cls);
+ installNsmHandlers();
}
}
return new ClassHierarchyNode(
@@ -584,6 +1263,41 @@
);
}
+ KernelTypeBuilder recordSupertype(KernelTypeBuilder supertype) {
+ if (supertype is KernelNamedTypeBuilder) {
+ debug?.log(
+ "In ${this.cls.fullNameForErrors} recordSupertype(${supertype.fullNameForErrors})");
+ Declaration declaration = supertype.declaration;
+ if (declaration is! KernelClassBuilder) return supertype;
+ KernelClassBuilder cls = declaration;
+ if (cls.isMixinApplication) {
+ recordSupertype(cls.mixedInType);
+ }
+ List<TypeVariableBuilder<TypeBuilder, Object>> typeVariables =
+ cls.typeVariables;
+ if (typeVariables == null) {
+ substitutions[cls.target] = Substitution.empty;
+ assert(cls.target.typeParameters.isEmpty);
+ } else {
+ List<KernelTypeBuilder> arguments =
+ supertype.arguments ?? computeDefaultTypeArguments(supertype);
+ if (arguments.length != typeVariables.length) {
+ arguments = computeDefaultTypeArguments(supertype);
+ }
+ List<DartType> kernelArguments = new List<DartType>(arguments.length);
+ List<TypeParameter> kernelParameters =
+ new List<TypeParameter>(arguments.length);
+ for (int i = 0; i < arguments.length; i++) {
+ kernelParameters[i] = typeVariables[i].target;
+ kernelArguments[i] = arguments[i].build(this.cls.parent);
+ }
+ substitutions[cls.target] =
+ Substitution.fromPairs(kernelParameters, kernelArguments);
+ }
+ }
+ return supertype;
+ }
+
List<KernelTypeBuilder> substSupertypes(
KernelNamedTypeBuilder supertype, List<KernelTypeBuilder> supertypes) {
Declaration declaration = supertype.declaration;
@@ -591,7 +1305,13 @@
KernelClassBuilder cls = declaration;
List<TypeVariableBuilder<TypeBuilder, Object>> typeVariables =
cls.typeVariables;
- if (typeVariables == null) return supertypes;
+ if (typeVariables == null) {
+ debug?.log("In ${this.cls.fullNameForErrors} $supertypes aren't substed");
+ for (int i = 0; i < supertypes.length; i++) {
+ recordSupertype(supertypes[i]);
+ }
+ return supertypes;
+ }
Map<TypeVariableBuilder<TypeBuilder, Object>, TypeBuilder> substitution =
<TypeVariableBuilder<TypeBuilder, Object>, TypeBuilder>{};
List<KernelTypeBuilder> arguments =
@@ -602,10 +1322,14 @@
List<KernelTypeBuilder> result;
for (int i = 0; i < supertypes.length; i++) {
KernelTypeBuilder supertype = supertypes[i];
- KernelTypeBuilder substed = supertype.subst(substitution);
+ KernelTypeBuilder substed =
+ recordSupertype(supertype.subst(substitution));
if (supertype != substed) {
+ debug?.log("In ${this.cls.fullNameForErrors} $supertype -> $substed");
result ??= supertypes.toList();
result[i] = substed;
+ } else {
+ debug?.log("In ${this.cls.fullNameForErrors} $supertype isn't substed");
}
}
return result ?? supertypes;
@@ -616,7 +1340,9 @@
List<KernelTypeBuilder> result =
new List<KernelTypeBuilder>(cls.typeVariables.length);
for (int i = 0; i < result.length; ++i) {
- result[i] = cls.typeVariables[i].defaultType;
+ KernelTypeVariableBuilder tv = cls.typeVariables[i];
+ result[i] = tv.defaultType ??
+ cls.library.loader.computeTypeBuilder(tv.target.defaultType);
}
return result;
}
@@ -644,8 +1370,10 @@
return null;
}
- MergeResult mergeInterfaces(KernelClassBuilder cls,
+ MergeResult mergeInterfaces(
ClassHierarchyNode supernode, List<KernelTypeBuilder> interfaces) {
+ debug?.log(
+ "mergeInterfaces($cls (${this.cls}) ${supernode.interfaces} ${interfaces}");
List<List<Declaration>> memberLists =
new List<List<Declaration>>(interfaces.length + 1);
List<List<Declaration>> setterLists =
@@ -665,12 +1393,12 @@
interfaceNode.interfaceSetters ?? interfaceNode.classSetters;
}
}
- return new MergeResult(
- mergeLists(cls, memberLists), mergeLists(cls, setterLists));
+ return new MergeResult(mergeLists(memberLists, MergeKind.interfacesMembers),
+ mergeLists(setterLists, MergeKind.interfacesMembers));
}
List<Declaration> mergeLists(
- KernelClassBuilder cls, List<List<Declaration>> input) {
+ List<List<Declaration>> input, MergeKind mergeKind) {
// This is a k-way merge sort (where k is `input.length + 1`). We merge the
// lists pairwise, which reduces the number of lists to merge by half on
// each iteration. Consequently, we perform O(log k) merges.
@@ -684,7 +1412,7 @@
} else if (second == null) {
output.add(first);
} else {
- output.add(merge(cls, first, second, MergeKind.interfaces));
+ output.add(merge(first, second, mergeKind));
}
}
if (input.length.isOdd) {
@@ -698,7 +1426,7 @@
/// Merge [and check] accessors. This entails copying mutable fields to
/// setters to simulate implied setters, and checking that setters don't
/// override regular methods.
- List<Declaration> mergeAccessors(KernelClassBuilder cls,
+ List<Declaration> mergeAccessors(
List<Declaration> members, List<Declaration> setters) {
final List<Declaration> mergedSetters = new List<Declaration>.filled(
members.length + setters.length, null,
@@ -743,7 +1471,7 @@
}
}
- void reportMissingMembers(KernelClassBuilder cls) {
+ void reportMissingMembers() {
Map<String, LocatedMessage> contextMap = <String, LocatedMessage>{};
for (int i = 0; i < abstractMembers.length; i++) {
Declaration declaration = abstractMembers[i];
@@ -773,12 +1501,12 @@
context: context);
}
- void installNsmHandlers(KernelClassBuilder cls) {
+ void installNsmHandlers() {
// TOOD(ahe): Implement this.
}
- List<Declaration> merge(KernelClassBuilder cls, List<Declaration> aList,
- List<Declaration> bList, MergeKind mergeKind) {
+ List<Declaration> merge(
+ List<Declaration> aList, List<Declaration> bList, MergeKind mergeKind) {
final List<Declaration> result = new List<Declaration>.filled(
aList.length + bList.length, null,
growable: true);
@@ -788,7 +1516,9 @@
while (i < aList.length && j < bList.length) {
final Declaration a = aList[i];
final Declaration b = bList[j];
- if (mergeKind == MergeKind.interfaces && a.isStatic) {
+ if ((mergeKind == MergeKind.interfacesMembers ||
+ mergeKind == MergeKind.interfacesSetters) &&
+ a.isStatic) {
i++;
continue;
}
@@ -798,7 +1528,7 @@
}
final int compare = compareDeclarations(a, b);
if (compare == 0) {
- result[storeIndex++] = handleMergeConflict(cls, a, b, mergeKind);
+ result[storeIndex++] = handleMergeConflict(a, b, mergeKind);
i++;
j++;
} else if (compare < 0) {
@@ -806,14 +1536,15 @@
result[storeIndex++] = a;
i++;
} else {
- handleOnlyB(cls, b, mergeKind);
- result[storeIndex++] = b;
+ result[storeIndex++] = handleOnlyB(b, mergeKind);
j++;
}
}
while (i < aList.length) {
final Declaration a = aList[i];
- if (mergeKind != MergeKind.interfaces || !a.isStatic) {
+ if (!(mergeKind == MergeKind.interfacesMembers ||
+ mergeKind == MergeKind.interfacesSetters) ||
+ !a.isStatic) {
handleOnlyA(a, mergeKind);
result[storeIndex++] = a;
}
@@ -822,8 +1553,7 @@
while (j < bList.length) {
final Declaration b = bList[j];
if (!b.isStatic) {
- handleOnlyB(cls, b, mergeKind);
- result[storeIndex++] = b;
+ result[storeIndex++] = handleOnlyB(b, mergeKind);
}
j++;
}
@@ -853,6 +1583,25 @@
KernelNamedTypeBuilder mixedInType = cls.mixedInType;
mixedInType.arguments = inferredArguments;
}
+
+ /// The class Function from dart:core is supposed to be ignored when used as
+ /// an interface.
+ List<KernelTypeBuilder> ignoreFunction(List<KernelTypeBuilder> interfaces) {
+ if (interfaces == null) return null;
+ for (int i = 0; i < interfaces.length; i++) {
+ KernelClassBuilder cls = getClass(interfaces[i]);
+ if (cls != null && cls.target == hierarchy.functionKernelClass) {
+ if (interfaces.length == 1) {
+ return null;
+ } else {
+ interfaces = interfaces.toList();
+ interfaces.removeAt(i);
+ return ignoreFunction(interfaces);
+ }
+ }
+ }
+ return interfaces;
+ }
}
class ClassHierarchyNode {
@@ -980,6 +1729,42 @@
}
}
+ Declaration getInterfaceMember(Name name, bool isSetter) {
+ return findMember(
+ name,
+ isSetter
+ ? interfaceSetters ?? classSetters
+ : interfaceMembers ?? classMembers);
+ }
+
+ Declaration findMember(Name name, List<Declaration> declarations) {
+ // TODO(ahe): Consider creating a map or scope. The obvious choice would be
+ // to use scopes, but they don't handle private names correctly.
+
+ // This is a copy of `ClassHierarchy.findMemberByName`.
+ int low = 0, high = declarations.length - 1;
+ while (low <= high) {
+ int mid = low + ((high - low) >> 1);
+ Declaration pivot = declarations[mid];
+ int comparison = ClassHierarchy.compareNames(name, pivot.target.name);
+ if (comparison < 0) {
+ high = mid - 1;
+ } else if (comparison > 0) {
+ low = mid + 1;
+ } else if (high != mid) {
+ // Ensure we find the first element of the given name.
+ high = mid;
+ } else {
+ return pivot;
+ }
+ }
+ return null;
+ }
+
+ Declaration getDispatchTarget(Name name, bool isSetter) {
+ return findMember(name, isSetter ? classSetters : classMembers);
+ }
+
static int compareMaxInheritancePath(
ClassHierarchyNode a, ClassHierarchyNode b) {
return b.maxInheritancePath.compareTo(a.maxInheritancePath);
@@ -996,17 +1781,28 @@
enum MergeKind {
/// Merging superclass members with the current class.
- superclass,
+ superclassMembers,
- /// Merging two interfaces.
- interfaces,
+ /// Merging superclass setters with the current class.
+ superclassSetters,
+
+ /// Merging members of two interfaces.
+ interfacesMembers,
+
+ /// Merging setters of two interfaces.
+ interfacesSetters,
/// Merging class members with interface members.
- supertypes,
+ supertypesMembers,
- /// Merging members with inherited setters, or setters with inherited
- /// members.
- accessors,
+ /// Merging class setters with interface setters.
+ supertypesSetters,
+
+ /// Merging members with inherited setters.
+ membersWithSetters,
+
+ /// Merging setters with inherited members.
+ settersWithMembers,
}
List<LocatedMessage> inheritedConflictContext(Declaration a, Declaration b) {
@@ -1123,3 +1919,611 @@
return hierarchy.getKernelLegacyLeastUpperBound(type1, type2);
}
}
+
+class DelayedOverrideCheck {
+ final KernelClassBuilder cls;
+ final Declaration a;
+ final Declaration b;
+
+ const DelayedOverrideCheck(this.cls, this.a, this.b);
+
+ void check(ClassHierarchyBuilder hierarchy) {
+ void callback(
+ Member declaredMember, Member interfaceMember, bool isSetter) {
+ cls.checkOverride(
+ hierarchy.types, declaredMember, interfaceMember, isSetter, callback,
+ isInterfaceCheck: !cls.isMixinApplication);
+ }
+
+ Declaration a = this.a;
+ debug?.log(
+ "Delayed override check of ${fullName(a)} ${fullName(b)} wrt. ${cls.fullNameForErrors}");
+ if (cls == a.parent) {
+ if (a is KernelProcedureBuilder) {
+ if (a.isGetter && !hasExplicitReturnType(a)) {
+ DartType type;
+ if (b.isGetter) {
+ Procedure bTarget = b.target;
+ type = bTarget.function.returnType;
+ } else if (b.isSetter) {
+ Procedure bTarget = b.target;
+ type = bTarget.function.positionalParameters.single.type;
+ } else if (b.isField) {
+ Field bTarget = b.target;
+ type = bTarget.type;
+ }
+ if (type != null) {
+ type = Substitution.fromInterfaceType(
+ hierarchy.getKernelTypeAsInstanceOf(
+ cls.cls.thisType, b.target.enclosingClass))
+ .substituteType(type);
+ if (!a.hadTypesInferred || !b.isSetter) {
+ inferReturnType(cls, a, type, a.hadTypesInferred, hierarchy);
+ }
+ }
+ } else if (a.isSetter && !hasExplictlyTypedFormalParameter(a, 0)) {
+ DartType type;
+ if (b.isGetter) {
+ Procedure bTarget = b.target;
+ type = bTarget.function.returnType;
+ } else if (b.isSetter) {
+ Procedure bTarget = b.target;
+ type = bTarget.function.positionalParameters.single.type;
+ } else if (b.isField) {
+ Field bTarget = b.target;
+ type = bTarget.type;
+ }
+ if (type != null) {
+ type = Substitution.fromInterfaceType(
+ hierarchy.getKernelTypeAsInstanceOf(
+ cls.cls.thisType, b.target.enclosingClass))
+ .substituteType(type);
+ if (!a.hadTypesInferred || !b.isGetter) {
+ inferParameterType(cls, a, a.formals.single, type,
+ a.hadTypesInferred, hierarchy);
+ }
+ }
+ }
+ a.hadTypesInferred = true;
+ } else if (a is KernelFieldBuilder && a.type == null) {
+ DartType type;
+ if (b.isGetter) {
+ Procedure bTarget = b.target;
+ type = bTarget.function.returnType;
+ } else if (b.isSetter) {
+ Procedure bTarget = b.target;
+ type = bTarget.function.positionalParameters.single.type;
+ } else if (b.isField) {
+ Field bTarget = b.target;
+ type = bTarget.type;
+ }
+ if (type != null) {
+ type = Substitution.fromInterfaceType(
+ hierarchy.getKernelTypeAsInstanceOf(
+ cls.cls.thisType, b.target.enclosingClass))
+ .substituteType(type);
+ if (type != a.target.type) {
+ if (a.hadTypesInferred) {
+ if (b.isSetter &&
+ (!impliesSetter(a) ||
+ hierarchy.types.isSubtypeOfKernel(type, a.target.type))) {
+ type = a.target.type;
+ } else {
+ reportCantInferFieldType(cls, a);
+ type = const InvalidType();
+ }
+ }
+ debug?.log("Inferred type ${type} for ${fullName(a)}");
+ a.target.type = type;
+ }
+ }
+ a.hadTypesInferred = true;
+ }
+ }
+
+ callback(a.target, b.target, a.isSetter);
+ }
+}
+
+abstract class DelayedMember extends Declaration {
+ /// The class which has inherited [declarations].
+ @override
+ final KernelClassBuilder parent;
+
+ /// Conflicting declarations.
+ final List<Declaration> declarations;
+
+ final isSetter;
+
+ DelayedMember(this.parent, this.declarations, this.isSetter);
+
+ void addAllDeclarationsTo(List<Declaration> declarations) {
+ for (int i = 0; i < this.declarations.length; i++) {
+ addDeclarationIfDifferent(this.declarations[i], declarations);
+ }
+ assert(declarations.toSet().length == declarations.length);
+ }
+
+ Member check(ClassHierarchyBuilder hierarchy);
+
+ DelayedMember withParent(KernelClassBuilder parent);
+
+ @override
+ Uri get fileUri => parent.fileUri;
+
+ @override
+ int get charOffset => parent.charOffset;
+
+ @override
+ String get fullNameForErrors => declarations.map(fullName).join("%");
+
+ @override
+ Member get target => declarations.first.target;
+}
+
+/// This represents a concrete implementation inherited from a superclass that
+/// has conflicts with methods inherited from an interface. The concrete
+/// implementation is the first element of [declarations].
+class InheritedImplementationInterfaceConflict extends DelayedMember {
+ Member combinedMemberSignatureResult;
+
+ InheritedImplementationInterfaceConflict(
+ KernelClassBuilder parent, List<Declaration> declarations, bool isSetter)
+ : super(parent, declarations, isSetter);
+
+ @override
+ String toString() {
+ return "InheritedImplementationInterfaceConflict("
+ "${parent.fullNameForErrors}, "
+ "[${declarations.map(fullName).join(', ')}])";
+ }
+
+ @override
+ Member check(ClassHierarchyBuilder hierarchy) {
+ if (combinedMemberSignatureResult != null) {
+ return combinedMemberSignatureResult;
+ }
+ if (!parent.isAbstract) {
+ Declaration concreteImplementation = declarations.first;
+ for (int i = 1; i < declarations.length; i++) {
+ new DelayedOverrideCheck(
+ parent, concreteImplementation, declarations[i])
+ .check(hierarchy);
+ }
+ }
+ return combinedMemberSignatureResult =
+ new InterfaceConflict(parent, declarations, isSetter).check(hierarchy);
+ }
+
+ @override
+ DelayedMember withParent(KernelClassBuilder parent) {
+ return parent == this.parent
+ ? this
+ : new InheritedImplementationInterfaceConflict(
+ parent, declarations, isSetter);
+ }
+
+ static Declaration combined(KernelClassBuilder parent,
+ Declaration concreteImplementation, Declaration other, bool isSetter) {
+ List<Declaration> declarations = <Declaration>[];
+ if (concreteImplementation is DelayedMember) {
+ concreteImplementation.addAllDeclarationsTo(declarations);
+ } else {
+ declarations.add(concreteImplementation);
+ }
+ if (other is DelayedMember) {
+ other.addAllDeclarationsTo(declarations);
+ } else {
+ addDeclarationIfDifferent(other, declarations);
+ }
+ if (declarations.length == 1) {
+ return declarations.single;
+ } else {
+ return new InheritedImplementationInterfaceConflict(
+ parent, declarations, isSetter);
+ }
+ }
+}
+
+class InterfaceConflict extends DelayedMember {
+ InterfaceConflict(
+ KernelClassBuilder parent, List<Declaration> declarations, bool isSetter)
+ : super(parent, declarations, isSetter);
+
+ Member combinedMemberSignatureResult;
+
+ @override
+ String toString() {
+ return "InterfaceConflict(${parent.fullNameForErrors}, "
+ "[${declarations.map(fullName).join(', ')}])";
+ }
+
+ DartType computeMemberType(
+ ClassHierarchyBuilder hierarchy, DartType thisType, Member member) {
+ DartType type;
+ if (member is Procedure) {
+ if (member.isGetter) {
+ type = member.getterType;
+ } else if (member.isSetter) {
+ type = member.setterType;
+ } else {
+ type = member.function.functionType;
+ }
+ } else if (member is Field) {
+ type = member.type;
+ } else {
+ unhandled("${member.runtimeType}", "$member", parent.charOffset,
+ parent.fileUri);
+ }
+ return Substitution.fromInterfaceType(hierarchy.getKernelTypeAsInstanceOf(
+ thisType, member.enclosingClass))
+ .substituteType(type);
+ }
+
+ bool isMoreSpecific(ClassHierarchyBuilder hierarchy, DartType a, DartType b) {
+ if (isSetter) {
+ return hierarchy.types.isSubtypeOfKernel(b, a);
+ } else {
+ return hierarchy.types.isSubtypeOfKernel(a, b);
+ }
+ }
+
+ @override
+ Member check(ClassHierarchyBuilder hierarchy) {
+ if (combinedMemberSignatureResult != null) {
+ return combinedMemberSignatureResult;
+ }
+ if (parent.library is! KernelLibraryBuilder) {
+ return combinedMemberSignatureResult = declarations.first.target;
+ }
+ DartType thisType = parent.cls.thisType;
+ Declaration bestSoFar;
+ DartType bestTypeSoFar;
+ for (int i = declarations.length - 1; i >= 0; i--) {
+ Declaration candidate = declarations[i];
+ Member target = candidate.target;
+ DartType candidateType = computeMemberType(hierarchy, thisType, target);
+ if (bestSoFar == null) {
+ bestSoFar = candidate;
+ bestTypeSoFar = candidateType;
+ } else {
+ if (isMoreSpecific(hierarchy, candidateType, bestTypeSoFar)) {
+ debug?.log(
+ "Combined Member Signature: ${fullName(candidate)} ${candidateType} <: ${fullName(bestSoFar)} ${bestTypeSoFar}");
+ bestSoFar = candidate;
+ bestTypeSoFar = candidateType;
+ } else {
+ debug?.log(
+ "Combined Member Signature: ${fullName(candidate)} !<: ${fullName(bestSoFar)}");
+ }
+ }
+ }
+ if (bestSoFar != null) {
+ debug?.log("Combined Member Signature bestSoFar: ${fullName(bestSoFar)}");
+ for (int i = 0; i < declarations.length; i++) {
+ Declaration candidate = declarations[i];
+ Member target = candidate.target;
+ DartType candidateType = computeMemberType(hierarchy, thisType, target);
+ if (!isMoreSpecific(hierarchy, bestTypeSoFar, candidateType)) {
+ debug?.log(
+ "Combined Member Signature: ${fullName(bestSoFar)} !<: ${fullName(candidate)}");
+
+ if ("${parent.fileUri}" !=
+ "org-dartlang-sdk:///sdk/lib/js/dart2js/js_dart2js.dart" &&
+ "${parent.fileUri}" !=
+ "org-dartlang-sdk:///sdk/lib/_internal/js_runtime/lib/js_number.dart") {
+ // TODO(johnniwinther): Fix the dart2js libraries and remove the
+ // above URIs.
+ bestSoFar = null;
+ bestTypeSoFar = null;
+ }
+ break;
+ }
+ }
+ }
+ if (bestSoFar == null) {
+ String name = parent.fullNameForErrors;
+ int length = parent.isAnonymousMixinApplication ? 1 : name.length;
+ List<LocatedMessage> context = declarations.map((Declaration d) {
+ return messageDeclaredMemberConflictsWithInheritedMemberCause
+ .withLocation(d.fileUri, d.charOffset, d.fullNameForErrors.length);
+ }).toList();
+
+ parent.addProblem(
+ templateCombinedMemberSignatureFailed.withArguments(
+ parent.fullNameForErrors, declarations.first.fullNameForErrors),
+ parent.charOffset,
+ length,
+ context: context);
+ return null;
+ }
+ debug?.log(
+ "Combined Member Signature of ${fullNameForErrors}: ${fullName(bestSoFar)}");
+
+ ProcedureKind kind = ProcedureKind.Method;
+ if (bestSoFar.isField || bestSoFar.isSetter || bestSoFar.isGetter) {
+ kind = isSetter ? ProcedureKind.Setter : ProcedureKind.Getter;
+ }
+
+ debug?.log(
+ "Combined Member Signature of ${fullNameForErrors}: new ForwardingNode($parent, $bestSoFar, $declarations, $kind)");
+ Member stub =
+ new ForwardingNode(hierarchy, parent, bestSoFar, declarations, kind)
+ .finalize();
+ if (parent.cls == stub.enclosingClass) {
+ parent.cls.addMember(stub);
+ KernelLibraryBuilder library = parent.library;
+ if (bestSoFar.target is Procedure) {
+ library.forwardersOrigins..add(stub)..add(bestSoFar.target);
+ }
+ debug?.log(
+ "Combined Member Signature of ${fullNameForErrors}: added stub $stub");
+ if (parent.isMixinApplication) {
+ return combinedMemberSignatureResult = bestSoFar.target;
+ } else {
+ return combinedMemberSignatureResult = stub;
+ }
+ } else {
+ debug?.log(
+ "Combined Member Signature of ${fullNameForErrors}: picked bestSoFar");
+ return combinedMemberSignatureResult = bestSoFar.target;
+ }
+ }
+
+ @override
+ DelayedMember withParent(KernelClassBuilder parent) {
+ return parent == this.parent
+ ? this
+ : new InterfaceConflict(parent, declarations, isSetter);
+ }
+
+ static Declaration combined(
+ KernelClassBuilder parent, Declaration a, Declaration b, bool isSetter) {
+ List<Declaration> declarations = <Declaration>[];
+ if (a is DelayedMember) {
+ a.addAllDeclarationsTo(declarations);
+ } else {
+ declarations.add(a);
+ }
+ if (b is DelayedMember) {
+ b.addAllDeclarationsTo(declarations);
+ } else {
+ addDeclarationIfDifferent(b, declarations);
+ }
+ if (declarations.length == 1) {
+ return declarations.single;
+ } else {
+ return new InterfaceConflict(parent, declarations, isSetter);
+ }
+ }
+}
+
+class AbstractMemberOverridingImplementation extends DelayedMember {
+ AbstractMemberOverridingImplementation(
+ KernelClassBuilder parent,
+ Declaration abstractMember,
+ Declaration concreteImplementation,
+ bool isSetter)
+ : super(parent, <Declaration>[concreteImplementation, abstractMember],
+ isSetter);
+
+ Declaration get concreteImplementation => declarations[0];
+
+ Declaration get abstractMember => declarations[1];
+
+ Member check(ClassHierarchyBuilder hierarchy) {
+ if (!parent.isAbstract) {
+ new DelayedOverrideCheck(parent, concreteImplementation, abstractMember)
+ .check(hierarchy);
+ }
+
+ ProcedureKind kind = ProcedureKind.Method;
+ if (abstractMember.isSetter || abstractMember.isGetter) {
+ kind = isSetter ? ProcedureKind.Setter : ProcedureKind.Getter;
+ }
+ // This call will add a body to the abstract method if needed for
+ // isGenericCovariantImpl checks.
+ new ForwardingNode(hierarchy, parent, abstractMember, declarations, kind)
+ .finalize();
+ return abstractMember.target;
+ }
+
+ @override
+ DelayedMember withParent(KernelClassBuilder parent) {
+ return parent == this.parent
+ ? this
+ : new AbstractMemberOverridingImplementation(
+ parent, abstractMember, concreteImplementation, isSetter);
+ }
+
+ static Declaration selectAbstract(Declaration declaration) {
+ if (declaration is AbstractMemberOverridingImplementation) {
+ return declaration.abstractMember;
+ } else {
+ return declaration;
+ }
+ }
+
+ static Declaration selectConcrete(Declaration declaration) {
+ if (declaration is AbstractMemberOverridingImplementation) {
+ return declaration.concreteImplementation;
+ } else {
+ return declaration;
+ }
+ }
+}
+
+void addDeclarationIfDifferent(
+ Declaration declaration, List<Declaration> declarations) {
+ Member target = declaration.target;
+ if (target is Procedure) {
+ FunctionNode function = target.function;
+ for (int i = 0; i < declarations.length; i++) {
+ Member other = declarations[i].target;
+ if (other is Procedure) {
+ if (hasSameSignature(function, other.function)) return;
+ }
+ }
+ } else {
+ for (int i = 0; i < declarations.length; i++) {
+ if (declaration == declarations[i]) return;
+ }
+ }
+ declarations.add(declaration);
+}
+
+String fullName(Declaration declaration) {
+ if (declaration is DelayedMember) return declaration.fullNameForErrors;
+ Declaration parent = declaration.parent;
+ return parent == null
+ ? declaration.fullNameForErrors
+ : "${parent.fullNameForErrors}.${declaration.fullNameForErrors}";
+}
+
+int compareNamedParameters(VariableDeclaration a, VariableDeclaration b) {
+ return a.name.compareTo(b.name);
+}
+
+bool isAbstract(Declaration declaration) {
+ return declaration.target.isAbstract || declaration is InterfaceConflict;
+}
+
+bool inferParameterType(
+ KernelClassBuilder cls,
+ KernelProcedureBuilder member,
+ FormalParameterBuilder<KernelTypeBuilder> parameter,
+ DartType type,
+ bool hadTypesInferred,
+ ClassHierarchyBuilder hierarchy) {
+ debug?.log("Inferred type ${type} for ${parameter}");
+ if (type == parameter.target.type) return true;
+ bool result = true;
+ if (hadTypesInferred) {
+ reportCantInferParameterType(cls, member, parameter, hierarchy);
+ type = const InvalidType();
+ result = false;
+ }
+ parameter.target.type = type;
+ member.hadTypesInferred = true;
+ return result;
+}
+
+void reportCantInferParameterType(
+ KernelClassBuilder cls,
+ MemberBuilder member,
+ FormalParameterBuilder<KernelTypeBuilder> parameter,
+ ClassHierarchyBuilder hierarchy) {
+ String name = parameter.name;
+ cls.addProblem(
+ templateCantInferTypeDueToInconsistentOverrides.withArguments(name),
+ parameter.charOffset,
+ name.length,
+ wasHandled: true);
+}
+
+bool inferReturnType(KernelClassBuilder cls, KernelProcedureBuilder member,
+ DartType type, bool hadTypesInferred, ClassHierarchyBuilder hierarchy) {
+ if (type == member.target.function.returnType) return true;
+ bool result = true;
+ if (hadTypesInferred) {
+ reportCantInferReturnType(cls, member, hierarchy);
+ type = const InvalidType();
+ result = false;
+ } else {
+ member.hadTypesInferred = true;
+ }
+ member.target.function.returnType = type;
+ return result;
+}
+
+void reportCantInferReturnType(KernelClassBuilder cls, MemberBuilder member,
+ ClassHierarchyBuilder hierarchy) {
+ String name = member.fullNameForErrors;
+ List<LocatedMessage> context;
+ // // TODO(ahe): The following is for debugging, but could be cleaned up and
+ // // used to improve this error message in general.
+ //
+ // context = <LocatedMessage>[];
+ // ClassHierarchyNode supernode = hierarchy.getNodeFromType(cls.supertype);
+ // // TODO(ahe): Wrong template.
+ // Template<Message Function(String)> template =
+ // templateMissingImplementationCause;
+ // if (supernode != null) {
+ // Declaration superMember =
+ // supernode.getInterfaceMember(new Name(name), false);
+ // if (superMember != null) {
+ // context.add(template
+ // .withArguments(name)
+ // .withLocation(
+ // superMember.fileUri, superMember.charOffset, name.length));
+ // }
+ // superMember = supernode.getInterfaceMember(new Name(name), true);
+ // if (superMember != null) {
+ // context.add(template
+ // .withArguments(name)
+ // .withLocation(
+ // superMember.fileUri, superMember.charOffset, name.length));
+ // }
+ // }
+ // List<KernelTypeBuilder> directInterfaces = cls.interfaces;
+ // for (int i = 0; i < directInterfaces.length; i++) {
+ // ClassHierarchyNode supernode =
+ // hierarchy.getNodeFromType(directInterfaces[i]);
+ // if (supernode != null) {
+ // Declaration superMember =
+ // supernode.getInterfaceMember(new Name(name), false);
+ // if (superMember != null) {
+ // context.add(template
+ // .withArguments(name)
+ // .withLocation(
+ // superMember.fileUri, superMember.charOffset, name.length));
+ // }
+ // superMember = supernode.getInterfaceMember(new Name(name), true);
+ // if (superMember != null) {
+ // context.add(template
+ // .withArguments(name)
+ // .withLocation(
+ // superMember.fileUri, superMember.charOffset, name.length));
+ // }
+ // }
+ // }
+ cls.addProblem(
+ templateCantInferReturnTypeDueToInconsistentOverrides.withArguments(name),
+ member.charOffset,
+ name.length,
+ wasHandled: true,
+ context: context);
+}
+
+void reportCantInferFieldType(
+ KernelClassBuilder cls, KernelFieldBuilder member) {
+ String name = member.fullNameForErrors;
+ cls.addProblem(
+ templateCantInferTypeDueToInconsistentOverrides.withArguments(name),
+ member.charOffset,
+ name.length,
+ wasHandled: true);
+}
+
+KernelClassBuilder getClass(KernelTypeBuilder type) {
+ Declaration declaration = type.declaration;
+ return declaration is KernelClassBuilder ? declaration : null;
+}
+
+bool hasExplicitReturnType(Declaration declaration) {
+ assert(
+ declaration is KernelProcedureBuilder || declaration is DillMemberBuilder,
+ "${declaration.runtimeType}");
+ return declaration is KernelProcedureBuilder
+ ? declaration.returnType != null
+ : true;
+}
+
+bool hasExplictlyTypedFormalParameter(Declaration declaration, int index) {
+ assert(
+ declaration is KernelProcedureBuilder || declaration is DillMemberBuilder,
+ "${declaration.runtimeType}");
+ return declaration is KernelProcedureBuilder
+ ? declaration.formals[index].type != null
+ : true;
+}
diff --git a/pkg/front_end/lib/src/fasta/kernel/forwarding_node.dart b/pkg/front_end/lib/src/fasta/kernel/forwarding_node.dart
new file mode 100644
index 0000000..441c827
--- /dev/null
+++ b/pkg/front_end/lib/src/fasta/kernel/forwarding_node.dart
@@ -0,0 +1,416 @@
+// Copyright (c) 2019, 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.
+
+import "package:kernel/ast.dart"
+ show
+ Arguments,
+ Class,
+ DartType,
+ Expression,
+ Field,
+ FunctionNode,
+ Member,
+ Name,
+ NamedExpression,
+ Procedure,
+ ProcedureKind,
+ ReturnStatement,
+ SuperMethodInvocation,
+ SuperPropertyGet,
+ SuperPropertySet,
+ TypeParameter,
+ TypeParameterType,
+ VariableDeclaration,
+ VariableGet,
+ VoidType;
+
+import 'package:kernel/transformations/flags.dart' show TransformerFlag;
+
+import "package:kernel/type_algebra.dart" show Substitution;
+
+import "../problems.dart" show unhandled;
+
+import "../type_inference/type_inference_engine.dart"
+ show IncludesTypeParametersCovariantly;
+
+import "../type_inference/type_inferrer.dart" show getNamedFormal;
+
+import "kernel_builder.dart"
+ show ClassHierarchyBuilder, Declaration, DelayedMember, KernelClassBuilder;
+
+class ForwardingNode {
+ final ClassHierarchyBuilder hierarchy;
+
+ final KernelClassBuilder parent;
+
+ final Declaration combinedMemberSignatureResult;
+
+ final ProcedureKind kind;
+
+ /// A list containing the directly implemented and directly inherited
+ /// procedures of the class in question.
+ final List<Declaration> _candidates;
+
+ ForwardingNode(this.hierarchy, this.parent,
+ this.combinedMemberSignatureResult, this._candidates, this.kind);
+
+ Name get name => combinedMemberSignatureResult.target.name;
+
+ Class get enclosingClass => parent.cls;
+
+ /// Finishes handling of this node by propagating covariance and creating
+ /// forwarding stubs if necessary.
+ Member finalize() => _computeCovarianceFixes();
+
+ /// Tag the parameters of [interfaceMember] that need type checks
+ ///
+ /// Parameters can need type checks for calls coming from statically typed
+ /// call sites, due to covariant generics and overrides with explicit
+ /// `covariant` parameters.
+ ///
+ /// Tag parameters of [interfaceMember] that need such checks when the member
+ /// occurs in [enclosingClass]'s interface. If parameters need checks but
+ /// they would not be checked in an inherited implementation, a forwarding
+ /// stub is introduced as a place to put the checks.
+ Member _computeCovarianceFixes() {
+ Member interfaceMember = combinedMemberSignatureResult.target;
+ Substitution substitution =
+ _substitutionFor(interfaceMember, enclosingClass);
+ // We always create a forwarding stub when we've inherited a member from an
+ // interface other than the first override candidate. This is to work
+ // around a bug in the Kernel type checker where it chooses the first
+ // override candidate.
+ //
+ // TODO(kmillikin): Fix the Kernel type checker and stop creating these
+ // extra stubs.
+ Member stub = interfaceMember.enclosingClass == enclosingClass ||
+ interfaceMember == getCandidateAt(0)
+ ? interfaceMember
+ : _createForwardingStub(substitution, interfaceMember);
+
+ FunctionNode interfaceFunction = interfaceMember.function;
+ List<VariableDeclaration> interfacePositionalParameters =
+ getPositionalParameters(interfaceMember);
+ List<VariableDeclaration> interfaceNamedParameters =
+ interfaceFunction?.namedParameters ?? [];
+ List<TypeParameter> interfaceTypeParameters =
+ interfaceFunction?.typeParameters ?? [];
+
+ void createStubIfNeeded() {
+ if (stub != interfaceMember) return;
+ if (interfaceMember.enclosingClass == enclosingClass) return;
+ stub = _createForwardingStub(substitution, interfaceMember);
+ }
+
+ bool isImplCreated = false;
+ void createImplIfNeeded() {
+ if (isImplCreated) return;
+ createStubIfNeeded();
+ _createForwardingImplIfNeeded(stub.function);
+ isImplCreated = true;
+ }
+
+ IncludesTypeParametersCovariantly needsCheckVisitor = enclosingClass
+ .typeParameters.isEmpty
+ ? null
+ // TODO(ahe): It may be necessary to cache this object.
+ : new IncludesTypeParametersCovariantly(enclosingClass.typeParameters);
+ bool needsCheck(DartType type) => needsCheckVisitor == null
+ ? false
+ : substitution.substituteType(type).accept(needsCheckVisitor);
+ for (int i = 0; i < interfacePositionalParameters.length; i++) {
+ VariableDeclaration parameter = interfacePositionalParameters[i];
+ bool isGenericCovariantImpl =
+ parameter.isGenericCovariantImpl || needsCheck(parameter.type);
+ bool isCovariant = parameter.isCovariant;
+ VariableDeclaration superParameter = parameter;
+ for (int j = 0; j < _candidates.length; j++) {
+ Member otherMember = getCandidateAt(j);
+ if (otherMember is ForwardingNode) continue;
+ List<VariableDeclaration> otherPositionalParameters =
+ getPositionalParameters(otherMember);
+ if (otherPositionalParameters.length <= i) continue;
+ VariableDeclaration otherParameter = otherPositionalParameters[i];
+ if (j == 0) superParameter = otherParameter;
+ if (identical(otherMember, interfaceMember)) continue;
+ if (otherParameter.isGenericCovariantImpl) {
+ isGenericCovariantImpl = true;
+ }
+ if (otherParameter.isCovariant) {
+ isCovariant = true;
+ }
+ }
+ if (isGenericCovariantImpl) {
+ if (!superParameter.isGenericCovariantImpl) {
+ createImplIfNeeded();
+ }
+ if (!parameter.isGenericCovariantImpl) {
+ createStubIfNeeded();
+ stub.function.positionalParameters[i].isGenericCovariantImpl = true;
+ }
+ }
+ if (isCovariant) {
+ if (!superParameter.isCovariant) {
+ createImplIfNeeded();
+ }
+ if (!parameter.isCovariant) {
+ createStubIfNeeded();
+ stub.function.positionalParameters[i].isCovariant = true;
+ }
+ }
+ }
+ for (int i = 0; i < interfaceNamedParameters.length; i++) {
+ VariableDeclaration parameter = interfaceNamedParameters[i];
+ bool isGenericCovariantImpl =
+ parameter.isGenericCovariantImpl || needsCheck(parameter.type);
+ bool isCovariant = parameter.isCovariant;
+ VariableDeclaration superParameter = parameter;
+ for (int j = 0; j < _candidates.length; j++) {
+ Member otherMember = getCandidateAt(j);
+ if (otherMember is ForwardingNode) continue;
+ VariableDeclaration otherParameter =
+ getNamedFormal(otherMember.function, parameter.name);
+ if (otherParameter == null) continue;
+ if (j == 0) superParameter = otherParameter;
+ if (identical(otherMember, interfaceMember)) continue;
+ if (otherParameter.isGenericCovariantImpl) {
+ isGenericCovariantImpl = true;
+ }
+ if (otherParameter.isCovariant) {
+ isCovariant = true;
+ }
+ }
+ if (isGenericCovariantImpl) {
+ if (!superParameter.isGenericCovariantImpl) {
+ createImplIfNeeded();
+ }
+ if (!parameter.isGenericCovariantImpl) {
+ createStubIfNeeded();
+ stub.function.namedParameters[i].isGenericCovariantImpl = true;
+ }
+ }
+ if (isCovariant) {
+ if (!superParameter.isCovariant) {
+ createImplIfNeeded();
+ }
+ if (!parameter.isCovariant) {
+ createStubIfNeeded();
+ stub.function.namedParameters[i].isCovariant = true;
+ }
+ }
+ }
+ for (int i = 0; i < interfaceTypeParameters.length; i++) {
+ TypeParameter typeParameter = interfaceTypeParameters[i];
+ bool isGenericCovariantImpl = typeParameter.isGenericCovariantImpl ||
+ needsCheck(typeParameter.bound);
+ TypeParameter superTypeParameter = typeParameter;
+ for (int j = 0; j < _candidates.length; j++) {
+ Member otherMember = getCandidateAt(j);
+ if (otherMember is ForwardingNode) continue;
+ List<TypeParameter> otherTypeParameters =
+ otherMember.function.typeParameters;
+ if (otherTypeParameters.length <= i) continue;
+ TypeParameter otherTypeParameter = otherTypeParameters[i];
+ if (j == 0) superTypeParameter = otherTypeParameter;
+ if (identical(otherMember, interfaceMember)) continue;
+ if (otherTypeParameter.isGenericCovariantImpl) {
+ isGenericCovariantImpl = true;
+ }
+ }
+ if (isGenericCovariantImpl) {
+ if (!superTypeParameter.isGenericCovariantImpl) {
+ createImplIfNeeded();
+ }
+ if (!typeParameter.isGenericCovariantImpl) {
+ createStubIfNeeded();
+ stub.function.typeParameters[i].isGenericCovariantImpl = true;
+ }
+ }
+ }
+ return stub;
+ }
+
+ void _createForwardingImplIfNeeded(FunctionNode function) {
+ if (function.body != null) {
+ // There is already an implementation; nothing further needs to be done.
+ return;
+ }
+ // Find the concrete implementation in the superclass; this is what we need
+ // to forward to. If we can't find one, then the method is fully abstract
+ // and we don't need to do anything.
+ Class superclass = enclosingClass.superclass;
+ if (superclass == null) return;
+ Procedure procedure = function.parent;
+ Member superTarget = hierarchy.getDispatchTargetKernel(
+ superclass, procedure.name, kind == ProcedureKind.Setter);
+ if (superTarget == null) return;
+ if (superTarget is Procedure && superTarget.isForwardingStub) {
+ superTarget = _getForwardingStubSuperTarget(superTarget);
+ }
+ procedure.isAbstract = false;
+ if (!procedure.isForwardingStub) {
+ // This procedure exists abstractly in the source code; we need to make it
+ // concrete and give it a body that is a forwarding stub. This situation
+ // is called a "forwarding semi-stub".
+ procedure.isForwardingStub = true;
+ procedure.isForwardingSemiStub = true;
+ }
+ List<Expression> positionalArguments = function.positionalParameters
+ .map<Expression>((parameter) => new VariableGet(parameter))
+ .toList();
+ List<NamedExpression> namedArguments = function.namedParameters
+ .map((parameter) =>
+ new NamedExpression(parameter.name, new VariableGet(parameter)))
+ .toList();
+ List<DartType> typeArguments = function.typeParameters
+ .map<DartType>((typeParameter) => new TypeParameterType(typeParameter))
+ .toList();
+ Arguments arguments = new Arguments(positionalArguments,
+ types: typeArguments, named: namedArguments);
+ Expression superCall;
+ switch (kind) {
+ case ProcedureKind.Method:
+ case ProcedureKind.Operator:
+ superCall = new SuperMethodInvocation(name, arguments, superTarget);
+ break;
+ case ProcedureKind.Getter:
+ superCall = new SuperPropertyGet(name, superTarget);
+ break;
+ case ProcedureKind.Setter:
+ superCall =
+ new SuperPropertySet(name, positionalArguments[0], superTarget);
+ break;
+ default:
+ unhandled('$kind', '_createForwardingImplIfNeeded', -1, null);
+ break;
+ }
+ function.body = new ReturnStatement(superCall)..parent = function;
+ procedure.transformerFlags |= TransformerFlag.superCalls;
+ procedure.forwardingStubSuperTarget = superTarget;
+ }
+
+ /// Creates a forwarding stub based on the given [target].
+ Procedure _createForwardingStub(Substitution substitution, Member target) {
+ VariableDeclaration copyParameter(VariableDeclaration parameter) {
+ return new VariableDeclaration(parameter.name,
+ type: substitution.substituteType(parameter.type),
+ isCovariant: parameter.isCovariant)
+ ..isGenericCovariantImpl = parameter.isGenericCovariantImpl;
+ }
+
+ List<TypeParameter> targetTypeParameters =
+ target.function?.typeParameters ?? [];
+ List<TypeParameter> typeParameters;
+ if (targetTypeParameters.isNotEmpty) {
+ typeParameters =
+ new List<TypeParameter>.filled(targetTypeParameters.length, null);
+ Map<TypeParameter, DartType> additionalSubstitution =
+ <TypeParameter, DartType>{};
+ for (int i = 0; i < targetTypeParameters.length; i++) {
+ TypeParameter targetTypeParameter = targetTypeParameters[i];
+ TypeParameter typeParameter = new TypeParameter(
+ targetTypeParameter.name, null)
+ ..isGenericCovariantImpl = targetTypeParameter.isGenericCovariantImpl;
+ typeParameters[i] = typeParameter;
+ additionalSubstitution[targetTypeParameter] =
+ new TypeParameterType(typeParameter);
+ }
+ substitution = Substitution.combine(
+ substitution, Substitution.fromMap(additionalSubstitution));
+ for (int i = 0; i < typeParameters.length; i++) {
+ typeParameters[i].bound =
+ substitution.substituteType(targetTypeParameters[i].bound);
+ }
+ }
+ List<VariableDeclaration> positionalParameters =
+ getPositionalParameters(target).map(copyParameter).toList();
+ List<VariableDeclaration> namedParameters =
+ target.function?.namedParameters?.map(copyParameter)?.toList() ?? [];
+ FunctionNode function = new FunctionNode(null,
+ positionalParameters: positionalParameters,
+ namedParameters: namedParameters,
+ typeParameters: typeParameters,
+ requiredParameterCount: getRequiredParameterCount(target),
+ returnType: substitution.substituteType(getReturnType(target)));
+ Member finalTarget;
+ if (target is Procedure && target.isForwardingStub) {
+ finalTarget = target.forwardingStubInterfaceTarget;
+ } else {
+ finalTarget = target;
+ }
+ return new Procedure(name, kind, function,
+ isAbstract: true,
+ isForwardingStub: true,
+ fileUri: enclosingClass.fileUri,
+ forwardingStubInterfaceTarget: finalTarget)
+ ..startFileOffset = enclosingClass.fileOffset
+ ..fileOffset = enclosingClass.fileOffset
+ ..parent = enclosingClass;
+ }
+
+ /// Returns the [i]th element of [_candidates], finalizing it if necessary.
+ Member getCandidateAt(int i) {
+ Declaration candidate = _candidates[i];
+ assert(candidate is! DelayedMember);
+ return candidate.target;
+ }
+
+ static Member _getForwardingStubSuperTarget(Procedure forwardingStub) {
+ // TODO(paulberry): when dartbug.com/31562 is fixed, this should become
+ // easier.
+ ReturnStatement body = forwardingStub.function.body;
+ Expression expression = body.expression;
+ if (expression is SuperMethodInvocation) {
+ return expression.interfaceTarget;
+ } else if (expression is SuperPropertySet) {
+ return expression.interfaceTarget;
+ } else {
+ return unhandled('${expression.runtimeType}',
+ '_getForwardingStubSuperTarget', -1, null);
+ }
+ }
+
+ Substitution _substitutionFor(Member candidate, Class class_) {
+ return Substitution.fromInterfaceType(hierarchy.getKernelTypeAsInstanceOf(
+ class_.thisType, candidate.enclosingClass));
+ }
+
+ List<VariableDeclaration> getPositionalParameters(Member member) {
+ if (member is Field) {
+ if (kind == ProcedureKind.Setter) {
+ return <VariableDeclaration>[
+ new VariableDeclaration("_",
+ type: member.type, isCovariant: member.isCovariant)
+ ..isGenericCovariantImpl = member.isGenericCovariantImpl
+ ];
+ } else {
+ return <VariableDeclaration>[];
+ }
+ } else {
+ return member.function.positionalParameters;
+ }
+ }
+
+ int getRequiredParameterCount(Member member) {
+ switch (kind) {
+ case ProcedureKind.Getter:
+ return 0;
+ case ProcedureKind.Setter:
+ return 1;
+ default:
+ return member.function.requiredParameterCount;
+ }
+ }
+
+ DartType getReturnType(Member member) {
+ switch (kind) {
+ case ProcedureKind.Getter:
+ return member is Field ? member.type : member.function.returnType;
+ case ProcedureKind.Setter:
+ return const VoidType();
+ default:
+ return member.function.returnType;
+ }
+ }
+}
diff --git a/pkg/front_end/lib/src/fasta/kernel/implicit_field_type.dart b/pkg/front_end/lib/src/fasta/kernel/implicit_field_type.dart
index 902db15..0120dc6 100644
--- a/pkg/front_end/lib/src/fasta/kernel/implicit_field_type.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/implicit_field_type.dart
@@ -17,7 +17,9 @@
final MemberBuilder member;
final Token initializerToken;
- const ImplicitFieldType(this.member, this.initializerToken);
+ bool isStarted = false;
+
+ ImplicitFieldType(this.member, this.initializerToken);
accept(DartTypeVisitor<Object> v) {
unsupported("accept", member.charOffset, member.fileUri);
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_builder.dart
index afd74e5..4141ffa 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_builder.dart
@@ -16,7 +16,8 @@
export '../builder/builder.dart';
-export 'class_hierarchy_builder.dart' show ClassHierarchyBuilder;
+export 'class_hierarchy_builder.dart'
+ show ClassHierarchyBuilder, DelayedMember, DelayedOverrideCheck;
export 'implicit_field_type.dart' show ImplicitFieldType;
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart
index 151c074..fabd811 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart
@@ -122,6 +122,8 @@
import 'kernel_target.dart' show KernelTarget;
+import 'types.dart' show Types;
+
abstract class KernelClassBuilder
extends ClassBuilder<KernelTypeBuilder, InterfaceType> {
KernelClassBuilder actualOrigin;
@@ -521,7 +523,7 @@
}
void handleSeenCovariant(
- ClassHierarchy hierarchy,
+ Types types,
Member declaredMember,
Member interfaceMember,
bool isSetter,
@@ -529,9 +531,8 @@
// When a parameter is covariant we have to check that we also
// override the same member in all parents.
for (Supertype supertype in interfaceMember.enclosingClass.supers) {
- Member m = hierarchy.getInterfaceMember(
- supertype.classNode, interfaceMember.name,
- setter: isSetter);
+ Member m = types.hierarchy.getInterfaceMemberKernel(
+ supertype.classNode, interfaceMember.name, isSetter);
if (m != null) {
callback(declaredMember, m, isSetter);
}
@@ -539,8 +540,7 @@
}
void checkOverride(
- ClassHierarchy hierarchy,
- TypeEnvironment typeEnvironment,
+ Types types,
Member declaredMember,
Member interfaceMember,
bool isSetter,
@@ -556,25 +556,25 @@
if (declaredMember is Procedure && interfaceMember is Procedure) {
if (declaredMember.kind == ProcedureKind.Method &&
interfaceMember.kind == ProcedureKind.Method) {
- bool seenCovariant = checkMethodOverride(hierarchy, typeEnvironment,
- declaredMember, interfaceMember, isInterfaceCheck);
+ bool seenCovariant = checkMethodOverride(
+ types, declaredMember, interfaceMember, isInterfaceCheck);
if (seenCovariant) {
handleSeenCovariant(
- hierarchy, declaredMember, interfaceMember, isSetter, callback);
+ types, declaredMember, interfaceMember, isSetter, callback);
}
}
if (declaredMember.kind == ProcedureKind.Getter &&
interfaceMember.kind == ProcedureKind.Getter) {
- checkGetterOverride(hierarchy, typeEnvironment, declaredMember,
- interfaceMember, isInterfaceCheck);
+ checkGetterOverride(
+ types, declaredMember, interfaceMember, isInterfaceCheck);
}
if (declaredMember.kind == ProcedureKind.Setter &&
interfaceMember.kind == ProcedureKind.Setter) {
- bool seenCovariant = checkSetterOverride(hierarchy, typeEnvironment,
- declaredMember, interfaceMember, isInterfaceCheck);
+ bool seenCovariant = checkSetterOverride(
+ types, declaredMember, interfaceMember, isInterfaceCheck);
if (seenCovariant) {
handleSeenCovariant(
- hierarchy, declaredMember, interfaceMember, isSetter, callback);
+ types, declaredMember, interfaceMember, isSetter, callback);
}
}
} else {
@@ -582,19 +582,24 @@
declaredMember is Procedure && declaredMember.isGetter;
bool interfaceMemberHasGetter = interfaceMember is Field ||
interfaceMember is Procedure && interfaceMember.isGetter;
- bool declaredMemberHasSetter = declaredMember is Field ||
+ bool declaredMemberHasSetter = (declaredMember is Field &&
+ !declaredMember.isFinal &&
+ !declaredMember.isConst) ||
declaredMember is Procedure && declaredMember.isSetter;
- bool interfaceMemberHasSetter = interfaceMember is Field ||
+ bool interfaceMemberHasSetter = (interfaceMember is Field &&
+ !interfaceMember.isFinal &&
+ !interfaceMember.isConst) ||
interfaceMember is Procedure && interfaceMember.isSetter;
if (declaredMemberHasGetter && interfaceMemberHasGetter) {
- checkGetterOverride(hierarchy, typeEnvironment, declaredMember,
- interfaceMember, isInterfaceCheck);
- } else if (declaredMemberHasSetter && interfaceMemberHasSetter) {
- bool seenCovariant = checkSetterOverride(hierarchy, typeEnvironment,
- declaredMember, interfaceMember, isInterfaceCheck);
+ checkGetterOverride(
+ types, declaredMember, interfaceMember, isInterfaceCheck);
+ }
+ if (declaredMemberHasSetter && interfaceMemberHasSetter) {
+ bool seenCovariant = checkSetterOverride(
+ types, declaredMember, interfaceMember, isInterfaceCheck);
if (seenCovariant) {
handleSeenCovariant(
- hierarchy, declaredMember, interfaceMember, isSetter, callback);
+ types, declaredMember, interfaceMember, isSetter, callback);
}
}
}
@@ -602,85 +607,10 @@
}
void checkOverrides(
- ClassHierarchy hierarchy, TypeEnvironment typeEnvironment) {
- void overridePairCallback(
- Member declaredMember, Member interfaceMember, bool isSetter) {
- checkOverride(hierarchy, typeEnvironment, declaredMember, interfaceMember,
- isSetter, overridePairCallback);
- }
-
- hierarchy.forEachOverridePair(cls, overridePairCallback);
- }
+ ClassHierarchy hierarchy, TypeEnvironment typeEnvironment) {}
void checkAbstractMembers(CoreTypes coreTypes, ClassHierarchy hierarchy,
- TypeEnvironment typeEnvironment) {
- // TODO(ahe): Move this to [ClassHierarchyBuilder].
- if (isAbstract) {
- // Unimplemented members allowed
- return;
- }
-
- bool mustHaveImplementation(Member member) {
- // Public member
- if (!member.name.isPrivate) return true;
- // Private member in different library
- if (member.enclosingLibrary != cls.enclosingLibrary) return false;
- // Private member in patch
- if (member.fileUri != member.enclosingClass.fileUri) return false;
- // Private member in same library
- return true;
- }
-
- void overridePairCallback(
- Member declaredMember, Member interfaceMember, bool isSetter) {
- checkOverride(hierarchy, typeEnvironment, declaredMember, interfaceMember,
- isSetter, overridePairCallback,
- isInterfaceCheck: true);
- }
-
- void findMissingImplementations({bool setters}) {
- List<Member> dispatchTargets =
- hierarchy.getDispatchTargets(cls, setters: setters);
- int targetIndex = 0;
- for (Member interfaceMember
- in hierarchy.getInterfaceMembers(cls, setters: setters)) {
- if (mustHaveImplementation(interfaceMember)) {
- while (targetIndex < dispatchTargets.length &&
- ClassHierarchy.compareMembers(
- dispatchTargets[targetIndex], interfaceMember) <
- 0) {
- targetIndex++;
- }
- bool foundTarget = targetIndex < dispatchTargets.length &&
- ClassHierarchy.compareMembers(
- dispatchTargets[targetIndex], interfaceMember) <=
- 0;
- if (foundTarget) {
- Member dispatchTarget = dispatchTargets[targetIndex];
- while (dispatchTarget is Procedure &&
- !dispatchTarget.isExternal &&
- dispatchTarget.forwardingStubSuperTarget != null) {
- dispatchTarget =
- (dispatchTarget as Procedure).forwardingStubSuperTarget;
- }
- while (interfaceMember is Procedure &&
- !interfaceMember.isExternal &&
- interfaceMember.forwardingStubInterfaceTarget != null) {
- interfaceMember =
- (interfaceMember as Procedure).forwardingStubInterfaceTarget;
- }
- if (!hierarchy.isSubtypeOf(dispatchTarget.enclosingClass,
- interfaceMember.enclosingClass)) {
- overridePairCallback(dispatchTarget, interfaceMember, setters);
- }
- }
- }
- }
- }
-
- findMissingImplementations(setters: false);
- findMissingImplementations(setters: true);
- }
+ TypeEnvironment typeEnvironment) {}
bool hasUserDefinedNoSuchMethod(
Class klass, ClassHierarchy hierarchy, Class objectClass) {
@@ -907,7 +837,7 @@
}
Substitution _computeInterfaceSubstitution(
- ClassHierarchy hierarchy,
+ Types types,
Member declaredMember,
Member interfaceMember,
FunctionNode declaredFunction,
@@ -915,8 +845,9 @@
bool isInterfaceCheck) {
Substitution interfaceSubstitution = Substitution.empty;
if (interfaceMember.enclosingClass.typeParameters.isNotEmpty) {
- interfaceSubstitution = Substitution.fromSupertype(
- hierarchy.getClassAsInstanceOf(cls, interfaceMember.enclosingClass));
+ interfaceSubstitution = Substitution.fromInterfaceType(types.hierarchy
+ .getKernelTypeAsInstanceOf(
+ cls.thisType, interfaceMember.enclosingClass));
}
if (declaredFunction?.typeParameters?.length !=
interfaceFunction?.typeParameters?.length) {
@@ -983,17 +914,18 @@
}
Substitution _computeDeclaredSubstitution(
- ClassHierarchy hierarchy, Member declaredMember) {
+ Types types, Member declaredMember) {
Substitution declaredSubstitution = Substitution.empty;
if (declaredMember.enclosingClass.typeParameters.isNotEmpty) {
- declaredSubstitution = Substitution.fromSupertype(
- hierarchy.getClassAsInstanceOf(cls, declaredMember.enclosingClass));
+ declaredSubstitution = Substitution.fromInterfaceType(types.hierarchy
+ .getKernelTypeAsInstanceOf(
+ cls.thisType, declaredMember.enclosingClass));
}
return declaredSubstitution;
}
- bool _checkTypes(
- TypeEnvironment typeEnvironment,
+ void _checkTypes(
+ Types types,
Substitution interfaceSubstitution,
Substitution declaredSubstitution,
Member declaredMember,
@@ -1004,7 +936,7 @@
VariableDeclaration declaredParameter,
bool isInterfaceCheck,
{bool asIfDeclaredParameter = false}) {
- if (library.loader.target.backendTarget.legacyMode) return false;
+ if (library.loader.target.backendTarget.legacyMode) return;
if (interfaceSubstitution != null) {
interfaceType = interfaceSubstitution.substituteType(interfaceType);
@@ -1017,9 +949,9 @@
DartType subtype = inParameter ? interfaceType : declaredType;
DartType supertype = inParameter ? declaredType : interfaceType;
- if (typeEnvironment.isSubtypeOf(subtype, supertype)) {
+ if (types.isSubtypeOfKernel(subtype, supertype)) {
// No problem--the proper subtyping relation is satisfied.
- } else if (isCovariant && typeEnvironment.isSubtypeOf(supertype, subtype)) {
+ } else if (isCovariant && types.isSubtypeOfKernel(supertype, subtype)) {
// No problem--the overriding parameter is marked "covariant" and has
// a type which is a subtype of the parameter it overrides.
} else if (subtype is InvalidType || supertype is InvalidType) {
@@ -1057,19 +989,13 @@
interfaceMember.fileOffset, noLength)
] +
inheritedContext(isInterfaceCheck, declaredMember));
- return true;
}
- return false;
}
/// Returns whether a covariant parameter was seen and more methods thus have
/// to be checked.
- bool checkMethodOverride(
- ClassHierarchy hierarchy,
- TypeEnvironment typeEnvironment,
- Procedure declaredMember,
- Procedure interfaceMember,
- bool isInterfaceCheck) {
+ bool checkMethodOverride(Types types, Procedure declaredMember,
+ Procedure interfaceMember, bool isInterfaceCheck) {
assert(declaredMember.kind == ProcedureKind.Method);
assert(interfaceMember.kind == ProcedureKind.Method);
bool seenCovariant = false;
@@ -1077,7 +1003,7 @@
FunctionNode interfaceFunction = interfaceMember.function;
Substitution interfaceSubstitution = _computeInterfaceSubstitution(
- hierarchy,
+ types,
declaredMember,
interfaceMember,
declaredFunction,
@@ -1085,10 +1011,10 @@
isInterfaceCheck);
Substitution declaredSubstitution =
- _computeDeclaredSubstitution(hierarchy, declaredMember);
+ _computeDeclaredSubstitution(types, declaredMember);
_checkTypes(
- typeEnvironment,
+ types,
interfaceSubstitution,
declaredSubstitution,
declaredMember,
@@ -1143,7 +1069,7 @@
var declaredParameter = declaredFunction.positionalParameters[i];
var interfaceParameter = interfaceFunction.positionalParameters[i];
_checkTypes(
- typeEnvironment,
+ types,
interfaceSubstitution,
declaredSubstitution,
declaredMember,
@@ -1220,7 +1146,7 @@
}
var declaredParameter = declaredNamedParameters.current;
_checkTypes(
- typeEnvironment,
+ types,
interfaceSubstitution,
declaredSubstitution,
declaredMember,
@@ -1235,25 +1161,16 @@
return seenCovariant;
}
- void checkGetterOverride(
- ClassHierarchy hierarchy,
- TypeEnvironment typeEnvironment,
- Member declaredMember,
- Member interfaceMember,
- bool isInterfaceCheck) {
+ void checkGetterOverride(Types types, Member declaredMember,
+ Member interfaceMember, bool isInterfaceCheck) {
Substitution interfaceSubstitution = _computeInterfaceSubstitution(
- hierarchy,
- declaredMember,
- interfaceMember,
- null,
- null,
- isInterfaceCheck);
+ types, declaredMember, interfaceMember, null, null, isInterfaceCheck);
Substitution declaredSubstitution =
- _computeDeclaredSubstitution(hierarchy, declaredMember);
+ _computeDeclaredSubstitution(types, declaredMember);
var declaredType = declaredMember.getterType;
var interfaceType = interfaceMember.getterType;
_checkTypes(
- typeEnvironment,
+ types,
interfaceSubstitution,
declaredSubstitution,
declaredMember,
@@ -1267,29 +1184,25 @@
/// Returns whether a covariant parameter was seen and more methods thus have
/// to be checked.
- bool checkSetterOverride(
- ClassHierarchy hierarchy,
- TypeEnvironment typeEnvironment,
- Member declaredMember,
- Member interfaceMember,
- bool isInterfaceCheck) {
+ bool checkSetterOverride(Types types, Member declaredMember,
+ Member interfaceMember, bool isInterfaceCheck) {
Substitution interfaceSubstitution = _computeInterfaceSubstitution(
- hierarchy,
- declaredMember,
- interfaceMember,
- null,
- null,
- isInterfaceCheck);
+ types, declaredMember, interfaceMember, null, null, isInterfaceCheck);
Substitution declaredSubstitution =
- _computeDeclaredSubstitution(hierarchy, declaredMember);
+ _computeDeclaredSubstitution(types, declaredMember);
var declaredType = declaredMember.setterType;
var interfaceType = interfaceMember.setterType;
var declaredParameter =
declaredMember.function?.positionalParameters?.elementAt(0);
bool isCovariant = declaredParameter?.isCovariant ?? false;
- if (declaredMember is Field) isCovariant = declaredMember.isCovariant;
+ if (!isCovariant && declaredMember is Field) {
+ isCovariant = declaredMember.isCovariant;
+ }
+ if (!isCovariant && interfaceMember is Field) {
+ isCovariant = interfaceMember.isCovariant;
+ }
_checkTypes(
- typeEnvironment,
+ types,
interfaceSubstitution,
declaredSubstitution,
declaredMember,
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart
index d34ba34..b8fc291 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart
@@ -26,8 +26,6 @@
TreeNode,
VariableGet;
-import 'kernel_shadow_ast.dart' show ShadowClass;
-
import '../fasta_codes.dart'
show
LocatedMessage,
@@ -86,7 +84,7 @@
String name,
Scope scope,
Scope constructors,
- ShadowClass cls,
+ Class cls,
this.enumConstantInfos,
this.intType,
this.listType,
@@ -114,7 +112,7 @@
KernelTypeBuilder stringType = new KernelNamedTypeBuilder("String", null);
KernelNamedTypeBuilder objectType =
new KernelNamedTypeBuilder("Object", null);
- ShadowClass cls = new ShadowClass(name: name);
+ Class cls = new Class(name: name);
Map<String, MemberBuilder> members = <String, MemberBuilder>{};
Map<String, MemberBuilder> constructors = <String, MemberBuilder>{};
KernelNamedTypeBuilder selfType = new KernelNamedTypeBuilder(name, null);
@@ -253,7 +251,6 @@
members.forEach(setParent);
constructors.forEach(setParent);
selfType.bind(enumBuilder);
- ShadowClass.setBuilder(cls, enumBuilder);
return enumBuilder;
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart
index 904f47d..82987a8 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart
@@ -5,15 +5,22 @@
library fasta.kernel_field_builder;
import 'package:kernel/ast.dart'
- show Class, DartType, DynamicType, Expression, Field, Name, NullLiteral;
+ show Class, DartType, Expression, Field, InvalidType, Name, NullLiteral;
-import '../fasta_codes.dart' show messageInternalProblemAlreadyInitialized;
+import '../fasta_codes.dart'
+ show
+ messageInternalProblemAlreadyInitialized,
+ templateCantInferTypeDueToCircularity;
-import '../problems.dart' show internalProblem, unsupported;
+import '../problems.dart' show internalProblem;
import '../type_inference/type_inference_engine.dart'
show IncludesTypeParametersCovariantly;
+import '../type_inference/type_inferrer.dart' show TypeInferrerImpl;
+
+import '../type_inference/type_schema.dart' show UnknownType;
+
import 'kernel_body_builder.dart' show KernelBodyBuilder;
import 'kernel_builder.dart'
@@ -26,17 +33,16 @@
KernelTypeBuilder,
MetadataBuilder;
-import 'kernel_shadow_ast.dart' show ShadowField;
-
class KernelFieldBuilder extends FieldBuilder<Expression> {
- final ShadowField field;
+ final Field field;
final List<MetadataBuilder> metadata;
final KernelTypeBuilder type;
+ bool hadTypesInferred = false;
+
KernelFieldBuilder(this.metadata, this.type, String name, int modifiers,
Declaration compilationUnit, int charOffset, int charEndOffset)
- : field = new ShadowField(null, type == null,
- fileUri: compilationUnit?.fileUri)
+ : field = new Field(null, fileUri: compilationUnit?.fileUri)
..fileOffset = charOffset
..fileEndOffset = charEndOffset,
super(name, modifiers, compilationUnit, charOffset);
@@ -84,32 +90,76 @@
..hasImplicitGetter = isInstanceMember
..hasImplicitSetter = isInstanceMember && !isConst && !isFinal
..isStatic = !isInstanceMember;
- if (isEligibleForInference && !isInstanceMember) {
- library.loader.typeInferenceEngine
- .recordStaticFieldInferenceCandidate(field, library);
- }
return field;
}
Field get target => field;
- void prepareTopLevelInference() {
- if (!isEligibleForInference) return;
+ @override
+ void inferType() {
KernelLibraryBuilder library = this.library;
- var typeInferrer = library.loader.typeInferenceEngine
- .createTopLevelTypeInferrer(
- field.enclosingClass?.thisType, field, null);
- if (hasInitializer) {
- if (field.type is! ImplicitFieldType) {
- unsupported(
- "$name has unexpected type ${field.type}", charOffset, fileUri);
- return;
- }
- ImplicitFieldType type = field.type;
- field.type = const DynamicType();
- initializer = new KernelBodyBuilder.forField(this, typeInferrer)
- .parseFieldInitializer(type.initializerToken);
+ if (field.type is! ImplicitFieldType) {
+ // We have already inferred a type.
+ return;
}
+ ImplicitFieldType type = field.type;
+ if (type.member != this) {
+ // The implicit type was inherited.
+ KernelFieldBuilder other = type.member;
+ other.inferCopiedType(field);
+ return;
+ }
+ if (type.isStarted) {
+ library.addProblem(
+ templateCantInferTypeDueToCircularity.withArguments(name),
+ charOffset,
+ name.length,
+ fileUri);
+ field.type = const InvalidType();
+ return;
+ }
+ type.isStarted = true;
+ TypeInferrerImpl typeInferrer = library.loader.typeInferenceEngine
+ .createTopLevelTypeInferrer(
+ fileUri, field.enclosingClass?.thisType, null);
+ initializer = new KernelBodyBuilder.forField(this, typeInferrer)
+ .parseFieldInitializer(type.initializerToken);
+
+ DartType inferredType = typeInferrer.inferDeclarationType(typeInferrer
+ .inferExpression(field.initializer, const UnknownType(), true,
+ isVoidAllowed: true));
+
+ if (field.type is ImplicitFieldType) {
+ // `field.type` may have changed if a circularity was detected when
+ // [inferredType] was computed.
+ field.type = inferredType;
+
+ IncludesTypeParametersCovariantly needsCheckVisitor;
+ if (parent is ClassBuilder) {
+ Class enclosingClass = parent.target;
+ if (enclosingClass.typeParameters.isNotEmpty) {
+ needsCheckVisitor = new IncludesTypeParametersCovariantly(
+ enclosingClass.typeParameters);
+ }
+ }
+ if (needsCheckVisitor != null) {
+ if (field.type.accept(needsCheckVisitor)) {
+ field.isGenericCovariantImpl = true;
+ }
+ }
+ }
+
+ // The following is a hack. The outline should contain the compiled
+ // initializers, however, as top-level inference is subtly different from
+ // we need to compile the field initializer again when everything else is
+ // compiled.
+ field.initializer = null;
+ }
+
+ void inferCopiedType(Field other) {
+ inferType();
+ other.type = field.type;
+ other.initializer = null;
}
@override
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart
index a7fbd0a..507779e 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart
@@ -104,6 +104,8 @@
namedMixinApplicationMask,
staticMask;
+import '../names.dart' show indexSetName;
+
import '../problems.dart' show unexpected, unhandled;
import '../severity.dart' show Severity;
@@ -203,6 +205,8 @@
List<KernelFormalParameterBuilder> untypedInitializingFormals;
+ List<KernelFieldBuilder> implicitlyTypedFields;
+
KernelLibraryBuilder(Uri uri, Uri fileUri, Loader loader, this.actualOrigin,
[Scope scope, Library target])
: library = target ??
@@ -640,6 +644,7 @@
assert(type == null);
field.target.type =
new ImplicitFieldType(field, initializerTokenForInference);
+ (implicitlyTypedFields ??= <KernelFieldBuilder>[]).add(field);
}
loader.target.metadataCollector
?.setDocumentationComment(field.target, documentationComment);
@@ -705,6 +710,14 @@
String nativeMethodName,
{bool isTopLevel}) {
MetadataCollector metadataCollector = loader.target.metadataCollector;
+ if (returnType == null) {
+ if (kind == ProcedureKind.Operator &&
+ identical(name, indexSetName.name)) {
+ returnType = addVoidType(charOffset);
+ } else if (kind == ProcedureKind.Setter) {
+ returnType = addVoidType(charOffset);
+ }
+ }
ProcedureBuilder procedure = new KernelProcedureBuilder(
metadata,
modifiers,
@@ -1337,9 +1350,9 @@
}
@override
- void includePart(
+ bool includePart(
covariant KernelLibraryBuilder part, Set<Uri> usedParts, int partOffset) {
- super.includePart(part, usedParts, partOffset);
+ if (!super.includePart(part, usedParts, partOffset)) return false;
nativeMethods.addAll(part.nativeMethods);
boundlessTypeVariables.addAll(part.boundlessTypeVariables);
// Check that the targets are different. This is not normally a problem
@@ -1348,6 +1361,16 @@
target.problemsAsJson ??= <String>[];
target.problemsAsJson.addAll(part.target.problemsAsJson);
}
+ List<KernelFieldBuilder> partImplicitlyTypedFields =
+ part.takeImplicitlyTypedFields();
+ if (partImplicitlyTypedFields != null) {
+ if (implicitlyTypedFields == null) {
+ implicitlyTypedFields = partImplicitlyTypedFields;
+ } else {
+ implicitlyTypedFields.addAll(partImplicitlyTypedFields);
+ }
+ }
+ return true;
}
@override
@@ -1784,6 +1807,13 @@
untypedInitializingFormals = null;
return count;
}
+
+ @override
+ List<KernelFieldBuilder> takeImplicitlyTypedFields() {
+ List<KernelFieldBuilder> result = implicitlyTypedFields;
+ implicitlyTypedFields = null;
+ return result;
+ }
}
Uri computeLibraryUri(Declaration declaration) {
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart
index ae0e197..2edd446 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart
@@ -30,7 +30,6 @@
TypeParameter,
TypeParameterType,
VariableDeclaration,
- VoidType,
setParents;
import 'package:kernel/type_algebra.dart' show containsTypeVariable, substitute;
@@ -73,8 +72,7 @@
TypeVariableBuilder,
isRedirectingGenerativeConstructorImplementation;
-import 'kernel_shadow_ast.dart'
- show ShadowProcedure, VariableDeclarationJudgment;
+import 'kernel_shadow_ast.dart' show VariableDeclarationJudgment;
import 'redirecting_factory_body.dart' show RedirectingFactoryBody;
@@ -274,7 +272,7 @@
}
class KernelProcedureBuilder extends KernelFunctionBuilder {
- final ShadowProcedure procedure;
+ final Procedure procedure;
final int charOpenParenOffset;
AsyncMarker actualAsyncModifier = AsyncMarker.Sync;
@@ -282,6 +280,8 @@
@override
KernelProcedureBuilder actualOrigin;
+ bool hadTypesInferred = false;
+
KernelProcedureBuilder(
List<MetadataBuilder> metadata,
int modifiers,
@@ -296,11 +296,11 @@
this.charOpenParenOffset,
int charEndOffset,
[String nativeMethodName])
- : procedure = new ShadowProcedure(null, kind, null, returnType == null,
- fileUri: compilationUnit?.fileUri)
- ..startFileOffset = startCharOffset
- ..fileOffset = charOffset
- ..fileEndOffset = charEndOffset,
+ : procedure =
+ new Procedure(null, kind, null, fileUri: compilationUnit?.fileUri)
+ ..startFileOffset = startCharOffset
+ ..fileOffset = charOffset
+ ..fileEndOffset = charEndOffset,
super(metadata, modifiers, returnType, name, typeVariables, formals,
compilationUnit, charOffset, nativeMethodName);
@@ -353,11 +353,6 @@
procedure.isConst = isConst;
procedure.name = new Name(name, library.target);
}
- if (!library.loader.target.legacyMode &&
- (isSetter || (isOperator && name == '[]=')) &&
- returnType == null) {
- procedure.function.returnType = const VoidType();
- }
return procedure;
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart
index b0ebe25..b0f9c9e 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart
@@ -62,10 +62,8 @@
import '../type_inference/inference_helper.dart' show InferenceHelper;
-import '../type_inference/interface_resolver.dart' show InterfaceResolver;
-
import '../type_inference/type_inference_engine.dart'
- show IncludesTypeParametersCovariantly, InferenceNode, TypeInferenceEngine;
+ show IncludesTypeParametersCovariantly, TypeInferenceEngine;
import '../type_inference/type_inferrer.dart'
show ExpressionInferenceResult, TypeInferrer, TypeInferrerImpl;
@@ -273,59 +271,6 @@
}
}
-/// Shadow object representing a class in kernel form.
-class ShadowClass extends Class {
- ClassInferenceInfo _inferenceInfo;
-
- ShadowClass(
- {String name,
- Supertype supertype,
- Supertype mixedInType,
- List<TypeParameter> typeParameters,
- List<Supertype> implementedTypes,
- List<Procedure> procedures,
- List<Field> fields})
- : super(
- name: name,
- supertype: supertype,
- mixedInType: mixedInType,
- typeParameters: typeParameters,
- implementedTypes: implementedTypes,
- procedures: procedures,
- fields: fields);
-
- /// Resolves all forwarding nodes for this class, propagates covariance
- /// annotations, and creates forwarding stubs as needed.
- void finalizeCovariance(InterfaceResolver interfaceResolver) {
- interfaceResolver.finalizeCovariance(
- this, _inferenceInfo.gettersAndMethods, _inferenceInfo.builder.library);
- interfaceResolver.finalizeCovariance(
- this, _inferenceInfo.setters, _inferenceInfo.builder.library);
- }
-
- /// Creates API members for this class.
- void setupApiMembers(InterfaceResolver interfaceResolver) {
- interfaceResolver.createApiMembers(this, _inferenceInfo.gettersAndMethods,
- _inferenceInfo.setters, _inferenceInfo.builder.library);
- }
-
- static void clearClassInferenceInfo(ShadowClass class_) {
- class_._inferenceInfo = null;
- }
-
- static ClassInferenceInfo getClassInferenceInfo(Class class_) {
- if (class_ is ShadowClass) return class_._inferenceInfo;
- return null;
- }
-
- /// Initializes the class inference information associated with the given
- /// [class_], starting with the fact that it is associated with the given
- /// [builder].
- static void setBuilder(ShadowClass class_, SourceClassBuilder builder) {
- class_._inferenceInfo = new ClassInferenceInfo(builder);
- }
-}
-
/// Abstract shadow object representing a complex assignment in kernel form.
///
/// Since there are many forms a complex assignment might have been desugared
@@ -628,32 +573,6 @@
}
}
-/// Concrete shadow object representing a field in kernel form.
-class ShadowField extends Field implements ShadowMember {
- @override
- InferenceNode inferenceNode;
-
- ShadowTypeInferrer _typeInferrer;
-
- final bool _isImplicitlyTyped;
-
- ShadowField(Name name, this._isImplicitlyTyped, {Uri fileUri})
- : super(name, fileUri: fileUri) {}
-
- @override
- void setInferredType(
- TypeInferenceEngine engine, Uri uri, DartType inferredType) {
- type = inferredType;
- }
-
- static bool isImplicitlyTyped(ShadowField field) => field._isImplicitlyTyped;
-
- static void setInferenceNode(ShadowField field, InferenceNode node) {
- assert(field.inferenceNode == null);
- field.inferenceNode = node;
- }
-}
-
/// Concrete shadow object representing a field initializer in kernel form.
class ShadowFieldInitializer extends FieldInitializer
implements InitializerJudgment {
@@ -993,18 +912,6 @@
}
}
-/// Abstract shadow object representing a field or procedure in kernel form.
-abstract class ShadowMember implements Member {
- Uri get fileUri;
-
- InferenceNode get inferenceNode;
-
- void set inferenceNode(InferenceNode value);
-
- void setInferredType(
- TypeInferenceEngine engine, Uri uri, DartType inferredType);
-}
-
/// Shadow object for [MethodInvocation].
class MethodInvocationJudgment extends MethodInvocation
implements ExpressionJudgment {
@@ -1103,37 +1010,6 @@
}
}
-/// Concrete shadow object representing a procedure in kernel form.
-class ShadowProcedure extends Procedure implements ShadowMember {
- @override
- InferenceNode inferenceNode;
-
- final bool _hasImplicitReturnType;
-
- ShadowProcedure(Name name, ProcedureKind kind, FunctionNode function,
- this._hasImplicitReturnType,
- {Uri fileUri, bool isAbstract: false})
- : super(name, kind, function, fileUri: fileUri, isAbstract: isAbstract);
-
- @override
- void setInferredType(
- TypeInferenceEngine engine, Uri uri, DartType inferredType) {
- if (isSetter) {
- if (function.positionalParameters.length > 0) {
- function.positionalParameters[0].type = inferredType;
- }
- } else if (isGetter) {
- function.returnType = inferredType;
- } else {
- unhandled("setInferredType", "not accessor", fileOffset, uri);
- }
- }
-
- static bool hasImplicitReturnType(ShadowProcedure procedure) {
- return procedure._hasImplicitReturnType;
- }
-}
-
/// Concrete shadow object representing an assignment to a property.
class PropertyAssignmentJudgment extends ComplexAssignmentJudgmentWithReceiver {
/// If this assignment uses null-aware access (`?.`), the conditional
@@ -1463,14 +1339,8 @@
@override
ShadowTypeInferrer createTopLevelTypeInferrer(
- InterfaceType thisType, ShadowField field, KernelLibraryBuilder library) {
- return field._typeInferrer =
- new TypeInferrer(this, field.fileUri, true, thisType, library);
- }
-
- @override
- ShadowTypeInferrer getFieldTypeInferrer(ShadowField field) {
- return field._typeInferrer;
+ Uri uri, InterfaceType thisType, KernelLibraryBuilder library) {
+ return new TypeInferrer(this, uri, true, thisType, library);
}
}
@@ -1486,7 +1356,7 @@
super.private(engine, uri, topLevel, thisType, library);
@override
- Expression getFieldInitializer(ShadowField field) {
+ Expression getFieldInitializer(Field field) {
return field.initializer;
}
@@ -1529,13 +1399,6 @@
}
@override
- DartType inferFieldTopLevel(ShadowField field) {
- if (field.initializer == null) return const DynamicType();
- return inferExpression(field.initializer, const UnknownType(), true,
- isVoidAllowed: true);
- }
-
- @override
void inferInitializer(
InferenceHelper helper, kernel.Initializer initializer) {
assert(initializer is InitializerJudgment);
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
index a8166db..d329a82 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
@@ -87,7 +87,6 @@
import 'kernel_builder.dart'
show
ClassBuilder,
- ClassHierarchyBuilder,
Declaration,
InvalidTypeBuilder,
KernelClassBuilder,
@@ -149,8 +148,6 @@
loader = createLoader();
}
- void set builderHierarchy(ClassHierarchyBuilder o) {}
-
SourceLoader createLoader() =>
new SourceLoader(fileSystem, includeComments, this);
@@ -265,8 +262,7 @@
component =
link(new List<Library>.from(loader.libraries), nameRoot: nameRoot);
computeCoreTypes();
- builderHierarchy =
- loader.buildClassHierarchy(myClasses, objectClassBuilder);
+ loader.buildClassHierarchy(myClasses, objectClassBuilder);
loader.computeHierarchy();
loader.performTopLevelInference(myClasses);
loader.checkSupertypes(myClasses);
diff --git a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
index be97aab..2e8f07b 100644
--- a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
@@ -38,19 +38,17 @@
TypeVariableBuilder,
compareProcedures;
-import '../kernel/kernel_shadow_ast.dart' show ShadowClass;
-
import '../problems.dart' show unexpected, unhandled;
-ShadowClass initializeClass(
- ShadowClass cls,
+Class initializeClass(
+ Class cls,
List<TypeVariableBuilder> typeVariables,
String name,
KernelLibraryBuilder parent,
int startCharOffset,
int charOffset,
int charEndOffset) {
- cls ??= new ShadowClass(
+ cls ??= new Class(
name: name,
typeParameters:
KernelTypeVariableBuilder.kernelTypeParametersFromBuilders(
@@ -100,12 +98,10 @@
: actualCls = initializeClass(cls, typeVariables, name, parent,
startCharOffset, charOffset, charEndOffset),
super(metadata, modifiers, name, typeVariables, supertype, interfaces,
- scope, constructors, parent, charOffset) {
- ShadowClass.setBuilder(this.cls, this);
- }
+ scope, constructors, parent, charOffset);
@override
- ShadowClass get cls => origin.actualCls;
+ Class get cls => origin.actualCls;
@override
KernelLibraryBuilder get library => super.library;
@@ -242,20 +238,6 @@
constructorScopeBuilder.addMember(name, memberBuilder);
}
- void prepareTopLevelInference() {
- scope.forEach((String name, Declaration declaration) {
- do {
- if (declaration is KernelFieldBuilder) {
- declaration.prepareTopLevelInference();
- }
- declaration = declaration.next;
- } while (declaration != null);
- });
- if (!isPatch) {
- cls.setupApiMembers(library.loader.interfaceResolver);
- }
- }
-
@override
int finishPatch() {
if (!isPatch) return 0;
diff --git a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
index 7aadb95..9caf738 100644
--- a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
@@ -696,7 +696,7 @@
}
}
- void includePart(
+ bool includePart(
SourceLibraryBuilder<T, R> part, Set<Uri> usedParts, int partOffset) {
if (part.partOfUri != null) {
if (uriIsValid(part.partOfUri) && part.partOfUri != uri) {
@@ -708,7 +708,7 @@
partOffset,
noLength,
fileUri);
- return;
+ return false;
}
} else if (part.partOfName != null) {
if (name != null) {
@@ -721,7 +721,7 @@
partOffset,
noLength,
fileUri);
- return;
+ return false;
}
} else {
// This is an error, but the part is not removed from the list of parts,
@@ -732,7 +732,7 @@
partOffset,
noLength,
fileUri);
- return;
+ return false;
}
} else {
// This is an error, but the part is not removed from the list of parts,
@@ -742,7 +742,7 @@
addProblem(templateMissingPartOf.withArguments(part.fileUri),
partOffset, noLength, fileUri);
}
- return;
+ return false;
}
part.validatePart(this, usedParts);
NameIterator partDeclarations = part.nameIterator;
@@ -791,6 +791,7 @@
part.partOfLibrary = this;
part.scope.becomePartOf(scope);
// TODO(ahe): Include metadata from part?
+ return true;
}
void buildInitialScopes() {
diff --git a/pkg/front_end/lib/src/fasta/source/source_loader.dart b/pkg/front_end/lib/src/fasta/source/source_loader.dart
index 470caa2..c80258b 100644
--- a/pkg/front_end/lib/src/fasta/source/source_loader.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_loader.dart
@@ -68,17 +68,18 @@
templateSourceOutlineSummary,
templateUntranslatableUri;
-import '../kernel/kernel_shadow_ast.dart'
- show ShadowClass, ShadowTypeInferenceEngine;
+import '../kernel/kernel_shadow_ast.dart' show ShadowTypeInferenceEngine;
import '../kernel/kernel_builder.dart'
show
ClassBuilder,
ClassHierarchyBuilder,
Declaration,
+ DelayedMember,
+ DelayedOverrideCheck,
EnumBuilder,
+ FieldBuilder,
KernelClassBuilder,
- KernelFieldBuilder,
KernelProcedureBuilder,
KernelTypeBuilder,
LibraryBuilder,
@@ -105,8 +106,6 @@
import '../scanner.dart' show ErrorToken, ScannerResult, Token, scan;
-import '../type_inference/interface_resolver.dart' show InterfaceResolver;
-
import 'diet_listener.dart' show DietListener;
import 'diet_parser.dart' show DietParser;
@@ -126,6 +125,8 @@
final Map<Uri, List<int>> sourceBytes = <Uri, List<int>>{};
+ ClassHierarchyBuilder builderHierarchy;
+
// Used when building directly to kernel.
ClassHierarchy hierarchy;
CoreTypes coreTypes;
@@ -136,8 +137,6 @@
ShadowTypeInferenceEngine typeInferenceEngine;
- InterfaceResolver interfaceResolver;
-
Instrumentation instrumentation;
CollectionTransformer collectionTransformer;
@@ -588,6 +587,10 @@
break;
}
}
+ if (allSupertypesProcessed && cls.isPatch) {
+ allSupertypesProcessed =
+ topologicallySortedClasses.contains(cls.origin);
+ }
if (allSupertypesProcessed) {
topologicallySortedClasses.add(cls);
checkClassSupertypes(cls, directSupertypes, blackListedClasses);
@@ -863,27 +866,33 @@
}
void checkOverrides(List<SourceClassBuilder> sourceClasses) {
- assert(hierarchy != null);
- for (SourceClassBuilder builder in sourceClasses) {
- if (builder.library.loader == this && !builder.isPatch) {
- builder.checkOverrides(
- hierarchy, typeInferenceEngine?.typeSchemaEnvironment);
- }
+ List<DelayedOverrideCheck> overrideChecks =
+ builderHierarchy.overrideChecks.toList();
+ builderHierarchy.overrideChecks.clear();
+ for (int i = 0; i < overrideChecks.length; i++) {
+ overrideChecks[i].check(builderHierarchy);
}
- ticker.logMs("Checked overrides");
+ ticker.logMs("Checked ${overrideChecks.length} overrides");
+
+ typeInferenceEngine?.finishTopLevelInitializingFormals();
+ ticker.logMs("Finished initializing formals");
}
void checkAbstractMembers(List<SourceClassBuilder> sourceClasses) {
- // TODO(ahe): Move this to [ClassHierarchyBuilder].
- if (target.legacyMode) return;
- assert(hierarchy != null);
- for (SourceClassBuilder builder in sourceClasses) {
- if (builder.library.loader == this && !builder.isPatch) {
- builder.checkAbstractMembers(
- coreTypes, hierarchy, typeInferenceEngine.typeSchemaEnvironment);
- }
+ List<DelayedMember> delayedMemberChecks =
+ builderHierarchy.delayedMemberChecks.toList();
+ builderHierarchy.delayedMemberChecks.clear();
+ Set<Class> changedClasses = new Set<Class>();
+ for (int i = 0; i < delayedMemberChecks.length; i++) {
+ delayedMemberChecks[i].check(builderHierarchy);
+ changedClasses.add(delayedMemberChecks[i].parent.cls);
}
- ticker.logMs("Checked abstract members");
+ ticker.logMs(
+ "Computed ${delayedMemberChecks.length} combined member signatures");
+
+ hierarchy.applyMemberChanges(changedClasses, findDescendants: false);
+ ticker
+ .logMs("Updated ${changedClasses.length} classes in kernel hierarchy");
}
void checkRedirectingFactories(List<SourceClassBuilder> sourceClasses) {
@@ -930,12 +939,12 @@
ticker.logMs("Checked mixin declaration applications");
}
- ClassHierarchyBuilder buildClassHierarchy(
+ void buildClassHierarchy(
List<SourceClassBuilder> sourceClasses, ClassBuilder objectClass) {
- ClassHierarchyBuilder hierarchy = ClassHierarchyBuilder.build(
+ builderHierarchy = ClassHierarchyBuilder.build(
objectClass, sourceClasses, this, coreTypes);
+ typeInferenceEngine?.hierarchyBuilder = builderHierarchy;
ticker.logMs("Built class hierarchy");
- return hierarchy;
}
void createTypeInferenceEngine() {
@@ -951,58 +960,30 @@
/// might be subject to type inference, and records dependencies between
/// them.
typeInferenceEngine.prepareTopLevel(coreTypes, hierarchy);
- interfaceResolver = new InterfaceResolver(typeInferenceEngine,
- typeInferenceEngine.typeSchemaEnvironment, instrumentation);
+ List<FieldBuilder> allImplicitlyTypedFields = <FieldBuilder>[];
for (LibraryBuilder library in builders.values) {
if (library.loader == this) {
- Iterator<Declaration> iterator = library.iterator;
- while (iterator.moveNext()) {
- Declaration member = iterator.current;
- if (member is KernelFieldBuilder) {
- member.prepareTopLevelInference();
- }
+ List<FieldBuilder> implicitlyTypedFields =
+ library.takeImplicitlyTypedFields();
+ if (implicitlyTypedFields != null) {
+ allImplicitlyTypedFields.addAll(implicitlyTypedFields);
}
}
}
- for (int i = 0; i < sourceClasses.length; i++) {
- sourceClasses[i].prepareTopLevelInference();
+
+ for (int i = 0; i < allImplicitlyTypedFields.length; i++) {
+ // TODO(ahe): This can cause a crash for parts that failed to get
+ // included, see for example,
+ // tests/standalone_2/io/http_cookie_date_test.dart.
+ allImplicitlyTypedFields[i].inferType();
}
+
typeInferenceEngine.isTypeInferencePrepared = true;
- ticker.logMs("Prepared top level inference");
- /// The second phase of top level initializer inference, which is to visit
- /// fields and top level variables in topologically-sorted order and assign
- /// their types.
- typeInferenceEngine.finishTopLevelFields();
- List<Class> changedClasses = new List<Class>();
- for (var builder in sourceClasses) {
- if (builder.isPatch) continue;
- ShadowClass class_ = builder.target;
- int memberCount = class_.fields.length +
- class_.constructors.length +
- class_.procedures.length +
- class_.redirectingFactoryConstructors.length;
- class_.finalizeCovariance(interfaceResolver);
- ShadowClass.clearClassInferenceInfo(class_);
- int newMemberCount = class_.fields.length +
- class_.constructors.length +
- class_.procedures.length +
- class_.redirectingFactoryConstructors.length;
- if (newMemberCount != memberCount) {
- // The inference potentially adds new members (but doesn't otherwise
- // change the classes), so if the member count has changed we need to
- // update the class in the class hierarchy.
- changedClasses.add(class_);
- }
- }
-
- typeInferenceEngine.finishTopLevelInitializingFormals();
- interfaceResolver = null;
// Since finalization of covariance may have added forwarding stubs, we need
// to recompute the class hierarchy so that method compilation will properly
// target those forwarding stubs.
hierarchy.onAmbiguousSupertypes = ignoreAmbiguousSupertypes;
- hierarchy.applyMemberChanges(changedClasses, findDescendants: true);
ticker.logMs("Performed top level inference");
}
diff --git a/pkg/front_end/lib/src/fasta/type_inference/interface_resolver.dart b/pkg/front_end/lib/src/fasta/type_inference/interface_resolver.dart
deleted file mode 100644
index d596481..0000000
--- a/pkg/front_end/lib/src/fasta/type_inference/interface_resolver.dart
+++ /dev/null
@@ -1,1234 +0,0 @@
-// 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.md file.
-
-import 'package:kernel/ast.dart'
- show
- Arguments,
- Class,
- DartType,
- DynamicType,
- Expression,
- Field,
- FunctionNode,
- FunctionType,
- InvalidType,
- Member,
- Name,
- NamedExpression,
- Procedure,
- ProcedureKind,
- ReturnStatement,
- SuperMethodInvocation,
- SuperPropertyGet,
- SuperPropertySet,
- TypeParameter,
- TypeParameterType,
- VariableDeclaration,
- VariableGet,
- VoidType;
-
-import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
-
-import 'package:kernel/transformations/flags.dart' show TransformerFlag;
-
-import 'package:kernel/type_algebra.dart' show Substitution;
-
-import 'package:kernel/src/hierarchy_based_type_environment.dart'
- show HierarchyBasedTypeEnvironment;
-
-import '../../base/instrumentation.dart'
- show Instrumentation, InstrumentationValueLiteral;
-
-import '../builder/builder.dart' show LibraryBuilder;
-
-import '../kernel/kernel_library_builder.dart' show KernelLibraryBuilder;
-
-import '../kernel/kernel_shadow_ast.dart'
- show ShadowClass, ShadowField, ShadowProcedure, VariableDeclarationJudgment;
-
-import '../messages.dart'
- show
- noLength,
- templateCantInferTypeDueToCircularity,
- templateCantInferTypeDueToInconsistentOverrides;
-
-import '../names.dart' show indexSetName;
-
-import '../problems.dart' show unhandled;
-
-import 'type_inference_engine.dart'
- show
- FieldInitializerInferenceNode,
- IncludesTypeParametersCovariantly,
- InferenceNode,
- TypeInferenceEngine;
-
-import 'type_inferrer.dart' show getNamedFormal;
-
-import 'type_schema_environment.dart'
- show
- getNamedParameterType,
- getPositionalParameterType,
- substituteTypeParams;
-
-/// Concrete class derived from [InferenceNode] to represent type inference of
-/// getters, setters, and fields based on inheritance.
-class AccessorInferenceNode extends InferenceNode {
- final InterfaceResolver _interfaceResolver;
-
- /// The method whose return type and/or parameter types should be inferred.
- final Procedure _declaredMethod;
-
- /// A list containing the methods overridden by [_declaredMethod], if any.
- final List<Member> _candidates;
-
- /// The index of the first method in [_candidates] overridden by
- /// [_declaredMethod].
- final int _start;
-
- /// The past-the-end index of the last method in [_candidates] overridden by
- /// [_declaredMethod].
- final int _end;
-
- final LibraryBuilder _library;
-
- final Uri _fileUri;
-
- AccessorInferenceNode(this._interfaceResolver, this._declaredMethod,
- this._candidates, this._start, this._end, this._library, this._fileUri);
-
- String get _name {
- if (_declaredMethod is! SyntheticAccessor && _declaredMethod.isSetter) {
- return _declaredMethod.function.positionalParameters[0].name;
- }
- return _declaredMethod.name.name;
- }
-
- int get _offset {
- if (_declaredMethod is! SyntheticAccessor && _declaredMethod.isSetter) {
- return _declaredMethod.function.positionalParameters[0].fileOffset;
- }
- return _declaredMethod.fileOffset;
- }
-
- @override
- void resolveInternal() {
- var declaredMethod = _declaredMethod;
- var kind = declaredMethod.kind;
- var overriddenTypes = _computeAccessorOverriddenTypes();
- DartType inferredType;
- if (isCircular) {
- inferredType = const InvalidType();
- _library.addProblem(
- templateCantInferTypeDueToCircularity.withArguments(_name),
- _offset,
- noLength,
- _fileUri);
- } else {
- inferredType = _interfaceResolver.matchTypes(
- overriddenTypes, _library, _name, _fileUri, _offset);
- }
- if (declaredMethod is SyntheticAccessor) {
- declaredMethod._field.type = inferredType;
- } else {
- if (kind == ProcedureKind.Getter) {
- declaredMethod.function.returnType = inferredType;
- } else {
- declaredMethod.function.positionalParameters[0].type = inferredType;
- }
- }
- }
-
- /// Computes the types of the getters and setters overridden by
- /// [_declaredMethod], with appropriate type parameter substitutions.
- List<DartType> _computeAccessorOverriddenTypes() {
- var overriddenTypes = <DartType>[];
- for (int i = _start; i < _end; i++) {
- var candidate = _candidates[i];
- Procedure resolvedCandidate;
- if (candidate is ForwardingNode) {
- resolvedCandidate = candidate.resolve();
- } else {
- resolvedCandidate = candidate;
- }
- DartType overriddenType;
- if (resolvedCandidate is SyntheticAccessor) {
- var field = resolvedCandidate._field;
- TypeInferenceEngine.resolveInferenceNode(field);
- overriddenType = field.type;
- } else if (resolvedCandidate.function != null) {
- switch (resolvedCandidate.kind) {
- case ProcedureKind.Getter:
- overriddenType = resolvedCandidate.function.returnType;
- break;
- case ProcedureKind.Setter:
- overriddenType =
- resolvedCandidate.function.positionalParameters[0].type;
- break;
- default:
- // Illegal override (error will be reported elsewhere). Just skip
- // this override.
- continue;
- }
- } else {
- // This can happen if there are errors. Just skip this override.
- continue;
- }
- overriddenTypes.add(_interfaceResolver
- ._substitutionFor(resolvedCandidate, _declaredMethod.enclosingClass)
- .substituteType(overriddenType));
- }
- return overriddenTypes;
- }
-}
-
-/// A [ForwardingNode] represents a method, getter, or setter within a class's
-/// interface that is either implemented in the class directly or inherited from
-/// a superclass.
-///
-/// This class allows us to defer the determination of exactly which member is
-/// inherited, as well as the propagation of covariance annotations, and
-/// the creation of forwarding stubs, until type inference.
-class ForwardingNode extends Procedure {
- /// The [InterfaceResolver] that created this [ForwardingNode].
- final InterfaceResolver _interfaceResolver;
-
- /// A list containing the directly implemented and directly inherited
- /// procedures of the class in question.
- ///
- /// Note that many [ForwardingNode]s share the same [_candidates] list;
- /// consult [_start] and [_end] to see which entries in this list are relevant
- /// to this [ForwardingNode].
- final List<Member> _candidates;
-
- /// Index of the first entry in [_candidates] relevant to this
- /// [ForwardingNode].
- final int _start;
-
- /// Index just beyond the last entry in [_candidates] relevant to this
- /// [ForwardingNode].
- final int _end;
-
- /// The member this node resolves to (if it has been computed); otherwise
- /// `null`.
- Member _resolution;
-
- /// The result of finalizing this node (if the node has been finalized);
- /// otherwise `null`.
- Member _finalResolution;
-
- /// If this forwarding node represents a member that needs type inference, the
- /// corresponding [InferenceNode]; otherwise `null`.
- InferenceNode _inferenceNode;
-
- ForwardingNode(this._interfaceResolver, this._inferenceNode, Class class_,
- Name name, ProcedureKind kind, this._candidates, this._start, this._end)
- : super(name, kind, null) {
- parent = class_;
- }
-
- /// Finishes handling of this node by propagating covariance and creating
- /// forwarding stubs if necessary.
- Procedure finalize() => _finalResolution ??= _finalize();
-
- /// Returns the declared or inherited member this node resolves to.
- ///
- /// Does not create forwarding stubs.
- Procedure resolve() => _resolution ??= _resolve();
-
- /// Tag the parameters of [interfaceMember] that need type checks
- ///
- /// Parameters can need type checks for calls coming from statically typed
- /// call sites, due to covariant generics and overrides with explicit
- /// `covariant` parameters.
- ///
- /// Tag parameters of [interfaceMember] that need such checks when the member
- /// occurs in [enclosingClass]'s interface. If parameters need checks but
- /// they would not be checked in an inherited implementation, a forwarding
- /// stub is introduced as a place to put the checks.
- Procedure _computeCovarianceFixes(Procedure interfaceMember) {
- var substitution =
- _interfaceResolver._substitutionFor(interfaceMember, enclosingClass);
- // We always create a forwarding stub when we've inherited a member from an
- // interface other than the first override candidate. This is to work
- // around a bug in the Kernel type checker where it chooses the first
- // override candidate.
- //
- // TODO(kmillikin): Fix the Kernel type checker and stop creating these
- // extra stubs.
- var stub = interfaceMember.enclosingClass == enclosingClass ||
- interfaceMember == _resolvedCandidate(_start)
- ? interfaceMember
- : _createForwardingStub(substitution, interfaceMember);
-
- var interfaceFunction = interfaceMember.function;
- var interfacePositionalParameters = interfaceFunction.positionalParameters;
- var interfaceNamedParameters = interfaceFunction.namedParameters;
- var interfaceTypeParameters = interfaceFunction.typeParameters;
-
- void createStubIfNeeded() {
- if (stub != interfaceMember) return;
- if (interfaceMember.enclosingClass == enclosingClass) return;
- stub = _createForwardingStub(substitution, interfaceMember);
- }
-
- bool isImplCreated = false;
- void createImplIfNeeded() {
- if (isImplCreated) return;
- createStubIfNeeded();
- _createForwardingImplIfNeeded(stub.function);
- isImplCreated = true;
- }
-
- IncludesTypeParametersCovariantly needsCheckVisitor =
- enclosingClass.typeParameters.isEmpty
- ? null
- : ShadowClass.getClassInferenceInfo(enclosingClass)
- .needsCheckVisitor ??=
- new IncludesTypeParametersCovariantly(
- enclosingClass.typeParameters);
- bool needsCheck(DartType type) => needsCheckVisitor == null
- ? false
- : substitution.substituteType(type).accept(needsCheckVisitor);
- for (int i = 0; i < interfacePositionalParameters.length; i++) {
- var parameter = interfacePositionalParameters[i];
- var isGenericCovariantImpl =
- parameter.isGenericCovariantImpl || needsCheck(parameter.type);
- var isCovariant = parameter.isCovariant;
- var superParameter = parameter;
- for (int j = _start; j < _end; j++) {
- var otherMember = _finalizedCandidate(j);
- if (otherMember is ForwardingNode) continue;
- var otherPositionalParameters =
- otherMember.function.positionalParameters;
- if (otherPositionalParameters.length <= i) continue;
- var otherParameter = otherPositionalParameters[i];
- if (j == _start) superParameter = otherParameter;
- if (identical(otherMember, interfaceMember)) continue;
- if (otherParameter.isGenericCovariantImpl) {
- isGenericCovariantImpl = true;
- }
- if (otherParameter.isCovariant) {
- isCovariant = true;
- }
- }
- if (isGenericCovariantImpl) {
- if (!superParameter.isGenericCovariantImpl) {
- createImplIfNeeded();
- }
- if (!parameter.isGenericCovariantImpl) {
- createStubIfNeeded();
- stub.function.positionalParameters[i].isGenericCovariantImpl = true;
- }
- }
- if (isCovariant) {
- if (!superParameter.isCovariant) {
- createImplIfNeeded();
- }
- if (!parameter.isCovariant) {
- createStubIfNeeded();
- stub.function.positionalParameters[i].isCovariant = true;
- }
- }
- }
- for (int i = 0; i < interfaceNamedParameters.length; i++) {
- var parameter = interfaceNamedParameters[i];
- var isGenericCovariantImpl =
- parameter.isGenericCovariantImpl || needsCheck(parameter.type);
- var isCovariant = parameter.isCovariant;
- var superParameter = parameter;
- for (int j = _start; j < _end; j++) {
- var otherMember = _finalizedCandidate(j);
- if (otherMember is ForwardingNode) continue;
- var otherParameter =
- getNamedFormal(otherMember.function, parameter.name);
- if (otherParameter == null) continue;
- if (j == _start) superParameter = otherParameter;
- if (identical(otherMember, interfaceMember)) continue;
- if (otherParameter.isGenericCovariantImpl) {
- isGenericCovariantImpl = true;
- }
- if (otherParameter.isCovariant) {
- isCovariant = true;
- }
- }
- if (isGenericCovariantImpl) {
- if (!superParameter.isGenericCovariantImpl) {
- createImplIfNeeded();
- }
- if (!parameter.isGenericCovariantImpl) {
- createStubIfNeeded();
- stub.function.namedParameters[i].isGenericCovariantImpl = true;
- }
- }
- if (isCovariant) {
- if (!superParameter.isCovariant) {
- createImplIfNeeded();
- }
- if (!parameter.isCovariant) {
- createStubIfNeeded();
- stub.function.namedParameters[i].isCovariant = true;
- }
- }
- }
- for (int i = 0; i < interfaceTypeParameters.length; i++) {
- var typeParameter = interfaceTypeParameters[i];
- var isGenericCovariantImpl = typeParameter.isGenericCovariantImpl;
- var superTypeParameter = typeParameter;
- for (int j = _start; j < _end; j++) {
- var otherMember = _finalizedCandidate(j);
- if (otherMember is ForwardingNode) continue;
- var otherTypeParameters = otherMember.function.typeParameters;
- if (otherTypeParameters.length <= i) continue;
- var otherTypeParameter = otherTypeParameters[i];
- if (j == _start) superTypeParameter = otherTypeParameter;
- if (identical(otherMember, interfaceMember)) continue;
- if (otherTypeParameter.isGenericCovariantImpl) {
- isGenericCovariantImpl = true;
- }
- }
- if (isGenericCovariantImpl) {
- if (!superTypeParameter.isGenericCovariantImpl) {
- createImplIfNeeded();
- }
- if (!typeParameter.isGenericCovariantImpl) {
- createStubIfNeeded();
- stub.function.typeParameters[i].isGenericCovariantImpl = true;
- }
- }
- }
- return stub;
- }
-
- void _createForwardingImplIfNeeded(FunctionNode function) {
- if (function.body != null) {
- // There is already an implementation; nothing further needs to be done.
- return;
- }
- // Find the concrete implementation in the superclass; this is what we need
- // to forward to. If we can't find one, then the method is fully abstract
- // and we don't need to do anything.
- var superclass = enclosingClass.superclass;
- if (superclass == null) return;
- Procedure procedure = function.parent;
- var superTarget = _interfaceResolver._typeEnvironment.hierarchy
- .getDispatchTarget(superclass, procedure.name,
- setter: kind == ProcedureKind.Setter);
- if (superTarget == null) return;
- if (superTarget is Procedure && superTarget.isForwardingStub) {
- superTarget = _getForwardingStubSuperTarget(superTarget);
- }
- procedure.isAbstract = false;
- if (!procedure.isForwardingStub) {
- // This procedure exists abstractly in the source code; we need to make it
- // concrete and give it a body that is a forwarding stub. This situation
- // is called a "forwarding semi-stub".
- procedure.isForwardingStub = true;
- procedure.isForwardingSemiStub = true;
- _interfaceResolver._instrumentation?.record(
- procedure.fileUri,
- procedure.fileOffset,
- 'forwardingStub',
- new InstrumentationValueLiteral('semi-stub'));
- }
- var positionalArguments = function.positionalParameters
- .map<Expression>((parameter) => new VariableGet(parameter))
- .toList();
- var namedArguments = function.namedParameters
- .map((parameter) =>
- new NamedExpression(parameter.name, new VariableGet(parameter)))
- .toList();
- var typeArguments = function.typeParameters
- .map<DartType>((typeParameter) => new TypeParameterType(typeParameter))
- .toList();
- var arguments = new Arguments(positionalArguments,
- types: typeArguments, named: namedArguments);
- Expression superCall;
- switch (kind) {
- case ProcedureKind.Method:
- case ProcedureKind.Operator:
- superCall = new SuperMethodInvocation(name, arguments, superTarget);
- break;
- case ProcedureKind.Getter:
- superCall = new SuperPropertyGet(
- name,
- superTarget is SyntheticAccessor
- ? superTarget._field
- : superTarget);
- break;
- case ProcedureKind.Setter:
- superCall = new SuperPropertySet(
- name,
- positionalArguments[0],
- superTarget is SyntheticAccessor
- ? superTarget._field
- : superTarget);
- break;
- default:
- unhandled('$kind', '_createForwardingImplIfNeeded', -1, null);
- break;
- }
- function.body = new ReturnStatement(superCall)..parent = function;
- procedure.transformerFlags |= TransformerFlag.superCalls;
- procedure.forwardingStubSuperTarget = superTarget;
- }
-
- /// Creates a forwarding stub based on the given [target].
- Procedure _createForwardingStub(Substitution substitution, Procedure target) {
- VariableDeclaration copyParameter(VariableDeclaration parameter) {
- return new VariableDeclaration(parameter.name,
- type: substitution.substituteType(parameter.type),
- isCovariant: parameter.isCovariant)
- ..isGenericCovariantImpl = parameter.isGenericCovariantImpl;
- }
-
- var targetTypeParameters = target.function.typeParameters;
- List<TypeParameter> typeParameters;
- if (targetTypeParameters.isNotEmpty) {
- typeParameters =
- new List<TypeParameter>.filled(targetTypeParameters.length, null);
- var additionalSubstitution = <TypeParameter, DartType>{};
- for (int i = 0; i < targetTypeParameters.length; i++) {
- var targetTypeParameter = targetTypeParameters[i];
- var typeParameter = new TypeParameter(targetTypeParameter.name, null)
- ..isGenericCovariantImpl = targetTypeParameter.isGenericCovariantImpl;
- typeParameters[i] = typeParameter;
- additionalSubstitution[targetTypeParameter] =
- new TypeParameterType(typeParameter);
- }
- substitution = Substitution.combine(
- substitution, Substitution.fromMap(additionalSubstitution));
- for (int i = 0; i < typeParameters.length; i++) {
- typeParameters[i].bound =
- substitution.substituteType(targetTypeParameters[i].bound);
- }
- }
- var positionalParameters =
- target.function.positionalParameters.map(copyParameter).toList();
- var namedParameters =
- target.function.namedParameters.map(copyParameter).toList();
- var function = new FunctionNode(null,
- positionalParameters: positionalParameters,
- namedParameters: namedParameters,
- typeParameters: typeParameters,
- requiredParameterCount: target.function.requiredParameterCount,
- returnType: substitution.substituteType(target.function.returnType));
- Member finalTarget;
- if (target is Procedure && target.isForwardingStub) {
- finalTarget = target.forwardingStubInterfaceTarget;
- } else if (target is SyntheticAccessor) {
- finalTarget = target._field;
- } else {
- finalTarget = target;
- }
- return new Procedure(name, kind, function,
- isAbstract: true,
- isForwardingStub: true,
- fileUri: enclosingClass.fileUri,
- forwardingStubInterfaceTarget: finalTarget)
- ..startFileOffset = enclosingClass.fileOffset
- ..fileOffset = enclosingClass.fileOffset
- ..parent = enclosingClass;
- }
-
- /// Creates a forwarding stub for this node if necessary, and propagates
- /// covariance information.
- Procedure _finalize() {
- return _computeCovarianceFixes(resolve());
- }
-
- /// Returns the [i]th element of [_candidates], finalizing it if necessary.
- Procedure _finalizedCandidate(int i) {
- Procedure candidate = _candidates[i];
- return candidate is ForwardingNode &&
- _interfaceResolver.isTypeInferencePrepared
- ? candidate.finalize()
- : candidate;
- }
-
- /// Determines which inherited member this node resolves to, and also performs
- /// type inference.
- Procedure _resolve() {
- Procedure inheritedMember = _candidates[_start];
- bool isDeclaredInThisClass =
- identical(inheritedMember.enclosingClass, enclosingClass);
- if (isDeclaredInThisClass) {
- if (_inferenceNode != null) {
- _inferenceNode.resolve();
- _inferenceNode = null;
- }
- } else {
- // If there are multiple inheritance candidates, the inherited member is
- // the member whose type is a subtype of all the others. We can find it
- // by two passes over the list of members. For the first pass, we step
- // through the candidates, updating inheritedMember each time we find a
- // member whose type is a subtype of the previous inheritedMember. As we
- // do this, we also work out the necessary substitution for matching up
- // type parameters between this class and the corresponding superclass.
- //
- // Since the subtyping relation is reflexive, we will favor the most
- // recently visited candidate in the case where the types are the same.
- // We want to favor earlier candidates, so we visit the candidate list
- // backwards.
- inheritedMember = _resolvedCandidate(_end - 1);
- var inheritedMemberSubstitution =
- _interfaceResolver._substitutionFor(inheritedMember, enclosingClass);
- var inheritedMemberType = inheritedMember is ForwardingNode
- ? const DynamicType()
- : inheritedMemberSubstitution.substituteType(
- kind == ProcedureKind.Setter
- ? inheritedMember.setterType
- : inheritedMember.getterType);
- for (int i = _end - 2; i >= _start; i--) {
- var candidate = _resolvedCandidate(i);
- var substitution =
- _interfaceResolver._substitutionFor(candidate, enclosingClass);
- bool isBetter;
- DartType type;
- if (kind == ProcedureKind.Setter) {
- type = candidate is ForwardingNode
- ? const DynamicType()
- : substitution.substituteType(candidate.setterType);
- // Setters are contravariant in their setter type, so we have to
- // reverse the check.
- isBetter = _interfaceResolver._typeEnvironment
- .isSubtypeOf(inheritedMemberType, type);
- } else {
- type = candidate is ForwardingNode
- ? const DynamicType()
- : substitution.substituteType(candidate.getterType);
- isBetter = _interfaceResolver._typeEnvironment
- .isSubtypeOf(type, inheritedMemberType);
- }
- if (isBetter) {
- inheritedMember = candidate;
- inheritedMemberSubstitution = substitution;
- inheritedMemberType = type;
- }
- }
- // For the second pass, we verify that inheritedMember is a subtype of all
- // the other potentially inherited members.
- // TODO(paulberry): implement this.
- }
- return inheritedMember;
- }
-
- /// Returns the [i]th element of [_candidates], resolving it if necessary.
- Procedure _resolvedCandidate(int i) {
- Procedure candidate = _candidates[i];
- return candidate is ForwardingNode &&
- _interfaceResolver.isTypeInferencePrepared
- ? candidate.resolve()
- : candidate;
- }
-
- static void createForwardingImplIfNeededForTesting(
- ForwardingNode node, FunctionNode function) {
- node._createForwardingImplIfNeeded(function);
- }
-
- /// Public method allowing tests to access [_createForwardingStub].
- ///
- /// This method is static so that it can be easily eliminated by tree shaking
- /// when not needed.
- static Procedure createForwardingStubForTesting(
- ForwardingNode node, Substitution substitution, Procedure target) {
- return node._createForwardingStub(substitution, target);
- }
-
- /// For testing: get the list of candidates relevant to a given node.
- static List<Procedure> getCandidates(ForwardingNode node) {
- return node._candidates.sublist(node._start, node._end);
- }
-
- static Member _getForwardingStubSuperTarget(Procedure forwardingStub) {
- // TODO(paulberry): when dartbug.com/31562 is fixed, this should become
- // easier.
- ReturnStatement body = forwardingStub.function.body;
- var expression = body.expression;
- if (expression is SuperMethodInvocation) {
- return expression.interfaceTarget;
- } else if (expression is SuperPropertySet) {
- return expression.interfaceTarget;
- } else {
- return unhandled('${expression.runtimeType}',
- '_getForwardingStubSuperTarget', -1, null);
- }
- }
-}
-
-/// An [InterfaceResolver] keeps track of the information necessary to resolve
-/// method calls, gets, and sets within a chunk of code being compiled, to
-/// infer covariance annotations, and to create forwarwding stubs when necessary
-/// to meet covariance requirements.
-class InterfaceResolver {
- final TypeInferenceEngine _typeInferenceEngine;
-
- final HierarchyBasedTypeEnvironment _typeEnvironment;
-
- final Instrumentation _instrumentation;
-
- InterfaceResolver(
- this._typeInferenceEngine, this._typeEnvironment, this._instrumentation);
-
- /// Indicates whether the "prepare" phase of type inference is complete.
- bool get isTypeInferencePrepared =>
- _typeInferenceEngine.isTypeInferencePrepared;
-
- /// Report an error if all types in [types] are not equal using `==`.
- ///
- /// Returns the type if there is at least one and they are all equal,
- /// otherwise the type `dynamic`. [library], [name], [fileUri], and
- /// [charOffset] are used to report the error.
- DartType matchTypes(Iterable<DartType> types, LibraryBuilder library,
- String name, Uri fileUri, int charOffset) {
- DartType first;
- for (var type in types) {
- if (first == null) {
- first = type;
- } else if (first != type) {
- // Types don't match. Report an error.
- library.addProblem(
- templateCantInferTypeDueToInconsistentOverrides.withArguments(name),
- charOffset,
- noLength,
- fileUri);
- return const DynamicType();
- }
- }
- // If there are no overridden types, infer `dynamic`.
- return first ?? const DynamicType();
- }
-
- /// Computes the types of the methods overridden by [method] in [class_].
- ///
- /// The types have the type parameters of [class_] substituted appropriately.
- ///
- /// [candidates] has the list of inherited interface methods with the same
- /// name as [method] as a sublist from [start] inclusive to [end] exclusive.
- List<FunctionType> _computeMethodOverriddenTypes(Class class_,
- Procedure method, List<Member> candidates, int start, int end) {
- var overriddenTypes = <FunctionType>[];
- var declaredTypeParameters = method.function.typeParameters;
- for (int i = start; i < end; ++i) {
- var candidate = candidates[i];
- if (candidate is SyntheticAccessor) {
- // This can happen if there are errors. Just skip this override.
- continue;
- }
- var candidateFunction = candidate.function;
- if (candidateFunction == null) {
- // This can happen if there are errors. Just skip this override.
- continue;
- }
- var substitution = _substitutionFor(candidate, class_);
- FunctionType overriddenType =
- substitution.substituteType(candidateFunction.functionType);
- var overriddenTypeParameters = overriddenType.typeParameters;
- if (overriddenTypeParameters.length != declaredTypeParameters.length) {
- // Generic arity mismatch. Don't do any inference for this method.
- // TODO(paulberry): report an error.
- overriddenTypes.clear();
- break;
- } else if (overriddenTypeParameters.isNotEmpty) {
- var substitutionMap = <TypeParameter, DartType>{};
- for (int i = 0; i < declaredTypeParameters.length; ++i) {
- substitutionMap[overriddenTypeParameters[i]] =
- new TypeParameterType(declaredTypeParameters[i]);
- }
- overriddenType = substituteTypeParams(
- overriddenType, substitutionMap, declaredTypeParameters);
- }
- overriddenTypes.add(overriddenType);
- }
- return overriddenTypes;
- }
-
- void inferMethodType(LibraryBuilder library, Class class_, Procedure method,
- List<Member> candidates, int start, int end) {
- var overriddenTypes =
- _computeMethodOverriddenTypes(class_, method, candidates, start, end);
- if (ShadowProcedure.hasImplicitReturnType(method) &&
- method.name != indexSetName) {
- method.function.returnType = matchTypes(
- overriddenTypes.map((type) => type.returnType),
- library,
- method.name.name,
- class_.fileUri,
- method.fileOffset);
- }
- var positionalParameters = method.function.positionalParameters;
- for (int i = 0; i < positionalParameters.length; ++i) {
- if (VariableDeclarationJudgment.isImplicitlyTyped(
- positionalParameters[i])) {
- // Note that if the parameter is not present in the overridden method,
- // getPositionalParameterType treats it as dynamic. This is consistent
- // with the behavior called for in the informal top level type inference
- // spec, which says:
- //
- // If there is no corresponding parameter position in the overridden
- // method to infer from and the signatures are compatible, it is
- // treated as dynamic (e.g. overriding a one parameter method with a
- // method that takes a second optional parameter). Note: if there
- // is no corresponding parameter position in the overridden method to
- // infer from and the signatures are incompatible (e.g. overriding a
- // one parameter method with a method that takes a second
- // non-optional parameter), the inference result is not defined and
- // tools are free to either emit an error, or to defer the error to
- // override checking.
- positionalParameters[i].type = matchTypes(
- overriddenTypes.map((type) => getPositionalParameterType(type, i)),
- library,
- positionalParameters[i].name,
- class_.fileUri,
- positionalParameters[i].fileOffset);
- }
- }
- var namedParameters = method.function.namedParameters;
- for (int i = 0; i < namedParameters.length; i++) {
- if (VariableDeclarationJudgment.isImplicitlyTyped(namedParameters[i])) {
- var name = namedParameters[i].name;
- namedParameters[i].type = matchTypes(
- overriddenTypes.map((type) => getNamedParameterType(type, name)),
- library,
- namedParameters[i].name,
- class_.fileUri,
- namedParameters[i].fileOffset);
- }
- }
- }
-
- /// Populates [getters] and [setters] with the members of the given [class_]'s
- /// interface.
- ///
- /// [getters] will contain methods and getters, [setters] will contain
- /// setters. Some members cannot be resolved immediately. For instance,
- /// top-level type inference has not yet inferred field types based on
- /// initializers and so we cannot yet do override based resolution of getters
- /// and setters. Members of the class's interface that need to be resolved
- /// later are represented by a [ForwardingNode] object.
- void createApiMembers(Class class_, List<Member> getters,
- List<Member> setters, LibraryBuilder library) {
- var candidates = ClassHierarchy.mergeSortedLists(
- getCandidates(class_, false), getCandidates(class_, true));
- // Now create getter and perhaps setter forwarding nodes for each unique
- // name.
- getters.length = candidates.length;
- setters.length = candidates.length;
- int getterIndex = 0;
- int setterIndex = 0;
- // To detect conflicts between instance members (possibly inherited ones)
- // and static members, use a map from names to lists of members. There can
- // be more than one static member with a given name, e.g., if there is a
- // getter and a setter. We will report both conflicts.
- forEachApiMember(candidates, (int start, int end, Name name) {
- Procedure member = candidates[start];
- ProcedureKind kind = _kindOf(member);
- if (kind != ProcedureKind.Getter && kind != ProcedureKind.Setter) {
- for (int i = start + 1; i < end; ++i) {
- if (_kindOf(candidates[i]) != kind) return;
- }
- if (member.enclosingClass == class_ && _requiresTypeInference(member)) {
- inferMethodType(library, class_, member, candidates, start + 1, end);
- }
- var forwardingNode = new ForwardingNode(
- this, null, class_, name, kind, candidates, start, end);
- getters[getterIndex++] = forwardingNode.finalize();
- if (library is KernelLibraryBuilder &&
- forwardingNode.finalize() != forwardingNode.resolve()) {
- library.forwardersOrigins.add(forwardingNode.finalize());
- library.forwardersOrigins.add(forwardingNode.resolve());
- }
- return;
- }
-
- Procedure declaredGetter;
- int inheritedGetterStart = start;
- int getterEnd = start;
- if (kind == ProcedureKind.Getter) {
- if (member.enclosingClass == class_) {
- declaredGetter = member;
- ++inheritedGetterStart;
- }
- while (++getterEnd < end) {
- ProcedureKind currentKind = _kindOf(candidates[getterEnd]);
- if (currentKind == ProcedureKind.Setter) break;
- if (currentKind != ProcedureKind.Getter) return;
- }
- }
-
- Procedure declaredSetter;
- int inheritedSetterStart = getterEnd;
- if (getterEnd < end) {
- member = candidates[getterEnd];
- if (member.enclosingClass == class_) {
- declaredSetter = member;
- ++inheritedSetterStart;
- }
- }
-
- InferenceNode getterInferenceNode;
- if (start < getterEnd) {
- if (declaredGetter != null) {
- getterInferenceNode = _createInferenceNode(
- class_,
- declaredGetter,
- candidates,
- inheritedGetterStart,
- getterEnd,
- inheritedSetterStart,
- end,
- library,
- class_.fileUri);
- }
- // Getters need to be resolved later, as part of type inference, so just
- // save the forwarding node for now.
- //
- // Choose a representative to use for error reporting, such as if a
- // class inherits this getter and tries to declare a method with the
- // same name.
- Member representative = candidates[start];
- getters[getterIndex++] = new ForwardingNode(this, getterInferenceNode,
- class_, name, ProcedureKind.Getter, candidates, start, getterEnd)
- ..fileUri = representative.fileUri
- ..fileOffset = representative.fileOffset
- ..fileEndOffset = representative.fileEndOffset;
- }
- if (getterEnd < end) {
- InferenceNode setterInferenceNode;
- if (declaredSetter != null) {
- setterInferenceNode = declaredSetter is SyntheticAccessor
- ? getterInferenceNode
- : _createInferenceNode(
- class_,
- declaredSetter,
- candidates,
- inheritedSetterStart,
- end,
- inheritedGetterStart,
- getterEnd,
- library,
- class_.fileUri);
- }
- Member representative = candidates[getterEnd];
- var forwardingNode = new ForwardingNode(this, setterInferenceNode,
- class_, name, ProcedureKind.Setter, candidates, getterEnd, end)
- ..fileUri = representative.fileUri
- ..fileOffset = representative.fileOffset
- ..fileEndOffset = representative.fileEndOffset;
- // Setters need to be resolved later, as part of type inference, so just
- // save the forwarding node for now.
- setters[setterIndex++] = forwardingNode;
- }
- });
- getters.length = getterIndex;
- setters.length = setterIndex;
- }
-
- void finalizeCovariance(
- Class class_, List<Member> apiMembers, LibraryBuilder library) {
- for (int i = 0; i < apiMembers.length; i++) {
- var member = apiMembers[i];
- Member resolution;
- if (member is ForwardingNode) {
- apiMembers[i] = resolution = member.finalize();
- if (library is KernelLibraryBuilder &&
- member.finalize() != member.resolve()) {
- library.forwardersOrigins.add(member.finalize());
- library.forwardersOrigins.add(member.resolve());
- }
- } else {
- resolution = member;
- }
- if (resolution is Procedure &&
- resolution.isSyntheticForwarder &&
- identical(resolution.enclosingClass, class_)) {
- class_.addMember(resolution);
- }
- }
- }
-
- /// Gets a list of members implemented or potentially inherited by [class_],
- /// sorted so that members with the same name are contiguous.
- ///
- /// If [setters] is `true`, setters are reported; otherwise getters, methods,
- /// and operators are reported.
- List<Procedure> getCandidates(Class class_, bool setters) {
- // First create a list of candidates for inheritance based on the members
- // declared directly in the class.
- List<Procedure> candidates = _typeEnvironment.hierarchy
- .getDeclaredMembers(class_, setters: setters)
- .map((member) => makeCandidate(member, setters))
- .toList();
- // Merge in candidates from superclasses.
- if (class_.superclass != null) {
- candidates = _mergeCandidates(candidates, class_.superclass, setters);
- }
- for (var supertype in class_.implementedTypes) {
- candidates = _mergeCandidates(candidates, supertype.classNode, setters);
- }
- return candidates;
- }
-
- /// Creates the appropriate [InferenceNode] for inferring [procedure] in the
- /// context of [class_].
- ///
- /// [candidates] a list containing the procedures overridden by [procedure],
- /// if any. [start] is the index of the first such procedure, and [end] is
- /// the past-the-end index of the last such procedure.
- ///
- /// For getters and setters, [crossStart] and [crossEnd] are the start and end
- /// indices of the corresponding overridden setters/getters, respectively.
- InferenceNode _createInferenceNode(
- Class class_,
- Procedure procedure,
- List<Member> candidates,
- int start,
- int end,
- int crossStart,
- int crossEnd,
- LibraryBuilder library,
- Uri fileUri) {
- InferenceNode node;
- if (procedure.isAccessor && _requiresTypeInference(procedure)) {
- if (start < end) {
- node = new AccessorInferenceNode(
- this, procedure, candidates, start, end, library, fileUri);
- } else if (crossStart < crossEnd) {
- node = new AccessorInferenceNode(this, procedure, candidates,
- crossStart, crossEnd, library, fileUri);
- } else if (procedure is SyntheticAccessor &&
- procedure._field.initializer != null) {
- node = new FieldInitializerInferenceNode(
- _typeInferenceEngine, procedure._field, library);
- }
-
- if (node != null && procedure is SyntheticAccessor) {
- ShadowField.setInferenceNode(procedure._field, node);
- }
- }
- return node;
- }
-
- /// Retrieves a list of the interface members of the given [class_].
- ///
- /// If [setters] is true, setters are retrieved; otherwise getters and methods
- /// are retrieved.
- List<Member> _getInterfaceMembers(Class class_, bool setters) {
- // If class_ is being compiled from source, retrieve its forwarding nodes.
- var inferenceInfo = ShadowClass.getClassInferenceInfo(class_);
- if (inferenceInfo != null) {
- return setters ? inferenceInfo.setters : inferenceInfo.gettersAndMethods;
- } else {
- return _typeEnvironment.hierarchy
- .getInterfaceMembers(class_, setters: setters);
- }
- }
-
- /// Merges together the list of interface inheritance candidates in
- /// [candidates] with interface inheritance candidates from superclass
- /// [class_].
- ///
- /// Any candidates from [class_] are converted into interface inheritance
- /// candidates using [_makeCandidate].
- List<Procedure> _mergeCandidates(
- List<Procedure> candidates, Class class_, bool setters) {
- List<Member> members = _getInterfaceMembers(class_, setters);
- if (candidates.isEmpty) {
- return members.map((member) => makeCandidate(member, setters)).toList();
- }
- if (members.isEmpty) return candidates;
- List<Procedure> result = <Procedure>[]..length =
- candidates.length + members.length;
- int storeIndex = 0;
- int i = 0, j = 0;
- while (i < candidates.length && j < members.length) {
- Procedure candidate = candidates[i];
- Member member = members[j];
- int compare = ClassHierarchy.compareMembers(candidate, member);
- if (compare <= 0) {
- result[storeIndex++] = candidate;
- ++i;
- // If the same member occurs in both lists, skip the duplicate.
- if (identical(candidate, member)) ++j;
- } else {
- result[storeIndex++] = makeCandidate(member, setters);
- ++j;
- }
- }
- while (i < candidates.length) {
- result[storeIndex++] = candidates[i++];
- }
- while (j < members.length) {
- result[storeIndex++] = makeCandidate(members[j++], setters);
- }
- result.length = storeIndex;
- return result;
- }
-
- /// Determines the appropriate substitution to translate type parameters
- /// mentioned in the given [candidate] to type parameters on [class_].
- Substitution _substitutionFor(Procedure candidate, Class class_) {
- return Substitution.fromInterfaceType(_typeEnvironment.getTypeAsInstanceOf(
- class_.thisType, candidate.enclosingClass));
- }
-
- /// Executes [callback] once for each uniquely named member of [candidates].
- ///
- /// The [start] and [end] values passed to [callback] are the start and
- /// past-the-end indices into [candidates] of a group of members having the
- /// same name. The [name] value passed to [callback] is the common name.
- static void forEachApiMember(
- List<Member> candidates, void callback(int start, int end, Name name)) {
- int i = 0;
- while (i < candidates.length) {
- var name = candidates[i].name;
- int j = i + 1;
- while (j < candidates.length && candidates[j].name == name) {
- j++;
- }
- callback(i, j, name);
- i = j;
- }
- }
-
- /// Transforms [member] into a candidate for interface inheritance.
- ///
- /// Fields are transformed into getters and setters; methods are passed
- /// through unchanged.
- static Procedure makeCandidate(Member member, bool setter) {
- if (member is Procedure) return member;
- if (member is Field) {
- // TODO(paulberry): don't set the type or covariance annotations here,
- // since they might not have been inferred yet. Instead, ensure that this
- // information is propagated to the getter/setter during type inference.
- var type = member.type;
- var isGenericCovariantImpl = member.isGenericCovariantImpl;
- var isCovariant = member.isCovariant;
- if (setter) {
- var valueParam = new VariableDeclaration('_', type: type)
- ..isGenericCovariantImpl = isGenericCovariantImpl
- ..isCovariant = isCovariant;
- var function = new FunctionNode(null,
- positionalParameters: [valueParam], returnType: const VoidType());
- return new SyntheticAccessor(
- member.name, ProcedureKind.Setter, function, member)
- ..parent = member.enclosingClass;
- } else {
- var function = new FunctionNode(null, returnType: type);
- return new SyntheticAccessor(
- member.name, ProcedureKind.Getter, function, member)
- ..parent = member.enclosingClass;
- }
- }
- return unhandled('${member.runtimeType}', 'makeCandidate', -1, null);
- }
-
- static ProcedureKind _kindOf(Procedure procedure) => procedure.kind;
-
- /// Determines whether the given [procedure] will require type inference.
- static bool _requiresTypeInference(Procedure procedure) {
- if (procedure is SyntheticAccessor) {
- return ShadowField.isImplicitlyTyped(procedure._field);
- }
- if (procedure.kind != ProcedureKind.Setter &&
- ShadowProcedure.hasImplicitReturnType(procedure)) {
- // Inference of the return type of `[]=` is handled separately by
- // KernelProcedureBuilder.build, since there are no dependencies.
- if (procedure.kind != ProcedureKind.Operator ||
- procedure.name.name != '[]=') {
- return true;
- }
- }
- var function = procedure.function;
- for (var parameter in function.positionalParameters) {
- if (VariableDeclarationJudgment.isImplicitlyTyped(parameter)) return true;
- }
- for (var parameter in function.namedParameters) {
- if (VariableDeclarationJudgment.isImplicitlyTyped(parameter)) return true;
- }
- return false;
- }
-}
-
-/// A [SyntheticAccessor] represents the getter or setter implied by a field.
-class SyntheticAccessor extends Procedure {
- /// The field associated with the synthetic accessor.
- final Field _field;
-
- SyntheticAccessor(
- Name name, ProcedureKind kind, FunctionNode function, this._field)
- : super(
- name,
- kind,
- kind == ProcedureKind.Setter
- ? new SyntheticAccessorFunctionNode.setter(_field)
- : new SyntheticAccessorFunctionNode.getter(_field),
- fileUri: _field.fileUri) {
- fileOffset = _field.fileOffset;
- }
-
- @override
- DartType get getterType => _field.type;
-
- static getField(SyntheticAccessor accessor) => accessor._field;
-}
-
-/// A [SyntheticAccessorFunctionNode] represents the [FunctionNode] part of the
-/// getter or setter implied by a field.
-///
-/// For getters, [returnType] maps to the underlying field's type, so that if
-/// type inference fills in the type of the field, the change will automatically
-/// be reflected in the synthetic getter.
-class SyntheticAccessorFunctionNode extends FunctionNode {
- final Field _field;
-
- SyntheticAccessorFunctionNode.getter(this._field)
- : super(new ReturnStatement());
-
- SyntheticAccessorFunctionNode.setter(this._field)
- : super(new ReturnStatement(),
- positionalParameters: [new SyntheticSetterParameter(_field)]);
-
- @override
- DartType get returnType =>
- positionalParameters.isEmpty ? _field.type : const VoidType();
-}
-
-/// A [SyntheticSetterParameter] represents the "value" parameter of the setter
-/// implied by a field.
-///
-/// The getters [isCovariant], [isGenericCovariantImpl],
-/// [isGenericCovariantInterface], and [type] map to the underlying field's
-/// properties, so that if these properties are modified on the field, the
-/// change will automatically be reflected in the synthetic setter. Similarly,
-/// the setters [isCovariant], [isGenericCovariantImpl], and
-/// [isGenericCovariantInterface] update the corresponding properties on the
-/// field, so that covariance propagation logic can act uniformly on [Procedure]
-/// objects without having to have special case handling for fields.
-class SyntheticSetterParameter extends VariableDeclaration {
- final Field _field;
-
- SyntheticSetterParameter(this._field)
- : super('_', isCovariant: _field.isCovariant);
-
- @override
- bool get isCovariant => _field.isCovariant;
-
- @override
- void set isCovariant(bool value) {
- _field.isCovariant = value;
- }
-
- @override
- bool get isGenericCovariantImpl => _field.isGenericCovariantImpl;
-
- @override
- void set isGenericCovariantImpl(bool value) {
- _field.isGenericCovariantImpl = value;
- }
-
- @override
- DartType get type => _field.type;
-}
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
index bbf090a..b28fc43 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
@@ -11,7 +11,6 @@
Field,
FunctionType,
InterfaceType,
- InvalidType,
Member,
TypeParameter,
TypeParameterType,
@@ -25,63 +24,16 @@
import '../../base/instrumentation.dart' show Instrumentation;
import '../kernel/kernel_builder.dart'
- show LibraryBuilder, KernelLibraryBuilder;
+ show
+ ClassHierarchyBuilder,
+ ImplicitFieldType,
+ LibraryBuilder,
+ KernelLibraryBuilder;
-import '../kernel/kernel_shadow_ast.dart' show ShadowField, ShadowMember;
-
-import '../messages.dart' show noLength, templateCantInferTypeDueToCircularity;
-
-import 'type_inferrer.dart' show TypeInferrer, TypeInferrerImpl;
+import 'type_inferrer.dart' show TypeInferrer;
import 'type_schema_environment.dart' show TypeSchemaEnvironment;
-/// Concrete class derived from [InferenceNode] to represent type inference of a
-/// field based on its initializer.
-class FieldInitializerInferenceNode extends InferenceNode {
- final TypeInferenceEngine _typeInferenceEngine;
-
- /// The field whose type should be inferred.
- final ShadowField field;
-
- final LibraryBuilder _library;
-
- FieldInitializerInferenceNode(
- this._typeInferenceEngine, this.field, this._library);
-
- @override
- void resolveInternal() {
- var typeInferrer = _typeInferenceEngine.getFieldTypeInferrer(field);
- // Note: in the event that there is erroneous code, it's possible for
- // typeInferrer to be null. If this happens, just skip type inference for
- // this field.
- if (typeInferrer != null) {
- var inferredType = typeInferrer
- .inferDeclarationType(typeInferrer.inferFieldTopLevel(field));
- if (isCircular) {
- // Report the appropriate error.
- _library.addProblem(
- templateCantInferTypeDueToCircularity
- .withArguments(field.name.name),
- field.fileOffset,
- noLength,
- field.fileUri);
- inferredType = const InvalidType();
- }
- field.setInferredType(
- _typeInferenceEngine, typeInferrer.uri, inferredType);
- // TODO(paulberry): if type != null, then check that the type of the
- // initializer is assignable to it.
- }
- // TODO(paulberry): the following is a hack so that outlines don't contain
- // initializers. But it means that we rebuild the initializers when doing
- // a full compile. There should be a better way.
- field.initializer = null;
- }
-
- @override
- String toString() => field.toString();
-}
-
/// Visitor to check whether a given type mentions any of a class's type
/// parameters in a covariant fashion.
class IncludesTypeParametersCovariantly extends DartTypeVisitor<bool> {
@@ -131,67 +83,6 @@
}
}
-/// Base class for tracking dependencies during top level type inference.
-///
-/// Fields, accessors, and methods can have their types inferred in a variety of
-/// ways; there will a derived class for each kind of inference.
-abstract class InferenceNode {
- /// The node currently being evaluated, or `null` if no node is being
- /// evaluated.
- static InferenceNode _currentNode;
-
- /// Indicates whether the type inference corresponding to this node has been
- /// completed.
- bool _isResolved = false;
-
- /// Indicates whether this node participates in a circularity.
- bool _isCircular = false;
-
- /// If this node is currently being evaluated, and its evaluation caused a
- /// recursive call to another node's [resolve] method, a pointer to the latter
- /// node; otherwise `null`.
- InferenceNode _nextNode;
-
- /// Indicates whether this node participates in a circularity.
- ///
- /// This may be called at the end of [resolveInternal] to check whether a
- /// circularity was detected during evaluation.
- bool get isCircular => _isCircular;
-
- /// Evaluates this node, properly accounting for circularities.
- void resolve() {
- if (_isResolved) return;
- if (_nextNode != null || identical(_currentNode, this)) {
- // An accessor depends on itself (possibly by way of intermediate
- // accessors). Mark all accessors involved as circular.
- var node = this;
- do {
- node._isCircular = true;
- node._isResolved = true;
- node = node._nextNode;
- } while (node != null);
- } else {
- var previousNode = _currentNode;
- assert(previousNode?._nextNode == null);
- _currentNode = this;
- previousNode?._nextNode = this;
- resolveInternal();
- assert(identical(_currentNode, this));
- previousNode?._nextNode = null;
- _currentNode = previousNode;
- _isResolved = true;
- }
- }
-
- /// Evaluates this node, possibly by making recursive calls to the [resolve]
- /// method of this node or other nodes.
- ///
- /// Circularity detection is handled by [resolve], which calls this method.
- /// Once this method has made all recursive calls to [resolve], it may use
- /// [isCircular] to detect whether a circularity has occurred.
- void resolveInternal();
-}
-
/// Keeps track of the global state for the type inference that occurs outside
/// of method bodies and initializers.
///
@@ -201,6 +92,8 @@
abstract class TypeInferenceEngine {
ClassHierarchy classHierarchy;
+ ClassHierarchyBuilder hierarchyBuilder;
+
CoreTypes coreTypes;
/// Indicates whether the "prepare" phase of type inference is complete.
@@ -208,8 +101,6 @@
TypeSchemaEnvironment typeSchemaEnvironment;
- final staticInferenceNodes = <FieldInitializerInferenceNode>[];
-
/// A map containing constructors with initializing formals whose types
/// need to be inferred.
///
@@ -237,21 +128,7 @@
/// Creates a [TypeInferrer] object which is ready to perform type inference
/// on the given [field].
TypeInferrer createTopLevelTypeInferrer(
- InterfaceType thisType, ShadowField field, KernelLibraryBuilder library);
-
- /// Retrieve the [TypeInferrer] for the given [field], which was created by
- /// a previous call to [createTopLevelTypeInferrer].
- TypeInferrerImpl getFieldTypeInferrer(ShadowField field);
-
- /// Performs the second phase of top level initializer inference, which is to
- /// visit all accessors and top level variables that were passed to
- /// [recordAccessor] in topologically-sorted order and assign their types.
- void finishTopLevelFields() {
- for (var node in staticInferenceNodes) {
- node.resolve();
- }
- staticInferenceNodes.clear();
- }
+ Uri uri, InterfaceType thisType, KernelLibraryBuilder library);
/// Performs the third phase of top level inference, which is to visit all
/// constructors still needing inference and infer the types of their
@@ -295,20 +172,17 @@
new TypeSchemaEnvironment(coreTypes, hierarchy);
}
- /// Records that the given static [field] will need top level type inference.
- void recordStaticFieldInferenceCandidate(
- ShadowField field, LibraryBuilder library) {
- var node = new FieldInitializerInferenceNode(this, field, library);
- ShadowField.setInferenceNode(field, node);
- staticInferenceNodes.add(node);
- }
-
- static void resolveInferenceNode(Member member) {
- if (member is ShadowMember) {
- if (member.inferenceNode != null) {
- member.inferenceNode.resolve();
- member.inferenceNode = null;
+ static Member resolveInferenceNode(Member member) {
+ if (member is Field) {
+ DartType type = member.type;
+ if (type is ImplicitFieldType) {
+ if (type.member.target != member) {
+ type.member.inferCopiedType(member);
+ } else {
+ type.member.inferType();
+ }
}
}
+ return member;
}
}
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
index 05052a6..0a3e58d 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
@@ -103,8 +103,6 @@
import '../kernel/kernel_shadow_ast.dart'
show
ExpressionJudgment,
- ShadowClass,
- ShadowField,
ShadowTypeInferenceEngine,
ShadowTypeInferrer,
VariableDeclarationJudgment,
@@ -119,8 +117,6 @@
import 'inference_helper.dart' show InferenceHelper;
-import 'interface_resolver.dart' show ForwardingNode, SyntheticAccessor;
-
import 'type_constraint_gatherer.dart' show TypeConstraintGatherer;
import 'type_inference_engine.dart'
@@ -750,7 +746,8 @@
Class classNode = receiverType is InterfaceType
? receiverType.classNode
: coreTypes.objectClass;
- Member interfaceMember = _getInterfaceMember(classNode, name, setter);
+ Member interfaceMember =
+ _getInterfaceMember(classNode, name, setter, fileOffset);
if (instrumented &&
receiverType != const DynamicType() &&
interfaceMember != null) {
@@ -911,7 +908,8 @@
if (calleeType is FunctionType) {
return calleeType;
} else if (followCall && calleeType is InterfaceType) {
- var member = _getInterfaceMember(calleeType.classNode, callName, false);
+ var member =
+ _getInterfaceMember(calleeType.classNode, callName, false, -1);
var callType = getCalleeType(member, calleeType);
if (callType is FunctionType) {
return callType;
@@ -969,7 +967,7 @@
/// Gets the initializer for the given [field], or `null` if there is no
/// initializer.
- Expression getFieldInitializer(ShadowField field);
+ Expression getFieldInitializer(Field field);
/// If the [member] is a forwarding stub, return the target it forwards to.
/// Otherwise return the given [member].
@@ -1160,12 +1158,6 @@
this.helper = null;
}
- /// Performs type inference on the given [field]'s initializer expression.
- ///
- /// Derived classes should provide an implementation that calls
- /// [inferExpression] for the given [field]'s initializer expression.
- DartType inferFieldTopLevel(ShadowField field);
-
@override
void inferFunctionBody(InferenceHelper helper, DartType returnType,
AsyncMarker asyncMarker, Statement body) {
@@ -1829,25 +1821,16 @@
}
}
- Member _getInterfaceMember(Class class_, Name name, bool setter) {
- if (class_ is ShadowClass) {
- var classInferenceInfo = ShadowClass.getClassInferenceInfo(class_);
- if (classInferenceInfo != null) {
- var member = ClassHierarchy.findMemberByName(
- setter
- ? classInferenceInfo.setters
- : classInferenceInfo.gettersAndMethods,
- name);
- if (member == null) return null;
- member = member is ForwardingNode ? member.resolve() : member;
- member = member is SyntheticAccessor
- ? SyntheticAccessor.getField(member)
- : member;
- TypeInferenceEngine.resolveInferenceNode(member);
- return member;
- }
+ Member _getInterfaceMember(
+ Class class_, Name name, bool setter, int charOffset) {
+ Member member = engine.hierarchyBuilder.getCombinedMemberSignatureKernel(
+ class_, name, setter, charOffset, library);
+ if (member == null && (library?.isPatch ?? false)) {
+ // TODO(dmitryas): Hack for parts.
+ member ??=
+ classHierarchy.getInterfaceMember(class_, name, setter: setter);
}
- return classHierarchy.getInterfaceMember(class_, name, setter: setter);
+ return TypeInferenceEngine.resolveInferenceNode(member);
}
/// Determines if the given [expression]'s type is precisely known at compile
diff --git a/pkg/front_end/messages.status b/pkg/front_end/messages.status
index 2140750..f4317d0 100644
--- a/pkg/front_end/messages.status
+++ b/pkg/front_end/messages.status
@@ -39,7 +39,6 @@
CantInferPackagesFromPackageUri/analyzerCode: Fail
CantInferPackagesFromPackageUri/example: Fail
CantInferTypeDueToCircularity/example: Fail
-CantInferTypeDueToInconsistentOverrides/example: Fail
CantUseSuperBoundedTypeForInstanceCreation/analyzerCode: Fail
CantUseSuperBoundedTypeForInstanceCreation/example: Fail
ColonInPlaceOfIn/example: Fail
diff --git a/pkg/front_end/messages.yaml b/pkg/front_end/messages.yaml
index 4d4737d..27acf2a 100644
--- a/pkg/front_end/messages.yaml
+++ b/pkg/front_end/messages.yaml
@@ -2949,6 +2949,13 @@
template: "Can't infer a type for '#name' as some of the inherited members have different types."
tip: "Try adding an explicit type."
analyzerCode: INVALID_METHOD_OVERRIDE
+ external: testcases/inference/inconsistent_overrides.dart
+
+CantInferReturnTypeDueToInconsistentOverrides:
+ template: "Can't infer a return type for '#name' as some of the inherited members have different types."
+ tip: "Try adding an explicit type."
+ analyzerCode: INVALID_METHOD_OVERRIDE
+ external: testcases/inference/inconsistent_overrides.dart
CantInferTypeDueToCircularity:
template: "Can't infer the type of '#string': circularity found during type inference."
@@ -3573,3 +3580,19 @@
main() {
<int>[...null];
}
+
+CombinedMemberSignatureFailed:
+ template: "Class '#name' inherits multiple members named '#name2' with incompatible signatures."
+ tip: "Try adding a declaration of '#name2' to '#name'."
+ analyzerCode: INCONSISTENT_INHERITANCE
+ script:
+ - |
+ abstract class I1 {
+ foo(x);
+ }
+
+ abstract class I2 {
+ foo();
+ }
+
+ abstract class C implements I2, I1 {}
diff --git a/pkg/front_end/test/fasta/testing/suite.dart b/pkg/front_end/test/fasta/testing/suite.dart
index cc77877..342f2ca 100644
--- a/pkg/front_end/test/fasta/testing/suite.dart
+++ b/pkg/front_end/test/fasta/testing/suite.dart
@@ -374,7 +374,7 @@
UriTranslator uriTranslator = new UriTranslator(
const TargetLibrariesSpecification('vm'),
context.uriTranslator.packages);
- KernelTarget sourceTarget = new KernelTestingTarget(
+ KernelTarget sourceTarget = new KernelTarget(
StandardFileSystem.instance, false, dillTarget, uriTranslator);
sourceTarget.setEntryPoints(<Uri>[description.uri]);
@@ -469,15 +469,6 @@
}
}
-class KernelTestingTarget extends KernelTarget {
- @override
- ClassHierarchyBuilder builderHierarchy;
-
- KernelTestingTarget(StandardFileSystem fileSystem, bool includeComments,
- DillTarget dillTarget, UriTranslator uriTranslator)
- : super(fileSystem, includeComments, dillTarget, uriTranslator);
-}
-
class MatchHierarchy extends Step<Component, Component, FastaContext> {
const MatchHierarchy();
@@ -487,8 +478,8 @@
Component component, FastaContext context) async {
Uri uri =
component.uriToSource.keys.firstWhere((uri) => uri?.scheme == "file");
- KernelTestingTarget target = context.componentToTarget[component];
- ClassHierarchyBuilder hierarchy = target.builderHierarchy;
+ KernelTarget target = context.componentToTarget[component];
+ ClassHierarchyBuilder hierarchy = target.loader.builderHierarchy;
StringBuffer sb = new StringBuffer();
for (ClassHierarchyNode node in hierarchy.nodes.values) {
node.toString(sb);
diff --git a/pkg/front_end/test/fasta/type_inference/interface_resolver_test.dart b/pkg/front_end/test/fasta/type_inference/interface_resolver_test.dart
deleted file mode 100644
index b19a80f..0000000
--- a/pkg/front_end/test/fasta/type_inference/interface_resolver_test.dart
+++ /dev/null
@@ -1,1049 +0,0 @@
-// 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.
-
-import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
-import 'package:front_end/src/fasta/type_inference/interface_resolver.dart';
-import 'package:front_end/src/fasta/type_inference/type_schema_environment.dart';
-import 'package:kernel/ast.dart';
-import 'package:kernel/class_hierarchy.dart';
-import 'package:kernel/core_types.dart';
-import 'package:kernel/testing/mock_sdk_component.dart';
-import 'package:kernel/type_algebra.dart';
-import 'package:test/test.dart';
-import 'package:test_reflective_loader/test_reflective_loader.dart';
-
-main() {
- defineReflectiveSuite(() {
- defineReflectiveTests(InterfaceResolverTest);
- });
-}
-
-@reflectiveTest
-class InterfaceResolverTest {
- final Library testLib;
-
- final Component component;
-
- final CoreTypes coreTypes;
-
- ClassHierarchy cachedClassHierarchy;
-
- TypeSchemaEnvironment cachedTypeEnvironment;
-
- InterfaceResolver cachedInterfaceResolver;
-
- InterfaceResolverTest()
- : this._(new Library(Uri.parse('org-dartlang:///test.dart'), name: 'lib'),
- createMockSdkComponent());
-
- InterfaceResolverTest._(this.testLib, Component component)
- : component = component..libraries.add(testLib..parent = component),
- coreTypes = new CoreTypes(component);
-
- ClassHierarchy get classHierarchy {
- return cachedClassHierarchy ??= new ClassHierarchy(component);
- }
-
- TypeSchemaEnvironment get typeEnvironment {
- return cachedTypeEnvironment ??=
- new TypeSchemaEnvironment(coreTypes, classHierarchy);
- }
-
- InterfaceResolver get interfaceResolver {
- return cachedInterfaceResolver ??=
- new InterfaceResolver(null, typeEnvironment, null);
- }
-
- InterfaceType get intType => coreTypes.intClass.rawType;
-
- Class get listClass => coreTypes.listClass;
-
- InterfaceType get numType => coreTypes.numClass.rawType;
-
- Class get objectClass => coreTypes.objectClass;
-
- InterfaceType get objectType => objectClass.rawType;
-
- void checkCandidate(Procedure procedure, bool setter) {
- var class_ = makeClass(procedures: [procedure]);
- var candidate = getCandidate(class_, setter);
- expect(candidate, same(procedure));
- }
-
- void checkCandidateOrder(Class class_, Member member) {
- // Check that InterfaceResolver prioritizes [member]
- var candidates = getCandidates(class_, false);
- expect(candidates[0], same(member));
-
- // Check that both implementations of [ClassHierarchy] prioritize [member]
- // ahead of [other]
- void check(ClassHierarchy classHierarchy) {
- var interfaceMember =
- classHierarchy.getInterfaceMember(class_, member.name);
- expect(interfaceMember, same(member));
- }
-
- check(new ClassHierarchy(component));
- }
-
- Procedure getCandidate(Class class_, bool setter) {
- var candidates = getCandidates(class_, setter);
- expect(candidates, hasLength(1));
- return candidates[0];
- }
-
- List<Procedure> getCandidates(Class class_, bool setters) =>
- interfaceResolver.getCandidates(class_, setters);
-
- ForwardingNode getForwardingNode(Class class_, bool setter) {
- var forwardingNodes = getForwardingNodes(class_, setter);
- expect(forwardingNodes, hasLength(1));
- return forwardingNodes[0];
- }
-
- List<ForwardingNode> getForwardingNodes(Class class_, bool setters) {
- var forwardingNodes = <ForwardingNode>[];
- var candidates = getCandidates(class_, setters);
- InterfaceResolver.forEachApiMember(candidates,
- (int start, int end, Name name) {
- forwardingNodes.add(new ForwardingNode(interfaceResolver, null, class_,
- name, candidates[start].kind, candidates, start, end));
- });
- return forwardingNodes;
- }
-
- Member getStubTarget(Procedure stub) {
- var body = stub.function.body;
- if (body == null) return null;
- if (body is ReturnStatement) {
- var expression = body.expression;
- if (expression is SuperMethodInvocation) {
- return expression.interfaceTarget;
- } else if (expression is SuperPropertySet) {
- return expression.interfaceTarget;
- } else {
- fail('Unexpected expression type: ${expression.runtimeType}');
- }
- } else {
- fail('Unexpected body type: ${body.runtimeType}');
- }
- }
-
- Class makeClass(
- {String name,
- Supertype supertype,
- Supertype mixedInType,
- List<TypeParameter> typeParameters,
- List<Supertype> implementedTypes,
- List<Procedure> procedures,
- List<Field> fields}) {
- resetInterfaceResolver();
- var class_ = new ShadowClass(
- name: name ?? 'C',
- supertype: supertype ?? objectClass.asThisSupertype,
- mixedInType: mixedInType,
- typeParameters: typeParameters,
- implementedTypes: implementedTypes,
- procedures: procedures,
- fields: fields);
- testLib.addClass(class_);
- return class_;
- }
-
- Procedure makeEmptyMethod(
- {ProcedureKind kind: ProcedureKind.Method,
- String name: 'foo',
- List<TypeParameter> typeParameters,
- List<VariableDeclaration> positionalParameters,
- List<VariableDeclaration> namedParameters,
- int requiredParameterCount,
- DartType returnType: const VoidType(),
- bool isAbstract: false}) {
- var body = isAbstract ? null : new ReturnStatement(new NullLiteral());
- var function = new FunctionNode(body,
- typeParameters: typeParameters,
- positionalParameters: positionalParameters,
- namedParameters: namedParameters,
- requiredParameterCount: requiredParameterCount,
- returnType: returnType);
- return new ShadowProcedure(new Name(name), kind, function, false,
- isAbstract: isAbstract);
- }
-
- Field makeField(
- {String name: 'foo',
- DartType type: const DynamicType(),
- bool isFinal: false}) {
- return new Field(new Name(name), type: type, isFinal: isFinal);
- }
-
- Procedure makeForwardingStub(Procedure method, bool setter,
- {Substitution substitution}) {
- var a = makeClass(name: 'A', procedures: [method]);
- var b = makeClass(name: 'B', supertype: a.asThisSupertype);
- var node = getForwardingNode(b, setter);
- var stub = ForwardingNode.createForwardingStubForTesting(
- node, substitution ?? Substitution.empty, method);
- ForwardingNode.createForwardingImplIfNeededForTesting(node, stub.function);
- return stub;
- }
-
- Procedure makeGetter(
- {String name: 'foo', DartType getterType: const DynamicType()}) {
- var body = new ReturnStatement(new NullLiteral());
- var function = new FunctionNode(body, returnType: getterType);
- return new ShadowProcedure(
- new Name(name), ProcedureKind.Getter, function, false);
- }
-
- Procedure makeSetter(
- {String name: 'foo',
- DartType setterType: const DynamicType(),
- bool isCovariant: false}) {
- var parameter = new VariableDeclarationJudgment('value', 0,
- type: setterType, isCovariant: isCovariant);
- var body = new Block([]);
- var function = new FunctionNode(body,
- positionalParameters: [parameter], returnType: const VoidType());
- return new ShadowProcedure(
- new Name(name), ProcedureKind.Setter, function, false);
- }
-
- void resetInterfaceResolver() {
- cachedClassHierarchy = null;
- cachedTypeEnvironment = null;
- cachedInterfaceResolver = null;
- }
-
- void test_candidate_for_field_getter() {
- var field = makeField();
- var class_ = makeClass(fields: [field]);
- var candidate = getCandidate(class_, false);
- expect(candidate, const TypeMatcher<SyntheticAccessor>());
- expect(candidate.parent, same(class_));
- expect(candidate.name, field.name);
- expect(candidate.kind, ProcedureKind.Getter);
- expect(candidate.function.positionalParameters, isEmpty);
- expect(candidate.function.namedParameters, isEmpty);
- expect(candidate.function.typeParameters, isEmpty);
- }
-
- void test_candidate_for_field_setter() {
- var field = makeField();
- var class_ = makeClass(fields: [field]);
- var candidate = getCandidate(class_, true);
- expect(candidate, const TypeMatcher<SyntheticAccessor>());
- expect(candidate.parent, same(class_));
- expect(candidate.name, field.name);
- expect(candidate.kind, ProcedureKind.Setter);
- expect(candidate.function.positionalParameters, hasLength(1));
- expect(candidate.function.positionalParameters[0].name, '_');
- expect(candidate.function.namedParameters, isEmpty);
- expect(candidate.function.typeParameters, isEmpty);
- expect(candidate.function.returnType, const VoidType());
- }
-
- void test_candidate_for_getter() {
- var function = new FunctionNode(null);
- var getter = new ShadowProcedure(
- new Name('foo'), ProcedureKind.Getter, function, false);
- checkCandidate(getter, false);
- }
-
- void test_candidate_for_method() {
- checkCandidate(makeEmptyMethod(), false);
- }
-
- void test_candidate_for_setter() {
- var parameter = new VariableDeclarationJudgment('value', 0);
- var function = new FunctionNode(null,
- positionalParameters: [parameter], returnType: const VoidType());
- var setter = new ShadowProcedure(
- new Name('foo'), ProcedureKind.Setter, function, false);
- checkCandidate(setter, true);
- }
-
- void test_candidate_from_interface() {
- var method = makeEmptyMethod();
- var a = makeClass(name: 'A', procedures: [method]);
- var b = makeClass(name: 'B', implementedTypes: [a.asThisSupertype]);
- var candidate = getCandidate(b, false);
- expect(candidate, same(method));
- }
-
- void test_candidate_from_mixin() {
- var method = makeEmptyMethod();
- var a = makeClass(name: 'A', procedures: [method]);
- var b = makeClass(name: 'B', mixedInType: a.asThisSupertype);
- var candidate = getCandidate(b, false);
- expect(candidate, same(method));
- }
-
- void test_candidate_from_superclass() {
- var method = makeEmptyMethod();
- var a = makeClass(name: 'A', procedures: [method]);
- var b = makeClass(name: 'B', supertype: a.asThisSupertype);
- var candidate = getCandidate(b, false);
- expect(candidate, same(method));
- }
-
- void test_candidate_order_interfaces() {
- var methodA = makeEmptyMethod();
- var methodB = makeEmptyMethod();
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(name: 'B', procedures: [methodB]);
- var c = makeClass(
- name: 'C', implementedTypes: [a.asThisSupertype, b.asThisSupertype]);
- checkCandidateOrder(c, methodA);
- }
-
- void test_candidate_order_mixin_before_superclass() {
- var methodA = makeEmptyMethod();
- var methodB = makeEmptyMethod();
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(name: 'B', procedures: [methodB]);
- var c = makeClass(
- name: 'C',
- supertype: a.asThisSupertype,
- mixedInType: b.asThisSupertype);
- checkCandidateOrder(c, methodB);
- }
-
- void test_candidate_order_superclass_before_interface() {
- var methodA = makeEmptyMethod();
- var methodB = makeEmptyMethod();
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(name: 'B', procedures: [methodB]);
- var c = makeClass(
- name: 'C',
- supertype: a.asThisSupertype,
- implementedTypes: [b.asThisSupertype]);
- checkCandidateOrder(c, methodA);
- }
-
- void test_createForwardingStub_abstract() {
- var method = makeEmptyMethod(isAbstract: true);
- var stub = makeForwardingStub(method, false);
- expect(stub.isAbstract, isTrue);
- expect(stub.function.body, isNull);
- }
-
- void test_createForwardingStub_getter() {
- var getter = makeGetter(getterType: numType);
- var stub = makeForwardingStub(getter, false);
- expect(stub.name, getter.name);
- expect(stub.kind, ProcedureKind.Getter);
- expect(stub.function.positionalParameters, isEmpty);
- expect(stub.function.namedParameters, isEmpty);
- expect(stub.function.typeParameters, isEmpty);
- expect(stub.function.requiredParameterCount, 0);
- expect(stub.function.returnType, numType);
- var body = stub.function.body as ReturnStatement;
- var expression = body.expression as SuperPropertyGet;
- expect(expression.name, getter.name);
- expect(expression.interfaceTarget, same(getter));
- }
-
- void test_createForwardingStub_getter_for_field() {
- var field = makeField(type: numType);
- var stub = makeForwardingStub(
- InterfaceResolver.makeCandidate(field, false), false);
- expect(stub.name, field.name);
- expect(stub.kind, ProcedureKind.Getter);
- expect(stub.function.positionalParameters, isEmpty);
- expect(stub.function.namedParameters, isEmpty);
- expect(stub.function.typeParameters, isEmpty);
- expect(stub.function.requiredParameterCount, 0);
- expect(stub.function.returnType, numType);
- var body = stub.function.body as ReturnStatement;
- var expression = body.expression as SuperPropertyGet;
- expect(expression.name, field.name);
- expect(expression.interfaceTarget, same(field));
- }
-
- void test_createForwardingStub_operator() {
- var operator = makeEmptyMethod(
- kind: ProcedureKind.Operator,
- name: '[]=',
- positionalParameters: [
- new VariableDeclarationJudgment('index', 0, type: intType),
- new VariableDeclarationJudgment('value', 0, type: numType)
- ]);
- var stub = makeForwardingStub(operator, false);
- expect(stub.name, operator.name);
- expect(stub.kind, ProcedureKind.Operator);
- expect(stub.function.positionalParameters, hasLength(2));
- expect(stub.function.positionalParameters[0].name,
- operator.function.positionalParameters[0].name);
- expect(stub.function.positionalParameters[0].type, intType);
- expect(stub.function.positionalParameters[1].name,
- operator.function.positionalParameters[1].name);
- expect(stub.function.positionalParameters[1].type, numType);
- expect(stub.function.namedParameters, isEmpty);
- expect(stub.function.typeParameters, isEmpty);
- expect(stub.function.requiredParameterCount, 2);
- expect(stub.function.returnType, const VoidType());
- var body = stub.function.body as ReturnStatement;
- var expression = body.expression as SuperMethodInvocation;
- expect(expression.name, operator.name);
- expect(expression.interfaceTarget, same(operator));
- var arguments = expression.arguments;
- expect(arguments.positional, hasLength(2));
- expect((arguments.positional[0] as VariableGet).variable,
- same(stub.function.positionalParameters[0]));
- expect((arguments.positional[1] as VariableGet).variable,
- same(stub.function.positionalParameters[1]));
- }
-
- void test_createForwardingStub_optionalNamedParameter() {
- var parameter = new VariableDeclarationJudgment('x', 0, type: intType);
- var method = makeEmptyMethod(namedParameters: [parameter]);
- var stub = makeForwardingStub(method, false);
- expect(stub.function.namedParameters, hasLength(1));
- expect(stub.function.namedParameters[0].name, 'x');
- expect(stub.function.namedParameters[0].type, intType);
- expect(stub.function.requiredParameterCount, 0);
- var arguments = ((stub.function.body as ReturnStatement).expression
- as SuperMethodInvocation)
- .arguments;
- expect(arguments.named, hasLength(1));
- expect(arguments.named[0].name, 'x');
- expect((arguments.named[0].value as VariableGet).variable,
- same(stub.function.namedParameters[0]));
- }
-
- void test_createForwardingStub_optionalPositionalParameter() {
- var parameter = new VariableDeclarationJudgment('x', 0, type: intType);
- var method = makeEmptyMethod(
- positionalParameters: [parameter], requiredParameterCount: 0);
- var stub = makeForwardingStub(method, false);
- expect(stub.function.positionalParameters, hasLength(1));
- expect(stub.function.positionalParameters[0].name, 'x');
- expect(stub.function.positionalParameters[0].type, intType);
- expect(stub.function.requiredParameterCount, 0);
- var arguments = ((stub.function.body as ReturnStatement).expression
- as SuperMethodInvocation)
- .arguments;
- expect(arguments.positional, hasLength(1));
- expect((arguments.positional[0] as VariableGet).variable,
- same(stub.function.positionalParameters[0]));
- }
-
- void test_createForwardingStub_requiredParameter() {
- var parameter = new VariableDeclarationJudgment('x', 0, type: intType);
- var method = makeEmptyMethod(positionalParameters: [parameter]);
- var stub = makeForwardingStub(method, false);
- expect(stub.function.positionalParameters, hasLength(1));
- expect(stub.function.positionalParameters[0].name, 'x');
- expect(stub.function.positionalParameters[0].type, intType);
- expect(stub.function.requiredParameterCount, 1);
- var arguments = ((stub.function.body as ReturnStatement).expression
- as SuperMethodInvocation)
- .arguments;
- expect(arguments.positional, hasLength(1));
- expect((arguments.positional[0] as VariableGet).variable,
- same(stub.function.positionalParameters[0]));
- }
-
- void test_createForwardingStub_setter() {
- var setter = makeSetter(setterType: numType);
- var stub = makeForwardingStub(setter, true);
- expect(stub.name, setter.name);
- expect(stub.kind, ProcedureKind.Setter);
- expect(stub.function.positionalParameters, hasLength(1));
- expect(stub.function.positionalParameters[0].name,
- setter.function.positionalParameters[0].name);
- expect(stub.function.positionalParameters[0].type, numType);
- expect(stub.function.namedParameters, isEmpty);
- expect(stub.function.typeParameters, isEmpty);
- expect(stub.function.requiredParameterCount, 1);
- expect(stub.function.returnType, const VoidType());
- var body = stub.function.body as ReturnStatement;
- var expression = body.expression as SuperPropertySet;
- expect(expression.name, setter.name);
- expect(expression.interfaceTarget, same(setter));
- expect((expression.value as VariableGet).variable,
- same(stub.function.positionalParameters[0]));
- }
-
- void test_createForwardingStub_setter_for_field() {
- var field = makeField(type: numType);
- var stub =
- makeForwardingStub(InterfaceResolver.makeCandidate(field, true), true);
- expect(stub.name, field.name);
- expect(stub.kind, ProcedureKind.Setter);
- expect(stub.function.positionalParameters, hasLength(1));
- expect(stub.function.positionalParameters[0].name, '_');
- expect(stub.function.positionalParameters[0].type, numType);
- expect(stub.function.namedParameters, isEmpty);
- expect(stub.function.typeParameters, isEmpty);
- expect(stub.function.requiredParameterCount, 1);
- expect(stub.function.returnType, const VoidType());
- var body = stub.function.body as ReturnStatement;
- var expression = body.expression as SuperPropertySet;
- expect(expression.name, field.name);
- expect(expression.interfaceTarget, same(field));
- expect((expression.value as VariableGet).variable,
- same(stub.function.positionalParameters[0]));
- }
-
- void test_createForwardingStub_simple() {
- var method = makeEmptyMethod();
- var stub = makeForwardingStub(method, false);
- expect(stub.name, method.name);
- expect(stub.kind, ProcedureKind.Method);
- expect(stub.isAbstract, isFalse);
- expect(stub.function.positionalParameters, isEmpty);
- expect(stub.function.namedParameters, isEmpty);
- expect(stub.function.typeParameters, isEmpty);
- expect(stub.function.requiredParameterCount, 0);
- expect(stub.function.returnType, const VoidType());
- var body = stub.function.body as ReturnStatement;
- var expression = body.expression as SuperMethodInvocation;
- expect(expression.name, method.name);
- expect(expression.interfaceTarget, same(method));
- expect(expression.arguments.positional, isEmpty);
- expect(expression.arguments.named, isEmpty);
- expect(expression.arguments.types, isEmpty);
- }
-
- void test_createForwardingStub_substitute() {
- // class C<T> { T foo(T x, {T y}); }
- var T = new TypeParameter('T', objectType);
- var x =
- new VariableDeclarationJudgment('x', 0, type: new TypeParameterType(T));
- var y =
- new VariableDeclarationJudgment('y', 0, type: new TypeParameterType(T));
- var method = makeEmptyMethod(
- positionalParameters: [x],
- namedParameters: [y],
- returnType: new TypeParameterType(T));
- var substitution = Substitution.fromPairs([T], [intType]);
- var stub = makeForwardingStub(method, false, substitution: substitution);
- expect(stub.function.positionalParameters[0].type, intType);
- expect(stub.function.namedParameters[0].type, intType);
- expect(stub.function.returnType, intType);
- }
-
- void test_createForwardingStub_typeParameter() {
- var typeParameter = new TypeParameter('T', numType);
- var method = makeEmptyMethod(typeParameters: [typeParameter]);
- var stub = makeForwardingStub(method, false);
- expect(stub.function.typeParameters, hasLength(1));
- expect(stub.function.typeParameters[0].name, 'T');
- expect(stub.function.typeParameters[0].bound, numType);
- var arguments = ((stub.function.body as ReturnStatement).expression
- as SuperMethodInvocation)
- .arguments;
- expect(arguments.types, hasLength(1));
- var typeArgument = arguments.types[0] as TypeParameterType;
- expect(typeArgument.parameter, same(stub.function.typeParameters[0]));
- expect(typeArgument.promotedBound, isNull);
- }
-
- void test_createForwardingStub_typeParameter_and_substitution() {
- // class C<T> { void foo<U>(T x, U y); }
- var T = new TypeParameter('T', objectType);
- var U = new TypeParameter('U', objectType);
- var x =
- new VariableDeclarationJudgment('x', 0, type: new TypeParameterType(T));
- var y =
- new VariableDeclarationJudgment('y', 0, type: new TypeParameterType(U));
- var method =
- makeEmptyMethod(typeParameters: [U], positionalParameters: [x, y]);
- var substitution = Substitution.fromPairs([T], [intType]);
- var stub = makeForwardingStub(method, false, substitution: substitution);
- expect(stub.function.positionalParameters[0].type, intType);
- var stubYType =
- stub.function.positionalParameters[1].type as TypeParameterType;
- expect(stubYType.parameter, same(stub.function.typeParameters[0]));
- }
-
- void test_createForwardingStub_typeParameter_substituteUses() {
- // class C { void foo<T>(T x); }
- var typeParameter = new TypeParameter('T', objectType);
- var param = new VariableDeclarationJudgment('x', 0,
- type: new TypeParameterType(typeParameter));
- var method = makeEmptyMethod(
- typeParameters: [typeParameter], positionalParameters: [param]);
- var stub = makeForwardingStub(method, false);
- var stubXType =
- stub.function.positionalParameters[0].type as TypeParameterType;
- expect(stubXType.parameter, same(stub.function.typeParameters[0]));
- }
-
- void test_createForwardingStub_typeParameter_substituteUses_fBounded() {
- // class C { void foo<T extends List<T>>(T x); }
- var typeParameter = new TypeParameter('T', null);
- typeParameter.bound =
- new InterfaceType(listClass, [new TypeParameterType(typeParameter)]);
- var param = new VariableDeclarationJudgment('x', 0,
- type: new TypeParameterType(typeParameter));
- var method = makeEmptyMethod(
- typeParameters: [typeParameter], positionalParameters: [param]);
- var stub = makeForwardingStub(method, false);
- var stubTypeParameter = stub.function.typeParameters[0];
- var stubTypeParameterBound = stubTypeParameter.bound as InterfaceType;
- var stubTypeParameterBoundArg =
- stubTypeParameterBound.typeArguments[0] as TypeParameterType;
- expect(stubTypeParameterBoundArg.parameter, same(stubTypeParameter));
- var stubXType =
- stub.function.positionalParameters[0].type as TypeParameterType;
- expect(stubXType.parameter, same(stubTypeParameter));
- }
-
- void test_direct_isGenericCovariant() {
- var typeParameter = new TypeParameter('T', objectType);
- var u = new TypeParameter('U', new TypeParameterType(typeParameter))
- ..isGenericCovariantImpl = true;
- var x = new VariableDeclarationJudgment('x', 0,
- type: new TypeParameterType(typeParameter));
- var y = new VariableDeclarationJudgment('y', 0,
- type: new TypeParameterType(typeParameter));
- var method = makeEmptyMethod(
- typeParameters: [u], positionalParameters: [x], namedParameters: [y]);
- var class_ =
- makeClass(typeParameters: [typeParameter], procedures: [method]);
- var node = getForwardingNode(class_, false);
- ShadowClass.setBuilder(class_, null);
- var resolvedMethod = node.finalize();
- expect(resolvedMethod, same(method));
- expect(u.isGenericCovariantImpl, isTrue);
- expect(x.isGenericCovariantImpl, isTrue);
- expect(x.isCovariant, isFalse);
- expect(y.isGenericCovariantImpl, isTrue);
- expect(y.isCovariant, isFalse);
- }
-
- void test_direct_isGenericCovariant_field() {
- var typeParameter = new TypeParameter('T', objectType);
- var field = makeField(type: new TypeParameterType(typeParameter));
- var class_ = makeClass(typeParameters: [typeParameter], fields: [field]);
- var node = getForwardingNode(class_, true);
- ShadowClass.setBuilder(class_, null);
- var resolvedAccessor = node.finalize() as SyntheticAccessor;
- expect(SyntheticAccessor.getField(resolvedAccessor), same(field));
- expect(field.isGenericCovariantImpl, isTrue);
- expect(field.isCovariant, isFalse);
- }
-
- void test_field_isCovariant_inherited() {
- var fieldA = makeField(type: numType)..isCovariant = true;
- var fieldB = makeField(type: numType);
- var a = makeClass(name: 'A', fields: [fieldA]);
- var b = makeClass(
- name: 'B', implementedTypes: [a.asThisSupertype], fields: [fieldB]);
- var node = getForwardingNode(b, true);
- var resolvedAccessor = node.finalize() as SyntheticAccessor;
- expect(SyntheticAccessor.getField(resolvedAccessor), same(fieldB));
- expect(fieldB.isGenericCovariantImpl, isFalse);
- expect(fieldB.isCovariant, isTrue);
- }
-
- void test_field_isGenericCovariantImpl_inherited() {
- var typeParameter = new TypeParameter('T', objectType);
- var fieldA = makeField(type: new TypeParameterType(typeParameter))
- ..isGenericCovariantImpl = true;
- var fieldB = makeField(type: numType);
- var a =
- makeClass(name: 'A', typeParameters: [typeParameter], fields: [fieldA]);
- var b = makeClass(name: 'B', implementedTypes: [
- new Supertype(a, [numType])
- ], fields: [
- fieldB
- ]);
- var node = getForwardingNode(b, true);
- var resolvedAccessor = node.finalize() as SyntheticAccessor;
- expect(SyntheticAccessor.getField(resolvedAccessor), same(fieldB));
- expect(fieldB.isGenericCovariantImpl, isTrue);
- expect(fieldB.isCovariant, isFalse);
- }
-
- void test_forwardingNodes_multiple() {
- var methodAf = makeEmptyMethod(name: 'f');
- var methodBf = makeEmptyMethod(name: 'f');
- var methodAg = makeEmptyMethod(name: 'g');
- var methodBg = makeEmptyMethod(name: 'g');
- var a = makeClass(name: 'A', procedures: [methodAf, methodAg]);
- var b = makeClass(
- name: 'B',
- supertype: a.asThisSupertype,
- procedures: [methodBf, methodBg]);
- var forwardingNodes = getForwardingNodes(b, false);
- expect(forwardingNodes, hasLength(2));
- var nodef = ClassHierarchy.findMemberByName(forwardingNodes, methodAf.name);
- var nodeg = ClassHierarchy.findMemberByName(forwardingNodes, methodAg.name);
- expect(nodef, isNot(same(nodeg)));
- expect(nodef.parent, b);
- expect(nodeg.parent, b);
- {
- var candidates = ForwardingNode.getCandidates(nodef);
- expect(candidates, hasLength(2));
- expect(candidates[0], same(methodBf));
- expect(candidates[1], same(methodAf));
- }
- {
- var candidates = ForwardingNode.getCandidates(nodeg);
- expect(candidates, hasLength(2));
- expect(candidates[0], same(methodBg));
- expect(candidates[1], same(methodAg));
- }
- }
-
- void test_forwardingNodes_single() {
- var methodA = makeEmptyMethod();
- var methodB = makeEmptyMethod();
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(
- name: 'B', supertype: a.asThisSupertype, procedures: [methodB]);
- var forwardingNodes = getForwardingNodes(b, false);
- expect(forwardingNodes, hasLength(1));
- expect(forwardingNodes[0].parent, b);
- expect(forwardingNodes[0].name, methodA.name);
- var candidates = ForwardingNode.getCandidates(forwardingNodes[0]);
- expect(candidates, hasLength(2));
- expect(candidates[0], same(methodB));
- expect(candidates[1], same(methodA));
- }
-
- void test_forwardingStub_isCovariant_inherited() {
- var methodA = makeEmptyMethod(positionalParameters: [
- new VariableDeclarationJudgment('x', 0, type: numType)
- ], namedParameters: [
- new VariableDeclarationJudgment('y', 0, type: numType)
- ]);
- var methodB = makeEmptyMethod(positionalParameters: [
- new VariableDeclarationJudgment('x', 0, type: intType)..isCovariant = true
- ], namedParameters: [
- new VariableDeclarationJudgment('y', 0, type: intType)..isCovariant = true
- ]);
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(name: 'B', procedures: [methodB]);
- var c = makeClass(
- name: 'C',
- supertype: a.asThisSupertype,
- implementedTypes: [b.asThisSupertype]);
- var node = getForwardingNode(c, false);
- var stub = node.finalize();
- var x = stub.function.positionalParameters[0];
- expect(x.isGenericCovariantImpl, isFalse);
- expect(x.isCovariant, isTrue);
- var y = stub.function.namedParameters[0];
- expect(y.isGenericCovariantImpl, isFalse);
- expect(y.isCovariant, isTrue);
- expect(stub.forwardingStubInterfaceTarget, same(methodA));
- expect(getStubTarget(stub), same(methodA));
- }
-
- void test_forwardingStub_isGenericCovariantImpl_inherited() {
- var methodA = makeEmptyMethod(typeParameters: [
- new TypeParameter('U', numType)
- ], positionalParameters: [
- new VariableDeclarationJudgment('x', 0, type: numType)
- ], namedParameters: [
- new VariableDeclarationJudgment('y', 0, type: numType)
- ]);
- var typeParameterB = new TypeParameter('T', objectType);
- var methodB = makeEmptyMethod(typeParameters: [
- new TypeParameter('U', new TypeParameterType(typeParameterB))
- ..isGenericCovariantImpl = true
- ], positionalParameters: [
- new VariableDeclarationJudgment('x', 0,
- type: new TypeParameterType(typeParameterB))
- ..isGenericCovariantImpl = true
- ], namedParameters: [
- new VariableDeclarationJudgment('y', 0,
- type: new TypeParameterType(typeParameterB))
- ..isGenericCovariantImpl = true
- ]);
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(
- name: 'B', typeParameters: [typeParameterB], procedures: [methodB]);
- var c =
- makeClass(name: 'C', supertype: a.asThisSupertype, implementedTypes: [
- new Supertype(b, [numType])
- ]);
- var node = getForwardingNode(c, false);
- var stub = node.finalize();
- var u = stub.function.typeParameters[0];
- expect(u.isGenericCovariantImpl, isTrue);
- var x = stub.function.positionalParameters[0];
- expect(x.isGenericCovariantImpl, isTrue);
- expect(x.isCovariant, isFalse);
- var y = stub.function.namedParameters[0];
- expect(y.isGenericCovariantImpl, isTrue);
- expect(y.isCovariant, isFalse);
- expect(stub.forwardingStubInterfaceTarget, same(methodA));
- expect(getStubTarget(stub), same(methodA));
- }
-
- void test_interfaceTarget_cascaded() {
- var methodC = makeEmptyMethod(positionalParameters: [
- new VariableDeclaration('x', type: intType),
- new VariableDeclaration('y', type: intType)
- ]);
- var c = makeClass(name: 'C', procedures: [methodC]);
- var t = new TypeParameter('T', objectType);
- var methodI1 = makeEmptyMethod(positionalParameters: [
- new VariableDeclaration('x', type: new TypeParameterType(t))
- ..isGenericCovariantImpl = true,
- new VariableDeclaration('y', type: intType)
- ]);
- var i1 = makeClass(name: 'I1', typeParameters: [t], procedures: [methodI1]);
- // Let's say D was previously compiled, so it already has a forwarding stub
- var d =
- makeClass(name: 'D', supertype: c.asThisSupertype, implementedTypes: [
- new Supertype(i1, [intType])
- ]);
- var nodeD = getForwardingNode(d, false);
- var methodD = ForwardingNode.createForwardingStubForTesting(
- nodeD, Substitution.empty, methodC);
- d.addMember(methodD);
- ForwardingNode.createForwardingImplIfNeededForTesting(
- nodeD, methodD.function);
- // To ensure that we don't accidentally make use of information that was
- // computed prior to adding the forwarding stub, reset the interface
- // resolver.
- resetInterfaceResolver();
- var u = new TypeParameter('U', objectType);
- var methodI2 = makeEmptyMethod(positionalParameters: [
- new VariableDeclaration('x', type: intType),
- new VariableDeclaration('y', type: new TypeParameterType(u))
- ..isGenericCovariantImpl = true
- ]);
- var i2 = makeClass(name: 'I2', typeParameters: [u], procedures: [methodI2]);
- var e =
- makeClass(name: 'E', supertype: d.asThisSupertype, implementedTypes: [
- new Supertype(i2, [intType])
- ]);
- var nodeE = getForwardingNode(e, false);
- var stub = nodeE.finalize();
- expect(stub.forwardingStubInterfaceTarget, same(methodC));
- expect(getStubTarget(stub), same(methodC));
- }
-
- void test_interfaceTarget_cascaded_setter() {
- var setterC = makeSetter(setterType: intType);
- var c = makeClass(name: 'C', procedures: [setterC]);
- var t = new TypeParameter('T', objectType);
- var setterI1 = makeSetter(setterType: new TypeParameterType(t));
- var i1 = makeClass(name: 'I1', typeParameters: [t], procedures: [setterI1]);
- // Let's say D was previously compiled, so it already has a forwarding stub
- var d =
- makeClass(name: 'D', supertype: c.asThisSupertype, implementedTypes: [
- new Supertype(i1, [intType])
- ]);
- var nodeD = getForwardingNode(d, true);
- var setterD = ForwardingNode.createForwardingStubForTesting(
- nodeD, Substitution.empty, setterC);
- d.addMember(setterD);
- ForwardingNode.createForwardingImplIfNeededForTesting(
- nodeD, setterD.function);
- // To ensure that we don't accidentally make use of information that was
- // computed prior to adding the forwarding stub, reset the interface
- // resolver.
- resetInterfaceResolver();
- var setterI2 = makeSetter(setterType: intType, isCovariant: true);
- var i2 = makeClass(name: 'I2', procedures: [setterI2]);
- var e = makeClass(
- name: 'E',
- supertype: d.asThisSupertype,
- implementedTypes: [i2.asThisSupertype]);
- var nodeE = getForwardingNode(e, true);
- var stub = nodeE.finalize();
- expect(stub.forwardingStubInterfaceTarget, same(setterC));
- expect(getStubTarget(stub), same(setterC));
- }
-
- void test_interfaceTarget_field() {
- var fieldA = makeField(type: numType, isFinal: true);
- var fieldB = makeField(type: intType, isFinal: true);
- var a = makeClass(name: 'A', fields: [fieldA]);
- var b = makeClass(name: 'B', fields: [fieldB]);
- var c = makeClass(
- name: 'C',
- supertype: a.asThisSupertype,
- implementedTypes: [b.asThisSupertype]);
- var node = getForwardingNode(c, false);
- var stub = node.finalize();
- expect(stub.forwardingStubInterfaceTarget, same(fieldB));
- }
-
- void test_merge_candidates_including_mixin() {
- var methodA = makeEmptyMethod();
- var methodB = makeEmptyMethod();
- var methodC = makeEmptyMethod();
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(name: 'B', procedures: [methodB]);
- var c = makeClass(name: 'C', procedures: [methodC]);
- var d = makeClass(
- name: 'D',
- supertype: a.asThisSupertype,
- mixedInType: b.asThisSupertype,
- implementedTypes: [c.asThisSupertype]);
- var candidates = getCandidates(d, false);
- expect(candidates, hasLength(3));
- expect(candidates[0], same(methodB));
- expect(candidates[1], same(methodA));
- expect(candidates[2], same(methodC));
- }
-
- void test_merge_candidates_not_including_mixin() {
- var methodA = makeEmptyMethod();
- var methodB = makeEmptyMethod();
- var methodC = makeEmptyMethod();
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(name: 'B', procedures: [methodB]);
- var c = makeClass(
- name: 'C',
- supertype: a.asThisSupertype,
- implementedTypes: [b.asThisSupertype],
- procedures: [methodC]);
- var candidates = getCandidates(c, false);
- expect(candidates, hasLength(3));
- expect(candidates[0], same(methodC));
- expect(candidates[1], same(methodA));
- expect(candidates[2], same(methodB));
- }
-
- void test_resolve_directly_declared() {
- var parameterA = new VariableDeclarationJudgment('x', 0,
- type: objectType, isCovariant: true);
- var methodA = makeEmptyMethod(positionalParameters: [parameterA]);
- var parameterB = new VariableDeclarationJudgment('x', 0,
- type: intType, isCovariant: true);
- var methodB = makeEmptyMethod(positionalParameters: [parameterB]);
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(
- name: 'B', supertype: a.asThisSupertype, procedures: [methodB]);
- var node = getForwardingNode(b, false);
- expect(node.finalize(), same(methodB));
- }
-
- void test_resolve_favor_first() {
- // When multiple methods have equivalent types, favor the first one.
- var methodA = makeEmptyMethod();
- var methodB = makeEmptyMethod();
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(name: 'B', procedures: [methodB]);
- var c = makeClass(
- name: 'C', implementedTypes: [a.asThisSupertype, b.asThisSupertype]);
- var node = getForwardingNode(c, false);
- expect(node.finalize(), same(methodA));
- }
-
- void test_resolve_field() {
- var field = makeField();
- var a = makeClass(name: 'A', fields: [field]);
- var b = makeClass(name: 'B', supertype: a.asThisSupertype);
- var node = getForwardingNode(b, false);
- var accessor = node.finalize() as SyntheticAccessor;
- expect(SyntheticAccessor.getField(accessor), same(field));
- }
-
- void test_resolve_first() {
- var methodA = makeEmptyMethod(returnType: intType);
- var methodB = makeEmptyMethod(returnType: numType);
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(name: 'B', procedures: [methodB]);
- var c = makeClass(
- name: 'C', implementedTypes: [a.asThisSupertype, b.asThisSupertype]);
- var node = getForwardingNode(c, false);
- expect(node.finalize(), same(methodA));
- }
-
- void test_resolve_second() {
- var methodA = makeEmptyMethod(returnType: numType);
- var methodB = makeEmptyMethod(returnType: intType);
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(name: 'B', procedures: [methodB]);
- var c = makeClass(
- name: 'C', implementedTypes: [a.asThisSupertype, b.asThisSupertype]);
- var node = getForwardingNode(c, false);
- var stub = node.finalize();
- expect(stub.forwardingStubInterfaceTarget, same(methodB));
- expect(getStubTarget(stub), isNull);
- expect(stub.function.returnType, intType);
- }
-
- void test_resolve_setters() {
- var setterA = makeSetter(setterType: intType);
- var setterB = makeSetter(setterType: objectType);
- var setterC = makeSetter(setterType: numType);
- var a = makeClass(name: 'A', procedures: [setterA]);
- var b = makeClass(name: 'B', procedures: [setterB]);
- var c = makeClass(name: 'C', procedures: [setterC]);
- var d = makeClass(name: 'D', implementedTypes: [
- a.asThisSupertype,
- b.asThisSupertype,
- c.asThisSupertype
- ]);
- var node = getForwardingNode(d, true);
- var stub = node.finalize();
- expect(stub.forwardingStubInterfaceTarget, same(setterB));
- expect(getStubTarget(stub), isNull);
- expect(stub.function.positionalParameters[0].type, objectType);
- }
-
- void test_resolve_with_added_implementation() {
- var methodA = makeEmptyMethod(positionalParameters: [
- new VariableDeclarationJudgment('x', 0, type: numType)
- ]);
- var typeParamB = new TypeParameter('T', objectType);
- var methodB = makeEmptyMethod(positionalParameters: [
- new VariableDeclarationJudgment('x', 0,
- type: new TypeParameterType(typeParamB))
- ..isGenericCovariantImpl = true
- ]);
- var methodC = makeEmptyMethod(positionalParameters: [
- new VariableDeclarationJudgment('x', 0, type: numType)
- ], isAbstract: true);
- var a = makeClass(name: 'A', procedures: [methodA]);
- var b = makeClass(
- name: 'B', typeParameters: [typeParamB], procedures: [methodB]);
- var c =
- makeClass(name: 'C', supertype: a.asThisSupertype, implementedTypes: [
- new Supertype(b, [numType])
- ], procedures: [
- methodC
- ]);
- var node = getForwardingNode(c, false);
- expect(methodC.function.body, isNull);
- var resolvedMethod = node.finalize();
- expect(resolvedMethod, same(methodC));
- expect(methodC.function.body, isNotNull);
- expect(methodC.forwardingStubInterfaceTarget, isNull);
- expect(getStubTarget(methodC), same(methodA));
- }
-
- void test_resolve_with_substitutions() {
- var typeParamA = new TypeParameter('T', objectType);
- var typeParamB = new TypeParameter('T', objectType);
- var typeParamC = new TypeParameter('T', objectType);
- var methodA =
- makeEmptyMethod(returnType: new TypeParameterType(typeParamA));
- var methodB =
- makeEmptyMethod(returnType: new TypeParameterType(typeParamB));
- var methodC =
- makeEmptyMethod(returnType: new TypeParameterType(typeParamC));
- var a = makeClass(
- name: 'A', typeParameters: [typeParamA], procedures: [methodA]);
- var b = makeClass(
- name: 'B', typeParameters: [typeParamB], procedures: [methodB]);
- var c = makeClass(
- name: 'C', typeParameters: [typeParamC], procedures: [methodC]);
- var d = makeClass(
- name: 'D',
- supertype: new Supertype(a, [objectType]),
- implementedTypes: [
- new Supertype(b, [intType]),
- new Supertype(c, [numType])
- ]);
- var node = getForwardingNode(d, false);
- var stub = node.finalize();
- expect(stub.forwardingStubInterfaceTarget, same(methodB));
- expect(getStubTarget(stub), isNull);
- expect(stub.function.returnType, intType);
- }
-}
diff --git a/pkg/front_end/testcases/abstract_members.dart.hierarchy.expect b/pkg/front_end/testcases/abstract_members.dart.hierarchy.expect
index 231e9e1..99a7137 100644
--- a/pkg/front_end/testcases/abstract_members.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/abstract_members.dart.hierarchy.expect
@@ -288,7 +288,7 @@
Object._simpleInstanceOf
B.bMethod
Object._instanceOf
- MyMock1.noSuchMethod
+ MyMock2.MyMock1.noSuchMethod%MyMock2.noSuchMethod
A.abstractMethod
Object._identityHashCode
Object.hashCode
@@ -308,7 +308,7 @@
Object._simpleInstanceOf
B.bMethod
Object._instanceOf
- MyMock1.noSuchMethod
+ MyMock2.MyMock1.noSuchMethod%MyMock2.noSuchMethod
A.abstractMethod
Interface1.interfaceMethod1
Object._identityHashCode
@@ -338,7 +338,7 @@
Object._simpleInstanceOf
B.bMethod
Object._instanceOf
- Object.noSuchMethod
+ MyMock3.Object.noSuchMethod%MyMock3.noSuchMethod
A.abstractMethod
Object._identityHashCode
Object.hashCode
@@ -358,7 +358,7 @@
Object._simpleInstanceOf
B.bMethod
Object._instanceOf
- Object.noSuchMethod
+ MyMock3.Object.noSuchMethod%MyMock3.noSuchMethod
A.abstractMethod
Interface1.interfaceMethod1
Object._identityHashCode
diff --git a/pkg/front_end/testcases/abstract_members.dart.legacy.expect b/pkg/front_end/testcases/abstract_members.dart.legacy.expect
index 5a3c3d0..0322fcb 100644
--- a/pkg/front_end/testcases/abstract_members.dart.legacy.expect
+++ b/pkg/front_end/testcases/abstract_members.dart.legacy.expect
@@ -194,7 +194,7 @@
synthetic constructor •() → self::MyMock1
: super self::B::•()
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
return null;
no-such-method-forwarder method interfaceMethod2() → void
return this.{self::MyMock1::noSuchMethod}(new core::_InvocationMirror::_withType(#interfaceMethod2, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{})));
@@ -217,13 +217,13 @@
synthetic constructor •() → self::MyMock2
: super self::MyMock1::•()
;
- abstract method noSuchMethod(dynamic _) → dynamic;
+ abstract method noSuchMethod(core::Invocation _) → dynamic;
}
class MyMock3 extends self::B {
synthetic constructor •() → self::MyMock3
: super self::B::•()
;
- abstract method noSuchMethod(dynamic _) → dynamic;
+ abstract method noSuchMethod(core::Invocation _) → dynamic;
no-such-method-forwarder get interfaceMethod1() → dynamic
return this.{self::MyMock3::noSuchMethod}(new core::_InvocationMirror::_withType(#interfaceMethod1, 1, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} dynamic;
no-such-method-forwarder set property3(dynamic _) → void
diff --git a/pkg/front_end/testcases/abstract_members.dart.legacy.transformed.expect b/pkg/front_end/testcases/abstract_members.dart.legacy.transformed.expect
index 5a3c3d0..0322fcb 100644
--- a/pkg/front_end/testcases/abstract_members.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/abstract_members.dart.legacy.transformed.expect
@@ -194,7 +194,7 @@
synthetic constructor •() → self::MyMock1
: super self::B::•()
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
return null;
no-such-method-forwarder method interfaceMethod2() → void
return this.{self::MyMock1::noSuchMethod}(new core::_InvocationMirror::_withType(#interfaceMethod2, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{})));
@@ -217,13 +217,13 @@
synthetic constructor •() → self::MyMock2
: super self::MyMock1::•()
;
- abstract method noSuchMethod(dynamic _) → dynamic;
+ abstract method noSuchMethod(core::Invocation _) → dynamic;
}
class MyMock3 extends self::B {
synthetic constructor •() → self::MyMock3
: super self::B::•()
;
- abstract method noSuchMethod(dynamic _) → dynamic;
+ abstract method noSuchMethod(core::Invocation _) → dynamic;
no-such-method-forwarder get interfaceMethod1() → dynamic
return this.{self::MyMock3::noSuchMethod}(new core::_InvocationMirror::_withType(#interfaceMethod1, 1, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} dynamic;
no-such-method-forwarder set property3(dynamic _) → void
diff --git a/pkg/front_end/testcases/abstract_members.dart.outline.expect b/pkg/front_end/testcases/abstract_members.dart.outline.expect
index ad1e730..c54c9fb 100644
--- a/pkg/front_end/testcases/abstract_members.dart.outline.expect
+++ b/pkg/front_end/testcases/abstract_members.dart.outline.expect
@@ -197,7 +197,7 @@
class MyMock1 extends self::B {
synthetic constructor •() → self::MyMock1
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
;
no-such-method-forwarder method interfaceMethod2() → void
return this.{self::MyMock1::noSuchMethod}(new core::_InvocationMirror::_withType(#interfaceMethod2, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{})));
@@ -219,12 +219,12 @@
class MyMock2 extends self::MyMock1 {
synthetic constructor •() → self::MyMock2
;
- abstract method noSuchMethod(dynamic _) → dynamic;
+ abstract method noSuchMethod(core::Invocation _) → dynamic;
}
class MyMock3 extends self::B {
synthetic constructor •() → self::MyMock3
;
- abstract method noSuchMethod(dynamic _) → dynamic;
+ abstract method noSuchMethod(core::Invocation _) → dynamic;
no-such-method-forwarder get interfaceMethod1() → dynamic
return this.{self::MyMock3::noSuchMethod}(new core::_InvocationMirror::_withType(#interfaceMethod1, 1, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} dynamic;
no-such-method-forwarder set property3(dynamic _) → void
diff --git a/pkg/front_end/testcases/bad_setter_abstract.dart.legacy.expect b/pkg/front_end/testcases/bad_setter_abstract.dart.legacy.expect
index e84ce6f..f93d1cb 100644
--- a/pkg/front_end/testcases/bad_setter_abstract.dart.legacy.expect
+++ b/pkg/front_end/testcases/bad_setter_abstract.dart.legacy.expect
@@ -47,13 +47,13 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- set a(dynamic #synthetic) → dynamic {
+ set a(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:10:8: Error: A setter should have exactly one formal parameter.
set a();
^";
;
}
- set d(dynamic #synthetic) → dynamic {
+ set d(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:11:8: Error: A setter should have exactly one formal parameter.
set d(x, y);
^";
@@ -68,13 +68,13 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- set a(dynamic #synthetic) → dynamic {
+ set a(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:15:8: Error: A setter should have exactly one formal parameter.
set a();
^";
;
}
- set d(dynamic #synthetic) → dynamic {
+ set d(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:16:8: Error: A setter should have exactly one formal parameter.
set d(x, y);
^";
@@ -85,13 +85,13 @@
}
}
}
-static set b(dynamic #synthetic) → dynamic {
+static set b(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:5:6: Error: A setter should have exactly one formal parameter.
set b();
^";
;
}
-static set c(dynamic #synthetic) → dynamic {
+static set c(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:7:6: Error: A setter should have exactly one formal parameter.
set c(x, y);
^";
diff --git a/pkg/front_end/testcases/bad_setter_abstract.dart.legacy.transformed.expect b/pkg/front_end/testcases/bad_setter_abstract.dart.legacy.transformed.expect
index e84ce6f..f93d1cb 100644
--- a/pkg/front_end/testcases/bad_setter_abstract.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/bad_setter_abstract.dart.legacy.transformed.expect
@@ -47,13 +47,13 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- set a(dynamic #synthetic) → dynamic {
+ set a(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:10:8: Error: A setter should have exactly one formal parameter.
set a();
^";
;
}
- set d(dynamic #synthetic) → dynamic {
+ set d(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:11:8: Error: A setter should have exactly one formal parameter.
set d(x, y);
^";
@@ -68,13 +68,13 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- set a(dynamic #synthetic) → dynamic {
+ set a(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:15:8: Error: A setter should have exactly one formal parameter.
set a();
^";
;
}
- set d(dynamic #synthetic) → dynamic {
+ set d(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:16:8: Error: A setter should have exactly one formal parameter.
set d(x, y);
^";
@@ -85,13 +85,13 @@
}
}
}
-static set b(dynamic #synthetic) → dynamic {
+static set b(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:5:6: Error: A setter should have exactly one formal parameter.
set b();
^";
;
}
-static set c(dynamic #synthetic) → dynamic {
+static set c(dynamic #synthetic) → void {
invalid-expression "pkg/front_end/testcases/bad_setter_abstract.dart:7:6: Error: A setter should have exactly one formal parameter.
set c(x, y);
^";
diff --git a/pkg/front_end/testcases/bad_setter_abstract.dart.outline.expect b/pkg/front_end/testcases/bad_setter_abstract.dart.outline.expect
index 68dcc4d..65b27e3 100644
--- a/pkg/front_end/testcases/bad_setter_abstract.dart.outline.expect
+++ b/pkg/front_end/testcases/bad_setter_abstract.dart.outline.expect
@@ -18,22 +18,22 @@
class A extends core::Object {
synthetic constructor •() → self::A
;
- set a(dynamic #synthetic) → dynamic
+ set a(dynamic #synthetic) → void
;
- set d(dynamic #synthetic) → dynamic
+ set d(dynamic #synthetic) → void
;
}
abstract class B extends core::Object {
synthetic constructor •() → self::B
;
- set a(dynamic #synthetic) → dynamic
+ set a(dynamic #synthetic) → void
;
- set d(dynamic #synthetic) → dynamic
+ set d(dynamic #synthetic) → void
;
}
-static set b(dynamic #synthetic) → dynamic
+static set b(dynamic #synthetic) → void
;
-static set c(dynamic #synthetic) → dynamic
+static set c(dynamic #synthetic) → void
;
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/bug32866.dart.legacy.expect b/pkg/front_end/testcases/bug32866.dart.legacy.expect
index f62f9f6..5cf6726 100644
--- a/pkg/front_end/testcases/bug32866.dart.legacy.expect
+++ b/pkg/front_end/testcases/bug32866.dart.legacy.expect
@@ -9,7 +9,7 @@
abstract get f() → core::String;
}
class A extends core::Object implements self::B {
- final field dynamic f;
+ final field core::String f;
constructor •(dynamic f) → self::A
: self::A::f = f, super core::Object::•()
;
diff --git a/pkg/front_end/testcases/bug32866.dart.legacy.transformed.expect b/pkg/front_end/testcases/bug32866.dart.legacy.transformed.expect
index f62f9f6..5cf6726 100644
--- a/pkg/front_end/testcases/bug32866.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/bug32866.dart.legacy.transformed.expect
@@ -9,7 +9,7 @@
abstract get f() → core::String;
}
class A extends core::Object implements self::B {
- final field dynamic f;
+ final field core::String f;
constructor •(dynamic f) → self::A
: self::A::f = f, super core::Object::•()
;
diff --git a/pkg/front_end/testcases/bug32866.dart.outline.expect b/pkg/front_end/testcases/bug32866.dart.outline.expect
index 0b51724..c902755 100644
--- a/pkg/front_end/testcases/bug32866.dart.outline.expect
+++ b/pkg/front_end/testcases/bug32866.dart.outline.expect
@@ -8,7 +8,7 @@
abstract get f() → core::String;
}
class A extends core::Object implements self::B {
- final field dynamic f;
+ final field core::String f;
constructor •(dynamic f) → self::A
;
}
diff --git a/pkg/front_end/testcases/bug33206.dart.legacy.expect b/pkg/front_end/testcases/bug33206.dart.legacy.expect
index b0dba95..1d53254 100644
--- a/pkg/front_end/testcases/bug33206.dart.legacy.expect
+++ b/pkg/front_end/testcases/bug33206.dart.legacy.expect
@@ -11,7 +11,7 @@
constructor •(dynamic x, dynamic y) → self::X
: self::X::x = x, self::X::y = y, super core::Object::•()
;
- method toString() → dynamic
+ method toString() → core::String
return "X(${this.{self::X::x}}, ${this.{self::X::y}})";
}
class Y extends core::Object {
diff --git a/pkg/front_end/testcases/bug33206.dart.legacy.transformed.expect b/pkg/front_end/testcases/bug33206.dart.legacy.transformed.expect
index 2a26c19..f484e4b 100644
--- a/pkg/front_end/testcases/bug33206.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/bug33206.dart.legacy.transformed.expect
@@ -11,7 +11,7 @@
constructor •(dynamic x, dynamic y) → self::X
: self::X::x = x, self::X::y = y, super core::Object::•()
;
- method toString() → dynamic
+ method toString() → core::String
return "X(${this.{self::X::x}}, ${this.{self::X::y}})";
}
class Y extends core::Object {
diff --git a/pkg/front_end/testcases/bug33206.dart.outline.expect b/pkg/front_end/testcases/bug33206.dart.outline.expect
index 95d83e8..3dd6634 100644
--- a/pkg/front_end/testcases/bug33206.dart.outline.expect
+++ b/pkg/front_end/testcases/bug33206.dart.outline.expect
@@ -10,7 +10,7 @@
final field dynamic y;
constructor •(dynamic x, dynamic y) → self::X
;
- method toString() → dynamic
+ method toString() → core::String
;
}
class Y extends core::Object {
diff --git a/pkg/front_end/testcases/covariant_generic.dart.outline.expect b/pkg/front_end/testcases/covariant_generic.dart.outline.expect
index 4b44219..da79e5c 100644
--- a/pkg/front_end/testcases/covariant_generic.dart.outline.expect
+++ b/pkg/front_end/testcases/covariant_generic.dart.outline.expect
@@ -12,7 +12,7 @@
;
method method(generic-covariant-impl self::Foo::T x) → void
;
- set setter(generic-covariant-impl self::Foo::T x) → dynamic
+ set setter(generic-covariant-impl self::Foo::T x) → void
;
method withCallback((self::Foo::T) → void callback) → void
;
diff --git a/pkg/front_end/testcases/escape.dart.legacy.expect b/pkg/front_end/testcases/escape.dart.legacy.expect
index 389e93a..ec93320 100644
--- a/pkg/front_end/testcases/escape.dart.legacy.expect
+++ b/pkg/front_end/testcases/escape.dart.legacy.expect
@@ -18,7 +18,7 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- operator ==(dynamic x) → dynamic
+ operator ==(dynamic x) → core::bool
return false;
}
class X extends core::Object implements self::A, self::B {
diff --git a/pkg/front_end/testcases/escape.dart.legacy.transformed.expect b/pkg/front_end/testcases/escape.dart.legacy.transformed.expect
index 389e93a..ec93320 100644
--- a/pkg/front_end/testcases/escape.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/escape.dart.legacy.transformed.expect
@@ -18,7 +18,7 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- operator ==(dynamic x) → dynamic
+ operator ==(dynamic x) → core::bool
return false;
}
class X extends core::Object implements self::A, self::B {
diff --git a/pkg/front_end/testcases/escape.dart.outline.expect b/pkg/front_end/testcases/escape.dart.outline.expect
index e98ed5f..1bccd65 100644
--- a/pkg/front_end/testcases/escape.dart.outline.expect
+++ b/pkg/front_end/testcases/escape.dart.outline.expect
@@ -15,7 +15,7 @@
class C extends core::Object {
synthetic constructor •() → self::C
;
- operator ==(dynamic x) → dynamic
+ operator ==(dynamic x) → core::bool
;
}
class X extends core::Object implements self::A, self::B {
diff --git a/pkg/front_end/testcases/ignore_function.dart b/pkg/front_end/testcases/ignore_function.dart
new file mode 100644
index 0000000..83c33eb
--- /dev/null
+++ b/pkg/front_end/testcases/ignore_function.dart
@@ -0,0 +1,21 @@
+// Copyright (c) 2019, 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.
+
+import "dart:core" as core;
+
+class A implements core.Function {
+ // No error here: core.Function is ignored.
+ operator ==(other) => false;
+}
+
+class B implements Function {
+ // Error here Object.== and Function.== disagree on the type of other.
+ operator ==(other) => false;
+}
+
+class Function {
+ core.bool operator ==(core.Object other) => false;
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/ignore_function.dart.hierarchy.expect b/pkg/front_end/testcases/ignore_function.dart.hierarchy.expect
new file mode 100644
index 0000000..329fb74
--- /dev/null
+++ b/pkg/front_end/testcases/ignore_function.dart.hierarchy.expect
@@ -0,0 +1,83 @@
+Object:
+ superclasses:
+ interfaces:
+ classMembers:
+ Object._haveSameRuntimeType
+ Object.toString
+ Object.runtimeType
+ Object._toString
+ Object._simpleInstanceOf
+ Object._hashCodeRnd
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._objectHashCode
+ Object._identityHashCode
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ classSetters:
+
+A:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ A.==
+ classSetters:
+
+Function:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Function.==
+ classSetters:
+
+B:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Function
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ B.==
+ classSetters:
+ interfaceMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ B.==
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/ignore_function.dart.legacy.expect b/pkg/front_end/testcases/ignore_function.dart.legacy.expect
new file mode 100644
index 0000000..5b8a8d2
--- /dev/null
+++ b/pkg/front_end/testcases/ignore_function.dart.legacy.expect
@@ -0,0 +1,36 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/ignore_function.dart:14:15: Error: Can't infer a type for 'other' as some of the inherited members have different types.
+// Try adding an explicit type.
+// operator ==(other) => false;
+// ^^^^^
+//
+import self as self;
+import "dart:core" as core;
+
+import "dart:core" as core;
+
+class A extends core::Object implements core::Function {
+ synthetic constructor •() → self::A
+ : super core::Object::•()
+ ;
+ operator ==(dynamic other) → core::bool
+ return false;
+}
+class B extends core::Object implements self::Function {
+ synthetic constructor •() → self::B
+ : super core::Object::•()
+ ;
+ operator ==(invalid-type other) → core::bool
+ return false;
+}
+class Function extends core::Object {
+ synthetic constructor •() → self::Function
+ : super core::Object::•()
+ ;
+ operator ==(core::Object other) → core::bool
+ return false;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/ignore_function.dart.legacy.transformed.expect b/pkg/front_end/testcases/ignore_function.dart.legacy.transformed.expect
new file mode 100644
index 0000000..5b8a8d2
--- /dev/null
+++ b/pkg/front_end/testcases/ignore_function.dart.legacy.transformed.expect
@@ -0,0 +1,36 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/ignore_function.dart:14:15: Error: Can't infer a type for 'other' as some of the inherited members have different types.
+// Try adding an explicit type.
+// operator ==(other) => false;
+// ^^^^^
+//
+import self as self;
+import "dart:core" as core;
+
+import "dart:core" as core;
+
+class A extends core::Object implements core::Function {
+ synthetic constructor •() → self::A
+ : super core::Object::•()
+ ;
+ operator ==(dynamic other) → core::bool
+ return false;
+}
+class B extends core::Object implements self::Function {
+ synthetic constructor •() → self::B
+ : super core::Object::•()
+ ;
+ operator ==(invalid-type other) → core::bool
+ return false;
+}
+class Function extends core::Object {
+ synthetic constructor •() → self::Function
+ : super core::Object::•()
+ ;
+ operator ==(core::Object other) → core::bool
+ return false;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/ignore_function.dart.outline.expect b/pkg/front_end/testcases/ignore_function.dart.outline.expect
new file mode 100644
index 0000000..a1585c3
--- /dev/null
+++ b/pkg/front_end/testcases/ignore_function.dart.outline.expect
@@ -0,0 +1,34 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/ignore_function.dart:14:15: Error: Can't infer a type for 'other' as some of the inherited members have different types.
+// Try adding an explicit type.
+// operator ==(other) => false;
+// ^^^^^
+//
+import self as self;
+import "dart:core" as core;
+
+import "dart:core" as core;
+
+class A extends core::Object implements core::Function {
+ synthetic constructor •() → self::A
+ ;
+ operator ==(dynamic other) → core::bool
+ ;
+}
+class B extends core::Object implements self::Function {
+ synthetic constructor •() → self::B
+ ;
+ operator ==(invalid-type other) → core::bool
+ ;
+}
+class Function extends core::Object {
+ synthetic constructor •() → self::Function
+ ;
+ operator ==(core::Object other) → core::bool
+ ;
+}
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/ignore_function.dart.strong.expect b/pkg/front_end/testcases/ignore_function.dart.strong.expect
new file mode 100644
index 0000000..5b8a8d2
--- /dev/null
+++ b/pkg/front_end/testcases/ignore_function.dart.strong.expect
@@ -0,0 +1,36 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/ignore_function.dart:14:15: Error: Can't infer a type for 'other' as some of the inherited members have different types.
+// Try adding an explicit type.
+// operator ==(other) => false;
+// ^^^^^
+//
+import self as self;
+import "dart:core" as core;
+
+import "dart:core" as core;
+
+class A extends core::Object implements core::Function {
+ synthetic constructor •() → self::A
+ : super core::Object::•()
+ ;
+ operator ==(dynamic other) → core::bool
+ return false;
+}
+class B extends core::Object implements self::Function {
+ synthetic constructor •() → self::B
+ : super core::Object::•()
+ ;
+ operator ==(invalid-type other) → core::bool
+ return false;
+}
+class Function extends core::Object {
+ synthetic constructor •() → self::Function
+ : super core::Object::•()
+ ;
+ operator ==(core::Object other) → core::bool
+ return false;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/ignore_function.dart.strong.transformed.expect b/pkg/front_end/testcases/ignore_function.dart.strong.transformed.expect
new file mode 100644
index 0000000..7ce92d7
--- /dev/null
+++ b/pkg/front_end/testcases/ignore_function.dart.strong.transformed.expect
@@ -0,0 +1,21 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+import "dart:core" as core;
+
+class A extends core::Object implements core::Function {
+ synthetic constructor •() → self::A
+ : super core::Object::•()
+ ;
+}
+class B extends core::Object implements self::Function {
+ synthetic constructor •() → self::B
+ : super core::Object::•()
+ ;
+}
+class Function extends core::Object {
+ synthetic constructor •() → self::Function
+ : super core::Object::•()
+ ;
+}
diff --git a/pkg/front_end/testcases/inference/circular_reference_via_closures.dart b/pkg/front_end/testcases/inference/circular_reference_via_closures.dart
index b63fb9a..69efb53 100644
--- a/pkg/front_end/testcases/inference/circular_reference_via_closures.dart
+++ b/pkg/front_end/testcases/inference/circular_reference_via_closures.dart
@@ -5,7 +5,7 @@
/*@testedFeatures=inference*/
library test;
-var x = /*@returnType=invalid-type*/ () => y;
+var x = /*@returnType=() -> invalid-type*/ () => y;
var y = /*@returnType=invalid-type*/ () => x;
main() {}
diff --git a/pkg/front_end/testcases/inference/circular_reference_via_closures.dart.strong.expect b/pkg/front_end/testcases/inference/circular_reference_via_closures.dart.strong.expect
index 73adfd1..bd67e53 100644
--- a/pkg/front_end/testcases/inference/circular_reference_via_closures.dart.strong.expect
+++ b/pkg/front_end/testcases/inference/circular_reference_via_closures.dart.strong.expect
@@ -2,18 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/circular_reference_via_closures.dart:9:5: Error: Can't infer the type of 'y': circularity found during type inference.
-// Specify the type explicitly.
-// var y = /*@returnType=invalid-type*/ () => x;
-// ^
-//
// pkg/front_end/testcases/inference/circular_reference_via_closures.dart:8:5: Error: Can't infer the type of 'x': circularity found during type inference.
// Specify the type explicitly.
-// var x = /*@returnType=invalid-type*/ () => y;
+// var x = /*@returnType=() -> invalid-type*/ () => y;
// ^
//
import self as self;
-static field invalid-type x = (() → invalid-type => self::y) as{TypeError} invalid-type;
-static field invalid-type y = (() → invalid-type => self::x) as{TypeError} invalid-type;
+static field invalid-type x = (() → () → invalid-type => self::y) as{TypeError} invalid-type;
+static field () → invalid-type y = () → invalid-type => self::x;
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/circular_reference_via_closures.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/circular_reference_via_closures.dart.strong.transformed.expect
index 73adfd1..bd67e53 100644
--- a/pkg/front_end/testcases/inference/circular_reference_via_closures.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/circular_reference_via_closures.dart.strong.transformed.expect
@@ -2,18 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/circular_reference_via_closures.dart:9:5: Error: Can't infer the type of 'y': circularity found during type inference.
-// Specify the type explicitly.
-// var y = /*@returnType=invalid-type*/ () => x;
-// ^
-//
// pkg/front_end/testcases/inference/circular_reference_via_closures.dart:8:5: Error: Can't infer the type of 'x': circularity found during type inference.
// Specify the type explicitly.
-// var x = /*@returnType=invalid-type*/ () => y;
+// var x = /*@returnType=() -> invalid-type*/ () => y;
// ^
//
import self as self;
-static field invalid-type x = (() → invalid-type => self::y) as{TypeError} invalid-type;
-static field invalid-type y = (() → invalid-type => self::x) as{TypeError} invalid-type;
+static field invalid-type x = (() → () → invalid-type => self::y) as{TypeError} invalid-type;
+static field () → invalid-type y = () → invalid-type => self::x;
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart b/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart
index b63fb9a..69efb53 100644
--- a/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart
+++ b/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart
@@ -5,7 +5,7 @@
/*@testedFeatures=inference*/
library test;
-var x = /*@returnType=invalid-type*/ () => y;
+var x = /*@returnType=() -> invalid-type*/ () => y;
var y = /*@returnType=invalid-type*/ () => x;
main() {}
diff --git a/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart.strong.expect b/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart.strong.expect
index 4f81f83..88a970d 100644
--- a/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart.strong.expect
+++ b/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart.strong.expect
@@ -2,18 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart:9:5: Error: Can't infer the type of 'y': circularity found during type inference.
-// Specify the type explicitly.
-// var y = /*@returnType=invalid-type*/ () => x;
-// ^
-//
// pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart:8:5: Error: Can't infer the type of 'x': circularity found during type inference.
// Specify the type explicitly.
-// var x = /*@returnType=invalid-type*/ () => y;
+// var x = /*@returnType=() -> invalid-type*/ () => y;
// ^
//
import self as self;
-static field invalid-type x = (() → invalid-type => self::y) as{TypeError} invalid-type;
-static field invalid-type y = (() → invalid-type => self::x) as{TypeError} invalid-type;
+static field invalid-type x = (() → () → invalid-type => self::y) as{TypeError} invalid-type;
+static field () → invalid-type y = () → invalid-type => self::x;
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart.strong.transformed.expect
index 4f81f83..88a970d 100644
--- a/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart.strong.transformed.expect
@@ -2,18 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart:9:5: Error: Can't infer the type of 'y': circularity found during type inference.
-// Specify the type explicitly.
-// var y = /*@returnType=invalid-type*/ () => x;
-// ^
-//
// pkg/front_end/testcases/inference/circular_reference_via_closures_initializer_types.dart:8:5: Error: Can't infer the type of 'x': circularity found during type inference.
// Specify the type explicitly.
-// var x = /*@returnType=invalid-type*/ () => y;
+// var x = /*@returnType=() -> invalid-type*/ () => y;
// ^
//
import self as self;
-static field invalid-type x = (() → invalid-type => self::y) as{TypeError} invalid-type;
-static field invalid-type y = (() → invalid-type => self::x) as{TypeError} invalid-type;
+static field invalid-type x = (() → () → invalid-type => self::y) as{TypeError} invalid-type;
+static field () → invalid-type y = () → invalid-type => self::x;
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/conflicting_fields.dart b/pkg/front_end/testcases/inference/conflicting_fields.dart
index 72edc67..8dacd55 100644
--- a/pkg/front_end/testcases/inference/conflicting_fields.dart
+++ b/pkg/front_end/testcases/inference/conflicting_fields.dart
@@ -17,6 +17,8 @@
class B extends A implements I {
get field1 => null;
get field2 => null;
+ set field1(value) {}
+ set field2(value) {}
}
main() {}
diff --git a/pkg/front_end/testcases/inference/conflicting_fields.dart.hierarchy.expect b/pkg/front_end/testcases/inference/conflicting_fields.dart.hierarchy.expect
index 058c190..b2b061e 100644
--- a/pkg/front_end/testcases/inference/conflicting_fields.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/inference/conflicting_fields.dart.hierarchy.expect
@@ -79,8 +79,8 @@
Object._simpleInstanceOfTrue
Object.==
classSetters:
- A.field1
- A.field2
+ B.field1
+ B.field2
interfaceMembers:
B.field1
Object.toString
@@ -95,5 +95,5 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
- A.field1
- A.field2
+ B.field1
+ B.field2
diff --git a/pkg/front_end/testcases/inference/conflicting_fields.dart.legacy.expect b/pkg/front_end/testcases/inference/conflicting_fields.dart.legacy.expect
index 67e1ae7..0a84181 100644
--- a/pkg/front_end/testcases/inference/conflicting_fields.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/conflicting_fields.dart.legacy.expect
@@ -1,4 +1,17 @@
library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/conflicting_fields.dart:20:14: Error: Can't infer a type for 'value' as some of the inherited members have different types.
+// Try adding an explicit type.
+// set field1(value) {}
+// ^^^^^
+//
+// pkg/front_end/testcases/inference/conflicting_fields.dart:21:14: Error: Can't infer a type for 'value' as some of the inherited members have different types.
+// Try adding an explicit type.
+// set field2(value) {}
+// ^^^^^
+//
import self as self;
import "dart:core" as core;
@@ -20,9 +33,11 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- get field1() → dynamic
+ get field1() → core::int
return null;
- get field2() → dynamic
+ get field2() → core::int
return null;
+ set field1(invalid-type value) → void {}
+ set field2(invalid-type value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/conflicting_fields.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/conflicting_fields.dart.legacy.transformed.expect
index 67e1ae7..0a84181 100644
--- a/pkg/front_end/testcases/inference/conflicting_fields.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/conflicting_fields.dart.legacy.transformed.expect
@@ -1,4 +1,17 @@
library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/conflicting_fields.dart:20:14: Error: Can't infer a type for 'value' as some of the inherited members have different types.
+// Try adding an explicit type.
+// set field1(value) {}
+// ^^^^^
+//
+// pkg/front_end/testcases/inference/conflicting_fields.dart:21:14: Error: Can't infer a type for 'value' as some of the inherited members have different types.
+// Try adding an explicit type.
+// set field2(value) {}
+// ^^^^^
+//
import self as self;
import "dart:core" as core;
@@ -20,9 +33,11 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- get field1() → dynamic
+ get field1() → core::int
return null;
- get field2() → dynamic
+ get field2() → core::int
return null;
+ set field1(invalid-type value) → void {}
+ set field2(invalid-type value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/conflicting_fields.dart.outline.expect b/pkg/front_end/testcases/inference/conflicting_fields.dart.outline.expect
index 6963ff2..57c1e7c 100644
--- a/pkg/front_end/testcases/inference/conflicting_fields.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/conflicting_fields.dart.outline.expect
@@ -1,4 +1,17 @@
library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/conflicting_fields.dart:20:14: Error: Can't infer a type for 'value' as some of the inherited members have different types.
+// Try adding an explicit type.
+// set field1(value) {}
+// ^^^^^
+//
+// pkg/front_end/testcases/inference/conflicting_fields.dart:21:14: Error: Can't infer a type for 'value' as some of the inherited members have different types.
+// Try adding an explicit type.
+// set field2(value) {}
+// ^^^^^
+//
import self as self;
import "dart:core" as core;
@@ -17,9 +30,13 @@
class B extends self::A implements self::I {
synthetic constructor •() → self::B
;
- get field1() → dynamic
+ get field1() → core::int
;
- get field2() → dynamic
+ get field2() → core::int
+ ;
+ set field1(invalid-type value) → void
+ ;
+ set field2(invalid-type value) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/inference/conflicting_fields.dart.strong.expect b/pkg/front_end/testcases/inference/conflicting_fields.dart.strong.expect
index 3f45ef6..fde411a 100644
--- a/pkg/front_end/testcases/inference/conflicting_fields.dart.strong.expect
+++ b/pkg/front_end/testcases/inference/conflicting_fields.dart.strong.expect
@@ -2,42 +2,25 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/conflicting_fields.dart:18:7: Error: Can't infer a type for 'field1' as some of the inherited members have different types.
+// pkg/front_end/testcases/inference/conflicting_fields.dart:18:7: Error: Can't infer a return type for 'field1' as some of the inherited members have different types.
// Try adding an explicit type.
// get field1 => null;
-// ^
+// ^^^^^^
//
-// pkg/front_end/testcases/inference/conflicting_fields.dart:19:7: Error: Can't infer a type for 'field2' as some of the inherited members have different types.
+// pkg/front_end/testcases/inference/conflicting_fields.dart:19:7: Error: Can't infer a return type for 'field2' as some of the inherited members have different types.
// Try adding an explicit type.
// get field2 => null;
-// ^
+// ^^^^^^
//
-// pkg/front_end/testcases/inference/conflicting_fields.dart:19:7: Error: The return type of the method 'B.field2' is 'dynamic', which does not match the return type, 'int', of the overridden method, 'A.field2'.
-// Change to a subtype of 'int'.
-// get field2 => null;
-// ^
-// pkg/front_end/testcases/inference/conflicting_fields.dart:9:7: Context: This is the overridden method ('field2').
-// int field2;
-// ^
+// pkg/front_end/testcases/inference/conflicting_fields.dart:20:14: Error: Can't infer a type for 'value' as some of the inherited members have different types.
+// Try adding an explicit type.
+// set field1(value) {}
+// ^^^^^
//
-// pkg/front_end/testcases/inference/conflicting_fields.dart:18:7: Error: The return type of the method 'B.field1' is 'dynamic', which does not match the return type, 'int', of the overridden method, 'I.field1'.
-// Change to a subtype of 'int'.
-// get field1 => null;
-// ^
-// pkg/front_end/testcases/inference/conflicting_fields.dart:13:7: Context: This is the overridden method ('field1').
-// int field1;
-// ^
-//
-// pkg/front_end/testcases/inference/conflicting_fields.dart:8:11: Error: The return type of the method 'A.field1' is 'dynamic', which does not match the return type, 'int', of the overridden method, 'I.field1'.
-// Change to a subtype of 'int'.
-// dynamic field1;
-// ^
-// pkg/front_end/testcases/inference/conflicting_fields.dart:13:7: Context: This is the overridden method ('field1').
-// int field1;
-// ^
-// pkg/front_end/testcases/inference/conflicting_fields.dart:17:7: Context: Both members are inherited by the non-abstract class 'B'.
-// class B extends A implements I {
-// ^
+// pkg/front_end/testcases/inference/conflicting_fields.dart:21:14: Error: Can't infer a type for 'value' as some of the inherited members have different types.
+// Try adding an explicit type.
+// set field2(value) {}
+// ^^^^^
//
import self as self;
import "dart:core" as core;
@@ -60,10 +43,11 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- get field1() → dynamic
+ get field1() → invalid-type
return null;
- get field2() → dynamic
+ get field2() → invalid-type
return null;
- abstract forwarding-stub set field2(dynamic _) → void;
+ set field1(invalid-type value) → void {}
+ set field2(invalid-type value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/conflicts_can_happen.dart.legacy.expect b/pkg/front_end/testcases/inference/conflicts_can_happen.dart.legacy.expect
index ae8c8ce..3e2c41e 100644
--- a/pkg/front_end/testcases/inference/conflicts_can_happen.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/conflicts_can_happen.dart.legacy.expect
@@ -1,4 +1,17 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/conflicts_can_happen.dart:25:7: Error: Can't infer a return type for 'a' as some of the inherited members have different types.
+// Try adding an explicit type.
+// get a => null;
+// ^
+//
+// pkg/front_end/testcases/inference/conflicts_can_happen.dart:30:7: Error: Can't infer a return type for 'a' as some of the inherited members have different types.
+// Try adding an explicit type.
+// get a => null;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -30,14 +43,14 @@
synthetic constructor •() → self::C1
: super core::Object::•()
;
- get a() → dynamic
+ get a() → invalid-type
return null;
}
class C2 extends core::Object implements self::B, self::A {
synthetic constructor •() → self::C2
: super core::Object::•()
;
- get a() → dynamic
+ get a() → invalid-type
return null;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/conflicts_can_happen.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/conflicts_can_happen.dart.legacy.transformed.expect
index ae8c8ce..3e2c41e 100644
--- a/pkg/front_end/testcases/inference/conflicts_can_happen.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/conflicts_can_happen.dart.legacy.transformed.expect
@@ -1,4 +1,17 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/conflicts_can_happen.dart:25:7: Error: Can't infer a return type for 'a' as some of the inherited members have different types.
+// Try adding an explicit type.
+// get a => null;
+// ^
+//
+// pkg/front_end/testcases/inference/conflicts_can_happen.dart:30:7: Error: Can't infer a return type for 'a' as some of the inherited members have different types.
+// Try adding an explicit type.
+// get a => null;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -30,14 +43,14 @@
synthetic constructor •() → self::C1
: super core::Object::•()
;
- get a() → dynamic
+ get a() → invalid-type
return null;
}
class C2 extends core::Object implements self::B, self::A {
synthetic constructor •() → self::C2
: super core::Object::•()
;
- get a() → dynamic
+ get a() → invalid-type
return null;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/conflicts_can_happen.dart.strong.expect b/pkg/front_end/testcases/inference/conflicts_can_happen.dart.strong.expect
index 6e8c47d..3e2c41e 100644
--- a/pkg/front_end/testcases/inference/conflicts_can_happen.dart.strong.expect
+++ b/pkg/front_end/testcases/inference/conflicts_can_happen.dart.strong.expect
@@ -2,52 +2,16 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/conflicts_can_happen.dart:25:7: Error: Can't infer a type for 'a' as some of the inherited members have different types.
+// pkg/front_end/testcases/inference/conflicts_can_happen.dart:25:7: Error: Can't infer a return type for 'a' as some of the inherited members have different types.
// Try adding an explicit type.
// get a => null;
// ^
//
-// pkg/front_end/testcases/inference/conflicts_can_happen.dart:30:7: Error: Can't infer a type for 'a' as some of the inherited members have different types.
+// pkg/front_end/testcases/inference/conflicts_can_happen.dart:30:7: Error: Can't infer a return type for 'a' as some of the inherited members have different types.
// Try adding an explicit type.
// get a => null;
// ^
//
-// pkg/front_end/testcases/inference/conflicts_can_happen.dart:25:7: Error: The return type of the method 'C1.a' is 'dynamic', which does not match the return type, 'I1', of the overridden method, 'A.a'.
-// - 'I1' is from 'pkg/front_end/testcases/inference/conflicts_can_happen.dart'.
-// Change to a subtype of 'I1'.
-// get a => null;
-// ^
-// pkg/front_end/testcases/inference/conflicts_can_happen.dart:17:12: Context: This is the overridden method ('a').
-// final I1 a = null;
-// ^
-//
-// pkg/front_end/testcases/inference/conflicts_can_happen.dart:25:7: Error: The return type of the method 'C1.a' is 'dynamic', which does not match the return type, 'I2', of the overridden method, 'B.a'.
-// - 'I2' is from 'pkg/front_end/testcases/inference/conflicts_can_happen.dart'.
-// Change to a subtype of 'I2'.
-// get a => null;
-// ^
-// pkg/front_end/testcases/inference/conflicts_can_happen.dart:21:12: Context: This is the overridden method ('a').
-// final I2 a = null;
-// ^
-//
-// pkg/front_end/testcases/inference/conflicts_can_happen.dart:30:7: Error: The return type of the method 'C2.a' is 'dynamic', which does not match the return type, 'I2', of the overridden method, 'B.a'.
-// - 'I2' is from 'pkg/front_end/testcases/inference/conflicts_can_happen.dart'.
-// Change to a subtype of 'I2'.
-// get a => null;
-// ^
-// pkg/front_end/testcases/inference/conflicts_can_happen.dart:21:12: Context: This is the overridden method ('a').
-// final I2 a = null;
-// ^
-//
-// pkg/front_end/testcases/inference/conflicts_can_happen.dart:30:7: Error: The return type of the method 'C2.a' is 'dynamic', which does not match the return type, 'I1', of the overridden method, 'A.a'.
-// - 'I1' is from 'pkg/front_end/testcases/inference/conflicts_can_happen.dart'.
-// Change to a subtype of 'I1'.
-// get a => null;
-// ^
-// pkg/front_end/testcases/inference/conflicts_can_happen.dart:17:12: Context: This is the overridden method ('a').
-// final I1 a = null;
-// ^
-//
import self as self;
import "dart:core" as core;
@@ -79,14 +43,14 @@
synthetic constructor •() → self::C1
: super core::Object::•()
;
- get a() → dynamic
+ get a() → invalid-type
return null;
}
class C2 extends core::Object implements self::B, self::A {
synthetic constructor •() → self::C2
: super core::Object::•()
;
- get a() → dynamic
+ get a() → invalid-type
return null;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.legacy.expect b/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.legacy.expect
index e3d2868..7883099 100644
--- a/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.legacy.expect
@@ -1,4 +1,12 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/conflicts_can_happen2.dart:34:7: Error: Can't infer a return type for 'a' as some of the inherited members have different types.
+// Try adding an explicit type.
+// get a => null;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -44,7 +52,7 @@
synthetic constructor •() → self::C2
: super core::Object::•()
;
- get a() → dynamic
+ get a() → invalid-type
return null;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.legacy.transformed.expect
index e3d2868..7883099 100644
--- a/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.legacy.transformed.expect
@@ -1,4 +1,12 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/conflicts_can_happen2.dart:34:7: Error: Can't infer a return type for 'a' as some of the inherited members have different types.
+// Try adding an explicit type.
+// get a => null;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -44,7 +52,7 @@
synthetic constructor •() → self::C2
: super core::Object::•()
;
- get a() → dynamic
+ get a() → invalid-type
return null;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.strong.expect b/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.strong.expect
index 411506a..7883099 100644
--- a/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.strong.expect
+++ b/pkg/front_end/testcases/inference/conflicts_can_happen2.dart.strong.expect
@@ -2,29 +2,11 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/conflicts_can_happen2.dart:34:7: Error: Can't infer a type for 'a' as some of the inherited members have different types.
+// pkg/front_end/testcases/inference/conflicts_can_happen2.dart:34:7: Error: Can't infer a return type for 'a' as some of the inherited members have different types.
// Try adding an explicit type.
// get a => null;
// ^
//
-// pkg/front_end/testcases/inference/conflicts_can_happen2.dart:34:7: Error: The return type of the method 'C2.a' is 'dynamic', which does not match the return type, 'I1', of the overridden method, 'A.a'.
-// - 'I1' is from 'pkg/front_end/testcases/inference/conflicts_can_happen2.dart'.
-// Change to a subtype of 'I1'.
-// get a => null;
-// ^
-// pkg/front_end/testcases/inference/conflicts_can_happen2.dart:22:12: Context: This is the overridden method ('a').
-// final I1 a = null;
-// ^
-//
-// pkg/front_end/testcases/inference/conflicts_can_happen2.dart:34:7: Error: The return type of the method 'C2.a' is 'dynamic', which does not match the return type, 'I2', of the overridden method, 'B.a'.
-// - 'I2' is from 'pkg/front_end/testcases/inference/conflicts_can_happen2.dart'.
-// Change to a subtype of 'I2'.
-// get a => null;
-// ^
-// pkg/front_end/testcases/inference/conflicts_can_happen2.dart:26:12: Context: This is the overridden method ('a').
-// final I2 a = null;
-// ^
-//
import self as self;
import "dart:core" as core;
@@ -70,7 +52,7 @@
synthetic constructor •() → self::C2
: super core::Object::•()
;
- get a() → dynamic
+ get a() → invalid-type
return null;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.legacy.expect b/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.legacy.expect
index 9a63601..ebc33e7 100644
--- a/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.legacy.expect
@@ -9,7 +9,7 @@
abstract get foo() → core::Iterable<core::String>;
}
class B extends core::Object implements self::A {
- final field dynamic foo = const <dynamic>[];
+ final field core::Iterable<core::String> foo = const <dynamic>[];
synthetic constructor •() → self::B
: super core::Object::•()
;
diff --git a/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.legacy.transformed.expect
index 9a63601..ebc33e7 100644
--- a/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.legacy.transformed.expect
@@ -9,7 +9,7 @@
abstract get foo() → core::Iterable<core::String>;
}
class B extends core::Object implements self::A {
- final field dynamic foo = const <dynamic>[];
+ final field core::Iterable<core::String> foo = const <dynamic>[];
synthetic constructor •() → self::B
: super core::Object::•()
;
diff --git a/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.outline.expect b/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.outline.expect
index 65ee9d5..945a5e0 100644
--- a/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/downwards_context_from_inferred_field_type.dart.outline.expect
@@ -8,7 +8,7 @@
abstract get foo() → core::Iterable<core::String>;
}
class B extends core::Object implements self::A {
- final field dynamic foo;
+ final field core::Iterable<core::String> foo;
synthetic constructor •() → self::B
;
}
diff --git a/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.legacy.expect b/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.legacy.expect
index d1361ce..a97723a 100644
--- a/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.legacy.expect
@@ -3,7 +3,7 @@
import "dart:core" as core;
class C extends core::Object implements self::B {
- final field dynamic x;
+ final field core::int x;
constructor •() → self::C
: self::C::x = self::f<dynamic>(), super core::Object::•()
;
diff --git a/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.legacy.transformed.expect
index d1361ce..a97723a 100644
--- a/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.legacy.transformed.expect
@@ -3,7 +3,7 @@
import "dart:core" as core;
class C extends core::Object implements self::B {
- final field dynamic x;
+ final field core::int x;
constructor •() → self::C
: self::C::x = self::f<dynamic>(), super core::Object::•()
;
diff --git a/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.outline.expect b/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.outline.expect
index e84a002..eda87a3 100644
--- a/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/field_initializer_context_implicit.dart.outline.expect
@@ -3,7 +3,7 @@
import "dart:core" as core;
class C extends core::Object implements self::B {
- final field dynamic x;
+ final field core::int x;
constructor •() → self::C
;
}
diff --git a/pkg/front_end/testcases/inference/future_then.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then.dart.legacy.expect
index 88b6639..7126780 100644
--- a/pkg/front_end/testcases/inference/future_then.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then.dart.legacy.transformed.expect
index 4f440e2..0e46318 100644
--- a/pkg/front_end/testcases/inference/future_then.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then.dart.outline.expect b/pkg/front_end/testcases/inference/future_then.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_2.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_2.dart.legacy.expect
index a91d75e..c555879 100644
--- a/pkg/front_end/testcases/inference/future_then_2.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_2.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_2.dart.legacy.transformed.expect
index 6538f9e..63c4c5c 100644
--- a/pkg/front_end/testcases/inference/future_then_2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_2.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_2.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_2.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_2.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_2.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_3.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_3.dart.legacy.expect
index 2a3484c..075602a 100644
--- a/pkg/front_end/testcases/inference/future_then_3.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_3.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_3.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_3.dart.legacy.transformed.expect
index 346e77b8..895ce5a 100644
--- a/pkg/front_end/testcases/inference/future_then_3.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_3.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_3.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_3.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_3.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_3.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_4.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_4.dart.legacy.expect
index c7d577e..8a393fd 100644
--- a/pkg/front_end/testcases/inference/future_then_4.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_4.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_4.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_4.dart.legacy.transformed.expect
index c90b143..98c8918 100644
--- a/pkg/front_end/testcases/inference/future_then_4.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_4.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_4.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_4.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_4.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_4.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_5.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_5.dart.legacy.expect
index 141e3e7..58d742b 100644
--- a/pkg/front_end/testcases/inference/future_then_5.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_5.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_5.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_5.dart.legacy.transformed.expect
index 33b2911..5d553da 100644
--- a/pkg/front_end/testcases/inference/future_then_5.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_5.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_5.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_5.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_5.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_5.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_6.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_6.dart.legacy.expect
index cc6a439..0cc6848 100644
--- a/pkg/front_end/testcases/inference/future_then_6.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_6.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_6.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_6.dart.legacy.transformed.expect
index 9ad93e8..6d284e6 100644
--- a/pkg/front_end/testcases/inference/future_then_6.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_6.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_6.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_6.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_6.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_6.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.expect
index 579d81d..d16fb57 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.transformed.expect
index 1ae82f7..37a9eaf 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_conditional.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.expect
index 3fbb4f7..b5e3e79 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.transformed.expect
index 9b1db02..e3526c6 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.expect
index a38c5ae..dc6b8a1 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.transformed.expect
index 364a78a..8031722 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.expect
index 189b93e..ac112f8 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.transformed.expect
index 4a5e294..0ebe142 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.expect
index 8b21e2e..f359eff 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.transformed.expect
index e5e7c73..d73e7d4 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.expect
index d4392fe..6231476 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.transformed.expect
index fecb72e..b10c087 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.expect
index 985e5ba..211f9f3 100644
--- a/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.transformed.expect
index f3c12bb..a55a43b 100644
--- a/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_ifNull.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_ifNull.dart.outline.expect
index 18f6651..6c0b0d6 100644
--- a/pkg/front_end/testcases/inference/future_then_ifNull.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_ifNull.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_upwards.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_upwards.dart.legacy.expect
index c454264..c131aa9 100644
--- a/pkg/front_end/testcases/inference/future_then_upwards.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_upwards.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_upwards.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_upwards.dart.legacy.transformed.expect
index c454264..c131aa9 100644
--- a/pkg/front_end/testcases/inference/future_then_upwards.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_upwards.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_upwards.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_upwards.dart.outline.expect
index e5a534c..68201b4 100644
--- a/pkg/front_end/testcases/inference/future_then_upwards.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_upwards.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_upwards_2.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_upwards_2.dart.legacy.expect
index 4c532cc..b418fd7 100644
--- a/pkg/front_end/testcases/inference/future_then_upwards_2.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_upwards_2.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_upwards_2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_upwards_2.dart.legacy.transformed.expect
index 4c532cc..b418fd7 100644
--- a/pkg/front_end/testcases/inference/future_then_upwards_2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_upwards_2.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_upwards_2.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_upwards_2.dart.outline.expect
index e5a534c..68201b4 100644
--- a/pkg/front_end/testcases/inference/future_then_upwards_2.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_upwards_2.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_then_upwards_3.dart.legacy.expect b/pkg/front_end/testcases/inference/future_then_upwards_3.dart.legacy.expect
index 86abe95..93fd95b 100644
--- a/pkg/front_end/testcases/inference/future_then_upwards_3.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_then_upwards_3.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_upwards_3.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_upwards_3.dart.legacy.transformed.expect
index 86abe95..93fd95b 100644
--- a/pkg/front_end/testcases/inference/future_then_upwards_3.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_upwards_3.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_then_upwards_3.dart.outline.expect b/pkg/front_end/testcases/inference/future_then_upwards_3.dart.outline.expect
index 9162c9b..a644d90 100644
--- a/pkg/front_end/testcases/inference/future_then_upwards_3.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_then_upwards_3.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(self::MyFuture::T x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.expect b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.expect
index aed7501..f9b1dde 100644
--- a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(dynamic x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.transformed.expect
index 7697712..24f847d 100644
--- a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(dynamic x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.outline.expect b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.outline.expect
index e80eb43..3e05a12 100644
--- a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(dynamic x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.expect b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.expect
index b3989b2..85cc477 100644
--- a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(dynamic x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.transformed.expect
index 8c463d9..7395c33 100644
--- a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value(dynamic x) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.outline.expect b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.outline.expect
index e80eb43..3e05a12 100644
--- a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value(dynamic x) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.expect b/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.expect
index c309ae6..3e9e23f 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value([dynamic x = null]) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.transformed.expect
index 5fb66a8..86df2a1 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value([dynamic x = null]) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards.dart.outline.expect b/pkg/front_end/testcases/inference/future_union_downwards.dart.outline.expect
index 263a94f..6fbd438 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value([dynamic x]) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.expect b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.expect
index a89b874..1f70652 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value([dynamic x = null]) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.transformed.expect
index ec5724d..1afd6d8 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value([dynamic x = null]) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.outline.expect b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.outline.expect
index 263a94f..6fbd438 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value([dynamic x]) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.expect b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.expect
index 9b07131..51e5fde 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value([dynamic x = null]) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.transformed.expect
index a3884a8..ec3fde4 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value([dynamic x = null]) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.outline.expect b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.outline.expect
index da18d4d..2d1e70e 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value([dynamic x]) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.expect b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.expect
index b27e6d9..ab6a0d3 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value([dynamic x = null]) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.transformed.expect
index ca29563..7fc5179 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
: super core::Object::•() {}
constructor value([dynamic x = null]) → self::MyFuture<self::MyFuture::T>
: super core::Object::•() {}
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
return null;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError = null}) → self::MyFuture<self::MyFuture::then::S>
return null;
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.outline.expect b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.outline.expect
index da18d4d..2d1e70e 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.outline.expect
@@ -10,7 +10,7 @@
;
constructor value([dynamic x]) → self::MyFuture<self::MyFuture::T>
;
- method noSuchMethod(dynamic invocation) → dynamic
+ method noSuchMethod(core::Invocation invocation) → dynamic
;
method then<S extends core::Object = dynamic>((self::MyFuture::T) → asy::FutureOr<self::MyFuture::then::S> f, {core::Function onError}) → self::MyFuture<self::MyFuture::then::S>
;
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type.dart.legacy.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type.dart.legacy.expect
index 1f86d32..b9c4222 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type.dart.legacy.expect
@@ -7,7 +7,7 @@
synthetic constructor •() → self::C<self::C::T>
: super self::D::•()
;
- method f<U extends core::Object = dynamic>(dynamic x) → dynamic {}
+ method f<U extends core::Object = dynamic>(self::C::f::U x) → (self::C::f::U) → void {}
}
class D<T extends core::Object = dynamic> extends core::Object {
synthetic constructor •() → self::D<self::D::T>
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type.dart.legacy.transformed.expect
index 1f86d32..b9c4222 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type.dart.legacy.transformed.expect
@@ -7,7 +7,7 @@
synthetic constructor •() → self::C<self::C::T>
: super self::D::•()
;
- method f<U extends core::Object = dynamic>(dynamic x) → dynamic {}
+ method f<U extends core::Object = dynamic>(self::C::f::U x) → (self::C::f::U) → void {}
}
class D<T extends core::Object = dynamic> extends core::Object {
synthetic constructor •() → self::D<self::D::T>
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type2.dart.legacy.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type2.dart.legacy.expect
index 08648c6..c1d63d6 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type2.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type2.dart.legacy.expect
@@ -7,7 +7,7 @@
synthetic constructor •() → self::C<self::C::T>
: super self::D::•()
;
- method f<U extends core::Object = dynamic>(dynamic g) → dynamic
+ method f<U extends core::Object = dynamic>(() → core::List<self::C::f::U> g) → void
return null;
}
abstract class D<T extends core::Object = dynamic> extends core::Object {
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type2.dart.legacy.transformed.expect
index 08648c6..c1d63d6 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_parameter_type2.dart.legacy.transformed.expect
@@ -7,7 +7,7 @@
synthetic constructor •() → self::C<self::C::T>
: super self::D::•()
;
- method f<U extends core::Object = dynamic>(dynamic g) → dynamic
+ method f<U extends core::Object = dynamic>(() → core::List<self::C::f::U> g) → void
return null;
}
abstract class D<T extends core::Object = dynamic> extends core::Object {
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_return_type.dart.legacy.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_return_type.dart.legacy.expect
index 57033a4..c9c76f5 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_return_type.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_return_type.dart.legacy.expect
@@ -7,7 +7,7 @@
synthetic constructor •() → self::C<self::C::T>
: super self::D::•()
;
- method f<U extends core::Object = dynamic>(dynamic x) → dynamic {}
+ method f<U extends core::Object = dynamic>(self::C::f::U x) → () → self::C::f::U {}
}
class D<T extends core::Object = dynamic> extends core::Object {
synthetic constructor •() → self::D<self::D::T>
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_return_type.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_return_type.dart.legacy.transformed.expect
index 57033a4..c9c76f5 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_return_type.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_function_return_type.dart.legacy.transformed.expect
@@ -7,7 +7,7 @@
synthetic constructor •() → self::C<self::C::T>
: super self::D::•()
;
- method f<U extends core::Object = dynamic>(dynamic x) → dynamic {}
+ method f<U extends core::Object = dynamic>(self::C::f::U x) → () → self::C::f::U {}
}
class D<T extends core::Object = dynamic> extends core::Object {
synthetic constructor •() → self::D<self::D::T>
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_method_type.dart.legacy.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_method_type.dart.legacy.expect
index 29528fb..0500661 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_method_type.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_method_type.dart.legacy.expect
@@ -13,7 +13,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- method m<S extends core::Object = dynamic>(dynamic x) → dynamic
+ method m<S extends core::Object = dynamic>(self::D::m::S x) → self::D::m::S
return x;
}
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_method_type.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_method_type.dart.legacy.transformed.expect
index 29528fb..0500661 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_method_type.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_method_type.dart.legacy.transformed.expect
@@ -13,7 +13,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- method m<S extends core::Object = dynamic>(dynamic x) → dynamic
+ method m<S extends core::Object = dynamic>(self::D::m::S x) → self::D::m::S
return x;
}
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/inference/inconsistent_overrides.dart b/pkg/front_end/testcases/inference/inconsistent_overrides.dart
new file mode 100644
index 0000000..9030aea
--- /dev/null
+++ b/pkg/front_end/testcases/inference/inconsistent_overrides.dart
@@ -0,0 +1,27 @@
+// Copyright (c) 2019, 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 test;
+
+/*@testedFeatures=inference*/
+
+class A {
+ A f(A x, {A y}) {}
+ A g(A x, {A y}) {}
+ A h(A x, {A y}) {}
+}
+
+class B extends A implements I {
+ f(x, {y}) {}
+ g(x, {y}) {}
+ h(x, {y}) {}
+}
+
+class I {
+ I f(I x, {I y}) {}
+ A g(I x, {I y}) {}
+ A h(A x, {I y}) {}
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/inference/inconsistent_overrides.dart.hierarchy.expect b/pkg/front_end/testcases/inference/inconsistent_overrides.dart.hierarchy.expect
new file mode 100644
index 0000000..ad5bb3a
--- /dev/null
+++ b/pkg/front_end/testcases/inference/inconsistent_overrides.dart.hierarchy.expect
@@ -0,0 +1,95 @@
+Object:
+ superclasses:
+ interfaces:
+ classMembers:
+ Object._haveSameRuntimeType
+ Object.toString
+ Object.runtimeType
+ Object._toString
+ Object._simpleInstanceOf
+ Object._hashCodeRnd
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._objectHashCode
+ Object._identityHashCode
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ classSetters:
+
+A:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ A.f
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ A.h
+ Object.hashCode
+ A.g
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ classSetters:
+
+I:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ I.f
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ I.h
+ Object.hashCode
+ I.g
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ classSetters:
+
+B:
+ superclasses:
+ Object
+ -> A
+ interfaces: I
+ classMembers:
+ B.f
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ B.h
+ Object.hashCode
+ B.g
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ classSetters:
+ interfaceMembers:
+ B.f
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ B.h
+ Object.hashCode
+ B.g
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/inference/inconsistent_overrides.dart.legacy.expect b/pkg/front_end/testcases/inference/inconsistent_overrides.dart.legacy.expect
new file mode 100644
index 0000000..d8b5742
--- /dev/null
+++ b/pkg/front_end/testcases/inference/inconsistent_overrides.dart.legacy.expect
@@ -0,0 +1,62 @@
+library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:3: Error: Can't infer a return type for 'f' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:5: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:18:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// h(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:17:5: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// g(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:17:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// g(x, {y}) {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+ synthetic constructor •() → self::A
+ : super core::Object::•()
+ ;
+ method f(self::A x, {self::A y = null}) → self::A {}
+ method g(self::A x, {self::A y = null}) → self::A {}
+ method h(self::A x, {self::A y = null}) → self::A {}
+}
+class B extends self::A implements self::I {
+ synthetic constructor •() → self::B
+ : super self::A::•()
+ ;
+ method f(invalid-type x, {invalid-type y = null}) → invalid-type {}
+ method g(invalid-type x, {invalid-type y = null}) → self::A {}
+ method h(self::A x, {invalid-type y = null}) → self::A {}
+}
+class I extends core::Object {
+ synthetic constructor •() → self::I
+ : super core::Object::•()
+ ;
+ method f(self::I x, {self::I y = null}) → self::I {}
+ method g(self::I x, {self::I y = null}) → self::A {}
+ method h(self::A x, {self::I y = null}) → self::A {}
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/inconsistent_overrides.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/inconsistent_overrides.dart.legacy.transformed.expect
new file mode 100644
index 0000000..d8b5742
--- /dev/null
+++ b/pkg/front_end/testcases/inference/inconsistent_overrides.dart.legacy.transformed.expect
@@ -0,0 +1,62 @@
+library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:3: Error: Can't infer a return type for 'f' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:5: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:18:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// h(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:17:5: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// g(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:17:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// g(x, {y}) {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+ synthetic constructor •() → self::A
+ : super core::Object::•()
+ ;
+ method f(self::A x, {self::A y = null}) → self::A {}
+ method g(self::A x, {self::A y = null}) → self::A {}
+ method h(self::A x, {self::A y = null}) → self::A {}
+}
+class B extends self::A implements self::I {
+ synthetic constructor •() → self::B
+ : super self::A::•()
+ ;
+ method f(invalid-type x, {invalid-type y = null}) → invalid-type {}
+ method g(invalid-type x, {invalid-type y = null}) → self::A {}
+ method h(self::A x, {invalid-type y = null}) → self::A {}
+}
+class I extends core::Object {
+ synthetic constructor •() → self::I
+ : super core::Object::•()
+ ;
+ method f(self::I x, {self::I y = null}) → self::I {}
+ method g(self::I x, {self::I y = null}) → self::A {}
+ method h(self::A x, {self::I y = null}) → self::A {}
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/inconsistent_overrides.dart.outline.expect b/pkg/front_end/testcases/inference/inconsistent_overrides.dart.outline.expect
new file mode 100644
index 0000000..26eafa0
--- /dev/null
+++ b/pkg/front_end/testcases/inference/inconsistent_overrides.dart.outline.expect
@@ -0,0 +1,69 @@
+library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:3: Error: Can't infer a return type for 'f' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:5: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:18:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// h(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:17:5: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// g(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:17:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// g(x, {y}) {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+ synthetic constructor •() → self::A
+ ;
+ method f(self::A x, {self::A y}) → self::A
+ ;
+ method g(self::A x, {self::A y}) → self::A
+ ;
+ method h(self::A x, {self::A y}) → self::A
+ ;
+}
+class B extends self::A implements self::I {
+ synthetic constructor •() → self::B
+ ;
+ method f(invalid-type x, {invalid-type y}) → invalid-type
+ ;
+ method g(invalid-type x, {invalid-type y}) → self::A
+ ;
+ method h(self::A x, {invalid-type y}) → self::A
+ ;
+}
+class I extends core::Object {
+ synthetic constructor •() → self::I
+ ;
+ method f(self::I x, {self::I y}) → self::I
+ ;
+ method g(self::I x, {self::I y}) → self::A
+ ;
+ method h(self::A x, {self::I y}) → self::A
+ ;
+}
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/inference/inconsistent_overrides.dart.strong.expect b/pkg/front_end/testcases/inference/inconsistent_overrides.dart.strong.expect
new file mode 100644
index 0000000..d8b5742
--- /dev/null
+++ b/pkg/front_end/testcases/inference/inconsistent_overrides.dart.strong.expect
@@ -0,0 +1,62 @@
+library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:3: Error: Can't infer a return type for 'f' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:5: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:16:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// f(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:18:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// h(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:17:5: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// g(x, {y}) {}
+// ^
+//
+// pkg/front_end/testcases/inference/inconsistent_overrides.dart:17:9: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// g(x, {y}) {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+ synthetic constructor •() → self::A
+ : super core::Object::•()
+ ;
+ method f(self::A x, {self::A y = null}) → self::A {}
+ method g(self::A x, {self::A y = null}) → self::A {}
+ method h(self::A x, {self::A y = null}) → self::A {}
+}
+class B extends self::A implements self::I {
+ synthetic constructor •() → self::B
+ : super self::A::•()
+ ;
+ method f(invalid-type x, {invalid-type y = null}) → invalid-type {}
+ method g(invalid-type x, {invalid-type y = null}) → self::A {}
+ method h(self::A x, {invalid-type y = null}) → self::A {}
+}
+class I extends core::Object {
+ synthetic constructor •() → self::I
+ : super core::Object::•()
+ ;
+ method f(self::I x, {self::I y = null}) → self::I {}
+ method g(self::I x, {self::I y = null}) → self::A {}
+ method h(self::A x, {self::I y = null}) → self::A {}
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.legacy.expect b/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.legacy.expect
index b9f3f55..ba7aef9 100644
--- a/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.legacy.expect
@@ -18,6 +18,6 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- operator []=(dynamic index, dynamic value) → dynamic {}
+ operator []=(dynamic index, dynamic value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.legacy.transformed.expect
index b9f3f55..ba7aef9 100644
--- a/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.legacy.transformed.expect
@@ -18,6 +18,6 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- operator []=(dynamic index, dynamic value) → dynamic {}
+ operator []=(dynamic index, dynamic value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.outline.expect b/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.outline.expect
index 431131a..ef008c4 100644
--- a/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/index_assign_operator_return_type.dart.outline.expect
@@ -17,7 +17,7 @@
class D extends self::C implements self::I {
synthetic constructor •() → self::D
;
- operator []=(dynamic index, dynamic value) → dynamic
+ operator []=(dynamic index, dynamic value) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.legacy.expect b/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.legacy.expect
index 5ffc002..587faf3 100644
--- a/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.legacy.expect
@@ -18,6 +18,6 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- operator []=(core::int index, dynamic value) → dynamic {}
+ operator []=(core::int index, dynamic value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.legacy.transformed.expect
index 5ffc002..587faf3 100644
--- a/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.legacy.transformed.expect
@@ -18,6 +18,6 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- operator []=(core::int index, dynamic value) → dynamic {}
+ operator []=(core::int index, dynamic value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.outline.expect b/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.outline.expect
index e1dc0dc..68f38e5 100644
--- a/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/index_assign_operator_return_type_2.dart.outline.expect
@@ -17,7 +17,7 @@
class D extends self::C implements self::I {
synthetic constructor •() → self::D
;
- operator []=(core::int index, dynamic value) → dynamic
+ operator []=(core::int index, dynamic value) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.legacy.expect
index 6657368..4b35f0e 100644
--- a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.legacy.expect
@@ -3,7 +3,7 @@
import "dart:core" as core;
class A extends core::Object implements self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::A
: super core::Object::•()
;
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- abstract get x() → dynamic;
+ abstract get x() → core::int;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.legacy.transformed.expect
index 6657368..4b35f0e 100644
--- a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.legacy.transformed.expect
@@ -3,7 +3,7 @@
import "dart:core" as core;
class A extends core::Object implements self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::A
: super core::Object::•()
;
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- abstract get x() → dynamic;
+ abstract get x() → core::int;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.outline.expect b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.outline.expect
index 41317cd..b7b8fe3 100644
--- a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_getter.dart.outline.expect
@@ -3,14 +3,14 @@
import "dart:core" as core;
class A extends core::Object implements self::B {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::A
;
}
abstract class B extends core::Object implements self::C {
synthetic constructor •() → self::B
;
- abstract get x() → dynamic;
+ abstract get x() → core::int;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.legacy.expect
index 67fa407..94de153 100644
--- a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.legacy.expect
@@ -3,7 +3,7 @@
import "dart:core" as core;
class A extends core::Object implements self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::A
: super core::Object::•()
;
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- abstract set x(dynamic value) → void;
+ abstract set x(core::int value) → void;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.legacy.transformed.expect
index 67fa407..94de153 100644
--- a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.legacy.transformed.expect
@@ -3,7 +3,7 @@
import "dart:core" as core;
class A extends core::Object implements self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::A
: super core::Object::•()
;
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- abstract set x(dynamic value) → void;
+ abstract set x(core::int value) → void;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.outline.expect b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.outline.expect
index 9de155a..25d6786 100644
--- a/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_field_from_later_inferred_setter.dart.outline.expect
@@ -3,14 +3,14 @@
import "dart:core" as core;
class A extends core::Object implements self::B {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::A
;
}
abstract class B extends core::Object implements self::C {
synthetic constructor •() → self::B
;
- abstract set x(dynamic value) → void;
+ abstract set x(core::int value) → void;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.legacy.expect
index 34995f9..b67d77f 100644
--- a/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.legacy.expect
@@ -1,4 +1,22 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:32:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
+// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:36:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
+// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:40:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -27,25 +45,25 @@
abstract get x() → core::double;
}
class E extends self::A implements self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::E
: super self::A::•()
;
}
class F extends self::A implements self::C {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::F
: super self::A::•()
;
}
class G extends self::A implements self::D {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::G
: super self::A::•()
;
}
class H extends self::C implements self::D {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::H
: super self::C::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.legacy.transformed.expect
index 34995f9..b67d77f 100644
--- a/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.legacy.transformed.expect
@@ -1,4 +1,22 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:32:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
+// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:36:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
+// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:40:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -27,25 +45,25 @@
abstract get x() → core::double;
}
class E extends self::A implements self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::E
: super self::A::•()
;
}
class F extends self::A implements self::C {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::F
: super self::A::•()
;
}
class G extends self::A implements self::D {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::G
: super self::A::•()
;
}
class H extends self::C implements self::D {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::H
: super self::C::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.outline.expect b/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.outline.expect
index c55fa65..ac7a863 100644
--- a/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.outline.expect
@@ -1,4 +1,22 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:32:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
+// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:36:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
+// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:40:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -23,22 +41,22 @@
abstract get x() → core::double;
}
class E extends self::A implements self::B {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::E
;
}
class F extends self::A implements self::C {
- field dynamic x;
+ field invalid-type x;
synthetic constructor •() → self::F
;
}
class G extends self::A implements self::D {
- field dynamic x;
+ field invalid-type x;
synthetic constructor •() → self::G
;
}
class H extends self::C implements self::D {
- field dynamic x;
+ field invalid-type x;
synthetic constructor •() → self::H
;
}
diff --git a/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.strong.expect b/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.strong.expect
index c24c0bb..b67d77f 100644
--- a/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.strong.expect
+++ b/pkg/front_end/testcases/inference/infer_field_override_multiple.dart.strong.expect
@@ -17,54 +17,6 @@
// var x;
// ^
//
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:32:7: Error: The return type of the method 'F.x' is 'dynamic', which does not match the return type, 'int', of the overridden method, 'A.x'.
-// Change to a subtype of 'int'.
-// var x;
-// ^
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:9:11: Context: This is the overridden method ('x').
-// int get x;
-// ^
-//
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:32:7: Error: The return type of the method 'F.x' is 'dynamic', which does not match the return type, 'num', of the overridden method, 'C.x'.
-// Change to a subtype of 'num'.
-// var x;
-// ^
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:17:11: Context: This is the overridden method ('x').
-// num get x;
-// ^
-//
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:36:7: Error: The return type of the method 'G.x' is 'dynamic', which does not match the return type, 'int', of the overridden method, 'A.x'.
-// Change to a subtype of 'int'.
-// var x;
-// ^
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:9:11: Context: This is the overridden method ('x').
-// int get x;
-// ^
-//
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:36:7: Error: The return type of the method 'G.x' is 'dynamic', which does not match the return type, 'double', of the overridden method, 'D.x'.
-// Change to a subtype of 'double'.
-// var x;
-// ^
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:21:14: Context: This is the overridden method ('x').
-// double get x;
-// ^
-//
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:40:7: Error: The return type of the method 'H.x' is 'dynamic', which does not match the return type, 'num', of the overridden method, 'C.x'.
-// Change to a subtype of 'num'.
-// var x;
-// ^
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:17:11: Context: This is the overridden method ('x').
-// num get x;
-// ^
-//
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:40:7: Error: The return type of the method 'H.x' is 'dynamic', which does not match the return type, 'double', of the overridden method, 'D.x'.
-// Change to a subtype of 'double'.
-// var x;
-// ^
-// pkg/front_end/testcases/inference/infer_field_override_multiple.dart:21:14: Context: This is the overridden method ('x').
-// double get x;
-// ^
-//
import self as self;
import "dart:core" as core;
@@ -99,19 +51,19 @@
;
}
class F extends self::A implements self::C {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::F
: super self::A::•()
;
}
class G extends self::A implements self::D {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::G
: super self::A::•()
;
}
class H extends self::C implements self::D {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::H
: super self::C::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.legacy.expect
index 651b972..f9b40cd 100644
--- a/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.legacy.expect
@@ -15,7 +15,7 @@
abstract get x() → core::int;
}
class C extends self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::C
: super self::B::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.legacy.transformed.expect
index 651b972..f9b40cd 100644
--- a/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.legacy.transformed.expect
@@ -15,7 +15,7 @@
abstract get x() → core::int;
}
class C extends self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::C
: super self::B::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.outline.expect b/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.outline.expect
index 07bf8f9..f76fc3b 100644
--- a/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_field_override_of_override.dart.outline.expect
@@ -13,7 +13,7 @@
abstract get x() → core::int;
}
class C extends self::B {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::C
;
}
diff --git a/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.legacy.expect
index 6e31b6d..c395f30 100644
--- a/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.legacy.expect
@@ -11,9 +11,9 @@
abstract set y(generic-covariant-impl core::List<self::A::T> value) → void;
}
class B extends self::A<core::int> {
- field dynamic x = null;
- field dynamic y = null;
- field dynamic z = null;
+ field core::List<core::int> x = null;
+ generic-covariant-impl field core::List<core::int> y = null;
+ generic-covariant-impl field core::List<core::int> z = null;
synthetic constructor •() → self::B
: super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.legacy.transformed.expect
index 6e31b6d..c395f30 100644
--- a/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.legacy.transformed.expect
@@ -11,9 +11,9 @@
abstract set y(generic-covariant-impl core::List<self::A::T> value) → void;
}
class B extends self::A<core::int> {
- field dynamic x = null;
- field dynamic y = null;
- field dynamic z = null;
+ field core::List<core::int> x = null;
+ generic-covariant-impl field core::List<core::int> y = null;
+ generic-covariant-impl field core::List<core::int> z = null;
synthetic constructor •() → self::B
: super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.outline.expect b/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.outline.expect
index 2fc6225..711058e 100644
--- a/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_field_override_with_substitution.dart.outline.expect
@@ -10,9 +10,9 @@
abstract set y(generic-covariant-impl core::List<self::A::T> value) → void;
}
class B extends self::A<core::int> {
- field dynamic x;
- field dynamic y;
- field dynamic z;
+ field core::List<core::int> x;
+ generic-covariant-impl field core::List<core::int> y;
+ generic-covariant-impl field core::List<core::int> z;
synthetic constructor •() → self::B
;
}
diff --git a/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.legacy.expect
index 72b90ee..9f9de47 100644
--- a/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.legacy.expect
@@ -16,25 +16,25 @@
return 0;
}
class C extends self::A {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::C
: super self::A::•()
;
}
class D extends self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::D
: super self::B::•()
;
}
class E extends core::Object implements self::A {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::E
: super core::Object::•()
;
}
class F extends core::Object implements self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::F
: super core::Object::•()
;
@@ -45,7 +45,7 @@
;
}
class G extends self::_G&Object&B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::G
: super self::_G&Object&B::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.legacy.transformed.expect
index 31c9fee..9f7817b 100644
--- a/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.legacy.transformed.expect
@@ -16,25 +16,25 @@
return 0;
}
class C extends self::A {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::C
: super self::A::•()
;
}
class D extends self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::D
: super self::B::•()
;
}
class E extends core::Object implements self::A {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::E
: super core::Object::•()
;
}
class F extends core::Object implements self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::F
: super core::Object::•()
;
@@ -47,7 +47,7 @@
return 0;
}
class G extends self::_G&Object&B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::G
: super self::_G&Object&B::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.outline.expect b/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.outline.expect
index b627b29..99e2051 100644
--- a/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_field_overrides_getter.dart.outline.expect
@@ -14,22 +14,22 @@
;
}
class C extends self::A {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::C
;
}
class D extends self::B {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::D
;
}
class E extends core::Object implements self::A {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::E
;
}
class F extends core::Object implements self::B {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::F
;
}
@@ -39,7 +39,7 @@
;
}
class G extends self::_G&Object&B {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::G
;
}
diff --git a/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.legacy.expect
index 8baaa28..3c16ce0 100644
--- a/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.legacy.expect
@@ -15,25 +15,25 @@
set x(core::int value) → void {}
}
class C extends self::A {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::C
: super self::A::•()
;
}
class D extends self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::D
: super self::B::•()
;
}
class E extends core::Object implements self::A {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::E
: super core::Object::•()
;
}
class F extends core::Object implements self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::F
: super core::Object::•()
;
@@ -44,7 +44,7 @@
;
}
class G extends self::_G&Object&B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::G
: super self::_G&Object&B::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.legacy.transformed.expect
index 1a36773..e3da27e 100644
--- a/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.legacy.transformed.expect
@@ -15,25 +15,25 @@
set x(core::int value) → void {}
}
class C extends self::A {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::C
: super self::A::•()
;
}
class D extends self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::D
: super self::B::•()
;
}
class E extends core::Object implements self::A {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::E
: super core::Object::•()
;
}
class F extends core::Object implements self::B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::F
: super core::Object::•()
;
@@ -45,7 +45,7 @@
set x(core::int value) → void {}
}
class G extends self::_G&Object&B {
- field dynamic x = null;
+ field core::int x = null;
synthetic constructor •() → self::G
: super self::_G&Object&B::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.outline.expect b/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.outline.expect
index 02e0c2b..0ce880d 100644
--- a/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_field_overrides_setter.dart.outline.expect
@@ -14,22 +14,22 @@
;
}
class C extends self::A {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::C
;
}
class D extends self::B {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::D
;
}
class E extends core::Object implements self::A {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::E
;
}
class F extends core::Object implements self::B {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::F
;
}
@@ -39,7 +39,7 @@
;
}
class G extends self::_G&Object&B {
- field dynamic x;
+ field core::int x;
synthetic constructor •() → self::G
;
}
diff --git a/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.legacy.expect
index 18097da..e03bb9e 100644
--- a/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.legacy.expect
@@ -10,7 +10,7 @@
set x(core::double value) → void {}
}
class B extends self::A {
- final field dynamic x;
+ final field core::int x;
constructor •(dynamic x) → self::B
: self::B::x = x, super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.legacy.transformed.expect
index 18097da..e03bb9e 100644
--- a/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
set x(core::double value) → void {}
}
class B extends self::A {
- final field dynamic x;
+ final field core::int x;
constructor •(dynamic x) → self::B
: self::B::x = x, super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.outline.expect b/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.outline.expect
index 96dbb50..4709de3 100644
--- a/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_final_field_getter_and_setter.dart.outline.expect
@@ -10,7 +10,7 @@
;
}
class B extends self::A {
- final field dynamic x;
+ final field core::int x;
constructor •(dynamic x) → self::B
;
}
diff --git a/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.legacy.expect
index 28bd84b..7dea358 100644
--- a/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.legacy.expect
@@ -9,7 +9,7 @@
abstract get x() → core::int;
}
class B extends self::A {
- final field dynamic x;
+ final field core::int x;
constructor •(dynamic x) → self::B
: self::B::x = x, super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.legacy.transformed.expect
index 28bd84b..7dea358 100644
--- a/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.legacy.transformed.expect
@@ -9,7 +9,7 @@
abstract get x() → core::int;
}
class B extends self::A {
- final field dynamic x;
+ final field core::int x;
constructor •(dynamic x) → self::B
: self::B::x = x, super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.outline.expect b/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.outline.expect
index 11b26c0..5e18eaa 100644
--- a/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_final_field_getter_only.dart.outline.expect
@@ -8,7 +8,7 @@
abstract get x() → core::int;
}
class B extends self::A {
- final field dynamic x;
+ final field core::int x;
constructor •(dynamic x) → self::B
;
}
diff --git a/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.legacy.expect
index d9bfe67..148028f 100644
--- a/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.legacy.expect
@@ -9,7 +9,7 @@
set x(core::double value) → void {}
}
class B extends self::A {
- final field dynamic x;
+ final field core::double x;
constructor •(dynamic x) → self::B
: self::B::x = x, super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.legacy.transformed.expect
index d9bfe67..148028f 100644
--- a/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.legacy.transformed.expect
@@ -9,7 +9,7 @@
set x(core::double value) → void {}
}
class B extends self::A {
- final field dynamic x;
+ final field core::double x;
constructor •(dynamic x) → self::B
: self::B::x = x, super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.outline.expect b/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.outline.expect
index b2085f3..b0206ee 100644
--- a/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_final_field_setter_only.dart.outline.expect
@@ -9,7 +9,7 @@
;
}
class B extends self::A {
- final field dynamic x;
+ final field core::double x;
constructor •(dynamic x) → self::B
;
}
diff --git a/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.legacy.expect
index 3d410db..1bb410b 100644
--- a/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.legacy.expect
@@ -12,6 +12,6 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- abstract get x() → dynamic;
+ abstract get x() → core::double;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.legacy.transformed.expect
index 3d410db..1bb410b 100644
--- a/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.legacy.transformed.expect
@@ -12,6 +12,6 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- abstract get x() → dynamic;
+ abstract get x() → core::double;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.outline.expect b/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.outline.expect
index 35c511d..83d3f12 100644
--- a/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_getter_cross_to_setter.dart.outline.expect
@@ -10,7 +10,7 @@
abstract class B extends self::A {
synthetic constructor •() → self::B
;
- abstract get x() → dynamic;
+ abstract get x() → core::double;
}
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.legacy.expect
index 69eff1f1..62a80b3 100644
--- a/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.legacy.expect
@@ -6,14 +6,14 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- get x() → dynamic
+ get x() → core::int
return self::f();
}
abstract class B extends core::Object implements self::C {
synthetic constructor •() → self::B
: super core::Object::•()
;
- abstract get x() → dynamic;
+ abstract get x() → core::int;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.legacy.transformed.expect
index 69eff1f1..62a80b3 100644
--- a/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.legacy.transformed.expect
@@ -6,14 +6,14 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- get x() → dynamic
+ get x() → core::int
return self::f();
}
abstract class B extends core::Object implements self::C {
synthetic constructor •() → self::B
: super core::Object::•()
;
- abstract get x() → dynamic;
+ abstract get x() → core::int;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.outline.expect b/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.outline.expect
index a346b2f..64fa771 100644
--- a/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_getter_from_later_inferred_getter.dart.outline.expect
@@ -5,13 +5,13 @@
class A extends core::Object implements self::B {
synthetic constructor •() → self::A
;
- get x() → dynamic
+ get x() → core::int
;
}
abstract class B extends core::Object implements self::C {
synthetic constructor •() → self::B
;
- abstract get x() → dynamic;
+ abstract get x() → core::int;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_method_missing_params.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_method_missing_params.dart.legacy.expect
index 5337a40..3c40a1e 100644
--- a/pkg/front_end/testcases/inference/infer_method_missing_params.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_method_missing_params.dart.legacy.expect
@@ -1,14 +1,4 @@
library test;
-//
-// Problems in library:
-//
-// pkg/front_end/testcases/inference/infer_method_missing_params.dart:23:3: Warning: The method 'C.f' has more required arguments than those of overridden method 'B.f'.
-// f(x, y);
-// ^
-// pkg/front_end/testcases/inference/infer_method_missing_params.dart:17:7: Context: This is the overridden method ('f').
-// int f(int x);
-// ^
-//
import self as self;
import "dart:core" as core;
@@ -32,8 +22,8 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- abstract method f(dynamic x, dynamic y) → dynamic;
- abstract method g(dynamic x, [dynamic y = null]) → dynamic;
- abstract method h(dynamic x, {dynamic y = null}) → dynamic;
+ abstract method f(core::int x, core::int y) → core::int;
+ abstract method g(core::int x, [core::int y = null]) → core::int;
+ abstract method h(core::int x, {core::int y = null}) → core::int;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_method_missing_params.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_method_missing_params.dart.legacy.transformed.expect
index 5337a40..3c40a1e 100644
--- a/pkg/front_end/testcases/inference/infer_method_missing_params.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_method_missing_params.dart.legacy.transformed.expect
@@ -1,14 +1,4 @@
library test;
-//
-// Problems in library:
-//
-// pkg/front_end/testcases/inference/infer_method_missing_params.dart:23:3: Warning: The method 'C.f' has more required arguments than those of overridden method 'B.f'.
-// f(x, y);
-// ^
-// pkg/front_end/testcases/inference/infer_method_missing_params.dart:17:7: Context: This is the overridden method ('f').
-// int f(int x);
-// ^
-//
import self as self;
import "dart:core" as core;
@@ -32,8 +22,8 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- abstract method f(dynamic x, dynamic y) → dynamic;
- abstract method g(dynamic x, [dynamic y = null]) → dynamic;
- abstract method h(dynamic x, {dynamic y = null}) → dynamic;
+ abstract method f(core::int x, core::int y) → core::int;
+ abstract method g(core::int x, [core::int y = null]) → core::int;
+ abstract method h(core::int x, {core::int y = null}) → core::int;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_method_missing_params.dart.outline.expect b/pkg/front_end/testcases/inference/infer_method_missing_params.dart.outline.expect
index 0ae3513..332234b 100644
--- a/pkg/front_end/testcases/inference/infer_method_missing_params.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_method_missing_params.dart.outline.expect
@@ -1,14 +1,4 @@
library test;
-//
-// Problems in library:
-//
-// pkg/front_end/testcases/inference/infer_method_missing_params.dart:23:3: Warning: The method 'C.f' has more required arguments than those of overridden method 'B.f'.
-// f(x, y);
-// ^
-// pkg/front_end/testcases/inference/infer_method_missing_params.dart:17:7: Context: This is the overridden method ('f').
-// int f(int x);
-// ^
-//
import self as self;
import "dart:core" as core;
@@ -29,9 +19,9 @@
abstract class C extends core::Object implements self::A, self::B {
synthetic constructor •() → self::C
;
- abstract method f(dynamic x, dynamic y) → dynamic;
- abstract method g(dynamic x, [dynamic y]) → dynamic;
- abstract method h(dynamic x, {dynamic y}) → dynamic;
+ abstract method f(core::int x, core::int y) → core::int;
+ abstract method g(core::int x, [core::int y]) → core::int;
+ abstract method h(core::int x, {core::int y}) → core::int;
}
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_field.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_field.dart.legacy.expect
index b4be5c0..1b88745 100644
--- a/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_field.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_field.dart.legacy.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::C
: super self::D::•()
;
- set foo(dynamic x) → dynamic {}
+ set foo(core::int x) → void {}
}
class D extends core::Object {
field core::int foo = null;
diff --git a/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_field.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_field.dart.legacy.transformed.expect
index b4be5c0..1b88745 100644
--- a/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_field.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_field.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::C
: super self::D::•()
;
- set foo(dynamic x) → dynamic {}
+ set foo(core::int x) → void {}
}
class D extends core::Object {
field core::int foo = null;
diff --git a/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_setter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_setter.dart.legacy.expect
index 6288aaf..688faaf 100644
--- a/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_setter.dart.legacy.expect
@@ -6,12 +6,12 @@
synthetic constructor •() → self::C
: super self::D::•()
;
- set foo(dynamic x) → dynamic {}
+ set foo(core::int x) → void {}
}
class D extends core::Object {
synthetic constructor •() → self::D
: super core::Object::•()
;
- set foo(core::int x) → dynamic {}
+ set foo(core::int x) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_setter.dart.legacy.transformed.expect
index 6288aaf..688faaf 100644
--- a/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_parameter_type_setter_from_setter.dart.legacy.transformed.expect
@@ -6,12 +6,12 @@
synthetic constructor •() → self::C
: super self::D::•()
;
- set foo(dynamic x) → dynamic {}
+ set foo(core::int x) → void {}
}
class D extends core::Object {
synthetic constructor •() → self::D
: super core::Object::•()
;
- set foo(core::int x) → dynamic {}
+ set foo(core::int x) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.legacy.expect
index 24beb1d..6f68db4 100644
--- a/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.legacy.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- static set foo(core::int x) → dynamic {}
+ static set foo(core::int x) → void {}
}
-static set bar(core::int x) → dynamic {}
+static set bar(core::int x) → void {}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.legacy.transformed.expect
index 24beb1d..6f68db4 100644
--- a/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- static set foo(core::int x) → dynamic {}
+ static set foo(core::int x) → void {}
}
-static set bar(core::int x) → dynamic {}
+static set bar(core::int x) → void {}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.outline.expect b/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.outline.expect
index e12c95b..42e1a1a 100644
--- a/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_return_type_for_static_setter.dart.outline.expect
@@ -5,10 +5,10 @@
class C extends core::Object {
synthetic constructor •() → self::C
;
- static set foo(core::int x) → dynamic
+ static set foo(core::int x) → void
;
}
-static set bar(core::int x) → dynamic
+static set bar(core::int x) → void
;
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.legacy.expect
index db7fb96..849953f 100644
--- a/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.legacy.expect
@@ -12,6 +12,6 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- abstract set x(dynamic value) → void;
+ abstract set x(core::double value) → void;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.legacy.transformed.expect
index db7fb96..849953f 100644
--- a/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.legacy.transformed.expect
@@ -12,6 +12,6 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- abstract set x(dynamic value) → void;
+ abstract set x(core::double value) → void;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.outline.expect b/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.outline.expect
index e80537c..1d8285f 100644
--- a/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_setter_cross_to_getter.dart.outline.expect
@@ -10,7 +10,7 @@
abstract class B extends self::A {
synthetic constructor •() → self::B
;
- abstract set x(dynamic value) → void;
+ abstract set x(core::double value) → void;
}
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.legacy.expect
index 0c5bffd..d58802b 100644
--- a/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.legacy.expect
@@ -6,13 +6,13 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- set x(dynamic value) → void {}
+ set x(core::int value) → void {}
}
abstract class B extends core::Object implements self::C {
synthetic constructor •() → self::B
: super core::Object::•()
;
- abstract set x(dynamic value) → void;
+ abstract set x(core::int value) → void;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.legacy.transformed.expect
index 0c5bffd..d58802b 100644
--- a/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.legacy.transformed.expect
@@ -6,13 +6,13 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- set x(dynamic value) → void {}
+ set x(core::int value) → void {}
}
abstract class B extends core::Object implements self::C {
synthetic constructor •() → self::B
: super core::Object::•()
;
- abstract set x(dynamic value) → void;
+ abstract set x(core::int value) → void;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.outline.expect b/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.outline.expect
index 47cd14e..462e7c5 100644
--- a/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_setter_from_later_inferred_setter.dart.outline.expect
@@ -5,13 +5,13 @@
class A extends core::Object implements self::B {
synthetic constructor •() → self::A
;
- set x(dynamic value) → void
+ set x(core::int value) → void
;
}
abstract class B extends core::Object implements self::C {
synthetic constructor •() → self::B
;
- abstract set x(dynamic value) → void;
+ abstract set x(core::int value) → void;
}
abstract class C extends core::Object {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.legacy.expect
index a8e04fb..670abbd 100644
--- a/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.legacy.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- set x(core::Object o) → dynamic {}
+ set x(core::Object o) → void {}
}
static method main() → dynamic {
new self::B::•().x = "hello";
diff --git a/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.legacy.transformed.expect
index a8e04fb..670abbd 100644
--- a/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.legacy.transformed.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- set x(core::Object o) → dynamic {}
+ set x(core::Object o) → void {}
}
static method main() → dynamic {
new self::B::•().x = "hello";
diff --git a/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.outline.expect b/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.outline.expect
index 4afa24f..2f2f40b 100644
--- a/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/infer_setter_return_type_only.dart.outline.expect
@@ -11,7 +11,7 @@
class B extends self::A {
synthetic constructor •() → self::B
;
- set x(core::Object o) → dynamic
+ set x(core::Object o) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/inference/infer_type_on_overridden_fields2.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_type_on_overridden_fields2.dart.legacy.expect
index 26d089c..2f5e471 100644
--- a/pkg/front_end/testcases/inference/infer_type_on_overridden_fields2.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_type_on_overridden_fields2.dart.legacy.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- get x() → dynamic
+ get x() → core::int
return 3;
}
static method foo() → dynamic {
diff --git a/pkg/front_end/testcases/inference/infer_type_on_overridden_fields2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_type_on_overridden_fields2.dart.legacy.transformed.expect
index 26d089c..2f5e471 100644
--- a/pkg/front_end/testcases/inference/infer_type_on_overridden_fields2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_type_on_overridden_fields2.dart.legacy.transformed.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- get x() → dynamic
+ get x() → core::int
return 3;
}
static method foo() → dynamic {
diff --git a/pkg/front_end/testcases/inference/infer_type_on_overridden_fields4.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_type_on_overridden_fields4.dart.legacy.expect
index 1159f05..922bf72 100644
--- a/pkg/front_end/testcases/inference/infer_type_on_overridden_fields4.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_type_on_overridden_fields4.dart.legacy.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- get x() → dynamic
+ get x() → core::int
return 3;
}
static method foo() → dynamic {
diff --git a/pkg/front_end/testcases/inference/infer_type_on_overridden_fields4.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_type_on_overridden_fields4.dart.legacy.transformed.expect
index 1159f05..922bf72 100644
--- a/pkg/front_end/testcases/inference/infer_type_on_overridden_fields4.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_type_on_overridden_fields4.dart.legacy.transformed.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- get x() → dynamic
+ get x() → core::int
return 3;
}
static method foo() → dynamic {
diff --git a/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles.dart.legacy.expect
index 4302f4f..3b2d1ac 100644
--- a/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles.dart.legacy.expect
@@ -9,7 +9,7 @@
synthetic constructor •() → self::C
: super inf::B::•()
;
- get x() → dynamic
+ get x() → core::int
return null;
}
class A extends core::Object {
diff --git a/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles.dart.legacy.transformed.expect
index 4302f4f..3b2d1ac 100644
--- a/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles.dart.legacy.transformed.expect
@@ -9,7 +9,7 @@
synthetic constructor •() → self::C
: super inf::B::•()
;
- get x() → dynamic
+ get x() → core::int
return null;
}
class A extends core::Object {
diff --git a/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles_b.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles_b.dart.legacy.expect
index 2e91f62..693b5a2 100644
--- a/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles_b.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles_b.dart.legacy.expect
@@ -22,7 +22,7 @@
synthetic constructor •() → test::C
: super self::B::•()
;
- get x() → dynamic
+ get x() → core::int
return null;
}
class A extends core::Object {
diff --git a/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles_b.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles_b.dart.legacy.transformed.expect
index 2e91f62..693b5a2 100644
--- a/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles_b.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_type_regardless_of_declaration_order_or_cycles_b.dart.legacy.transformed.expect
@@ -22,7 +22,7 @@
synthetic constructor •() → test::C
: super self::B::•()
;
- get x() → dynamic
+ get x() → core::int
return null;
}
class A extends core::Object {
diff --git a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_3.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_3.dart.legacy.expect
index 927f51d..0360763 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_3.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_3.dart.legacy.expect
@@ -13,9 +13,9 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- get x() → dynamic
+ get x() → core::int
return 3;
- get w() → dynamic
+ get w() → core::int
return "hello";
}
static method foo() → dynamic {
diff --git a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_3.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_3.dart.legacy.transformed.expect
index 927f51d..0360763 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_3.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_3.dart.legacy.transformed.expect
@@ -13,9 +13,9 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- get x() → dynamic
+ get x() → core::int
return 3;
- get w() → dynamic
+ get w() → core::int
return "hello";
}
static method foo() → dynamic {
diff --git a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_4.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_4.dart.legacy.expect
index 3c624e6..4f44d59 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_4.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_4.dart.legacy.expect
@@ -13,7 +13,7 @@
synthetic constructor •() → self::B<self::B::E>
: super self::A::•()
;
- get x() → dynamic
+ get x() → self::B::E
return this.{self::B::y};
}
static method foo() → dynamic {
diff --git a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_4.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_4.dart.legacy.transformed.expect
index 3c624e6..4f44d59 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_4.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_4.dart.legacy.transformed.expect
@@ -13,7 +13,7 @@
synthetic constructor •() → self::B<self::B::E>
: super self::A::•()
;
- get x() → dynamic
+ get x() → self::B::E
return this.{self::B::y};
}
static method foo() → dynamic {
diff --git a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_5.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_5.dart.legacy.expect
index 23fb83d..2a0386f 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_5.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_5.dart.legacy.expect
@@ -26,7 +26,7 @@
;
get y() → core::int
return 0;
- method m(dynamic a, (dynamic, self::B::E) → dynamic f) → dynamic {}
+ method m(dynamic a, (dynamic, self::B::E) → dynamic f) → core::String {}
}
static method foo() → dynamic {
core::int y = new self::B::•<dynamic>().m(null, null);
diff --git a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_5.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_5.dart.legacy.transformed.expect
index 23fb83d..2a0386f 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_5.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_5.dart.legacy.transformed.expect
@@ -26,7 +26,7 @@
;
get y() → core::int
return 0;
- method m(dynamic a, (dynamic, self::B::E) → dynamic f) → dynamic {}
+ method m(dynamic a, (dynamic, self::B::E) → dynamic f) → core::String {}
}
static method foo() → dynamic {
core::int y = new self::B::•<dynamic>().m(null, null);
diff --git a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle.dart.legacy.expect
index 2f73c7b..d9b9d5e 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle.dart.legacy.expect
@@ -23,7 +23,7 @@
;
get y() → core::int
return 0;
- method m(dynamic a, (dynamic, core::int) → dynamic f) → dynamic {}
+ method m(dynamic a, (dynamic, core::int) → dynamic f) → self::A<self::B::E> {}
}
static method foo() → dynamic {
core::int y = new self::B::•<core::String>().m(null, null).value;
diff --git a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle.dart.legacy.transformed.expect
index 2f73c7b..d9b9d5e 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle.dart.legacy.transformed.expect
@@ -23,7 +23,7 @@
;
get y() → core::int
return 0;
- method m(dynamic a, (dynamic, core::int) → dynamic f) → dynamic {}
+ method m(dynamic a, (dynamic, core::int) → dynamic f) → self::A<self::B::E> {}
}
static method foo() → dynamic {
core::int y = new self::B::•<core::String>().m(null, null).value;
diff --git a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle_a.dart.legacy.expect b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle_a.dart.legacy.expect
index c8150f5..b40ebe3 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle_a.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle_a.dart.legacy.expect
@@ -38,7 +38,7 @@
;
get y() → core::int
return 0;
- method m(dynamic a, (dynamic, core::int) → dynamic f) → dynamic {}
+ method m(dynamic a, (dynamic, core::int) → dynamic f) → test::A<test::B::E> {}
}
static method foo() → dynamic {
core::int y = new test::B::•<core::String>().m(null, null).value;
diff --git a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle_a.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle_a.dart.legacy.transformed.expect
index c8150f5..b40ebe3 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle_a.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_generic_instantiations_in_library_cycle_a.dart.legacy.transformed.expect
@@ -38,7 +38,7 @@
;
get y() → core::int
return 0;
- method m(dynamic a, (dynamic, core::int) → dynamic f) → dynamic {}
+ method m(dynamic a, (dynamic, core::int) → dynamic f) → test::A<test::B::E> {}
}
static method foo() → dynamic {
core::int y = new test::B::•<core::String>().m(null, null).value;
diff --git a/pkg/front_end/testcases/inference/setter_return_type.dart.legacy.expect b/pkg/front_end/testcases/inference/setter_return_type.dart.legacy.expect
index e0cd00f..7e9ace6 100644
--- a/pkg/front_end/testcases/inference/setter_return_type.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/setter_return_type.dart.legacy.expect
@@ -18,6 +18,6 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- set x(dynamic value) → dynamic {}
+ set x(core::int value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/setter_return_type.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/setter_return_type.dart.legacy.transformed.expect
index e0cd00f..7e9ace6 100644
--- a/pkg/front_end/testcases/inference/setter_return_type.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/setter_return_type.dart.legacy.transformed.expect
@@ -18,6 +18,6 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- set x(dynamic value) → dynamic {}
+ set x(core::int value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/setter_return_type.dart.outline.expect b/pkg/front_end/testcases/inference/setter_return_type.dart.outline.expect
index 5052808..1ae8232 100644
--- a/pkg/front_end/testcases/inference/setter_return_type.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/setter_return_type.dart.outline.expect
@@ -17,7 +17,7 @@
class D extends self::C implements self::I {
synthetic constructor •() → self::D
;
- set x(dynamic value) → dynamic
+ set x(core::int value) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/inference/super_index_set_substitution.dart.legacy.expect b/pkg/front_end/testcases/inference/super_index_set_substitution.dart.legacy.expect
index b1c6c5f..8793d9b 100644
--- a/pkg/front_end/testcases/inference/super_index_set_substitution.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/super_index_set_substitution.dart.legacy.expect
@@ -15,7 +15,7 @@
synthetic constructor •() → self::C<self::C::U>
: super self::B::•()
;
- operator []=(core::Object x, core::Object y) → void {}
+ operator []=(generic-covariant-impl core::Object x, generic-covariant-impl core::Object y) → void {}
method h() → void {
super.{self::B::[]=}(self::f<dynamic>(), self::f<dynamic>());
}
diff --git a/pkg/front_end/testcases/inference/super_index_set_substitution.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/super_index_set_substitution.dart.legacy.transformed.expect
index b1c6c5f..8793d9b 100644
--- a/pkg/front_end/testcases/inference/super_index_set_substitution.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/super_index_set_substitution.dart.legacy.transformed.expect
@@ -15,7 +15,7 @@
synthetic constructor •() → self::C<self::C::U>
: super self::B::•()
;
- operator []=(core::Object x, core::Object y) → void {}
+ operator []=(generic-covariant-impl core::Object x, generic-covariant-impl core::Object y) → void {}
method h() → void {
super.{self::B::[]=}(self::f<dynamic>(), self::f<dynamic>());
}
diff --git a/pkg/front_end/testcases/inference/super_index_set_substitution.dart.outline.expect b/pkg/front_end/testcases/inference/super_index_set_substitution.dart.outline.expect
index 80fd653..adfd796 100644
--- a/pkg/front_end/testcases/inference/super_index_set_substitution.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/super_index_set_substitution.dart.outline.expect
@@ -14,7 +14,7 @@
class C<U extends core::Object = dynamic> extends self::B<asy::Future<self::C::U>> {
synthetic constructor •() → self::C<self::C::U>
;
- operator []=(core::Object x, core::Object y) → void
+ operator []=(generic-covariant-impl core::Object x, generic-covariant-impl core::Object y) → void
;
method h() → void
;
diff --git a/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.legacy.expect b/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.legacy.expect
index 20df3bc..219fa54 100644
--- a/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.legacy.expect
@@ -26,7 +26,7 @@
synthetic constructor •() → self::C<self::C::U>
: super self::B::•()
;
- method g(core::Object x) → self::E<asy::Future<self::C::U>>
+ method g(generic-covariant-impl core::Object x) → self::E<asy::Future<self::C::U>>
return null;
method h() → void {
dynamic x = super.{self::B::g}(self::f<dynamic>());
diff --git a/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.legacy.transformed.expect
index 20df3bc..219fa54 100644
--- a/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.legacy.transformed.expect
@@ -26,7 +26,7 @@
synthetic constructor •() → self::C<self::C::U>
: super self::B::•()
;
- method g(core::Object x) → self::E<asy::Future<self::C::U>>
+ method g(generic-covariant-impl core::Object x) → self::E<asy::Future<self::C::U>>
return null;
method h() → void {
dynamic x = super.{self::B::g}(self::f<dynamic>());
diff --git a/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.outline.expect b/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.outline.expect
index f2b99a5..07019f3 100644
--- a/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/super_method_invocation_substitution.dart.outline.expect
@@ -22,7 +22,7 @@
class C<U extends core::Object = dynamic> extends self::B<asy::Future<self::C::U>> {
synthetic constructor •() → self::C<self::C::U>
;
- method g(core::Object x) → self::E<asy::Future<self::C::U>>
+ method g(generic-covariant-impl core::Object x) → self::E<asy::Future<self::C::U>>
;
method h() → void
;
diff --git a/pkg/front_end/testcases/inference/super_property_get_substitution.dart.legacy.expect b/pkg/front_end/testcases/inference/super_property_get_substitution.dart.legacy.expect
index fd035f1..87b866d 100644
--- a/pkg/front_end/testcases/inference/super_property_get_substitution.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/super_property_get_substitution.dart.legacy.expect
@@ -27,7 +27,7 @@
;
get x() → self::E<asy::Future<self::C::U>>
return null;
- set x(core::Object x) → void {}
+ set x(generic-covariant-impl core::Object x) → void {}
method g() → void {
dynamic y = super.{self::B::x};
}
diff --git a/pkg/front_end/testcases/inference/super_property_get_substitution.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/super_property_get_substitution.dart.legacy.transformed.expect
index fd035f1..87b866d 100644
--- a/pkg/front_end/testcases/inference/super_property_get_substitution.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/super_property_get_substitution.dart.legacy.transformed.expect
@@ -27,7 +27,7 @@
;
get x() → self::E<asy::Future<self::C::U>>
return null;
- set x(core::Object x) → void {}
+ set x(generic-covariant-impl core::Object x) → void {}
method g() → void {
dynamic y = super.{self::B::x};
}
diff --git a/pkg/front_end/testcases/inference/super_property_get_substitution.dart.outline.expect b/pkg/front_end/testcases/inference/super_property_get_substitution.dart.outline.expect
index caa88dc..941b8de 100644
--- a/pkg/front_end/testcases/inference/super_property_get_substitution.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/super_property_get_substitution.dart.outline.expect
@@ -23,7 +23,7 @@
;
get x() → self::E<asy::Future<self::C::U>>
;
- set x(core::Object x) → void
+ set x(generic-covariant-impl core::Object x) → void
;
method g() → void
;
diff --git a/pkg/front_end/testcases/inference/super_property_set_substitution.dart.legacy.expect b/pkg/front_end/testcases/inference/super_property_set_substitution.dart.legacy.expect
index ae129dc..fec3618 100644
--- a/pkg/front_end/testcases/inference/super_property_set_substitution.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference/super_property_set_substitution.dart.legacy.expect
@@ -27,7 +27,7 @@
;
get x() → self::E<asy::Future<self::C::U>>
return null;
- set x(core::Object x) → void {}
+ set x(generic-covariant-impl core::Object x) → void {}
method g() → void {
super.{self::B::x} = self::f<dynamic>();
}
diff --git a/pkg/front_end/testcases/inference/super_property_set_substitution.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/super_property_set_substitution.dart.legacy.transformed.expect
index ae129dc..fec3618 100644
--- a/pkg/front_end/testcases/inference/super_property_set_substitution.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/super_property_set_substitution.dart.legacy.transformed.expect
@@ -27,7 +27,7 @@
;
get x() → self::E<asy::Future<self::C::U>>
return null;
- set x(core::Object x) → void {}
+ set x(generic-covariant-impl core::Object x) → void {}
method g() → void {
super.{self::B::x} = self::f<dynamic>();
}
diff --git a/pkg/front_end/testcases/inference/super_property_set_substitution.dart.outline.expect b/pkg/front_end/testcases/inference/super_property_set_substitution.dart.outline.expect
index 1fa178c..cf71077 100644
--- a/pkg/front_end/testcases/inference/super_property_set_substitution.dart.outline.expect
+++ b/pkg/front_end/testcases/inference/super_property_set_substitution.dart.outline.expect
@@ -23,7 +23,7 @@
;
get x() → self::E<asy::Future<self::C::U>>
;
- set x(core::Object x) → void
+ set x(generic-covariant-impl core::Object x) → void
;
method g() → void
;
diff --git a/pkg/front_end/testcases/inference/try_catch_promotion.dart.hierarchy.expect b/pkg/front_end/testcases/inference/try_catch_promotion.dart.hierarchy.expect
index 148400f..3a8a7d9 100644
--- a/pkg/front_end/testcases/inference/try_catch_promotion.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/inference/try_catch_promotion.dart.hierarchy.expect
@@ -58,7 +58,7 @@
Object
interfaces:
classMembers:
- Object.toString
+ StackTrace.Object.toString%StackTrace.toString
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
@@ -77,7 +77,7 @@
-> StackTrace
interfaces:
classMembers:
- Object.toString
+ StackTrace.Object.toString%StackTrace.toString
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
diff --git a/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart b/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart
index 5d9af14..cf441f7 100644
--- a/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart
+++ b/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart
@@ -15,8 +15,8 @@
// There's a circularity between b and c because a.f is generic, so the type of
// c is required to infer b, and vice versa.
-var b = /*@returnType=invalid-type*/ () =>
- a. /*@typeArgs=invalid-type*/ /*@target=A::f*/ f(c);
+var b = /*@returnType=() -> invalid-type*/ () =>
+ a. /*@typeArgs=() -> invalid-type*/ /*@target=A::f*/ f(c);
var c = /*@returnType=invalid-type*/ () =>
a. /*@typeArgs=invalid-type*/ /*@target=A::f*/ f(b);
diff --git a/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart.strong.expect b/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart.strong.expect
index 1681eb9..2e9f7aa 100644
--- a/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart.strong.expect
+++ b/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart.strong.expect
@@ -2,14 +2,9 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart:20:5: Error: Can't infer the type of 'c': circularity found during type inference.
-// Specify the type explicitly.
-// var c = /*@returnType=invalid-type*/ () =>
-// ^
-//
// pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart:18:5: Error: Can't infer the type of 'b': circularity found during type inference.
// Specify the type explicitly.
-// var b = /*@returnType=invalid-type*/ () =>
+// var b = /*@returnType=() -> invalid-type*/ () =>
// ^
//
import self as self;
@@ -25,8 +20,8 @@
return 0;
}
static field self::A a = new self::A::•();
-static field invalid-type b = (() → invalid-type => self::a.{self::A::f}<invalid-type>(self::c)) as{TypeError} invalid-type;
-static field invalid-type c = (() → invalid-type => self::a.{self::A::f}<invalid-type>(self::b)) as{TypeError} invalid-type;
+static field invalid-type b = (() → () → invalid-type => self::a.{self::A::f}<() → invalid-type>(self::c)) as{TypeError} invalid-type;
+static field () → invalid-type c = () → invalid-type => self::a.{self::A::f}<invalid-type>(self::b);
static field () → () → core::int d = () → () → core::int => self::a.{self::A::f}<() → core::int>(self::e);
static field () → core::int e = () → core::int => self::a.{self::A::g}(self::d);
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart.strong.transformed.expect b/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart.strong.transformed.expect
index 1681eb9..2e9f7aa 100644
--- a/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart.strong.transformed.expect
@@ -2,14 +2,9 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart:20:5: Error: Can't infer the type of 'c': circularity found during type inference.
-// Specify the type explicitly.
-// var c = /*@returnType=invalid-type*/ () =>
-// ^
-//
// pkg/front_end/testcases/inference_new/dependency_only_if_generic_method.dart:18:5: Error: Can't infer the type of 'b': circularity found during type inference.
// Specify the type explicitly.
-// var b = /*@returnType=invalid-type*/ () =>
+// var b = /*@returnType=() -> invalid-type*/ () =>
// ^
//
import self as self;
@@ -25,8 +20,8 @@
return 0;
}
static field self::A a = new self::A::•();
-static field invalid-type b = (() → invalid-type => self::a.{self::A::f}<invalid-type>(self::c)) as{TypeError} invalid-type;
-static field invalid-type c = (() → invalid-type => self::a.{self::A::f}<invalid-type>(self::b)) as{TypeError} invalid-type;
+static field invalid-type b = (() → () → invalid-type => self::a.{self::A::f}<() → invalid-type>(self::c)) as{TypeError} invalid-type;
+static field () → invalid-type c = () → invalid-type => self::a.{self::A::f}<invalid-type>(self::b);
static field () → () → core::int d = () → () → core::int => self::a.{self::A::f}<() → core::int>(self::e);
static field () → core::int e = () → core::int => self::a.{self::A::g}(self::d);
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/dependency_only_if_overloaded.dart.strong.expect b/pkg/front_end/testcases/inference_new/dependency_only_if_overloaded.dart.strong.expect
index f2657ee..88b2f85 100644
--- a/pkg/front_end/testcases/inference_new/dependency_only_if_overloaded.dart.strong.expect
+++ b/pkg/front_end/testcases/inference_new/dependency_only_if_overloaded.dart.strong.expect
@@ -2,11 +2,6 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference_new/dependency_only_if_overloaded.dart:16:5: Error: Can't infer the type of 'b': circularity found during type inference.
-// Specify the type explicitly.
-// var b = a();
-// ^
-//
// pkg/front_end/testcases/inference_new/dependency_only_if_overloaded.dart:15:5: Error: Can't infer the type of 'a': circularity found during type inference.
// Specify the type explicitly.
// var a = /*@returnType=num*/ () => intValue /*@target=num::+*/ + b;
@@ -19,7 +14,7 @@
static field core::num numValue = 0;
static field core::double doubleValue = 0.0;
static field invalid-type a = (() → core::num => self::intValue.{core::num::+}(self::b as{TypeError} core::num)) as{TypeError} invalid-type;
-static field invalid-type b = self::a.call() as{TypeError} invalid-type;
+static field dynamic b = self::a.call();
static field () → core::num c = () → core::num => self::numValue.{core::num::+}(self::d);
static field core::num d = self::c.call();
static field () → core::double e = () → core::double => self::doubleValue.{core::double::+}(self::f);
diff --git a/pkg/front_end/testcases/inference_new/field_inference_circularity.dart.strong.expect b/pkg/front_end/testcases/inference_new/field_inference_circularity.dart.strong.expect
index e436c4f..4f2a4c9 100644
--- a/pkg/front_end/testcases/inference_new/field_inference_circularity.dart.strong.expect
+++ b/pkg/front_end/testcases/inference_new/field_inference_circularity.dart.strong.expect
@@ -7,11 +7,6 @@
// var x = /*@returnType=invalid-type*/ () => new B(). /*@target=B::x*/ x;
// ^
//
-// pkg/front_end/testcases/inference_new/field_inference_circularity.dart:17:7: Error: Can't infer the type of 'x': circularity found during type inference.
-// Specify the type explicitly.
-// var x;
-// ^
-//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/inference_new/field_inference_circularity.dart.strong.transformed.expect b/pkg/front_end/testcases/inference_new/field_inference_circularity.dart.strong.transformed.expect
index e436c4f..4f2a4c9 100644
--- a/pkg/front_end/testcases/inference_new/field_inference_circularity.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/field_inference_circularity.dart.strong.transformed.expect
@@ -7,11 +7,6 @@
// var x = /*@returnType=invalid-type*/ () => new B(). /*@target=B::x*/ x;
// ^
//
-// pkg/front_end/testcases/inference_new/field_inference_circularity.dart:17:7: Error: Can't infer the type of 'x': circularity found during type inference.
-// Specify the type explicitly.
-// var x;
-// ^
-//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.hierarchy.expect b/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.hierarchy.expect
index 7848afa..cf2893f 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.hierarchy.expect
@@ -56,3 +56,460 @@
Object.==
classSetters:
B.x
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+double:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ double.~/
+ double.minPositive
+ num.<=
+ num._equalToInteger
+ double.maxFinite
+ num.isInfinite
+ num.<
+ double._tryParseDouble
+ double.Object.toString%double.toString
+ double.+
+ double.negativeInfinity
+ num.clamp
+ num.toDouble
+ double._nativeParse
+ double.ceil
+ double.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ double./
+ double.abs
+ double.nan
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ double.remainder
+ double.infinity
+ num.isFinite
+ num.toInt
+ double.%
+ double.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ double.floorToDouble
+ Object._identityHashCode
+ num.>
+ double.roundToDouble
+ double.round
+ double.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ double.truncate
+ double.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ double.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ double.truncateToDouble
+ double.parse
+ double.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ double._parse
+ double.*
+ classSetters:
+ interfaceMembers:
+ double.~/
+ double.minPositive
+ num.<=
+ num._equalToInteger
+ double.maxFinite
+ num.isInfinite
+ num.<
+ double._tryParseDouble
+ double.Object.toString%double.toString
+ double.+
+ double.negativeInfinity
+ num.clamp
+ num.toDouble
+ double._nativeParse
+ double.ceil
+ double.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ double./
+ double.abs
+ double.nan
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ double.remainder
+ double.infinity
+ num.isFinite
+ num.toInt
+ double.%
+ double.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ double.floorToDouble
+ Object._identityHashCode
+ num.>
+ double.roundToDouble
+ double.round
+ double.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ double.truncate
+ double.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ double.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ double.truncateToDouble
+ double.parse
+ double.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ double._parse
+ double.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.legacy.expect b/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.legacy.expect
index 30f357c..86fb4dd 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.legacy.expect
@@ -1,4 +1,12 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart:16:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -10,7 +18,7 @@
abstract set x(core::double value) → void;
}
class B extends self::A {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::B
: super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.legacy.transformed.expect
index 30f357c..86fb4dd 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.legacy.transformed.expect
@@ -1,4 +1,12 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart:16:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -10,7 +18,7 @@
abstract set x(core::double value) → void;
}
class B extends self::A {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::B
: super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.outline.expect b/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.outline.expect
index 5006f0f..faa675a 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.outline.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.outline.expect
@@ -1,4 +1,12 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart:16:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -9,7 +17,7 @@
abstract set x(core::double value) → void;
}
class B extends self::A {
- field dynamic x;
+ field invalid-type x;
synthetic constructor •() → self::B
;
}
diff --git a/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.strong.expect b/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.strong.expect
index 9a78098..86fb4dd 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.strong.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart.strong.expect
@@ -2,13 +2,10 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart:16:7: Error: The return type of the method 'B.x' is 'int', which does not match the return type, 'double', of the overridden method, 'A.x'.
-// Change to a subtype of 'double'.
+// pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart:16:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
// var x;
// ^
-// pkg/front_end/testcases/inference_new/infer_field_getter_setter_mismatch.dart:10:12: Context: This is the overridden method ('x').
-// void set x(double value);
-// ^
//
import self as self;
import "dart:core" as core;
@@ -21,7 +18,7 @@
abstract set x(core::double value) → void;
}
class B extends self::A {
- field core::int x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::B
: super self::A::•()
;
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart
new file mode 100644
index 0000000..d6f3096
--- /dev/null
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart
@@ -0,0 +1,20 @@
+// Copyright (c) 2019, 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.
+
+abstract class A {
+ A get x;
+ void set x(B value);
+
+ B get y;
+ void set y(A value);
+}
+
+abstract class B extends A {}
+
+class C extends B {
+ var x;
+ var y;
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.hierarchy.expect b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.hierarchy.expect
new file mode 100644
index 0000000..b7417eb
--- /dev/null
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.hierarchy.expect
@@ -0,0 +1,85 @@
+Object:
+ superclasses:
+ interfaces:
+ classMembers:
+ Object._haveSameRuntimeType
+ Object.toString
+ Object.runtimeType
+ Object._toString
+ Object._simpleInstanceOf
+ Object._hashCodeRnd
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._objectHashCode
+ Object._identityHashCode
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ classSetters:
+
+A:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ A.y
+ Object.toString
+ A.x
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ classSetters:
+ A.y
+ A.x
+
+B:
+ superclasses:
+ Object
+ -> A
+ interfaces:
+ classMembers:
+ A.y
+ Object.toString
+ A.x
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ classSetters:
+ A.y
+ A.x
+
+C:
+ superclasses:
+ Object
+ -> A
+ -> B
+ interfaces:
+ classMembers:
+ C.y
+ Object.toString
+ C.x
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ classSetters:
+ C.y
+ C.x
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.legacy.expect b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.legacy.expect
new file mode 100644
index 0000000..0517fd9
--- /dev/null
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.legacy.expect
@@ -0,0 +1,34 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart:17:7: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var y;
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+abstract class A extends core::Object {
+ synthetic constructor •() → self::A
+ : super core::Object::•()
+ ;
+ abstract get x() → self::A;
+ abstract set x(self::B value) → void;
+ abstract get y() → self::B;
+ abstract set y(self::A value) → void;
+}
+abstract class B extends self::A {
+ synthetic constructor •() → self::B
+ : super self::A::•()
+ ;
+}
+class C extends self::B {
+ field self::A x = null;
+ field invalid-type y = null;
+ synthetic constructor •() → self::C
+ : super self::B::•()
+ ;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.legacy.transformed.expect
new file mode 100644
index 0000000..0517fd9
--- /dev/null
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.legacy.transformed.expect
@@ -0,0 +1,34 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart:17:7: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var y;
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+abstract class A extends core::Object {
+ synthetic constructor •() → self::A
+ : super core::Object::•()
+ ;
+ abstract get x() → self::A;
+ abstract set x(self::B value) → void;
+ abstract get y() → self::B;
+ abstract set y(self::A value) → void;
+}
+abstract class B extends self::A {
+ synthetic constructor •() → self::B
+ : super self::A::•()
+ ;
+}
+class C extends self::B {
+ field self::A x = null;
+ field invalid-type y = null;
+ synthetic constructor •() → self::C
+ : super self::B::•()
+ ;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.outline.expect b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.outline.expect
new file mode 100644
index 0000000..b6f7118
--- /dev/null
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.outline.expect
@@ -0,0 +1,32 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart:17:7: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var y;
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+abstract class A extends core::Object {
+ synthetic constructor •() → self::A
+ ;
+ abstract get x() → self::A;
+ abstract set x(self::B value) → void;
+ abstract get y() → self::B;
+ abstract set y(self::A value) → void;
+}
+abstract class B extends self::A {
+ synthetic constructor •() → self::B
+ ;
+}
+class C extends self::B {
+ field self::A x;
+ field invalid-type y;
+ synthetic constructor •() → self::C
+ ;
+}
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.strong.expect b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.strong.expect
new file mode 100644
index 0000000..0517fd9
--- /dev/null
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart.strong.expect
@@ -0,0 +1,34 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference_new/infer_field_override_accessors.dart:17:7: Error: Can't infer a type for 'y' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var y;
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+abstract class A extends core::Object {
+ synthetic constructor •() → self::A
+ : super core::Object::•()
+ ;
+ abstract get x() → self::A;
+ abstract set x(self::B value) → void;
+ abstract get y() → self::B;
+ abstract set y(self::A value) → void;
+}
+abstract class B extends self::A {
+ synthetic constructor •() → self::B
+ : super self::A::•()
+ ;
+}
+class C extends self::B {
+ field self::A x = null;
+ field invalid-type y = null;
+ synthetic constructor •() → self::C
+ : super self::B::•()
+ ;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.hierarchy.expect b/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.hierarchy.expect
index 167e1f9..b0e92da 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.hierarchy.expect
@@ -76,3 +76,327 @@
Object.==
classSetters:
C.x
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.legacy.expect b/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.legacy.expect
index d397440..d21c794 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.legacy.expect
@@ -1,4 +1,12 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart:19:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -15,7 +23,7 @@
abstract get x() → core::int;
}
class C extends self::B {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::C
: super self::B::•()
;
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.legacy.transformed.expect
index d397440..d21c794 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.legacy.transformed.expect
@@ -1,4 +1,12 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart:19:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -15,7 +23,7 @@
abstract get x() → core::int;
}
class C extends self::B {
- field dynamic x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::C
: super self::B::•()
;
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.outline.expect b/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.outline.expect
index c425d73..42cca77 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.outline.expect
@@ -1,4 +1,12 @@
library test;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart:19:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
+// var x;
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -13,7 +21,7 @@
abstract get x() → core::int;
}
class C extends self::B {
- field dynamic x;
+ field invalid-type x;
synthetic constructor •() → self::C
;
}
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.strong.expect b/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.strong.expect
index 83026ec..d21c794 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.strong.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart.strong.expect
@@ -2,13 +2,10 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart:19:7: Error: The return type of the method 'C.x' is 'int', which does not match the return type, 'num', of the overridden method, 'A.x'.
-// Change to a subtype of 'num'.
+// pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart:19:7: Error: Can't infer a type for 'x' as some of the inherited members have different types.
+// Try adding an explicit type.
// var x;
// ^
-// pkg/front_end/testcases/inference_new/infer_field_override_getter_overrides_setter.dart:9:12: Context: This is the overridden method ('x').
-// void set x(num value);
-// ^
//
import self as self;
import "dart:core" as core;
@@ -26,7 +23,7 @@
abstract get x() → core::int;
}
class C extends self::B {
- field core::int x = null;
+ field invalid-type x = null;
synthetic constructor •() → self::C
: super self::B::•()
;
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.hierarchy.expect b/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.hierarchy.expect
index 3dbfb21..6c951d9 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.hierarchy.expect
@@ -76,3 +76,327 @@
Object.==
classSetters:
C.x
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.legacy.expect b/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.legacy.expect
index 24c6ed9..eec7015 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.legacy.expect
@@ -15,7 +15,7 @@
abstract set x(core::int value) → void;
}
class C extends self::B {
- field dynamic x = null;
+ field core::num x = null;
synthetic constructor •() → self::C
: super self::B::•()
;
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.legacy.transformed.expect
index 24c6ed9..eec7015 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.legacy.transformed.expect
@@ -15,7 +15,7 @@
abstract set x(core::int value) → void;
}
class C extends self::B {
- field dynamic x = null;
+ field core::num x = null;
synthetic constructor •() → self::C
: super self::B::•()
;
diff --git a/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.outline.expect b/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.outline.expect
index 2d2fda0..ef2b978 100644
--- a/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.outline.expect
+++ b/pkg/front_end/testcases/inference_new/infer_field_override_setter_overrides_getter.dart.outline.expect
@@ -13,7 +13,7 @@
abstract set x(core::int value) → void;
}
class C extends self::B {
- field dynamic x;
+ field core::num x;
synthetic constructor •() → self::C
;
}
diff --git a/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart b/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart
index 9ffd8ea..f24c3f1 100644
--- a/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart
+++ b/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart
@@ -8,12 +8,12 @@
// In the code below, there is a circularity between A.b and x.
class A {
- var b = /*@returnType=invalid-type*/ () => x;
- var c = /*@returnType=invalid-type*/ () => x;
+ var b = /*@returnType=() -> invalid-type*/ () => x;
+ var c = /*@returnType=() -> invalid-type*/ () => x;
}
var a = new A();
var x = /*@returnType=invalid-type*/ () => a. /*@target=A::b*/ b;
-var y = /*@returnType=() -> invalid-type*/ () => a. /*@target=A::c*/ c;
+var y = /*@returnType=() -> () -> invalid-type*/ () => a. /*@target=A::c*/ c;
main() {}
diff --git a/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart.strong.expect b/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart.strong.expect
index 46baf2b..73a2dd9 100644
--- a/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart.strong.expect
+++ b/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart.strong.expect
@@ -4,25 +4,20 @@
//
// pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart:11:7: Error: Can't infer the type of 'b': circularity found during type inference.
// Specify the type explicitly.
-// var b = /*@returnType=invalid-type*/ () => x;
+// var b = /*@returnType=() -> invalid-type*/ () => x;
// ^
//
-// pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart:16:5: Error: Can't infer the type of 'x': circularity found during type inference.
-// Specify the type explicitly.
-// var x = /*@returnType=invalid-type*/ () => a. /*@target=A::b*/ b;
-// ^
-//
import self as self;
import "dart:core" as core;
class A extends core::Object {
- field invalid-type b = (() → invalid-type => self::x) as{TypeError} invalid-type;
- field () → invalid-type c = () → invalid-type => self::x;
+ field invalid-type b = (() → () → invalid-type => self::x) as{TypeError} invalid-type;
+ field () → () → invalid-type c = () → () → invalid-type => self::x;
synthetic constructor •() → self::A
: super core::Object::•()
;
}
static field self::A a = new self::A::•();
-static field invalid-type x = (() → invalid-type => self::a.{self::A::b}) as{TypeError} invalid-type;
-static field () → () → invalid-type y = () → () → invalid-type => self::a.{self::A::c};
+static field () → invalid-type x = () → invalid-type => self::a.{self::A::b};
+static field () → () → () → invalid-type y = () → () → () → invalid-type => self::a.{self::A::c};
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart.strong.transformed.expect b/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart.strong.transformed.expect
index 46baf2b..73a2dd9 100644
--- a/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart.strong.transformed.expect
@@ -4,25 +4,20 @@
//
// pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart:11:7: Error: Can't infer the type of 'b': circularity found during type inference.
// Specify the type explicitly.
-// var b = /*@returnType=invalid-type*/ () => x;
+// var b = /*@returnType=() -> invalid-type*/ () => x;
// ^
//
-// pkg/front_end/testcases/inference_new/infer_instance_field_ref_circular.dart:16:5: Error: Can't infer the type of 'x': circularity found during type inference.
-// Specify the type explicitly.
-// var x = /*@returnType=invalid-type*/ () => a. /*@target=A::b*/ b;
-// ^
-//
import self as self;
import "dart:core" as core;
class A extends core::Object {
- field invalid-type b = (() → invalid-type => self::x) as{TypeError} invalid-type;
- field () → invalid-type c = () → invalid-type => self::x;
+ field invalid-type b = (() → () → invalid-type => self::x) as{TypeError} invalid-type;
+ field () → () → invalid-type c = () → () → invalid-type => self::x;
synthetic constructor •() → self::A
: super core::Object::•()
;
}
static field self::A a = new self::A::•();
-static field invalid-type x = (() → invalid-type => self::a.{self::A::b}) as{TypeError} invalid-type;
-static field () → () → invalid-type y = () → () → invalid-type => self::a.{self::A::c};
+static field () → invalid-type x = () → invalid-type => self::a.{self::A::b};
+static field () → () → () → invalid-type y = () → () → () → invalid-type => self::a.{self::A::c};
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.legacy.expect b/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.legacy.expect
index f8f9e8f..3493bd8 100644
--- a/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.legacy.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
- method f() → dynamic {}
+ method f() → void {}
}
static field dynamic x = new self::C::•().f();
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.legacy.transformed.expect
index f8f9e8f..3493bd8 100644
--- a/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.legacy.transformed.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
- method f() → dynamic {}
+ method f() → void {}
}
static field dynamic x = new self::C::•().f();
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.outline.expect b/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.outline.expect
index ac467ff..fbaac00 100644
--- a/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.outline.expect
+++ b/pkg/front_end/testcases/inference_new/infer_use_of_void.dart.outline.expect
@@ -11,7 +11,7 @@
class C extends self::B {
synthetic constructor •() → self::C
;
- method f() → dynamic
+ method f() → void
;
}
static field dynamic x;
diff --git a/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.hierarchy.expect b/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.hierarchy.expect
index f92d773..5a9daa5 100644
--- a/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.hierarchy.expect
@@ -72,7 +72,7 @@
Object.==
classSetters:
interfaceMembers:
- I1.f
+ C.I1.f%I2.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -136,7 +136,7 @@
Object.==
classSetters:
interfaceMembers:
- I2.f
+ E.I2.f%I1.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -181,3 +181,327 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.legacy.expect b/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.legacy.expect
index 525f04b..e52d854 100644
--- a/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.legacy.expect
@@ -18,6 +18,7 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
+ abstract forwarding-stub method f(core::Object o) → void;
}
class D extends self::C {
synthetic constructor •() → self::D
diff --git a/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.legacy.transformed.expect
index 525f04b..e52d854 100644
--- a/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.legacy.transformed.expect
@@ -18,6 +18,7 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
+ abstract forwarding-stub method f(core::Object o) → void;
}
class D extends self::C {
synthetic constructor •() → self::D
diff --git a/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.outline.expect b/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.outline.expect
index cbba19d..68748a3 100644
--- a/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.outline.expect
+++ b/pkg/front_end/testcases/inference_new/multiple_interface_inheritance.dart.outline.expect
@@ -15,6 +15,7 @@
abstract class C extends core::Object implements self::I1, self::I2 {
synthetic constructor •() → self::C
;
+ abstract forwarding-stub method f(core::Object o) → void;
}
class D extends self::C {
synthetic constructor •() → self::D
diff --git a/pkg/front_end/testcases/inference_new/strongly_connected_component.dart b/pkg/front_end/testcases/inference_new/strongly_connected_component.dart
index 788e92f..d378992 100644
--- a/pkg/front_end/testcases/inference_new/strongly_connected_component.dart
+++ b/pkg/front_end/testcases/inference_new/strongly_connected_component.dart
@@ -14,7 +14,7 @@
// circularity, and for error recovery their type is set to `dynamic`.
// Thereafter, z infers without problems.
-var x = /*@returnType=invalid-type*/ () => f() ? y : z;
+var x = /*@returnType=() -> invalid-type*/ () => f() ? y : z;
var y = /*@returnType=invalid-type*/ () => x;
var z = /*@returnType=invalid-type*/ () => x;
diff --git a/pkg/front_end/testcases/inference_new/strongly_connected_component.dart.strong.expect b/pkg/front_end/testcases/inference_new/strongly_connected_component.dart.strong.expect
index 88bfdb0..b228e01 100644
--- a/pkg/front_end/testcases/inference_new/strongly_connected_component.dart.strong.expect
+++ b/pkg/front_end/testcases/inference_new/strongly_connected_component.dart.strong.expect
@@ -2,22 +2,17 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference_new/strongly_connected_component.dart:18:5: Error: Can't infer the type of 'y': circularity found during type inference.
-// Specify the type explicitly.
-// var y = /*@returnType=invalid-type*/ () => x;
-// ^
-//
// pkg/front_end/testcases/inference_new/strongly_connected_component.dart:17:5: Error: Can't infer the type of 'x': circularity found during type inference.
// Specify the type explicitly.
-// var x = /*@returnType=invalid-type*/ () => f() ? y : z;
+// var x = /*@returnType=() -> invalid-type*/ () => f() ? y : z;
// ^
//
import self as self;
import "dart:core" as core;
-static field invalid-type x = (() → invalid-type => self::f() ?{invalid-type} self::y : self::z) as{TypeError} invalid-type;
-static field invalid-type y = (() → invalid-type => self::x) as{TypeError} invalid-type;
-static field () → dynamic z = () → invalid-type => self::x;
+static field invalid-type x = (() → () → invalid-type => self::f() ?{() → invalid-type} self::y : self::z) as{TypeError} invalid-type;
+static field () → invalid-type y = () → invalid-type => self::x;
+static field () → invalid-type z = () → invalid-type => self::x;
static method f() → core::bool
return null;
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/strongly_connected_component.dart.strong.transformed.expect b/pkg/front_end/testcases/inference_new/strongly_connected_component.dart.strong.transformed.expect
index 9a54331..b228e01 100644
--- a/pkg/front_end/testcases/inference_new/strongly_connected_component.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/strongly_connected_component.dart.strong.transformed.expect
@@ -2,22 +2,17 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference_new/strongly_connected_component.dart:19:67: Error: Can't infer the type of 'y': circularity found during type inference.
+// pkg/front_end/testcases/inference_new/strongly_connected_component.dart:17:5: Error: Can't infer the type of 'x': circularity found during type inference.
// Specify the type explicitly.
-// var /*@error=CantInferTypeDueToCircularity*/ y = /*@returnType=dynamic*/ () =>
-// ^
-//
-// pkg/front_end/testcases/inference_new/strongly_connected_component.dart:17:67: Error: Can't infer the type of 'x': circularity found during type inference.
-// Specify the type explicitly.
-// var /*@error=CantInferTypeDueToCircularity*/ x = /*@returnType=dynamic*/ () =>
-// ^
+// var x = /*@returnType=() -> invalid-type*/ () => f() ? y : z;
+// ^
//
import self as self;
import "dart:core" as core;
-static field dynamic x = () → dynamic => self::f() ?{dynamic} self::y : self::z;
-static field dynamic y = () → dynamic => self::x;
-static field () → dynamic z = () → dynamic => self::x;
+static field invalid-type x = (() → () → invalid-type => self::f() ?{() → invalid-type} self::y : self::z) as{TypeError} invalid-type;
+static field () → invalid-type y = () → invalid-type => self::x;
+static field () → invalid-type z = () → invalid-type => self::x;
static method f() → core::bool
return null;
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.legacy.expect b/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.legacy.expect
index 0f54c8d..bae8810 100644
--- a/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.legacy.expect
@@ -26,7 +26,7 @@
synthetic constructor •() → self::C<self::C::U>
: super self::B::•()
;
- operator [](core::Object x) → self::E<asy::Future<self::C::U>>
+ operator [](generic-covariant-impl core::Object x) → self::E<asy::Future<self::C::U>>
return null;
method h() → void {
dynamic x = super.{self::B::[]}(self::f<dynamic>());
diff --git a/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.legacy.transformed.expect
index 0f54c8d..bae8810 100644
--- a/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.legacy.transformed.expect
@@ -26,7 +26,7 @@
synthetic constructor •() → self::C<self::C::U>
: super self::B::•()
;
- operator [](core::Object x) → self::E<asy::Future<self::C::U>>
+ operator [](generic-covariant-impl core::Object x) → self::E<asy::Future<self::C::U>>
return null;
method h() → void {
dynamic x = super.{self::B::[]}(self::f<dynamic>());
diff --git a/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.outline.expect b/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.outline.expect
index 12ca495..482f685 100644
--- a/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.outline.expect
+++ b/pkg/front_end/testcases/inference_new/super_index_get_substitution.dart.outline.expect
@@ -22,7 +22,7 @@
class C<U extends core::Object = dynamic> extends self::B<asy::Future<self::C::U>> {
synthetic constructor •() → self::C<self::C::U>
;
- operator [](core::Object x) → self::E<asy::Future<self::C::U>>
+ operator [](generic-covariant-impl core::Object x) → self::E<asy::Future<self::C::U>>
;
method h() → void
;
diff --git a/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.hierarchy.expect b/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.hierarchy.expect
index 00d3da3..59b9ccc 100644
--- a/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.hierarchy.expect
@@ -148,7 +148,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- D.foo
+ G.D.foo%E.foo%F.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
diff --git a/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.legacy.expect b/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.legacy.expect
index cef6169..869fb78 100644
--- a/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.legacy.expect
+++ b/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.legacy.expect
@@ -39,6 +39,7 @@
synthetic constructor •() → self::G
: super core::Object::•()
;
+ abstract forwarding-stub method foo() → self::B;
}
class H extends self::G {
synthetic constructor •() → self::H
diff --git a/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.legacy.transformed.expect
index cef6169..869fb78 100644
--- a/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.legacy.transformed.expect
@@ -39,6 +39,7 @@
synthetic constructor •() → self::G
: super core::Object::•()
;
+ abstract forwarding-stub method foo() → self::B;
}
class H extends self::G {
synthetic constructor •() → self::H
diff --git a/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.outline.expect b/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.outline.expect
index 8801b74..b028b33 100644
--- a/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.outline.expect
+++ b/pkg/front_end/testcases/inference_new/top_level_field_depends_on_multiple_inheritance.dart.outline.expect
@@ -32,6 +32,7 @@
abstract class G extends core::Object implements self::D, self::E, self::F {
synthetic constructor •() → self::G
;
+ abstract forwarding-stub method foo() → self::B;
}
class H extends self::G {
synthetic constructor •() → self::H
diff --git a/pkg/front_end/testcases/mixin_application_override.dart.hierarchy.expect b/pkg/front_end/testcases/mixin_application_override.dart.hierarchy.expect
index 8351797..bec105b 100644
--- a/pkg/front_end/testcases/mixin_application_override.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/mixin_application_override.dart.hierarchy.expect
@@ -193,7 +193,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ A1.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -292,7 +292,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ A2.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -422,7 +422,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ _A1X&S&M1 with M.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -456,7 +456,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ A1X.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -555,7 +555,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ _A2X&S&M1&M2 with M.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -590,7 +590,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ A2X.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -720,7 +720,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ _B1&S&M1 with M.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -754,7 +754,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ B1.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -853,7 +853,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ _B2&S&M1&M2 with M.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -888,7 +888,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ B2.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -1052,7 +1052,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ _B1X&S&M1 with M.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -1086,7 +1086,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ _B1X&S&M1&M with MX.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -1121,7 +1121,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ B1X.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -1220,7 +1220,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ _B2X&S&M1&M2 with M.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -1255,7 +1255,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ _B2X&S&M1&M2&M with MX.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -1291,7 +1291,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- M.foo
+ B2X.M.foo%S.foo
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
diff --git a/pkg/front_end/testcases/mixin_application_override.dart.legacy.expect b/pkg/front_end/testcases/mixin_application_override.dart.legacy.expect
index b5c4a61..0900d21 100644
--- a/pkg/front_end/testcases/mixin_application_override.dart.legacy.expect
+++ b/pkg/front_end/testcases/mixin_application_override.dart.legacy.expect
@@ -122,6 +122,66 @@
// class B2X extends S with M1, M2, M, MX {}
// ^^^
//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:26:7: Context: Override was introduced in the mixin application class 'A1X'.
+// class A1X = S with M1, M, MX;
+// ^^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:27:7: Context: Override was introduced in the mixin application class 'A2X'.
+// class A2X = S with M1, M2, M, MX;
+// ^^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:31:7: Context: Both members are inherited by the non-abstract class 'B1'.
+// class B1 extends S with M1, M {}
+// ^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:33:7: Context: Both members are inherited by the non-abstract class 'B2'.
+// class B2 extends S with M1, M2, M {}
+// ^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:37:7: Context: Both members are inherited by the non-abstract class 'B1X'.
+// class B1X extends S with M1, M, MX {}
+// ^^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:39:7: Context: Both members are inherited by the non-abstract class 'B2X'.
+// class B2X extends S with M1, M2, M, MX {}
+// ^^^
+//
import self as self;
import "dart:core" as core;
@@ -166,6 +226,7 @@
synthetic constructor •() → self::A1
: super self::_A1&S&M1::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _A2&S&M1 = self::S with self::M1 {
synthetic constructor •() → self::_A2&S&M1
@@ -181,6 +242,7 @@
synthetic constructor •() → self::A2
: super self::_A2&S&M1&M2::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _A0X&S&M = self::S with self::M {
synthetic constructor •() → self::_A0X&S&M
@@ -201,11 +263,13 @@
synthetic constructor •() → self::_A1X&S&M1&M
: super self::_A1X&S&M1::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class A1X = self::_A1X&S&M1&M with self::MX {
synthetic constructor •() → self::A1X
: super self::_A1X&S&M1&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _A2X&S&M1 = self::S with self::M1 {
synthetic constructor •() → self::_A2X&S&M1
@@ -221,11 +285,13 @@
synthetic constructor •() → self::_A2X&S&M1&M2&M
: super self::_A2X&S&M1&M2::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class A2X = self::_A2X&S&M1&M2&M with self::MX {
synthetic constructor •() → self::A2X
: super self::_A2X&S&M1&M2&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B0&S&M = self::S with self::M {
synthetic constructor •() → self::_B0&S&M
@@ -246,11 +312,13 @@
synthetic constructor •() → self::_B1&S&M1&M
: super self::_B1&S&M1::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class B1 extends self::_B1&S&M1&M {
synthetic constructor •() → self::B1
: super self::_B1&S&M1&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B2&S&M1 = self::S with self::M1 {
synthetic constructor •() → self::_B2&S&M1
@@ -266,11 +334,13 @@
synthetic constructor •() → self::_B2&S&M1&M2&M
: super self::_B2&S&M1&M2::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class B2 extends self::_B2&S&M1&M2&M {
synthetic constructor •() → self::B2
: super self::_B2&S&M1&M2&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B0X&S&M = self::S with self::M {
synthetic constructor •() → self::_B0X&S&M
@@ -296,16 +366,19 @@
synthetic constructor •() → self::_B1X&S&M1&M
: super self::_B1X&S&M1::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B1X&S&M1&M&MX = self::_B1X&S&M1&M with self::MX {
synthetic constructor •() → self::_B1X&S&M1&M&MX
: super self::_B1X&S&M1&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class B1X extends self::_B1X&S&M1&M&MX {
synthetic constructor •() → self::B1X
: super self::_B1X&S&M1&M&MX::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B2X&S&M1 = self::S with self::M1 {
synthetic constructor •() → self::_B2X&S&M1
@@ -321,15 +394,18 @@
synthetic constructor •() → self::_B2X&S&M1&M2&M
: super self::_B2X&S&M1&M2::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B2X&S&M1&M2&M&MX = self::_B2X&S&M1&M2&M with self::MX {
synthetic constructor •() → self::_B2X&S&M1&M2&M&MX
: super self::_B2X&S&M1&M2&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class B2X extends self::_B2X&S&M1&M2&M&MX {
synthetic constructor •() → self::B2X
: super self::_B2X&S&M1&M2&M&MX::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/mixin_application_override.dart.legacy.transformed.expect b/pkg/front_end/testcases/mixin_application_override.dart.legacy.transformed.expect
index c5a8827..49aba4d 100644
--- a/pkg/front_end/testcases/mixin_application_override.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/mixin_application_override.dart.legacy.transformed.expect
@@ -122,6 +122,66 @@
// class B2X extends S with M1, M2, M, MX {}
// ^^^
//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:26:7: Context: Override was introduced in the mixin application class 'A1X'.
+// class A1X = S with M1, M, MX;
+// ^^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:27:7: Context: Override was introduced in the mixin application class 'A2X'.
+// class A2X = S with M1, M2, M, MX;
+// ^^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:31:7: Context: Both members are inherited by the non-abstract class 'B1'.
+// class B1 extends S with M1, M {}
+// ^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:33:7: Context: Both members are inherited by the non-abstract class 'B2'.
+// class B2 extends S with M1, M2, M {}
+// ^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:37:7: Context: Both members are inherited by the non-abstract class 'B1X'.
+// class B1X extends S with M1, M, MX {}
+// ^^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:39:7: Context: Both members are inherited by the non-abstract class 'B2X'.
+// class B2X extends S with M1, M2, M, MX {}
+// ^^^
+//
import self as self;
import "dart:core" as core;
@@ -167,7 +227,7 @@
synthetic constructor •() → self::A1
: super self::_A1&S&M1::•()
;
- method foo() → dynamic {}
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _A2&S&M1 extends self::S implements self::M1 {
synthetic constructor •() → self::_A2&S&M1
@@ -183,7 +243,7 @@
synthetic constructor •() → self::A2
: super self::_A2&S&M1&M2::•()
;
- method foo() → dynamic {}
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _A0X&S&M extends self::S implements self::M {
synthetic constructor •() → self::_A0X&S&M
@@ -205,12 +265,13 @@
synthetic constructor •() → self::_A1X&S&M1&M
: super self::_A1X&S&M1::•()
;
- method foo() → dynamic {}
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class A1X extends self::_A1X&S&M1&M implements self::MX {
synthetic constructor •() → self::A1X
: super self::_A1X&S&M1&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _A2X&S&M1 extends self::S implements self::M1 {
synthetic constructor •() → self::_A2X&S&M1
@@ -226,12 +287,13 @@
synthetic constructor •() → self::_A2X&S&M1&M2&M
: super self::_A2X&S&M1&M2::•()
;
- method foo() → dynamic {}
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class A2X extends self::_A2X&S&M1&M2&M implements self::MX {
synthetic constructor •() → self::A2X
: super self::_A2X&S&M1&M2&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B0&S&M extends self::S implements self::M {
synthetic constructor •() → self::_B0&S&M
@@ -253,12 +315,13 @@
synthetic constructor •() → self::_B1&S&M1&M
: super self::_B1&S&M1::•()
;
- method foo() → dynamic {}
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class B1 extends self::_B1&S&M1&M {
synthetic constructor •() → self::B1
: super self::_B1&S&M1&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B2&S&M1 extends self::S implements self::M1 {
synthetic constructor •() → self::_B2&S&M1
@@ -274,12 +337,13 @@
synthetic constructor •() → self::_B2&S&M1&M2&M
: super self::_B2&S&M1&M2::•()
;
- method foo() → dynamic {}
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class B2 extends self::_B2&S&M1&M2&M {
synthetic constructor •() → self::B2
: super self::_B2&S&M1&M2&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B0X&S&M extends self::S implements self::M {
synthetic constructor •() → self::_B0X&S&M
@@ -306,17 +370,19 @@
synthetic constructor •() → self::_B1X&S&M1&M
: super self::_B1X&S&M1::•()
;
- method foo() → dynamic {}
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B1X&S&M1&M&MX extends self::_B1X&S&M1&M implements self::MX {
synthetic constructor •() → self::_B1X&S&M1&M&MX
: super self::_B1X&S&M1&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class B1X extends self::_B1X&S&M1&M&MX {
synthetic constructor •() → self::B1X
: super self::_B1X&S&M1&M&MX::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B2X&S&M1 extends self::S implements self::M1 {
synthetic constructor •() → self::_B2X&S&M1
@@ -332,16 +398,18 @@
synthetic constructor •() → self::_B2X&S&M1&M2&M
: super self::_B2X&S&M1&M2::•()
;
- method foo() → dynamic {}
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
abstract class _B2X&S&M1&M2&M&MX extends self::_B2X&S&M1&M2&M implements self::MX {
synthetic constructor •() → self::_B2X&S&M1&M2&M&MX
: super self::_B2X&S&M1&M2&M::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
class B2X extends self::_B2X&S&M1&M2&M&MX {
synthetic constructor •() → self::B2X
: super self::_B2X&S&M1&M2&M&MX::•()
;
+ abstract forwarding-stub method foo([dynamic x = null]) → dynamic;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/mixin_application_override.dart.outline.expect b/pkg/front_end/testcases/mixin_application_override.dart.outline.expect
index 9983cfb..90453d9 100644
--- a/pkg/front_end/testcases/mixin_application_override.dart.outline.expect
+++ b/pkg/front_end/testcases/mixin_application_override.dart.outline.expect
@@ -122,6 +122,66 @@
// class B2X extends S with M1, M2, M, MX {}
// ^^^
//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:26:7: Context: Override was introduced in the mixin application class 'A1X'.
+// class A1X = S with M1, M, MX;
+// ^^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:27:7: Context: Override was introduced in the mixin application class 'A2X'.
+// class A2X = S with M1, M2, M, MX;
+// ^^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:31:7: Context: Both members are inherited by the non-abstract class 'B1'.
+// class B1 extends S with M1, M {}
+// ^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:33:7: Context: Both members are inherited by the non-abstract class 'B2'.
+// class B2 extends S with M1, M2, M {}
+// ^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:37:7: Context: Both members are inherited by the non-abstract class 'B1X'.
+// class B1X extends S with M1, M, MX {}
+// ^^^
+//
+// pkg/front_end/testcases/mixin_application_override.dart:12:3: Warning: The method 'M.foo' has fewer positional arguments than those of overridden method 'S.foo'.
+// foo() {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:8:3: Context: This is the overridden method ('foo').
+// foo([x]) {}
+// ^
+// pkg/front_end/testcases/mixin_application_override.dart:39:7: Context: Both members are inherited by the non-abstract class 'B2X'.
+// class B2X extends S with M1, M2, M, MX {}
+// ^^^
+//
import self as self;
import "dart:core" as core;
@@ -163,6 +223,7 @@
synthetic constructor •() → self::A1
: super self::_A1&S&M1::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
abstract class _A2&S&M1 = self::S with self::M1 {
synthetic constructor •() → self::_A2&S&M1
@@ -178,6 +239,7 @@
synthetic constructor •() → self::A2
: super self::_A2&S&M1&M2::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
abstract class _A0X&S&M = self::S with self::M {
synthetic constructor •() → self::_A0X&S&M
@@ -198,11 +260,13 @@
synthetic constructor •() → self::_A1X&S&M1&M
: super self::_A1X&S&M1::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
class A1X = self::_A1X&S&M1&M with self::MX {
synthetic constructor •() → self::A1X
: super self::_A1X&S&M1&M::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
abstract class _A2X&S&M1 = self::S with self::M1 {
synthetic constructor •() → self::_A2X&S&M1
@@ -218,11 +282,13 @@
synthetic constructor •() → self::_A2X&S&M1&M2&M
: super self::_A2X&S&M1&M2::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
class A2X = self::_A2X&S&M1&M2&M with self::MX {
synthetic constructor •() → self::A2X
: super self::_A2X&S&M1&M2&M::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
abstract class _B0&S&M = self::S with self::M {
synthetic constructor •() → self::_B0&S&M
@@ -242,10 +308,12 @@
synthetic constructor •() → self::_B1&S&M1&M
: super self::_B1&S&M1::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
class B1 extends self::_B1&S&M1&M {
synthetic constructor •() → self::B1
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
abstract class _B2&S&M1 = self::S with self::M1 {
synthetic constructor •() → self::_B2&S&M1
@@ -261,10 +329,12 @@
synthetic constructor •() → self::_B2&S&M1&M2&M
: super self::_B2&S&M1&M2::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
class B2 extends self::_B2&S&M1&M2&M {
synthetic constructor •() → self::B2
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
abstract class _B0X&S&M = self::S with self::M {
synthetic constructor •() → self::_B0X&S&M
@@ -289,15 +359,18 @@
synthetic constructor •() → self::_B1X&S&M1&M
: super self::_B1X&S&M1::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
abstract class _B1X&S&M1&M&MX = self::_B1X&S&M1&M with self::MX {
synthetic constructor •() → self::_B1X&S&M1&M&MX
: super self::_B1X&S&M1&M::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
class B1X extends self::_B1X&S&M1&M&MX {
synthetic constructor •() → self::B1X
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
abstract class _B2X&S&M1 = self::S with self::M1 {
synthetic constructor •() → self::_B2X&S&M1
@@ -313,15 +386,18 @@
synthetic constructor •() → self::_B2X&S&M1&M2&M
: super self::_B2X&S&M1&M2::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
abstract class _B2X&S&M1&M2&M&MX = self::_B2X&S&M1&M2&M with self::MX {
synthetic constructor •() → self::_B2X&S&M1&M2&M&MX
: super self::_B2X&S&M1&M2&M::•()
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
class B2X extends self::_B2X&S&M1&M2&M&MX {
synthetic constructor •() → self::B2X
;
+ abstract forwarding-stub method foo([dynamic x]) → dynamic;
}
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/native_as_name.dart.legacy.expect b/pkg/front_end/testcases/native_as_name.dart.legacy.expect
index 52a151a..b2691b8 100644
--- a/pkg/front_end/testcases/native_as_name.dart.legacy.expect
+++ b/pkg/front_end/testcases/native_as_name.dart.legacy.expect
@@ -34,7 +34,7 @@
synthetic constructor •() → self::Z
: super core::Object::•()
;
- set native(core::String s) → dynamic
+ set native(core::String s) → void
return this.{self::Z::f} = s;
}
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/native_as_name.dart.legacy.transformed.expect b/pkg/front_end/testcases/native_as_name.dart.legacy.transformed.expect
index 52a151a..b2691b8 100644
--- a/pkg/front_end/testcases/native_as_name.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/native_as_name.dart.legacy.transformed.expect
@@ -34,7 +34,7 @@
synthetic constructor •() → self::Z
: super core::Object::•()
;
- set native(core::String s) → dynamic
+ set native(core::String s) → void
return this.{self::Z::f} = s;
}
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/native_as_name.dart.outline.expect b/pkg/front_end/testcases/native_as_name.dart.outline.expect
index 6c2884c..d5d6874 100644
--- a/pkg/front_end/testcases/native_as_name.dart.outline.expect
+++ b/pkg/front_end/testcases/native_as_name.dart.outline.expect
@@ -28,7 +28,7 @@
field core::String f;
synthetic constructor •() → self::Z
;
- set native(core::String s) → dynamic
+ set native(core::String s) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.legacy.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.legacy.expect
index 11c8d48..d420935 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.legacy.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.legacy.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return "bar";
no-such-method-forwarder get foo() → core::int
return this.{self::A::noSuchMethod}(new core::_InvocationMirror::_withType(#foo, 1, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} core::int;
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.legacy.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.legacy.transformed.expect
index 11c8d48..d420935 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.legacy.transformed.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return "bar";
no-such-method-forwarder get foo() → core::int
return this.{self::A::noSuchMethod}(new core::_InvocationMirror::_withType(#foo, 1, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} core::int;
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.outline.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.outline.expect
index 1756340..e7230a4 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.outline.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.outline.expect
@@ -10,7 +10,7 @@
class A extends core::Object implements self::I {
synthetic constructor •() → self::A
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
;
no-such-method-forwarder get foo() → core::int
return this.{self::A::noSuchMethod}(new core::_InvocationMirror::_withType(#foo, 1, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} core::int;
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.strong.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.strong.expect
index 2e65c41..8387d6d 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.strong.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.strong.expect
@@ -34,6 +34,6 @@
}
static method main() → dynamic {
self::A a = new self::A::•();
- self::expectTypeError(() → core::int => a.{self::A::foo});
+ self::expectTypeError(() → core::int => a.{self::I::foo});
self::expectTypeError(() → core::String => (a as dynamic).foo = "bar");
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.strong.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.strong.transformed.expect
index 2e65c41..8387d6d 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field.dart.strong.transformed.expect
@@ -34,6 +34,6 @@
}
static method main() → dynamic {
self::A a = new self::A::•();
- self::expectTypeError(() → core::int => a.{self::A::foo});
+ self::expectTypeError(() → core::int => a.{self::I::foo});
self::expectTypeError(() → core::String => (a as dynamic).foo = "bar");
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.legacy.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.legacy.expect
index 0e0e756..fa7bf1f 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.legacy.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.legacy.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic {
+ method noSuchMethod(core::Invocation i) → dynamic {
self::count = self::count.+(1);
return null;
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.legacy.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.legacy.transformed.expect
index e0f993c..dae5f70 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.legacy.transformed.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic {
+ method noSuchMethod(core::Invocation i) → dynamic {
self::count = self::count.+(1);
return null;
}
@@ -25,7 +25,7 @@
const synthetic constructor •() → self::_C&Object&B
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic {
+ method noSuchMethod(core::Invocation i) → dynamic {
self::count = self::count.+(1);
return null;
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.outline.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.outline.expect
index d92df10..11ba2e6 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.outline.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_arent_mixed_in.dart.outline.expect
@@ -10,7 +10,7 @@
class B extends core::Object implements self::A {
synthetic constructor •() → self::B
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
;
no-such-method-forwarder get foo() → core::int
return this.{self::B::noSuchMethod}(new core::_InvocationMirror::_withType(#foo, 1, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} core::int;
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.legacy.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.legacy.expect
index c7fedd2..b172437 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.legacy.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.legacy.expect
@@ -14,7 +14,7 @@
;
get foo() → core::int
return 42;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return "bar";
}
class C extends self::B {
@@ -29,7 +29,7 @@
: super core::Object::•()
;
set foo(core::int value) → void {}
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return "bar";
}
class E extends self::D {
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.legacy.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.legacy.transformed.expect
index c7fedd2..b172437 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.legacy.transformed.expect
@@ -14,7 +14,7 @@
;
get foo() → core::int
return 42;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return "bar";
}
class C extends self::B {
@@ -29,7 +29,7 @@
: super core::Object::•()
;
set foo(core::int value) → void {}
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return "bar";
}
class E extends self::D {
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.outline.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.outline.expect
index 523367d..ed38e84 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.outline.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.outline.expect
@@ -12,7 +12,7 @@
;
get foo() → core::int
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
;
}
class C extends self::B {
@@ -26,7 +26,7 @@
;
set foo(core::int value) → void
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
;
}
class E extends self::D {
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.strong.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.strong.expect
index cb4a71e..7417039 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.strong.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.strong.expect
@@ -51,5 +51,5 @@
self::C c = new self::C::•();
self::expectTypeError(() → core::String => (c as dynamic).foo = "bar");
self::E e = new self::E::•();
- self::expectTypeError(() → core::int => e.{self::E::foo});
+ self::expectTypeError(() → core::int => e.{self::A::foo});
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.strong.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.strong.transformed.expect
index cb4a71e..7417039 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_one_defined.dart.strong.transformed.expect
@@ -51,5 +51,5 @@
self::C c = new self::C::•();
self::expectTypeError(() → core::String => (c as dynamic).foo = "bar");
self::E e = new self::E::•();
- self::expectTypeError(() → core::int => e.{self::E::foo});
+ self::expectTypeError(() → core::int => e.{self::A::foo});
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.legacy.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.legacy.expect
index ed949f6..3daf444 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.legacy.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.legacy.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return <dynamic>[];
no-such-method-forwarder get foo() → core::List<core::int>
return this.{self::B::noSuchMethod}(new core::_InvocationMirror::_withType(#foo, 1, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} core::List<core::int>;
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.legacy.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.legacy.transformed.expect
index ed949f6..3daf444 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.legacy.transformed.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return <dynamic>[];
no-such-method-forwarder get foo() → core::List<core::int>
return this.{self::B::noSuchMethod}(new core::_InvocationMirror::_withType(#foo, 1, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} core::List<core::int>;
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.outline.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.outline.expect
index 9679fbf..0cdcb88 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.outline.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.outline.expect
@@ -10,7 +10,7 @@
class B extends core::Object implements self::A<core::int> {
synthetic constructor •() → self::B
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
;
no-such-method-forwarder get foo() → core::List<core::int>
return this.{self::B::noSuchMethod}(new core::_InvocationMirror::_withType(#foo, 1, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} core::List<core::int>;
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.strong.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.strong.expect
index 0b0b415..a705020 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.strong.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.strong.expect
@@ -29,6 +29,6 @@
}
static method main() → dynamic {
self::B b = new self::B::•();
- self::expectTypeError(() → core::List<core::int> => b.{self::B::foo});
+ self::expectTypeError(() → core::List<core::int> => b.{self::A::foo});
self::expectTypeError(() → core::List<dynamic> => (b as dynamic).foo = <dynamic>[]);
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.strong.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.strong.transformed.expect
index 0b0b415..a705020 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/abstract_accessors_from_field_with_substitution.dart.strong.transformed.expect
@@ -29,6 +29,6 @@
}
static method main() → dynamic {
self::B b = new self::B::•();
- self::expectTypeError(() → core::List<core::int> => b.{self::B::foo});
+ self::expectTypeError(() → core::List<core::int> => b.{self::A::foo});
self::expectTypeError(() → core::List<dynamic> => (b as dynamic).foo = <dynamic>[]);
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.legacy.expect b/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.legacy.expect
index 521bedd..b71a516 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.legacy.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.legacy.expect
@@ -18,7 +18,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
return null;
no-such-method-forwarder method foo() → dynamic
return this.{self::B::noSuchMethod}(new core::_InvocationMirror::_withType(#foo, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} dynamic;
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.legacy.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.legacy.transformed.expect
index 528ca88..7cd29a7 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.legacy.transformed.expect
@@ -18,7 +18,7 @@
synthetic constructor •() → self::B
: super core::Object::•()
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
return null;
no-such-method-forwarder method foo() → dynamic
return this.{self::B::noSuchMethod}(new core::_InvocationMirror::_withType(#foo, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} dynamic;
@@ -27,7 +27,7 @@
synthetic constructor •() → self::_C&A&B
: super self::A::•()
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
return null;
}
class C extends self::_C&A&B {
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.outline.expect b/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.outline.expect
index 8007c45..f04505e 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.outline.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/concrete_method_over_forwarder_in_mixin_application.dart.outline.expect
@@ -16,7 +16,7 @@
class B extends core::Object implements self::I {
synthetic constructor •() → self::B
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
;
no-such-method-forwarder method foo() → dynamic
return this.{self::B::noSuchMethod}(new core::_InvocationMirror::_withType(#foo, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} dynamic;
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/default_argument_values.dart.strong.expect b/pkg/front_end/testcases/no_such_method_forwarders/default_argument_values.dart.strong.expect
index 5f6f35b..075405d 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/default_argument_values.dart.strong.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/default_argument_values.dart.strong.expect
@@ -31,10 +31,10 @@
static method main() → dynamic {
self::B b = new self::B::•();
dynamic value;
- if(!(value = b.{self::B::foo}()).{core::String::==}("baz")) {
+ if(!(value = b.{self::A::foo}()).{core::String::==}("baz")) {
throw "Unexpected value: '${value}'; expected 'baz'.";
}
- if(!(value = b.{self::B::hest}()).{core::num::==}(42)) {
+ if(!(value = b.{self::A::hest}()).{core::num::==}(42)) {
throw "Unexpected value: '${value}'; expected '42'.";
}
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/default_argument_values.dart.strong.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/default_argument_values.dart.strong.transformed.expect
index 5f6f35b..075405d 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/default_argument_values.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/default_argument_values.dart.strong.transformed.expect
@@ -31,10 +31,10 @@
static method main() → dynamic {
self::B b = new self::B::•();
dynamic value;
- if(!(value = b.{self::B::foo}()).{core::String::==}("baz")) {
+ if(!(value = b.{self::A::foo}()).{core::String::==}("baz")) {
throw "Unexpected value: '${value}'; expected 'baz'.";
}
- if(!(value = b.{self::B::hest}()).{core::num::==}(42)) {
+ if(!(value = b.{self::A::hest}()).{core::num::==}(42)) {
throw "Unexpected value: '${value}'; expected '42'.";
}
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.legacy.expect b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.legacy.expect
index f0470a5..f405f12 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.legacy.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.legacy.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return null;
abstract method foo() → void;
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.legacy.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.legacy.transformed.expect
index f0470a5..f405f12 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return null;
abstract method foo() → void;
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.outline.expect b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.outline.expect
index 32e8f80..e5f2ba8 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.outline.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes.dart.outline.expect
@@ -5,7 +5,7 @@
abstract class A extends core::Object {
synthetic constructor •() → self::A
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
;
abstract method foo() → void;
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.legacy.expect b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.legacy.expect
index bf620af..05f2839 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.legacy.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.legacy.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return null;
abstract method foo() → void;
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.legacy.transformed.expect b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.legacy.transformed.expect
index bf620af..05f2839 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
return null;
abstract method foo() → void;
}
diff --git a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.outline.expect b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.outline.expect
index e72d0cf..df83640 100644
--- a/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.outline.expect
+++ b/pkg/front_end/testcases/no_such_method_forwarders/no_forwarders_for_abstract_classes_chain.dart.outline.expect
@@ -5,7 +5,7 @@
abstract class A extends core::Object {
synthetic constructor •() → self::A
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
;
abstract method foo() → void;
}
diff --git a/pkg/front_end/testcases/operators.dart.legacy.expect b/pkg/front_end/testcases/operators.dart.legacy.expect
index 9760fe2..639223b 100644
--- a/pkg/front_end/testcases/operators.dart.legacy.expect
+++ b/pkg/front_end/testcases/operators.dart.legacy.expect
@@ -18,7 +18,7 @@
return null;
operator /(dynamic other) → dynamic
return null;
- operator ==(dynamic other) → dynamic
+ operator ==(dynamic other) → core::bool
return null;
operator >(dynamic other) → dynamic
return null;
diff --git a/pkg/front_end/testcases/operators.dart.legacy.transformed.expect b/pkg/front_end/testcases/operators.dart.legacy.transformed.expect
index 9760fe2..639223b 100644
--- a/pkg/front_end/testcases/operators.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/operators.dart.legacy.transformed.expect
@@ -18,7 +18,7 @@
return null;
operator /(dynamic other) → dynamic
return null;
- operator ==(dynamic other) → dynamic
+ operator ==(dynamic other) → core::bool
return null;
operator >(dynamic other) → dynamic
return null;
diff --git a/pkg/front_end/testcases/operators.dart.outline.expect b/pkg/front_end/testcases/operators.dart.outline.expect
index 22aa8c4..68ed1ff 100644
--- a/pkg/front_end/testcases/operators.dart.outline.expect
+++ b/pkg/front_end/testcases/operators.dart.outline.expect
@@ -17,7 +17,7 @@
;
operator /(dynamic other) → dynamic
;
- operator ==(dynamic other) → dynamic
+ operator ==(dynamic other) → core::bool
;
operator >(dynamic other) → dynamic
;
diff --git a/pkg/front_end/testcases/optional.dart.outline.expect b/pkg/front_end/testcases/optional.dart.outline.expect
index 0f681fd..03d2b6e 100644
--- a/pkg/front_end/testcases/optional.dart.outline.expect
+++ b/pkg/front_end/testcases/optional.dart.outline.expect
@@ -22,13 +22,13 @@
class TestListener extends self::Listener {
synthetic constructor •() → self::TestListener
;
- method event(dynamic input, [dynamic x, dynamic y]) → void
+ method event(core::String input, [core::int x, core::int y]) → void
;
}
class ExtendedListener extends self::Listener {
synthetic constructor •() → self::ExtendedListener
;
- method event(dynamic input, [dynamic x, dynamic y, dynamic z]) → void
+ method event(core::String input, [core::int x, core::int y, dynamic z]) → void
;
}
class InvalidListener extends core::Object {
diff --git a/pkg/front_end/testcases/override_check_accessor_after_inference.dart.legacy.expect b/pkg/front_end/testcases/override_check_accessor_after_inference.dart.legacy.expect
index cf84a61..b8259ec 100644
--- a/pkg/front_end/testcases/override_check_accessor_after_inference.dart.legacy.expect
+++ b/pkg/front_end/testcases/override_check_accessor_after_inference.dart.legacy.expect
@@ -24,8 +24,8 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- set x(dynamic value) → void {}
- get y() → dynamic
+ set x(self::A value) → void {}
+ get y() → self::B
return null;
}
class E extends self::D {
diff --git a/pkg/front_end/testcases/override_check_accessor_after_inference.dart.legacy.transformed.expect b/pkg/front_end/testcases/override_check_accessor_after_inference.dart.legacy.transformed.expect
index cf84a61..b8259ec 100644
--- a/pkg/front_end/testcases/override_check_accessor_after_inference.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/override_check_accessor_after_inference.dart.legacy.transformed.expect
@@ -24,8 +24,8 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- set x(dynamic value) → void {}
- get y() → dynamic
+ set x(self::A value) → void {}
+ get y() → self::B
return null;
}
class E extends self::D {
diff --git a/pkg/front_end/testcases/override_check_accessor_after_inference.dart.outline.expect b/pkg/front_end/testcases/override_check_accessor_after_inference.dart.outline.expect
index 98a1f1b..f6baaa1 100644
--- a/pkg/front_end/testcases/override_check_accessor_after_inference.dart.outline.expect
+++ b/pkg/front_end/testcases/override_check_accessor_after_inference.dart.outline.expect
@@ -21,9 +21,9 @@
class D extends self::C {
synthetic constructor •() → self::D
;
- set x(dynamic value) → void
+ set x(self::A value) → void
;
- get y() → dynamic
+ get y() → self::B
;
}
class E extends self::D {
diff --git a/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.legacy.expect b/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.legacy.expect
index 7a03141..ec9f575 100644
--- a/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.legacy.expect
+++ b/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.legacy.expect
@@ -27,7 +27,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- set x1(self::B value) → void {}
+ set x1(covariant self::B value) → void {}
set x2(covariant self::B value) → void {}
set x3(covariant self::B value) → void {}
set x4(self::B value) → void {}
diff --git a/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.legacy.transformed.expect b/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.legacy.transformed.expect
index 7a03141..ec9f575 100644
--- a/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.legacy.transformed.expect
@@ -27,7 +27,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- set x1(self::B value) → void {}
+ set x1(covariant self::B value) → void {}
set x2(covariant self::B value) → void {}
set x3(covariant self::B value) → void {}
set x4(self::B value) → void {}
diff --git a/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.outline.expect b/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.outline.expect
index f5ae95c..eb8c429 100644
--- a/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.outline.expect
+++ b/pkg/front_end/testcases/override_check_accessor_with_covariant_modifier.dart.outline.expect
@@ -29,7 +29,7 @@
class D extends self::C {
synthetic constructor •() → self::D
;
- set x1(self::B value) → void
+ set x1(covariant self::B value) → void
;
set x2(covariant self::B value) → void
;
diff --git a/pkg/front_end/testcases/override_check_after_inference.dart.legacy.expect b/pkg/front_end/testcases/override_check_after_inference.dart.legacy.expect
index deaf420..adf56f6 100644
--- a/pkg/front_end/testcases/override_check_after_inference.dart.legacy.expect
+++ b/pkg/front_end/testcases/override_check_after_inference.dart.legacy.expect
@@ -22,7 +22,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- method f(dynamic x) → void {}
+ method f(self::A x) → void {}
}
class E extends self::D {
synthetic constructor •() → self::E
diff --git a/pkg/front_end/testcases/override_check_after_inference.dart.legacy.transformed.expect b/pkg/front_end/testcases/override_check_after_inference.dart.legacy.transformed.expect
index deaf420..adf56f6 100644
--- a/pkg/front_end/testcases/override_check_after_inference.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/override_check_after_inference.dart.legacy.transformed.expect
@@ -22,7 +22,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- method f(dynamic x) → void {}
+ method f(self::A x) → void {}
}
class E extends self::D {
synthetic constructor •() → self::E
diff --git a/pkg/front_end/testcases/override_check_after_inference.dart.outline.expect b/pkg/front_end/testcases/override_check_after_inference.dart.outline.expect
index 82c9ce4..6f3f1e6 100644
--- a/pkg/front_end/testcases/override_check_after_inference.dart.outline.expect
+++ b/pkg/front_end/testcases/override_check_after_inference.dart.outline.expect
@@ -19,7 +19,7 @@
class D extends self::C {
synthetic constructor •() → self::D
;
- method f(dynamic x) → void
+ method f(self::A x) → void
;
}
class E extends self::D {
diff --git a/pkg/front_end/testcases/override_check_two_substitutions.dart.legacy.expect b/pkg/front_end/testcases/override_check_two_substitutions.dart.legacy.expect
index dd0c4d5..05d92ea 100644
--- a/pkg/front_end/testcases/override_check_two_substitutions.dart.legacy.expect
+++ b/pkg/front_end/testcases/override_check_two_substitutions.dart.legacy.expect
@@ -12,6 +12,6 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- method f<V extends core::Object = dynamic>(core::Map<core::String, self::B::f::V> m) → void {}
+ method f<V extends core::Object = dynamic>(generic-covariant-impl core::Map<core::String, self::B::f::V> m) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/override_check_two_substitutions.dart.legacy.transformed.expect b/pkg/front_end/testcases/override_check_two_substitutions.dart.legacy.transformed.expect
index dd0c4d5..05d92ea 100644
--- a/pkg/front_end/testcases/override_check_two_substitutions.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/override_check_two_substitutions.dart.legacy.transformed.expect
@@ -12,6 +12,6 @@
synthetic constructor •() → self::B
: super self::A::•()
;
- method f<V extends core::Object = dynamic>(core::Map<core::String, self::B::f::V> m) → void {}
+ method f<V extends core::Object = dynamic>(generic-covariant-impl core::Map<core::String, self::B::f::V> m) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/override_check_two_substitutions.dart.outline.expect b/pkg/front_end/testcases/override_check_two_substitutions.dart.outline.expect
index e836ac4..713595c 100644
--- a/pkg/front_end/testcases/override_check_two_substitutions.dart.outline.expect
+++ b/pkg/front_end/testcases/override_check_two_substitutions.dart.outline.expect
@@ -11,7 +11,7 @@
class B extends self::A<core::String> {
synthetic constructor •() → self::B
;
- method f<V extends core::Object = dynamic>(core::Map<core::String, self::B::f::V> m) → void
+ method f<V extends core::Object = dynamic>(generic-covariant-impl core::Map<core::String, self::B::f::V> m) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.legacy.expect b/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.legacy.expect
index bd8f94e..30f268c 100644
--- a/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.legacy.expect
+++ b/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.legacy.expect
@@ -27,7 +27,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- method f1(self::B x) → void {}
+ method f1(covariant self::B x) → void {}
method f2(covariant self::B x) → void {}
method f3(covariant self::B x) → void {}
method f4(self::B x) → void {}
diff --git a/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.legacy.transformed.expect b/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.legacy.transformed.expect
index bd8f94e..30f268c 100644
--- a/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.legacy.transformed.expect
@@ -27,7 +27,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- method f1(self::B x) → void {}
+ method f1(covariant self::B x) → void {}
method f2(covariant self::B x) → void {}
method f3(covariant self::B x) → void {}
method f4(self::B x) → void {}
diff --git a/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.outline.expect b/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.outline.expect
index 2d4aa32..5ff196d 100644
--- a/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.outline.expect
+++ b/pkg/front_end/testcases/override_check_with_covariant_modifier.dart.outline.expect
@@ -29,7 +29,7 @@
class D extends self::C {
synthetic constructor •() → self::D
;
- method f1(self::B x) → void
+ method f1(covariant self::B x) → void
;
method f2(covariant self::B x) → void
;
diff --git a/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.legacy.expect b/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.legacy.expect
index 5a47079..ad364e1 100644
--- a/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.legacy.expect
+++ b/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.legacy.expect
@@ -15,7 +15,7 @@
C() : field = null;
^^^^^"
;
- set field(dynamic value) → dynamic {}
+ set field(dynamic value) → void {}
}
static method main() → dynamic {
new self::C::•();
diff --git a/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.legacy.transformed.expect b/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.legacy.transformed.expect
index 5a47079..ad364e1 100644
--- a/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.legacy.transformed.expect
@@ -15,7 +15,7 @@
C() : field = null;
^^^^^"
;
- set field(dynamic value) → dynamic {}
+ set field(dynamic value) → void {}
}
static method main() → dynamic {
new self::C::•();
diff --git a/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.outline.expect b/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.outline.expect
index 97d6cdd..1f58e29 100644
--- a/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.outline.expect
+++ b/pkg/front_end/testcases/rasta/bad_setter_initializer.dart.outline.expect
@@ -5,7 +5,7 @@
class C extends core::Object {
constructor •() → self::C
;
- set field(dynamic value) → dynamic
+ set field(dynamic value) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/rasta/issue_000025.dart.legacy.expect b/pkg/front_end/testcases/rasta/issue_000025.dart.legacy.expect
index 5fabc15..3be7ccc 100644
--- a/pkg/front_end/testcases/rasta/issue_000025.dart.legacy.expect
+++ b/pkg/front_end/testcases/rasta/issue_000025.dart.legacy.expect
@@ -4,7 +4,7 @@
static get x() → dynamic
return 42;
-static set x(dynamic val) → dynamic {}
+static set x(dynamic val) → void {}
static method main() → dynamic {
core::print(self::x);
core::print(self::x = 87);
diff --git a/pkg/front_end/testcases/rasta/issue_000025.dart.legacy.transformed.expect b/pkg/front_end/testcases/rasta/issue_000025.dart.legacy.transformed.expect
index 5fabc15..3be7ccc 100644
--- a/pkg/front_end/testcases/rasta/issue_000025.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/rasta/issue_000025.dart.legacy.transformed.expect
@@ -4,7 +4,7 @@
static get x() → dynamic
return 42;
-static set x(dynamic val) → dynamic {}
+static set x(dynamic val) → void {}
static method main() → dynamic {
core::print(self::x);
core::print(self::x = 87);
diff --git a/pkg/front_end/testcases/rasta/issue_000025.dart.outline.expect b/pkg/front_end/testcases/rasta/issue_000025.dart.outline.expect
index aab1950..8ee979d 100644
--- a/pkg/front_end/testcases/rasta/issue_000025.dart.outline.expect
+++ b/pkg/front_end/testcases/rasta/issue_000025.dart.outline.expect
@@ -3,7 +3,7 @@
static get x() → dynamic
;
-static set x(dynamic val) → dynamic
+static set x(dynamic val) → void
;
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/rasta/issue_000053.dart.legacy.expect b/pkg/front_end/testcases/rasta/issue_000053.dart.legacy.expect
index 230c10b..4dbd973 100644
--- a/pkg/front_end/testcases/rasta/issue_000053.dart.legacy.expect
+++ b/pkg/front_end/testcases/rasta/issue_000053.dart.legacy.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- operator ==(dynamic other) → dynamic
+ operator ==(dynamic other) → core::bool
return throw "x";
method test() → dynamic {
super.{core::Object::==}(null);
diff --git a/pkg/front_end/testcases/rasta/issue_000053.dart.legacy.transformed.expect b/pkg/front_end/testcases/rasta/issue_000053.dart.legacy.transformed.expect
index 230c10b..4dbd973 100644
--- a/pkg/front_end/testcases/rasta/issue_000053.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/rasta/issue_000053.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- operator ==(dynamic other) → dynamic
+ operator ==(dynamic other) → core::bool
return throw "x";
method test() → dynamic {
super.{core::Object::==}(null);
diff --git a/pkg/front_end/testcases/rasta/issue_000053.dart.outline.expect b/pkg/front_end/testcases/rasta/issue_000053.dart.outline.expect
index bc032b0..f3f1fd5 100644
--- a/pkg/front_end/testcases/rasta/issue_000053.dart.outline.expect
+++ b/pkg/front_end/testcases/rasta/issue_000053.dart.outline.expect
@@ -5,7 +5,7 @@
class C extends core::Object {
synthetic constructor •() → self::C
;
- operator ==(dynamic other) → dynamic
+ operator ==(dynamic other) → core::bool
;
method test() → dynamic
;
diff --git a/pkg/front_end/testcases/rasta/issue_000081.dart.outline.expect b/pkg/front_end/testcases/rasta/issue_000081.dart.outline.expect
index cb7bd6b..b12559d 100644
--- a/pkg/front_end/testcases/rasta/issue_000081.dart.outline.expect
+++ b/pkg/front_end/testcases/rasta/issue_000081.dart.outline.expect
@@ -11,7 +11,7 @@
field core::int _hashCode;
synthetic constructor •() → self::Sub
;
- get hashCode() → dynamic
+ get hashCode() → core::int
;
method foo() → dynamic
;
diff --git a/pkg/front_end/testcases/rasta/native_is_illegal.dart.outline.expect b/pkg/front_end/testcases/rasta/native_is_illegal.dart.outline.expect
index a7ea25b..fc3831b 100644
--- a/pkg/front_end/testcases/rasta/native_is_illegal.dart.outline.expect
+++ b/pkg/front_end/testcases/rasta/native_is_illegal.dart.outline.expect
@@ -5,7 +5,7 @@
class Bar extends core::Object {
get x() → self::Bar
;
- set x(self::Bar value) → dynamic
+ set x(self::Bar value) → void
;
method f() → dynamic
;
diff --git a/pkg/front_end/testcases/rasta/static.dart.legacy.expect b/pkg/front_end/testcases/rasta/static.dart.legacy.expect
index 70d0f8c..b9c1b3e 100644
--- a/pkg/front_end/testcases/rasta/static.dart.legacy.expect
+++ b/pkg/front_end/testcases/rasta/static.dart.legacy.expect
@@ -150,7 +150,7 @@
static method staticFunction() → dynamic {}
static get staticGetter() → dynamic
return null;
- static set staticSetter(dynamic _) → dynamic {}
+ static set staticSetter(dynamic _) → void {}
}
static method use(dynamic x) → dynamic {
if(x.==(new core::DateTime::now().millisecondsSinceEpoch))
diff --git a/pkg/front_end/testcases/rasta/static.dart.legacy.transformed.expect b/pkg/front_end/testcases/rasta/static.dart.legacy.transformed.expect
index 70d0f8c..b9c1b3e 100644
--- a/pkg/front_end/testcases/rasta/static.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/rasta/static.dart.legacy.transformed.expect
@@ -150,7 +150,7 @@
static method staticFunction() → dynamic {}
static get staticGetter() → dynamic
return null;
- static set staticSetter(dynamic _) → dynamic {}
+ static set staticSetter(dynamic _) → void {}
}
static method use(dynamic x) → dynamic {
if(x.==(new core::DateTime::now().millisecondsSinceEpoch))
diff --git a/pkg/front_end/testcases/rasta/static.dart.outline.expect b/pkg/front_end/testcases/rasta/static.dart.outline.expect
index 970c3bb..78a615c 100644
--- a/pkg/front_end/testcases/rasta/static.dart.outline.expect
+++ b/pkg/front_end/testcases/rasta/static.dart.outline.expect
@@ -11,7 +11,7 @@
;
static get staticGetter() → dynamic
;
- static set staticSetter(dynamic _) → dynamic
+ static set staticSetter(dynamic _) → void
;
}
static method use(dynamic x) → dynamic
diff --git a/pkg/front_end/testcases/rasta/super.dart.legacy.expect b/pkg/front_end/testcases/rasta/super.dart.legacy.expect
index 55dfd57..dbd7908 100644
--- a/pkg/front_end/testcases/rasta/super.dart.legacy.expect
+++ b/pkg/front_end/testcases/rasta/super.dart.legacy.expect
@@ -253,24 +253,24 @@
;
get e() → dynamic
return null;
- set g(dynamic _) → dynamic {}
+ set g(dynamic _) → void {}
get h() → dynamic
return null;
- set h(dynamic _) → dynamic {}
+ set h(dynamic _) → void {}
get i() → dynamic
return null;
operator [](dynamic _) → dynamic
return null;
- operator []=(dynamic a, dynamic b) → dynamic {}
+ operator []=(dynamic a, dynamic b) → void {}
operator ~() → dynamic
return 117;
operator unary-() → dynamic
return 117;
- operator ==(dynamic other) → dynamic
+ operator ==(dynamic other) → core::bool
return true;
method m() → void {}
method n() → void {}
- set n(dynamic _) → dynamic {}
+ set n(dynamic _) → void {}
}
class B extends self::A {
final field dynamic d = null;
@@ -279,8 +279,8 @@
;
get b() → dynamic
return null;
- set c(dynamic x) → dynamic {}
- set i(dynamic x) → dynamic {}
+ set c(dynamic x) → void {}
+ set i(dynamic x) → void {}
}
class C extends self::B {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/rasta/super.dart.legacy.transformed.expect b/pkg/front_end/testcases/rasta/super.dart.legacy.transformed.expect
index 55dfd57..dbd7908 100644
--- a/pkg/front_end/testcases/rasta/super.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/rasta/super.dart.legacy.transformed.expect
@@ -253,24 +253,24 @@
;
get e() → dynamic
return null;
- set g(dynamic _) → dynamic {}
+ set g(dynamic _) → void {}
get h() → dynamic
return null;
- set h(dynamic _) → dynamic {}
+ set h(dynamic _) → void {}
get i() → dynamic
return null;
operator [](dynamic _) → dynamic
return null;
- operator []=(dynamic a, dynamic b) → dynamic {}
+ operator []=(dynamic a, dynamic b) → void {}
operator ~() → dynamic
return 117;
operator unary-() → dynamic
return 117;
- operator ==(dynamic other) → dynamic
+ operator ==(dynamic other) → core::bool
return true;
method m() → void {}
method n() → void {}
- set n(dynamic _) → dynamic {}
+ set n(dynamic _) → void {}
}
class B extends self::A {
final field dynamic d = null;
@@ -279,8 +279,8 @@
;
get b() → dynamic
return null;
- set c(dynamic x) → dynamic {}
- set i(dynamic x) → dynamic {}
+ set c(dynamic x) → void {}
+ set i(dynamic x) → void {}
}
class C extends self::B {
synthetic constructor •() → self::C
diff --git a/pkg/front_end/testcases/rasta/super.dart.outline.expect b/pkg/front_end/testcases/rasta/super.dart.outline.expect
index d668783..9b0da41 100644
--- a/pkg/front_end/testcases/rasta/super.dart.outline.expect
+++ b/pkg/front_end/testcases/rasta/super.dart.outline.expect
@@ -22,29 +22,29 @@
;
get e() → dynamic
;
- set g(dynamic _) → dynamic
+ set g(dynamic _) → void
;
get h() → dynamic
;
- set h(dynamic _) → dynamic
+ set h(dynamic _) → void
;
get i() → dynamic
;
operator [](dynamic _) → dynamic
;
- operator []=(dynamic a, dynamic b) → dynamic
+ operator []=(dynamic a, dynamic b) → void
;
operator ~() → dynamic
;
operator unary-() → dynamic
;
- operator ==(dynamic other) → dynamic
+ operator ==(dynamic other) → core::bool
;
method m() → void
;
method n() → void
;
- set n(dynamic _) → dynamic
+ set n(dynamic _) → void
;
}
class B extends self::A {
@@ -53,9 +53,9 @@
;
get b() → dynamic
;
- set c(dynamic x) → dynamic
+ set c(dynamic x) → void
;
- set i(dynamic x) → dynamic
+ set i(dynamic x) → void
;
}
class C extends self::B {
diff --git a/pkg/front_end/testcases/rasta/super_operator.dart.outline.expect b/pkg/front_end/testcases/rasta/super_operator.dart.outline.expect
index d0ecc4d..01e59ad 100644
--- a/pkg/front_end/testcases/rasta/super_operator.dart.outline.expect
+++ b/pkg/front_end/testcases/rasta/super_operator.dart.outline.expect
@@ -9,7 +9,7 @@
;
operator [](dynamic i) → dynamic
;
- operator []=(dynamic i, dynamic val) → dynamic
+ operator []=(dynamic i, dynamic val) → void
;
}
class B extends self::A {
@@ -19,7 +19,7 @@
;
operator [](dynamic i) → dynamic
;
- operator []=(dynamic i, dynamic val) → dynamic
+ operator []=(dynamic i, dynamic val) → void
;
}
class Autobianchi extends core::Object {
diff --git a/pkg/front_end/testcases/redirection_chain_type_arguments.dart.legacy.expect b/pkg/front_end/testcases/redirection_chain_type_arguments.dart.legacy.expect
index bba4f23..32a5b17 100644
--- a/pkg/front_end/testcases/redirection_chain_type_arguments.dart.legacy.expect
+++ b/pkg/front_end/testcases/redirection_chain_type_arguments.dart.legacy.expect
@@ -25,7 +25,7 @@
constructor •() → self::C<self::C::V, self::C::S, self::C::R>
: super self::B::empty()
;
- method toString() → dynamic
+ method toString() → core::String
return "${self::C::V},${self::C::S},${self::C::R}";
}
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/redirection_chain_type_arguments.dart.legacy.transformed.expect b/pkg/front_end/testcases/redirection_chain_type_arguments.dart.legacy.transformed.expect
index bba4f23..32a5b17 100644
--- a/pkg/front_end/testcases/redirection_chain_type_arguments.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/redirection_chain_type_arguments.dart.legacy.transformed.expect
@@ -25,7 +25,7 @@
constructor •() → self::C<self::C::V, self::C::S, self::C::R>
: super self::B::empty()
;
- method toString() → dynamic
+ method toString() → core::String
return "${self::C::V},${self::C::S},${self::C::R}";
}
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/redirection_chain_type_arguments.dart.outline.expect b/pkg/front_end/testcases/redirection_chain_type_arguments.dart.outline.expect
index 3b0ee19..d4a0e63 100644
--- a/pkg/front_end/testcases/redirection_chain_type_arguments.dart.outline.expect
+++ b/pkg/front_end/testcases/redirection_chain_type_arguments.dart.outline.expect
@@ -21,7 +21,7 @@
class C<V extends core::Object = dynamic, S extends core::Object = dynamic, R extends core::Object = dynamic> extends self::B<self::C::V, self::C::S> {
constructor •() → self::C<self::C::V, self::C::S, self::C::R>
;
- method toString() → dynamic
+ method toString() → core::String
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.legacy.expect b/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.legacy.expect
index cee4e10..09e1d27 100644
--- a/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.legacy.expect
+++ b/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.legacy.expect
@@ -25,7 +25,7 @@
constructor •() → self::C<self::C::V, self::C::S, self::C::R>
: super self::B::empty()
;
- method toString() → dynamic
+ method toString() → core::String
return "${self::C::V},${self::C::S},${self::C::R}";
}
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.legacy.transformed.expect b/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.legacy.transformed.expect
index cee4e10..09e1d27 100644
--- a/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.legacy.transformed.expect
@@ -25,7 +25,7 @@
constructor •() → self::C<self::C::V, self::C::S, self::C::R>
: super self::B::empty()
;
- method toString() → dynamic
+ method toString() → core::String
return "${self::C::V},${self::C::S},${self::C::R}";
}
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.outline.expect b/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.outline.expect
index 2b481ac..f9db296 100644
--- a/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.outline.expect
+++ b/pkg/front_end/testcases/redirection_chain_type_arguments_subst.dart.outline.expect
@@ -21,7 +21,7 @@
class C<V extends core::Object = dynamic, S extends core::Object = dynamic, R extends core::Object = dynamic> extends self::B<self::C::V, self::C::S> {
constructor •() → self::C<self::C::V, self::C::S, self::C::R>
;
- method toString() → dynamic
+ method toString() → core::String
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/redirection_type_arguments.dart.legacy.expect b/pkg/front_end/testcases/redirection_type_arguments.dart.legacy.expect
index 2fff34d..0dc1e9e 100644
--- a/pkg/front_end/testcases/redirection_type_arguments.dart.legacy.expect
+++ b/pkg/front_end/testcases/redirection_type_arguments.dart.legacy.expect
@@ -17,7 +17,7 @@
const constructor •() → self::B<self::B::T>
: super self::A::empty()
;
- method toString() → dynamic
+ method toString() → core::String
return "${self::B::T}";
}
static method main() → void {
diff --git a/pkg/front_end/testcases/redirection_type_arguments.dart.legacy.transformed.expect b/pkg/front_end/testcases/redirection_type_arguments.dart.legacy.transformed.expect
index 2fff34d..0dc1e9e 100644
--- a/pkg/front_end/testcases/redirection_type_arguments.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/redirection_type_arguments.dart.legacy.transformed.expect
@@ -17,7 +17,7 @@
const constructor •() → self::B<self::B::T>
: super self::A::empty()
;
- method toString() → dynamic
+ method toString() → core::String
return "${self::B::T}";
}
static method main() → void {
diff --git a/pkg/front_end/testcases/redirection_type_arguments.dart.outline.expect b/pkg/front_end/testcases/redirection_type_arguments.dart.outline.expect
index 4e65df8..0fcea3e 100644
--- a/pkg/front_end/testcases/redirection_type_arguments.dart.outline.expect
+++ b/pkg/front_end/testcases/redirection_type_arguments.dart.outline.expect
@@ -14,7 +14,7 @@
class B<T extends core::Object = dynamic> extends self::A {
const constructor •() → self::B<self::B::T>
;
- method toString() → dynamic
+ method toString() → core::String
;
}
static method main() → void
diff --git a/pkg/front_end/testcases/regress/issue_30834.dart.legacy.expect b/pkg/front_end/testcases/regress/issue_30834.dart.legacy.expect
index d90c580..2f3e686 100644
--- a/pkg/front_end/testcases/regress/issue_30834.dart.legacy.expect
+++ b/pkg/front_end/testcases/regress/issue_30834.dart.legacy.expect
@@ -13,7 +13,7 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- set A(dynamic v) → dynamic {}
+ set A(dynamic v) → void {}
}
static method main() → dynamic {
dynamic a = new self::A::•();
diff --git a/pkg/front_end/testcases/regress/issue_30834.dart.legacy.transformed.expect b/pkg/front_end/testcases/regress/issue_30834.dart.legacy.transformed.expect
index d90c580..2f3e686 100644
--- a/pkg/front_end/testcases/regress/issue_30834.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/regress/issue_30834.dart.legacy.transformed.expect
@@ -13,7 +13,7 @@
synthetic constructor •() → self::A
: super core::Object::•()
;
- set A(dynamic v) → dynamic {}
+ set A(dynamic v) → void {}
}
static method main() → dynamic {
dynamic a = new self::A::•();
diff --git a/pkg/front_end/testcases/regress/issue_30834.dart.outline.expect b/pkg/front_end/testcases/regress/issue_30834.dart.outline.expect
index b7a0c48..f48580b 100644
--- a/pkg/front_end/testcases/regress/issue_30834.dart.outline.expect
+++ b/pkg/front_end/testcases/regress/issue_30834.dart.outline.expect
@@ -12,7 +12,7 @@
class A extends core::Object {
synthetic constructor •() → self::A
;
- set A(dynamic v) → dynamic
+ set A(dynamic v) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/regress/issue_32660.dart.hierarchy.expect b/pkg/front_end/testcases/regress/issue_32660.dart.hierarchy.expect
index 5c7b6fa..3cbcc36 100644
--- a/pkg/front_end/testcases/regress/issue_32660.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/regress/issue_32660.dart.hierarchy.expect
@@ -77,7 +77,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- A.foo
+ C.A.foo%B.foo
C.noSuchMethod
Object._identityHashCode
Object.hashCode
@@ -114,7 +114,7 @@
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
- D.foo
+ E.D.foo%E.foo
E.noSuchMethod
Object._identityHashCode
Object.hashCode
diff --git a/pkg/front_end/testcases/regress/issue_32660.dart.legacy.expect b/pkg/front_end/testcases/regress/issue_32660.dart.legacy.expect
index 46f8dc2..e4d64d6 100644
--- a/pkg/front_end/testcases/regress/issue_32660.dart.legacy.expect
+++ b/pkg/front_end/testcases/regress/issue_32660.dart.legacy.expect
@@ -1,4 +1,27 @@
library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/regress/issue_32660.dart:21:3: Warning: The method 'D.foo' has fewer named arguments than those of overridden method 'E.foo'.
+// foo(int x) => x;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:25:3: Context: This is the overridden method ('foo').
+// foo(int x, {int y});
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:24:7: Context: Both members are inherited by the non-abstract class 'E'.
+// class E extends D {
+// ^
+//
+// pkg/front_end/testcases/regress/issue_32660.dart:6:3: Warning: The method 'A.foo' has fewer named arguments than those of overridden method 'B.foo'.
+// foo(int x) => x;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:10:3: Context: This is the overridden method ('foo').
+// foo(int x, {int y}) => y;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:13:7: Context: Both members are inherited by the non-abstract class 'C'.
+// class C extends A implements B {
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -20,10 +43,11 @@
synthetic constructor •() → self::C
: super self::A::•()
;
- method noSuchMethod(dynamic i) → dynamic {
+ method noSuchMethod(core::Invocation i) → dynamic {
core::print("No such method!");
return 42;
}
+ abstract forwarding-stub method foo(core::int x, {core::int y = null}) → dynamic;
}
class D extends core::Object {
synthetic constructor •() → self::D
@@ -37,7 +61,7 @@
: super self::D::•()
;
abstract method foo(core::int x, {core::int y = null}) → dynamic;
- method noSuchMethod(dynamic i) → dynamic {
+ method noSuchMethod(core::Invocation i) → dynamic {
core::print(i.namedArguments);
return 42;
}
diff --git a/pkg/front_end/testcases/regress/issue_32660.dart.legacy.transformed.expect b/pkg/front_end/testcases/regress/issue_32660.dart.legacy.transformed.expect
index 46f8dc2..e4d64d6 100644
--- a/pkg/front_end/testcases/regress/issue_32660.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/regress/issue_32660.dart.legacy.transformed.expect
@@ -1,4 +1,27 @@
library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/regress/issue_32660.dart:21:3: Warning: The method 'D.foo' has fewer named arguments than those of overridden method 'E.foo'.
+// foo(int x) => x;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:25:3: Context: This is the overridden method ('foo').
+// foo(int x, {int y});
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:24:7: Context: Both members are inherited by the non-abstract class 'E'.
+// class E extends D {
+// ^
+//
+// pkg/front_end/testcases/regress/issue_32660.dart:6:3: Warning: The method 'A.foo' has fewer named arguments than those of overridden method 'B.foo'.
+// foo(int x) => x;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:10:3: Context: This is the overridden method ('foo').
+// foo(int x, {int y}) => y;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:13:7: Context: Both members are inherited by the non-abstract class 'C'.
+// class C extends A implements B {
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -20,10 +43,11 @@
synthetic constructor •() → self::C
: super self::A::•()
;
- method noSuchMethod(dynamic i) → dynamic {
+ method noSuchMethod(core::Invocation i) → dynamic {
core::print("No such method!");
return 42;
}
+ abstract forwarding-stub method foo(core::int x, {core::int y = null}) → dynamic;
}
class D extends core::Object {
synthetic constructor •() → self::D
@@ -37,7 +61,7 @@
: super self::D::•()
;
abstract method foo(core::int x, {core::int y = null}) → dynamic;
- method noSuchMethod(dynamic i) → dynamic {
+ method noSuchMethod(core::Invocation i) → dynamic {
core::print(i.namedArguments);
return 42;
}
diff --git a/pkg/front_end/testcases/regress/issue_32660.dart.outline.expect b/pkg/front_end/testcases/regress/issue_32660.dart.outline.expect
index 9dc571a..7b9f48b 100644
--- a/pkg/front_end/testcases/regress/issue_32660.dart.outline.expect
+++ b/pkg/front_end/testcases/regress/issue_32660.dart.outline.expect
@@ -1,4 +1,27 @@
library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/regress/issue_32660.dart:21:3: Warning: The method 'D.foo' has fewer named arguments than those of overridden method 'E.foo'.
+// foo(int x) => x;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:25:3: Context: This is the overridden method ('foo').
+// foo(int x, {int y});
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:24:7: Context: Both members are inherited by the non-abstract class 'E'.
+// class E extends D {
+// ^
+//
+// pkg/front_end/testcases/regress/issue_32660.dart:6:3: Warning: The method 'A.foo' has fewer named arguments than those of overridden method 'B.foo'.
+// foo(int x) => x;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:10:3: Context: This is the overridden method ('foo').
+// foo(int x, {int y}) => y;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:13:7: Context: Both members are inherited by the non-abstract class 'C'.
+// class C extends A implements B {
+// ^
+//
import self as self;
import "dart:core" as core;
@@ -17,8 +40,9 @@
class C extends self::A implements self::B {
synthetic constructor •() → self::C
;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
;
+ abstract forwarding-stub method foo(core::int x, {core::int y}) → dynamic;
}
class D extends core::Object {
synthetic constructor •() → self::D
@@ -30,7 +54,7 @@
synthetic constructor •() → self::E
;
abstract method foo(core::int x, {core::int y}) → dynamic;
- method noSuchMethod(dynamic i) → dynamic
+ method noSuchMethod(core::Invocation i) → dynamic
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/regress/issue_32660.dart.strong.expect b/pkg/front_end/testcases/regress/issue_32660.dart.strong.expect
index 910fc65..73b1b6a 100644
--- a/pkg/front_end/testcases/regress/issue_32660.dart.strong.expect
+++ b/pkg/front_end/testcases/regress/issue_32660.dart.strong.expect
@@ -2,16 +2,6 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/regress/issue_32660.dart:6:3: Error: The method 'A.foo' has fewer named arguments than those of overridden method 'B.foo'.
-// foo(int x) => x;
-// ^
-// pkg/front_end/testcases/regress/issue_32660.dart:10:3: Context: This is the overridden method ('foo').
-// foo(int x, {int y}) => y;
-// ^
-// pkg/front_end/testcases/regress/issue_32660.dart:13:7: Context: Both members are inherited by the non-abstract class 'C'.
-// class C extends A implements B {
-// ^
-//
// pkg/front_end/testcases/regress/issue_32660.dart:21:3: Error: The method 'D.foo' has fewer named arguments than those of overridden method 'E.foo'.
// foo(int x) => x;
// ^
@@ -22,6 +12,16 @@
// class E extends D {
// ^
//
+// pkg/front_end/testcases/regress/issue_32660.dart:6:3: Error: The method 'A.foo' has fewer named arguments than those of overridden method 'B.foo'.
+// foo(int x) => x;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:10:3: Context: This is the overridden method ('foo').
+// foo(int x, {int y}) => y;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:13:7: Context: Both members are inherited by the non-abstract class 'C'.
+// class C extends A implements B {
+// ^
+//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/regress/issue_32660.dart.strong.transformed.expect b/pkg/front_end/testcases/regress/issue_32660.dart.strong.transformed.expect
index 910fc65..73b1b6a 100644
--- a/pkg/front_end/testcases/regress/issue_32660.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/regress/issue_32660.dart.strong.transformed.expect
@@ -2,16 +2,6 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/regress/issue_32660.dart:6:3: Error: The method 'A.foo' has fewer named arguments than those of overridden method 'B.foo'.
-// foo(int x) => x;
-// ^
-// pkg/front_end/testcases/regress/issue_32660.dart:10:3: Context: This is the overridden method ('foo').
-// foo(int x, {int y}) => y;
-// ^
-// pkg/front_end/testcases/regress/issue_32660.dart:13:7: Context: Both members are inherited by the non-abstract class 'C'.
-// class C extends A implements B {
-// ^
-//
// pkg/front_end/testcases/regress/issue_32660.dart:21:3: Error: The method 'D.foo' has fewer named arguments than those of overridden method 'E.foo'.
// foo(int x) => x;
// ^
@@ -22,6 +12,16 @@
// class E extends D {
// ^
//
+// pkg/front_end/testcases/regress/issue_32660.dart:6:3: Error: The method 'A.foo' has fewer named arguments than those of overridden method 'B.foo'.
+// foo(int x) => x;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:10:3: Context: This is the overridden method ('foo').
+// foo(int x, {int y}) => y;
+// ^
+// pkg/front_end/testcases/regress/issue_32660.dart:13:7: Context: Both members are inherited by the non-abstract class 'C'.
+// class C extends A implements B {
+// ^
+//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/regress/issue_34225.dart.legacy.expect b/pkg/front_end/testcases/regress/issue_34225.dart.legacy.expect
index 24e8a2a..1b764c6 100644
--- a/pkg/front_end/testcases/regress/issue_34225.dart.legacy.expect
+++ b/pkg/front_end/testcases/regress/issue_34225.dart.legacy.expect
@@ -17,13 +17,13 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- static set C(dynamic v) → dynamic {}
+ static set C(dynamic v) → void {}
}
class D extends core::Object {
synthetic constructor •() → self::D
: super core::Object::•()
;
- set D(dynamic v) → dynamic {}
+ set D(dynamic v) → void {}
}
static method main() → dynamic {
dynamic c = new self::C::•();
diff --git a/pkg/front_end/testcases/regress/issue_34225.dart.legacy.transformed.expect b/pkg/front_end/testcases/regress/issue_34225.dart.legacy.transformed.expect
index 24e8a2a..1b764c6 100644
--- a/pkg/front_end/testcases/regress/issue_34225.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/regress/issue_34225.dart.legacy.transformed.expect
@@ -17,13 +17,13 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- static set C(dynamic v) → dynamic {}
+ static set C(dynamic v) → void {}
}
class D extends core::Object {
synthetic constructor •() → self::D
: super core::Object::•()
;
- set D(dynamic v) → dynamic {}
+ set D(dynamic v) → void {}
}
static method main() → dynamic {
dynamic c = new self::C::•();
diff --git a/pkg/front_end/testcases/regress/issue_34225.dart.outline.expect b/pkg/front_end/testcases/regress/issue_34225.dart.outline.expect
index 4582fae..5cfdb48 100644
--- a/pkg/front_end/testcases/regress/issue_34225.dart.outline.expect
+++ b/pkg/front_end/testcases/regress/issue_34225.dart.outline.expect
@@ -16,13 +16,13 @@
class C extends core::Object {
synthetic constructor •() → self::C
;
- static set C(dynamic v) → dynamic
+ static set C(dynamic v) → void
;
}
class D extends core::Object {
synthetic constructor •() → self::D
;
- set D(dynamic v) → dynamic
+ set D(dynamic v) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.legacy.expect
index 96700b1..2092b43 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.legacy.expect
@@ -13,15 +13,15 @@
synthetic constructor •() → self::C<self::C::U>
: super core::Object::•()
;
- method f1(core::int x) → void {}
- method f2(core::int x, [generic-covariant-impl self::C::U y = null]) → void {}
+ method f1(generic-covariant-impl core::int x) → void {}
+ method f2(generic-covariant-impl core::int x, [generic-covariant-impl self::C::U y = null]) → void {}
}
class D<U extends core::Object = dynamic> extends self::C<self::D::U> {
synthetic constructor •() → self::D<self::D::U>
: super self::C::•()
;
- method f1(core::int x) → void {}
- method f2(core::int x, [generic-covariant-impl self::D::U y = null]) → void {}
+ method f1(generic-covariant-impl core::int x) → void {}
+ method f2(generic-covariant-impl core::int x, [generic-covariant-impl self::D::U y = null]) → void {}
}
static method g1(self::C<core::num> c) → void {
c.f1(1);
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.legacy.transformed.expect
index 96700b1..2092b43 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.legacy.transformed.expect
@@ -13,15 +13,15 @@
synthetic constructor •() → self::C<self::C::U>
: super core::Object::•()
;
- method f1(core::int x) → void {}
- method f2(core::int x, [generic-covariant-impl self::C::U y = null]) → void {}
+ method f1(generic-covariant-impl core::int x) → void {}
+ method f2(generic-covariant-impl core::int x, [generic-covariant-impl self::C::U y = null]) → void {}
}
class D<U extends core::Object = dynamic> extends self::C<self::D::U> {
synthetic constructor •() → self::D<self::D::U>
: super self::C::•()
;
- method f1(core::int x) → void {}
- method f2(core::int x, [generic-covariant-impl self::D::U y = null]) → void {}
+ method f1(generic-covariant-impl core::int x) → void {}
+ method f2(generic-covariant-impl core::int x, [generic-covariant-impl self::D::U y = null]) → void {}
}
static method g1(self::C<core::num> c) → void {
c.f1(1);
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.outline.expect
index fe2f698..9779f69 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface.dart.outline.expect
@@ -11,17 +11,17 @@
class C<U extends core::Object = dynamic> extends core::Object implements self::I<core::int> {
synthetic constructor •() → self::C<self::C::U>
;
- method f1(core::int x) → void
+ method f1(generic-covariant-impl core::int x) → void
;
- method f2(core::int x, [generic-covariant-impl self::C::U y]) → void
+ method f2(generic-covariant-impl core::int x, [generic-covariant-impl self::C::U y]) → void
;
}
class D<U extends core::Object = dynamic> extends self::C<self::D::U> {
synthetic constructor •() → self::D<self::D::U>
;
- method f1(core::int x) → void
+ method f1(generic-covariant-impl core::int x) → void
;
- method f2(core::int x, [generic-covariant-impl self::D::U y]) → void
+ method f2(generic-covariant-impl core::int x, [generic-covariant-impl self::D::U y]) → void
;
}
static method g1(self::C<core::num> c) → void
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.hierarchy.expect
index 6ad21c9..eee2991 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.hierarchy.expect
@@ -91,7 +91,7 @@
Object.==
classSetters:
interfaceMembers:
- M.f
+ C.M.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.legacy.expect
index 144807a..226d14a 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.legacy.expect
@@ -24,6 +24,8 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x) → void
+ return super.{self::B::f}(x);
}
static method g1(self::C c) → void {
c.f(1);
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.legacy.transformed.expect
index 20d3a2e..9af26fa 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
- method f(core::int x) → void {}
+ method f(generic-covariant-impl core::int x) → void {}
}
static method g1(self::C c) → void {
c.f(1);
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.outline.expect
index 10f6ea9..db72bce 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.outline.expect
@@ -23,6 +23,8 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x) → void
+ return super.{self::B::f}(x);
}
static method g1(self::C c) → void
;
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.hierarchy.expect
index c6a5468..66e9deb 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.hierarchy.expect
@@ -73,7 +73,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.legacy.expect
index ca44867..dd05793 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.legacy.expect
@@ -18,6 +18,8 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x) → void
+ return super.{self::B::f}(x);
}
static method g1(self::C c) → void {
c.f(1);
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.legacy.transformed.expect
index ca44867..dd05793 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.legacy.transformed.expect
@@ -18,6 +18,8 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x) → void
+ return super.{self::B::f}(x);
}
static method g1(self::C c) → void {
c.f(1);
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.outline.expect
index ee14e2c..bd1c5ab 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super.dart.outline.expect
@@ -16,6 +16,8 @@
class C extends self::B implements self::I<core::int> {
synthetic constructor •() → self::C
;
+ forwarding-stub method f(generic-covariant-impl core::int x) → void
+ return super.{self::B::f}(x);
}
static method g1(self::C c) → void
;
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.hierarchy.expect
index 3b034c6..63ed69c 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.hierarchy.expect
@@ -90,7 +90,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.legacy.expect
index 45abbbf..b31bd2e 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.legacy.expect
@@ -23,6 +23,8 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x) → void
+ return super.{self::B::f}(x);
}
static method g1(self::C c) → void {
c.f(1);
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.legacy.transformed.expect
index 0e61a92..1fb19f0 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.legacy.transformed.expect
@@ -23,6 +23,8 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x) → void
+ return super.{self::B::f}(x);
}
static method g1(self::C c) → void {
c.f(1);
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.outline.expect
index 926b281..97f802d 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.outline.expect
@@ -21,6 +21,8 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x) → void
+ return super.{self::B::f}(x);
}
static method g1(self::C c) → void
;
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.legacy.expect
index 31aa1f7..9faa7e3 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.legacy.expect
@@ -19,7 +19,7 @@
synthetic constructor •() → self::E
: super self::D::•()
;
- method f(core::int x) → void {}
+ method f(covariant core::int x) → void {}
}
static method g1(self::C c) → void {
c.f(1.5);
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.legacy.transformed.expect
index 31aa1f7..9faa7e3 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.legacy.transformed.expect
@@ -19,7 +19,7 @@
synthetic constructor •() → self::E
: super self::D::•()
;
- method f(core::int x) → void {}
+ method f(covariant core::int x) → void {}
}
static method g1(self::C c) → void {
c.f(1.5);
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.outline.expect
index 3303a29..dd2a7ad 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword.dart.outline.expect
@@ -18,7 +18,7 @@
class E extends self::D {
synthetic constructor •() → self::E
;
- method f(core::int x) → void
+ method f(covariant core::int x) → void
;
}
static method g1(self::C c) → void
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.legacy.expect
index 306dd42..1f3710c 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.legacy.expect
@@ -15,7 +15,7 @@
;
}
class E extends core::Object implements self::D {
- field core::int x = null;
+ covariant field core::int x = null;
synthetic constructor •() → self::E
: super core::Object::•()
;
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.legacy.transformed.expect
index 306dd42..1f3710c 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.legacy.transformed.expect
@@ -15,7 +15,7 @@
;
}
class E extends core::Object implements self::D {
- field core::int x = null;
+ covariant field core::int x = null;
synthetic constructor •() → self::E
: super core::Object::•()
;
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.outline.expect
index 643c93c..063eafe 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field.dart.outline.expect
@@ -13,7 +13,7 @@
;
}
class E extends core::Object implements self::D {
- field core::int x;
+ covariant field core::int x;
synthetic constructor •() → self::E
;
}
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.legacy.expect
index 4e1a3ad..760a9dc 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.legacy.expect
@@ -20,6 +20,6 @@
;
get x() → core::int
return 0;
- set x(core::int value) → void {}
+ set x(covariant core::int value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.legacy.transformed.expect
index 4e1a3ad..760a9dc 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.legacy.transformed.expect
@@ -20,6 +20,6 @@
;
get x() → core::int
return 0;
- set x(core::int value) → void {}
+ set x(covariant core::int value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.outline.expect
index 358009c..0bc780e 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_field_inherited_by_setter.dart.outline.expect
@@ -17,7 +17,7 @@
;
get x() → core::int
;
- set x(core::int value) → void
+ set x(covariant core::int value) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.legacy.expect
index d5f7a72..cc9e3d7 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.legacy.expect
@@ -18,6 +18,6 @@
synthetic constructor •() → self::E
: super self::D::•()
;
- set x(core::int value) → void {}
+ set x(covariant core::int value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.legacy.transformed.expect
index d5f7a72..cc9e3d7 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.legacy.transformed.expect
@@ -18,6 +18,6 @@
synthetic constructor •() → self::E
: super self::D::•()
;
- set x(core::int value) → void {}
+ set x(covariant core::int value) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.outline.expect
index 8f94f9e..840f751 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter.dart.outline.expect
@@ -17,7 +17,7 @@
class E extends self::D {
synthetic constructor •() → self::E
;
- set x(core::int value) → void
+ set x(covariant core::int value) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.legacy.expect
index 79a95bb..492c9a2 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.legacy.expect
@@ -15,7 +15,7 @@
set x(covariant core::int value) → void {}
}
class E extends core::Object implements self::D {
- field core::int x = null;
+ covariant field core::int x = null;
synthetic constructor •() → self::E
: super core::Object::•()
;
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.legacy.transformed.expect
index 79a95bb..492c9a2 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.legacy.transformed.expect
@@ -15,7 +15,7 @@
set x(covariant core::int value) → void {}
}
class E extends core::Object implements self::D {
- field core::int x = null;
+ covariant field core::int x = null;
synthetic constructor •() → self::E
: super core::Object::•()
;
diff --git a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.outline.expect
index 97331e8..809ec55 100644
--- a/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/covariant_keyword_setter_inherited_by_field.dart.outline.expect
@@ -15,7 +15,7 @@
;
}
class E extends core::Object implements self::D {
- field core::int x;
+ covariant field core::int x;
synthetic constructor •() → self::E
;
}
diff --git a/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.legacy.expect
index 2efc919..a6d4f4c 100644
--- a/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.legacy.expect
@@ -13,7 +13,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- method f1(covariant core::int x) → void {}
+ method f1(covariant generic-covariant-impl core::int x) → void {}
}
static method g1(dynamic d) → void {
d.f1(1.5);
diff --git a/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.legacy.transformed.expect
index 2efc919..a6d4f4c 100644
--- a/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.legacy.transformed.expect
@@ -13,7 +13,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- method f1(covariant core::int x) → void {}
+ method f1(covariant generic-covariant-impl core::int x) → void {}
}
static method g1(dynamic d) → void {
d.f1(1.5);
diff --git a/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.outline.expect
index 87b6f89..6d8aa4a 100644
--- a/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/dynamic_invocation.dart.outline.expect
@@ -13,7 +13,7 @@
class D extends self::C<core::num> {
synthetic constructor •() → self::D
;
- method f1(covariant core::int x) → void
+ method f1(covariant generic-covariant-impl core::int x) → void
;
}
static method g1(dynamic d) → void
diff --git a/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.hierarchy.expect
index 1153bca..7869c3b 100644
--- a/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.hierarchy.expect
@@ -77,7 +77,7 @@
C.x
interfaceMembers:
Object.toString
- C.x
+ D.C.x%B.x
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
@@ -88,4 +88,4 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
- C.x
+ D.C.x%B.x
diff --git a/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.legacy.expect
index 084024b..4a50297 100644
--- a/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.legacy.expect
@@ -18,5 +18,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
+ forwarding-stub set x(generic-covariant-impl core::num _) → void
+ return super.{self::C::x} = _;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.legacy.transformed.expect
index 084024b..4a50297 100644
--- a/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.legacy.transformed.expect
@@ -18,5 +18,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
+ forwarding-stub set x(generic-covariant-impl core::num _) → void
+ return super.{self::C::x} = _;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.outline.expect
index d696974..8bf7b77 100644
--- a/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/field_forwarding_stub_generic_covariant.dart.outline.expect
@@ -15,6 +15,8 @@
class D extends self::C implements self::B<core::num> {
synthetic constructor •() → self::D
;
+ forwarding-stub set x(generic-covariant-impl core::num _) → void
+ return super.{self::C::x} = _;
}
static method main() → void
;
diff --git a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.hierarchy.expect
index 389c831..8993132 100644
--- a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.hierarchy.expect
@@ -82,7 +82,7 @@
classSetters:
B._x
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
B._x
Object.runtimeType
@@ -91,7 +91,7 @@
Object.noSuchMethod
Object._identityHashCode
Object.hashCode
- B.g
+ C.B.g%I.g
B.check
Object._simpleInstanceOfFalse
Object._simpleInstanceOfTrue
diff --git a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.legacy.expect
index 82a32ab..339d3dc 100644
--- a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.legacy.expect
@@ -30,6 +30,10 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f([generic-covariant-impl core::num x = 10]) → void
+ return super.{self::B::f}(x);
+ forwarding-stub method g({generic-covariant-impl core::num x = 20}) → void
+ return super.{self::B::g}(x: x);
}
static method main() → dynamic {
self::C c = new self::C::•();
diff --git a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.legacy.transformed.expect
index 82a32ab..339d3dc 100644
--- a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.legacy.transformed.expect
@@ -30,6 +30,10 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f([generic-covariant-impl core::num x = 10]) → void
+ return super.{self::B::f}(x);
+ forwarding-stub method g({generic-covariant-impl core::num x = 20}) → void
+ return super.{self::B::g}(x: x);
}
static method main() → dynamic {
self::C c = new self::C::•();
diff --git a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.outline.expect
index 5998e7f..d95ebff 100644
--- a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_default_values.dart.outline.expect
@@ -22,6 +22,10 @@
class C extends self::B implements self::I<core::num> {
synthetic constructor •() → self::C
;
+ forwarding-stub method f([generic-covariant-impl core::num x]) → void
+ return super.{self::B::f}(x);
+ forwarding-stub method g({generic-covariant-impl core::num x}) → void
+ return super.{self::B::g}(x: x);
}
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.hierarchy.expect
index c6a5468..66e9deb 100644
--- a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.hierarchy.expect
@@ -73,7 +73,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
diff --git a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.legacy.expect
index 5486a15..760fd0e 100644
--- a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.legacy.expect
@@ -18,5 +18,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x, core::int y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.legacy.transformed.expect
index 5486a15..760fd0e 100644
--- a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.legacy.transformed.expect
@@ -18,5 +18,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x, core::int y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.outline.expect
index a0b2b04..32a8732 100644
--- a/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/forwarding_stub_with_non_covariant_param.dart.outline.expect
@@ -16,6 +16,8 @@
class C extends self::B implements self::I<core::int> {
synthetic constructor •() → self::C
;
+ forwarding-stub method f(generic-covariant-impl core::int x, core::int y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void
;
diff --git a/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.legacy.expect
index 121a90b..add41b9 100644
--- a/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.legacy.expect
@@ -10,8 +10,8 @@
set x(generic-covariant-impl self::C::T t) → void {}
}
class D extends core::Object implements self::C<core::num> {
- field core::num x = null;
- field core::num y = null;
+ generic-covariant-impl field core::num x = null;
+ generic-covariant-impl field core::num y = null;
synthetic constructor •() → self::D
: super core::Object::•()
;
@@ -20,9 +20,9 @@
synthetic constructor •() → self::E
: super core::Object::•()
;
- set x(core::num t) → void {}
+ set x(generic-covariant-impl core::num t) → void {}
get y() → core::num
return null;
- set y(core::num t) → void {}
+ set y(generic-covariant-impl core::num t) → void {}
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.legacy.transformed.expect
index 121a90b..add41b9 100644
--- a/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.legacy.transformed.expect
@@ -10,8 +10,8 @@
set x(generic-covariant-impl self::C::T t) → void {}
}
class D extends core::Object implements self::C<core::num> {
- field core::num x = null;
- field core::num y = null;
+ generic-covariant-impl field core::num x = null;
+ generic-covariant-impl field core::num y = null;
synthetic constructor •() → self::D
: super core::Object::•()
;
@@ -20,9 +20,9 @@
synthetic constructor •() → self::E
: super core::Object::•()
;
- set x(core::num t) → void {}
+ set x(generic-covariant-impl core::num t) → void {}
get y() → core::num
return null;
- set y(core::num t) → void {}
+ set y(generic-covariant-impl core::num t) → void {}
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.outline.expect
index bf98c8f..53b0ab7 100644
--- a/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/generic_covariance_inheritance_setter_field.dart.outline.expect
@@ -10,19 +10,19 @@
;
}
class D extends core::Object implements self::C<core::num> {
- field core::num x;
- field core::num y;
+ generic-covariant-impl field core::num x;
+ generic-covariant-impl field core::num y;
synthetic constructor •() → self::D
;
}
class E extends core::Object implements self::C<core::num> {
synthetic constructor •() → self::E
;
- set x(core::num t) → void
+ set x(generic-covariant-impl core::num t) → void
;
get y() → core::num
;
- set y(core::num t) → void
+ set y(generic-covariant-impl core::num t) → void
;
}
static method main() → void
diff --git a/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.legacy.expect
index fc559f4..d50d07e 100644
--- a/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.legacy.expect
@@ -9,17 +9,17 @@
abstract set x(covariant core::Object value) → void;
}
class B extends core::Object implements self::A {
- field core::Object x = null;
+ covariant field core::Object x = null;
synthetic constructor •() → self::B
: super core::Object::•()
;
method f(covariant core::Object x) → void {}
}
class C<T extends core::Object = dynamic> extends core::Object implements self::B {
- generic-covariant-impl field self::C::T x = null;
+ covariant generic-covariant-impl field self::C::T x = null;
synthetic constructor •() → self::C<self::C::T>
: super core::Object::•()
;
- method f(generic-covariant-impl self::C::T x) → void {}
+ method f(covariant generic-covariant-impl self::C::T x) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.legacy.transformed.expect
index fc559f4..d50d07e 100644
--- a/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.legacy.transformed.expect
@@ -9,17 +9,17 @@
abstract set x(covariant core::Object value) → void;
}
class B extends core::Object implements self::A {
- field core::Object x = null;
+ covariant field core::Object x = null;
synthetic constructor •() → self::B
: super core::Object::•()
;
method f(covariant core::Object x) → void {}
}
class C<T extends core::Object = dynamic> extends core::Object implements self::B {
- generic-covariant-impl field self::C::T x = null;
+ covariant generic-covariant-impl field self::C::T x = null;
synthetic constructor •() → self::C<self::C::T>
: super core::Object::•()
;
- method f(generic-covariant-impl self::C::T x) → void {}
+ method f(covariant generic-covariant-impl self::C::T x) → void {}
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.outline.expect b/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.outline.expect
index 4ed0cca..037ffa8 100644
--- a/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks/generic_vs_explicit_covariance.dart.outline.expect
@@ -8,17 +8,17 @@
abstract set x(covariant core::Object value) → void;
}
class B extends core::Object implements self::A {
- field core::Object x;
+ covariant field core::Object x;
synthetic constructor •() → self::B
;
method f(covariant core::Object x) → void
;
}
class C<T extends core::Object = dynamic> extends core::Object implements self::B {
- generic-covariant-impl field self::C::T x;
+ covariant generic-covariant-impl field self::C::T x;
synthetic constructor •() → self::C<self::C::T>
;
- method f(generic-covariant-impl self::C::T x) → void
+ method f(covariant generic-covariant-impl self::C::T x) → void
;
}
static method main() → dynamic
diff --git a/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart b/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart
index 4b4ea07..47824ee 100644
--- a/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart
+++ b/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart
@@ -14,7 +14,7 @@
}
class C extends B implements I<num> {
- void /*@forwardingStub=semi-stub*/ f(num x);
+ void f(num x);
}
main() {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.hierarchy.expect
index c844506..0bd7033 100644
--- a/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.hierarchy.expect
@@ -60,7 +60,7 @@
-> B
interfaces: I<num>
classMembers:
- B.f
+ C.B.f%C.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -73,7 +73,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%C.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
diff --git a/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.legacy.expect
index 95fdf8b..5862850 100644
--- a/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.legacy.expect
@@ -18,6 +18,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
- abstract method f(core::num x) → void;
+ forwarding-stub forwarding-semi-stub method f(generic-covariant-impl core::num x) → void
+ return super.{self::B::f}(x);
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.legacy.transformed.expect
index 95fdf8b..5862850 100644
--- a/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.legacy.transformed.expect
@@ -18,6 +18,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
- abstract method f(core::num x) → void;
+ forwarding-stub forwarding-semi-stub method f(generic-covariant-impl core::num x) → void
+ return super.{self::B::f}(x);
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.outline.expect
index 8b7ff11..c8141fe 100644
--- a/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/abstract_override_becomes_forwarding_stub.dart.outline.expect
@@ -16,7 +16,8 @@
class C extends self::B implements self::I<core::num> {
synthetic constructor •() → self::C
;
- abstract method f(core::num x) → void;
+ forwarding-stub forwarding-semi-stub method f(generic-covariant-impl core::num x) → void
+ return super.{self::B::f}(x);
}
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.legacy.expect
index f9eaac1..2a7623e 100644
--- a/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.legacy.expect
@@ -29,7 +29,7 @@
synthetic constructor •() → self::E
: super self::C::•()
;
- method f(covariant core::int x) → void {}
+ method f(covariant generic-covariant-impl core::int x) → void {}
}
static method test() → dynamic {
dynamic x = new self::D::•().g4() as (core::Object) → dynamic;
diff --git a/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.legacy.transformed.expect
index f9eaac1..2a7623e 100644
--- a/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.legacy.transformed.expect
@@ -29,7 +29,7 @@
synthetic constructor •() → self::E
: super self::C::•()
;
- method f(covariant core::int x) → void {}
+ method f(covariant generic-covariant-impl core::int x) → void {}
}
static method test() → dynamic {
dynamic x = new self::D::•().g4() as (core::Object) → dynamic;
diff --git a/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.outline.expect
index 0c9d1ca..1f6aacf 100644
--- a/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/call_through_this.dart.outline.expect
@@ -24,7 +24,7 @@
class E extends self::C<core::num> {
synthetic constructor •() → self::E
;
- method f(covariant core::int x) → void
+ method f(covariant generic-covariant-impl core::int x) → void
;
}
static method test() → dynamic
diff --git a/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.hierarchy.expect
index d6381e8..54bc8ea 100644
--- a/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.hierarchy.expect
@@ -77,7 +77,7 @@
C.x
interfaceMembers:
Object.toString
- C.x
+ D.C.x%B.x
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
@@ -88,4 +88,328 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
- C.x
+ D.C.x%B.x
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.legacy.expect
index 3f2338c..eea0f36 100644
--- a/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.legacy.expect
@@ -18,5 +18,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
+ forwarding-stub set x(covariant core::num _) → void
+ return super.{self::C::x} = _;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.legacy.transformed.expect
index 3f2338c..eea0f36 100644
--- a/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.legacy.transformed.expect
@@ -18,5 +18,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
+ forwarding-stub set x(covariant core::num _) → void
+ return super.{self::C::x} = _;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.outline.expect
index 64163de..d8da134 100644
--- a/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/field_forwarding_stub_explicit_covariant.dart.outline.expect
@@ -15,6 +15,8 @@
class D extends self::C implements self::B {
synthetic constructor •() → self::D
;
+ forwarding-stub set x(covariant core::num _) → void
+ return super.{self::C::x} = _;
}
static method main() → void
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.legacy.expect
index a959413..f6be89d 100644
--- a/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.legacy.expect
@@ -10,19 +10,19 @@
;
}
abstract class C<T extends core::Object = dynamic> extends core::Object implements self::B<core::num> {
- field dynamic x = null;
+ generic-covariant-impl field core::num x = null;
synthetic constructor •() → self::C<self::C::T>
: super core::Object::•()
;
- abstract get y() → dynamic;
- abstract set y(dynamic value) → dynamic;
+ abstract get y() → core::num;
+ abstract set y(generic-covariant-impl core::num value) → void;
}
abstract class D<T extends core::Object = dynamic> extends core::Object implements self::B<self::D::T> {
- field dynamic x = null;
+ generic-covariant-impl field self::D::T x = null;
synthetic constructor •() → self::D<self::D::T>
: super core::Object::•()
;
- abstract get y() → dynamic;
- abstract set y(dynamic value) → dynamic;
+ abstract get y() → self::D::T;
+ abstract set y(generic-covariant-impl self::D::T value) → void;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.legacy.transformed.expect
index a959413..f6be89d 100644
--- a/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.legacy.transformed.expect
@@ -10,19 +10,19 @@
;
}
abstract class C<T extends core::Object = dynamic> extends core::Object implements self::B<core::num> {
- field dynamic x = null;
+ generic-covariant-impl field core::num x = null;
synthetic constructor •() → self::C<self::C::T>
: super core::Object::•()
;
- abstract get y() → dynamic;
- abstract set y(dynamic value) → dynamic;
+ abstract get y() → core::num;
+ abstract set y(generic-covariant-impl core::num value) → void;
}
abstract class D<T extends core::Object = dynamic> extends core::Object implements self::B<self::D::T> {
- field dynamic x = null;
+ generic-covariant-impl field self::D::T x = null;
synthetic constructor •() → self::D<self::D::T>
: super core::Object::•()
;
- abstract get y() → dynamic;
- abstract set y(dynamic value) → dynamic;
+ abstract get y() → self::D::T;
+ abstract set y(generic-covariant-impl self::D::T value) → void;
}
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.outline.expect
index 60525b9..2696bf4 100644
--- a/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/generic_covariance_based_on_inference.dart.outline.expect
@@ -9,18 +9,18 @@
;
}
abstract class C<T extends core::Object = dynamic> extends core::Object implements self::B<core::num> {
- field dynamic x;
+ generic-covariant-impl field core::num x;
synthetic constructor •() → self::C<self::C::T>
;
- abstract get y() → dynamic;
- abstract set y(dynamic value) → dynamic;
+ abstract get y() → core::num;
+ abstract set y(generic-covariant-impl core::num value) → void;
}
abstract class D<T extends core::Object = dynamic> extends core::Object implements self::B<self::D::T> {
- field dynamic x;
+ generic-covariant-impl field self::D::T x;
synthetic constructor •() → self::D<self::D::T>
;
- abstract get y() → dynamic;
- abstract set y(dynamic value) → dynamic;
+ abstract get y() → self::D::T;
+ abstract set y(generic-covariant-impl self::D::T value) → void;
}
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_field.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_field.dart.hierarchy.expect
index 94c8b5c..df047dc 100644
--- a/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_field.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_field.dart.hierarchy.expect
@@ -103,9 +103,9 @@
M.y
M.x
interfaceMembers:
- M.y
+ C.M.y%I.y
Object.toString
- M.x
+ C.M.x%I.x
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
@@ -116,5 +116,329 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
- M.y
- M.x
+ C.M.y%I.y
+ C.M.x%I.x
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_field.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_field.dart.outline.expect
index 4978034..b99aea3 100644
--- a/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_field.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_field.dart.outline.expect
@@ -32,6 +32,10 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub set y(covariant core::Object value) → void
+ return super.{self::B::y} = value;
+ forwarding-stub set x(generic-covariant-impl core::int _) → void
+ return super.{self::B::x} = _;
}
static method expectTypeError(() → void callback) → void
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_getter.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_getter.dart.hierarchy.expect
index dc66ff9..6fc8543 100644
--- a/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_getter.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_getter.dart.hierarchy.expect
@@ -99,7 +99,7 @@
interfaceMembers:
M.f
Object.toString
- M.x
+ C.M.x%I.x
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
@@ -136,7 +136,7 @@
interfaceMembers:
D.f
Object.toString
- M.x
+ D.M.x%I.x
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
diff --git a/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_setter.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_setter.dart.hierarchy.expect
index 94c8b5c..df047dc 100644
--- a/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_setter.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_setter.dart.hierarchy.expect
@@ -103,9 +103,9 @@
M.y
M.x
interfaceMembers:
- M.y
+ C.M.y%I.y
Object.toString
- M.x
+ C.M.x%I.x
Object.runtimeType
Object._simpleInstanceOf
Object._instanceOf
@@ -116,5 +116,329 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
- M.y
- M.x
+ C.M.y%I.y
+ C.M.x%I.x
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_setter.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_setter.dart.outline.expect
index 4b6371a..782ccf3 100644
--- a/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/mixin_forwarding_stub_setter.dart.outline.expect
@@ -38,6 +38,10 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub set y(covariant core::Object value) → void
+ return super.{self::B::y} = value;
+ forwarding-stub set x(generic-covariant-impl core::int value) → void
+ return super.{self::B::x} = value;
}
static method expectTypeError(() → void callback) → void
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_checked_via_target.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_checked_via_target.dart.hierarchy.expect
index 5459bc4..dbd4f79 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_checked_via_target.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_checked_via_target.dart.hierarchy.expect
@@ -73,7 +73,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -85,3 +85,327 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_checked_via_target.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/stub_checked_via_target.dart.outline.expect
index 4e4266a..91a76ee 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_checked_via_target.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_checked_via_target.dart.outline.expect
@@ -16,6 +16,8 @@
class C extends self::B implements self::I {
synthetic constructor •() → self::C
;
+ forwarding-stub method f(covariant core::Object x) → core::int
+ return super.{self::B::f}(x);
}
static method expectTypeError(() → void callback) → void
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.hierarchy.expect
index 6f7dc10..31fe103 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.hierarchy.expect
@@ -73,7 +73,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -85,3 +85,327 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.legacy.expect
index 7d32948..c8ec998 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.legacy.expect
@@ -19,5 +19,6 @@
synthetic constructor •() → self::C<self::C::T>
: super self::B::•()
;
+ abstract forwarding-stub method f(core::Object x) → (self::C::T) → void;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.legacy.transformed.expect
index 7d32948..c8ec998 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.legacy.transformed.expect
@@ -19,5 +19,6 @@
synthetic constructor •() → self::C<self::C::T>
: super self::B::•()
;
+ abstract forwarding-stub method f(core::Object x) → (self::C::T) → void;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.outline.expect
index 6b7705e..6cc2fc3 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_contravariant_from_class.dart.outline.expect
@@ -17,6 +17,7 @@
abstract class C<T extends core::Object = dynamic> extends self::B<(self::C::T) → void> implements self::I<(self::C::T) → void> {
synthetic constructor •() → self::C<self::C::T>
;
+ abstract forwarding-stub method f(core::Object x) → (self::C::T) → void;
}
static method main() → void
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.hierarchy.expect
index 6f7dc10..31fe103 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.hierarchy.expect
@@ -73,7 +73,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -85,3 +85,327 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.legacy.expect
index 5e95811..14a514f 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.legacy.expect
@@ -19,5 +19,7 @@
synthetic constructor •() → self::C<self::C::T>
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl ((self::C::T) → void) → void x, core::Object y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.legacy.transformed.expect
index 5e95811..14a514f 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.legacy.transformed.expect
@@ -19,5 +19,7 @@
synthetic constructor •() → self::C<self::C::T>
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl ((self::C::T) → void) → void x, core::Object y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.outline.expect
index 5526106..58d9b8f 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_class.dart.outline.expect
@@ -17,6 +17,8 @@
abstract class C<T extends core::Object = dynamic> extends self::B<(self::C::T) → void> implements self::I<(self::C::T) → void> {
synthetic constructor •() → self::C<self::C::T>
;
+ forwarding-stub method f(generic-covariant-impl ((self::C::T) → void) → void x, core::Object y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.hierarchy.expect
index c6a5468..f7b0451 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.hierarchy.expect
@@ -73,7 +73,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -85,3 +85,327 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.legacy.expect
index 3334045..082a15f 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.legacy.expect
@@ -18,5 +18,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x, core::Object y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.legacy.transformed.expect
index 3334045..082a15f 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.legacy.transformed.expect
@@ -18,5 +18,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(generic-covariant-impl core::int x, core::Object y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.outline.expect
index 205776d..5890db1 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_interface.dart.outline.expect
@@ -16,6 +16,8 @@
abstract class C extends self::B implements self::I<core::int> {
synthetic constructor •() → self::C
;
+ forwarding-stub method f(generic-covariant-impl core::int x, core::Object y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.hierarchy.expect
index 2defd9d..578a89f 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.hierarchy.expect
@@ -73,7 +73,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -85,3 +85,327 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.legacy.expect
index 3038f0e..04bbcf3 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.legacy.expect
@@ -18,5 +18,6 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ abstract forwarding-stub method f(generic-covariant-impl core::int x, core::Object y) → void;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.legacy.transformed.expect
index 3038f0e..04bbcf3 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.legacy.transformed.expect
@@ -18,5 +18,6 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ abstract forwarding-stub method f(generic-covariant-impl core::int x, core::Object y) → void;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.outline.expect
index 9e7de41..5c37f4b 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantImpl_from_super.dart.outline.expect
@@ -16,6 +16,7 @@
abstract class C extends self::B<core::int> implements self::I {
synthetic constructor •() → self::C
;
+ abstract forwarding-stub method f(generic-covariant-impl core::int x, core::Object y) → void;
}
static method main() → void
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.hierarchy.expect
index dfb9fc6..848ffc1 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.hierarchy.expect
@@ -120,7 +120,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -132,3 +132,327 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.legacy.expect
index df1249c..fd2002b 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.legacy.expect
@@ -13,17 +13,18 @@
synthetic constructor •() → self::B<self::B::T>
: super core::Object::•()
;
- method f((self::B::T) → void x, core::int y) → void {}
+ method f(generic-covariant-impl (self::B::T) → void x, core::int y) → void {}
}
abstract class I<T extends core::Object = dynamic> extends core::Object implements self::A<(self::I::T) → void> {
synthetic constructor •() → self::I<self::I::T>
: super core::Object::•()
;
- abstract method f((self::I::T) → void x, core::Object y) → void;
+ abstract method f(generic-covariant-impl (self::I::T) → void x, core::Object y) → void;
}
abstract class C<T extends core::Object = dynamic> extends self::B<(self::C::T) → void> implements self::I<(self::C::T) → void> {
synthetic constructor •() → self::C<self::C::T>
: super self::B::•()
;
+ abstract forwarding-stub method f(generic-covariant-impl ((self::C::T) → void) → void x, core::Object y) → void;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.legacy.transformed.expect
index df1249c..fd2002b 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.legacy.transformed.expect
@@ -13,17 +13,18 @@
synthetic constructor •() → self::B<self::B::T>
: super core::Object::•()
;
- method f((self::B::T) → void x, core::int y) → void {}
+ method f(generic-covariant-impl (self::B::T) → void x, core::int y) → void {}
}
abstract class I<T extends core::Object = dynamic> extends core::Object implements self::A<(self::I::T) → void> {
synthetic constructor •() → self::I<self::I::T>
: super core::Object::•()
;
- abstract method f((self::I::T) → void x, core::Object y) → void;
+ abstract method f(generic-covariant-impl (self::I::T) → void x, core::Object y) → void;
}
abstract class C<T extends core::Object = dynamic> extends self::B<(self::C::T) → void> implements self::I<(self::C::T) → void> {
synthetic constructor •() → self::C<self::C::T>
: super self::B::•()
;
+ abstract forwarding-stub method f(generic-covariant-impl ((self::C::T) → void) → void x, core::Object y) → void;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.outline.expect
index c638537..dcf62eb 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariantInterface_from_class.dart.outline.expect
@@ -11,17 +11,18 @@
class B<T extends core::Object = dynamic> extends core::Object implements self::A<(self::B::T) → void> {
synthetic constructor •() → self::B<self::B::T>
;
- method f((self::B::T) → void x, core::int y) → void
+ method f(generic-covariant-impl (self::B::T) → void x, core::int y) → void
;
}
abstract class I<T extends core::Object = dynamic> extends core::Object implements self::A<(self::I::T) → void> {
synthetic constructor •() → self::I<self::I::T>
;
- abstract method f((self::I::T) → void x, core::Object y) → void;
+ abstract method f(generic-covariant-impl (self::I::T) → void x, core::Object y) → void;
}
abstract class C<T extends core::Object = dynamic> extends self::B<(self::C::T) → void> implements self::I<(self::C::T) → void> {
synthetic constructor •() → self::C<self::C::T>
;
+ abstract forwarding-stub method f(generic-covariant-impl ((self::C::T) → void) → void x, core::Object y) → void;
}
static method main() → void
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.hierarchy.expect
index 5459bc4..dbd4f79 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.hierarchy.expect
@@ -73,7 +73,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -85,3 +85,327 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.legacy.expect
index 22a66005..ed5aa28 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.legacy.expect
@@ -18,5 +18,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(covariant core::int x, core::Object y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.legacy.transformed.expect
index 22a66005..ed5aa28 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.legacy.transformed.expect
@@ -18,5 +18,7 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ forwarding-stub method f(covariant core::int x, core::Object y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.outline.expect
index 91a90a9..ac22acd 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_interface.dart.outline.expect
@@ -16,6 +16,8 @@
abstract class C extends self::B implements self::I {
synthetic constructor •() → self::C
;
+ forwarding-stub method f(covariant core::int x, core::Object y) → void
+ return super.{self::B::f}(x, y);
}
static method main() → void
;
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.hierarchy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.hierarchy.expect
index 5459bc4..dbd4f79 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.hierarchy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.hierarchy.expect
@@ -73,7 +73,7 @@
Object.==
classSetters:
interfaceMembers:
- B.f
+ C.B.f%I.f
Object.toString
Object.runtimeType
Object._simpleInstanceOf
@@ -85,3 +85,327 @@
Object._simpleInstanceOfTrue
Object.==
interfaceSetters:
+
+Comparable:
+ superclasses:
+ Object
+ interfaces:
+ classMembers:
+ Object.toString
+ Object.runtimeType
+ Object._simpleInstanceOf
+ Object._instanceOf
+ Object.noSuchMethod
+ Object._identityHashCode
+ Comparable.compareTo
+ Object.hashCode
+ Object._simpleInstanceOfFalse
+ Object._simpleInstanceOfTrue
+ Object.==
+ Comparable.compare
+ classSetters:
+
+num:
+ Longest path to Object: 2
+ superclasses:
+ Object
+ interfaces: Comparable<num>
+ classMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ classSetters:
+ interfaceMembers:
+ num.~/
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ num._returnDoubleNull
+ num.Object.toString%num.toString
+ num._returnIntNull
+ num.+
+ num.clamp
+ num.toDouble
+ num.ceil
+ num.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ num.toStringAsExponential
+ num./
+ num.abs
+ num._moduloFromInteger
+ num._subFromInteger
+ num._addFromInteger
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ num.sign
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ num.floorToDouble
+ Object._identityHashCode
+ num.>
+ num.roundToDouble
+ num.round
+ num.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ num.truncate
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ num.ceilToDouble
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ num.truncateToDouble
+ num.parse
+ num.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ num.*
+ interfaceSetters:
+
+int:
+ Longest path to Object: 3
+ superclasses:
+ Object
+ -> num
+ interfaces: Comparable<num>
+ classMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ classSetters:
+ interfaceMembers:
+ int._minInt64
+ num.~/
+ int.toSigned
+ int._shrFromInteger
+ int._throwFormatException
+ int._parseBlock
+ num.<=
+ num._equalToInteger
+ num.isInfinite
+ num.<
+ int._int64OverflowLimits
+ int._parseRadix
+ int.Object.toString%int.toString
+ int._PARSE_LIMITS
+ int._kNull
+ num.+
+ num.clamp
+ num.toDouble
+ int.ceil
+ int.unary-
+ num._mulFromInteger
+ num.>=
+ Object.runtimeType
+ Object._simpleInstanceOf
+ num.isNegative
+ num.isNaN
+ int._initInt64OverflowLimits
+ int.isEven
+ num.toStringAsExponential
+ num./
+ int.abs
+ int._bitAndFromSmi
+ int.|
+ num._moduloFromInteger
+ int.gcd
+ int._int64UnsignedOverflowLimits
+ int.<<
+ num._subFromInteger
+ num._addFromInteger
+ int.toUnsigned
+ int.toRadixString
+ int._int64UnsignedSmiOverflowLimits
+ Object._instanceOf
+ num.remainder
+ num.isFinite
+ num.toInt
+ num.%
+ int._tryParseSmi
+ int.sign
+ int.>>
+ Object.noSuchMethod
+ num.toStringAsPrecision
+ int.modInverse
+ int.floorToDouble
+ Object._identityHashCode
+ num.>
+ int.roundToDouble
+ int.round
+ int._maxInt64
+ int.floor
+ num.compareTo
+ num.Object.hashCode%num.hashCode
+ num._truncDivFromInteger
+ int.truncate
+ int.^
+ int._shlFromInteger
+ int.&
+ num.-
+ Object._simpleInstanceOfFalse
+ num._greaterThanFromInteger
+ int.bitLength
+ int.ceilToDouble
+ int.modPow
+ int.isOdd
+ int._bitAndFromInteger
+ Object._simpleInstanceOfTrue
+ num.Object.==%num.==
+ int._bitOrFromInteger
+ int.truncateToDouble
+ int._bitXorFromInteger
+ int.parse
+ int.tryParse
+ num.toStringAsFixed
+ num._remainderFromInteger
+ int._parse
+ num.*
+ int.~
+ interfaceSetters:
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.legacy.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.legacy.expect
index cf870cc..1ce982c 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.legacy.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.legacy.expect
@@ -18,5 +18,6 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ abstract forwarding-stub method f(covariant core::int x, core::Object y) → void;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.legacy.transformed.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.legacy.transformed.expect
index cf870cc..1ce982c 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.legacy.transformed.expect
@@ -18,5 +18,6 @@
synthetic constructor •() → self::C
: super self::B::•()
;
+ abstract forwarding-stub method f(covariant core::int x, core::Object y) → void;
}
static method main() → void {}
diff --git a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.outline.expect b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.outline.expect
index d4b0825..9c7aa8f 100644
--- a/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.outline.expect
+++ b/pkg/front_end/testcases/runtime_checks_new/stub_from_interface_covariant_from_super.dart.outline.expect
@@ -16,6 +16,7 @@
abstract class C extends self::B implements self::I {
synthetic constructor •() → self::C
;
+ abstract forwarding-stub method f(covariant core::int x, core::Object y) → void;
}
static method main() → void
;
diff --git a/pkg/front_end/testcases/static_setter.dart.legacy.expect b/pkg/front_end/testcases/static_setter.dart.legacy.expect
index 05125e5..055ed11 100644
--- a/pkg/front_end/testcases/static_setter.dart.legacy.expect
+++ b/pkg/front_end/testcases/static_setter.dart.legacy.expect
@@ -7,7 +7,7 @@
: super core::Object::•()
;
}
-static set foo(dynamic x) → dynamic {}
+static set foo(dynamic x) → void {}
static method main() → dynamic {
self::foo = new self::Foo::•();
}
diff --git a/pkg/front_end/testcases/static_setter.dart.legacy.transformed.expect b/pkg/front_end/testcases/static_setter.dart.legacy.transformed.expect
index 05125e5..055ed11 100644
--- a/pkg/front_end/testcases/static_setter.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/static_setter.dart.legacy.transformed.expect
@@ -7,7 +7,7 @@
: super core::Object::•()
;
}
-static set foo(dynamic x) → dynamic {}
+static set foo(dynamic x) → void {}
static method main() → dynamic {
self::foo = new self::Foo::•();
}
diff --git a/pkg/front_end/testcases/static_setter.dart.outline.expect b/pkg/front_end/testcases/static_setter.dart.outline.expect
index 13eaefe..0c46d4c 100644
--- a/pkg/front_end/testcases/static_setter.dart.outline.expect
+++ b/pkg/front_end/testcases/static_setter.dart.outline.expect
@@ -6,7 +6,7 @@
synthetic constructor •() → self::Foo
;
}
-static set foo(dynamic x) → dynamic
+static set foo(dynamic x) → void
;
static method main() → dynamic
;
diff --git a/pkg/front_end/testcases/strong.status b/pkg/front_end/testcases/strong.status
index 7513191..450ac12 100644
--- a/pkg/front_end/testcases/strong.status
+++ b/pkg/front_end/testcases/strong.status
@@ -24,11 +24,13 @@
expressions: RuntimeError
external_import: RuntimeError # The native extension to import doesn't exist. This is ok.
fallthrough: ExpectationFileMismatch
+ignore_function: TypeCheckError
incomplete_field_formal_parameter: RuntimeError
inference/abstract_class_instantiation: InstrumentationMismatch # Issue #30040
+inference/conflicting_fields: ExpectationFileMismatch # Dynamic doesn't register as type inference.
inference/conflicting_fields: TypeCheckError
-inference/conflicts_can_happen: TypeCheckError
inference/conflicts_can_happen2: TypeCheckError
+inference/conflicts_can_happen: TypeCheckError
inference/constructors_infer_from_arguments_argument_not_assignable: TypeCheckError
inference/constructors_too_many_positional_arguments: InstrumentationMismatch # Issue #30040
inference/do_not_infer_overridden_fields_that_explicitly_say_dynamic_infer: TypeCheckError
@@ -43,9 +45,10 @@
inference/generic_methods_do_not_infer_invalid_override_of_generic_method: TypeCheckError
inference/generic_methods_handle_override_of_non_generic_with_generic: TypeCheckError
inference/generic_methods_infer_js_builtin: InstrumentationMismatch # Issue #30029
+inference/inconsistent_overrides: TypeCheckError
inference/infer_field_override_multiple: TypeCheckError
inference/infer_from_complex_expressions_if_outer_most_value_is_precise: TypeCheckError # Issue #35630
-inference/infer_method_missing_params: TypeCheckError
+inference/infer_method_missing_params: ExpectationFileMismatch # Not supposed to be able to infer types if supertypes disagree on number of parameters. An error may be missing as C.f and B.f are not compatible at all.
inference/infer_type_regardless_of_declaration_order_or_cycles: RuntimeError
inference/infer_types_on_generic_instantiations_4: RuntimeError
inference/infer_types_on_generic_instantiations_infer: TypeCheckError
@@ -65,16 +68,16 @@
inference_new/infer_assign_to_index_upwards: TypeCheckError
inference_new/infer_assign_to_property_custom: TypeCheckError
inference_new/infer_field_getter_setter_mismatch: TypeCheckError
+inference_new/infer_field_override_accessors: TypeCheckError
inference_new/infer_field_override_getter_overrides_setter: TypeCheckError
inference_new/invalid_assignment_during_toplevel_inference: TypeCheckError
-inference_new/strongly_connected_component: TypeCheckError
instantiate_to_bound/non_simple_class_parametrized_typedef_cycle: RuntimeError # Expected
instantiate_to_bound/non_simple_generic_function_in_bound_regress: RuntimeError # Expected
invalid_type: TypeCheckError
invocations: RuntimeError
issue34899: TypeCheckError
micro: RuntimeError
-mixin_application_override: TypeCheckError
+mixin_application_override: ExpectationFileMismatch # Too many errors.
optional: TypeCheckError
override_check_accessor_after_inference: TypeCheckError # Issue #31620
override_check_accessor_basic: TypeCheckError # Issue #31620
diff --git a/pkg/front_end/testcases/super_nsm.dart.legacy.expect b/pkg/front_end/testcases/super_nsm.dart.legacy.expect
index a0c7a8c..eb7ebeb 100644
--- a/pkg/front_end/testcases/super_nsm.dart.legacy.expect
+++ b/pkg/front_end/testcases/super_nsm.dart.legacy.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
return "C";
no-such-method-forwarder method interfaceMethod() → dynamic
return this.{self::C::noSuchMethod}(new core::_InvocationMirror::_withType(#interfaceMethod, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} dynamic;
@@ -21,7 +21,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
return "D";
method dMethod() → dynamic
return super.{self::C::interfaceMethod}();
diff --git a/pkg/front_end/testcases/super_nsm.dart.legacy.transformed.expect b/pkg/front_end/testcases/super_nsm.dart.legacy.transformed.expect
index a0c7a8c..eb7ebeb 100644
--- a/pkg/front_end/testcases/super_nsm.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/super_nsm.dart.legacy.transformed.expect
@@ -12,7 +12,7 @@
synthetic constructor •() → self::C
: super core::Object::•()
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
return "C";
no-such-method-forwarder method interfaceMethod() → dynamic
return this.{self::C::noSuchMethod}(new core::_InvocationMirror::_withType(#interfaceMethod, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} dynamic;
@@ -21,7 +21,7 @@
synthetic constructor •() → self::D
: super self::C::•()
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
return "D";
method dMethod() → dynamic
return super.{self::C::interfaceMethod}();
diff --git a/pkg/front_end/testcases/super_nsm.dart.outline.expect b/pkg/front_end/testcases/super_nsm.dart.outline.expect
index de7c531..6ec8595 100644
--- a/pkg/front_end/testcases/super_nsm.dart.outline.expect
+++ b/pkg/front_end/testcases/super_nsm.dart.outline.expect
@@ -10,7 +10,7 @@
class C extends core::Object implements self::I {
synthetic constructor •() → self::C
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
;
no-such-method-forwarder method interfaceMethod() → dynamic
return this.{self::C::noSuchMethod}(new core::_InvocationMirror::_withType(#interfaceMethod, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} dynamic;
@@ -18,7 +18,7 @@
class D extends self::C {
synthetic constructor •() → self::D
;
- method noSuchMethod(dynamic _) → dynamic
+ method noSuchMethod(core::Invocation _) → dynamic
;
method dMethod() → dynamic
;
diff --git a/pkg/front_end/testcases/text_serialization.status b/pkg/front_end/testcases/text_serialization.status
index 39e7a5b..d5bf761 100644
--- a/pkg/front_end/testcases/text_serialization.status
+++ b/pkg/front_end/testcases/text_serialization.status
@@ -102,6 +102,7 @@
functions: TextSerializationFailure # Was: Pass
future_or_test: TextSerializationFailure # Was: Pass
hello: TextSerializationFailure # Was: Pass
+ignore_function: TypeCheckError
illegal_named_function_expression: TextSerializationFailure # Was: Pass
illegal_named_function_expression_scope: TextSerializationFailure # Was: Pass
implicit_const_with_static_fields: TextSerializationFailure # Was: Pass
@@ -158,6 +159,7 @@
inference/complex_predecrement: TextSerializationFailure # Was: Pass
inference/conditional_lub: TextSerializationFailure # Was: Pass
inference/conditional_upwards_inference: TextSerializationFailure # Was: Pass
+inference/conflicting_fields: ExpectationFileMismatch
inference/conflicting_fields: TypeCheckError
inference/conflicts_can_happen2: TypeCheckError
inference/conflicts_can_happen: TypeCheckError
@@ -273,6 +275,7 @@
inference/generic_methods_nested_generic_instantiation: TextSerializationFailure # Was: Pass
inference/generic_methods_uses_greatest_lower_bound: TextSerializationFailure # Was: Pass
inference/greatest_closure_multiple_params: TextSerializationFailure # Was: Pass
+inference/inconsistent_overrides: TypeCheckError
inference/index_assign_operator_return_type: TextSerializationFailure # Was: Pass
inference/index_assign_operator_return_type_2: TextSerializationFailure # Was: Pass
inference/infer_accessor_from_later_inferred_field: TextSerializationFailure # Was: Pass
@@ -336,6 +339,7 @@
inference/infer_local_function_referenced_before_declaration: TextSerializationFailure # Was: Pass
inference/infer_local_function_return_type: TextSerializationFailure # Was: Pass
inference/infer_method_function_typed: TextSerializationFailure # Was: Pass
+inference/infer_method_missing_params: ExpectationFileMismatch
inference/infer_method_missing_params: TypeCheckError
inference/infer_parameter_type_setter_from_field: TextSerializationFailure # Was: Pass
inference/infer_parameter_type_setter_from_setter: TextSerializationFailure # Was: Pass
@@ -582,6 +586,7 @@
inference_new/infer_assign_to_static: TextSerializationFailure # Was: Pass
inference_new/infer_assign_to_static_upwards: TextSerializationFailure # Was: Pass
inference_new/infer_field_getter_setter_mismatch: TypeCheckError
+inference_new/infer_field_override_accessors: TypeCheckError
inference_new/infer_field_override_getter_overrides_setter: TypeCheckError
inference_new/infer_field_override_setter_overrides_getter: TextSerializationFailure # Was: Pass
inference_new/infer_instance_accessor_ref: TextSerializationFailure # Was: Pass
@@ -601,6 +606,7 @@
inference_new/super_index_get: TextSerializationFailure # Was: Pass
inference_new/super_index_get_substitution: TextSerializationFailure # Was: Pass
inference_new/switch: TextSerializationFailure # Was: Pass
+inference_new/top_level_field_depends_on_multiple_inheritance: ExpectationFileMismatch
inference_new/top_level_field_depends_on_multiple_inheritance: TextSerializationFailure # Was: Pass
inference_new/unsafe_block_closure_inference_function_call_explicit_dynamic_param_via_expr2: TextSerializationFailure # Was: Pass
inference_new/unsafe_block_closure_inference_function_call_explicit_type_param_via_expr2: TextSerializationFailure # Was: Pass
@@ -686,6 +692,7 @@
minimum_int: TextSerializationFailure # Was: Pass
missing_constructor: TextSerializationFailure # Was: Pass
mixin: TextSerializationFailure # Was: Pass
+mixin_application_override: ExpectationFileMismatch
mixin_application_override: TypeCheckError
mixin_conflicts: TextSerializationFailure
mixin_constructors_with_default_values: TextSerializationFailure # Was: Pass
@@ -949,6 +956,7 @@
runtime_checks/dynamic_invocation: TextSerializationFailure # Was: Pass
runtime_checks/dynamic_invocation_generic: TextSerializationFailure # Was: Pass
runtime_checks/dynamic_invocation_of_getter: TextSerializationFailure # Was: Pass
+runtime_checks/field_forwarding_stub_generic_covariant: ExpectationFileMismatch
runtime_checks/field_forwarding_stub_generic_covariant: TextSerializationFailure # Was: Pass
runtime_checks/forwarding_stub_with_default_values: TextSerializationFailure # Was: Pass
runtime_checks/forwarding_stub_with_non_covariant_param: TextSerializationFailure # Was: Pass
@@ -962,6 +970,7 @@
runtime_checks/implicit_downcast_if: TextSerializationFailure # Was: Pass
runtime_checks/implicit_downcast_not: TextSerializationFailure # Was: Pass
runtime_checks/implicit_downcast_while: TextSerializationFailure # Was: Pass
+runtime_checks_new/abstract_override_becomes_forwarding_stub: ExpectationFileMismatch
runtime_checks_new/abstract_override_becomes_forwarding_stub: TextSerializationFailure # Was: Pass
runtime_checks_new/call_through_this: TextSerializationFailure # Was: Pass
runtime_checks_new/contravariant_combiner: TextSerializationFailure # Was: Pass
@@ -971,12 +980,15 @@
runtime_checks_new/contravariant_index_get: TextSerializationFailure # Was: Pass
runtime_checks_new/derived_class_typed: TextSerializationFailure # Was: Pass
runtime_checks_new/field_forwarding_stub_abstract_generic_covariant: TextSerializationFailure # Was: Pass
+runtime_checks_new/field_forwarding_stub_explicit_covariant: ExpectationFileMismatch
runtime_checks_new/field_forwarding_stub_explicit_covariant: TextSerializationFailure # Was: Pass
runtime_checks_new/for_in_call_kinds: TextSerializationFailure # Was: Pass
runtime_checks_new/generic_covariance_based_on_inference: TextSerializationFailure # Was: Pass
runtime_checks_new/implicit_downcast_field: TextSerializationFailure # Was: Pass
+runtime_checks_new/mixin_forwarding_stub_field: ExpectationFileMismatch
runtime_checks_new/mixin_forwarding_stub_field: TypeCheckError
runtime_checks_new/mixin_forwarding_stub_getter: TypeCheckError
+runtime_checks_new/mixin_forwarding_stub_setter: ExpectationFileMismatch
runtime_checks_new/mixin_forwarding_stub_setter: TypeCheckError
runtime_checks_new/stub_checked_via_target: TextSerializationFailure # Was: Pass
runtime_checks_new/stub_from_interface_contravariant_from_class: TextSerializationFailure # Was: Pass
diff --git a/pkg/front_end/testcases/void_methods.dart.outline.expect b/pkg/front_end/testcases/void_methods.dart.outline.expect
index b73833b..881f4a6 100644
--- a/pkg/front_end/testcases/void_methods.dart.outline.expect
+++ b/pkg/front_end/testcases/void_methods.dart.outline.expect
@@ -6,9 +6,9 @@
field core::List<dynamic> list;
synthetic constructor •() → self::Foo
;
- set first(dynamic x) → dynamic
+ set first(dynamic x) → void
;
- operator []=(dynamic x, dynamic y) → dynamic
+ operator []=(dynamic x, dynamic y) → void
;
method clear() → void
;
diff --git a/pkg/kernel/lib/class_hierarchy.dart b/pkg/kernel/lib/class_hierarchy.dart
index 51f0730..a63f164 100644
--- a/pkg/kernel/lib/class_hierarchy.dart
+++ b/pkg/kernel/lib/class_hierarchy.dart
@@ -247,14 +247,14 @@
/// Compares members by name, using the same sort order as
/// [getDeclaredMembers] and [getInterfaceMembers].
static int compareMembers(Member first, Member second) {
- return _compareNames(first.name, second.name);
+ return compareNames(first.name, second.name);
}
/// Compares names, using the same sort order as [getDeclaredMembers] and
/// [getInterfaceMembers].
///
/// This is an arbitrary as-fast-as-possible sorting criterion.
- static int _compareNames(Name firstName, Name secondName) {
+ static int compareNames(Name firstName, Name secondName) {
int firstHash = firstName.hashCode;
int secondHash = secondName.hashCode;
if (firstHash != secondHash) return firstHash - secondHash;
@@ -291,7 +291,7 @@
while (low <= high) {
int mid = low + ((high - low) >> 1);
Member pivot = members[mid];
- int comparison = _compareNames(name, pivot.name);
+ int comparison = compareNames(name, pivot.name);
if (comparison < 0) {
high = mid - 1;
} else if (comparison > 0) {
diff --git a/tests/language_2/language_2_kernel.status b/tests/language_2/language_2_kernel.status
index f3b7552..563e5ad 100644
--- a/tests/language_2/language_2_kernel.status
+++ b/tests/language_2/language_2_kernel.status
@@ -67,8 +67,6 @@
generic_no_such_method_dispatcher_test: CompileTimeError
generic_tearoff_test: CompileTimeError
instantiate_tearoff_of_call_test: CompileTimeError
-issue31596_super_test/01: CompileTimeError
-issue31596_super_test/03: CompileTimeError
issue31596_super_test/05: RuntimeError
least_upper_bound_expansive_test/none: CompileTimeError
library_env_test/has_html_support: RuntimeError
@@ -258,7 +256,6 @@
implicit_creation/implicit_const_not_default_values_test/e5: MissingCompileTimeError
implicit_creation/implicit_const_not_default_values_test/e7: MissingCompileTimeError
implicit_creation/implicit_const_not_default_values_test/e8: MissingCompileTimeError
-mixin_method_override_test/G4: Crash # Assertion error: mixin_full_resolution.dart': 'src.typeParameters.length == dst.typeParameters.length': is not true.
spread_collections/await_test: Crash
spread_collections/const_error_test/02: MissingCompileTimeError
spread_collections/const_error_test/03: MissingCompileTimeError
@@ -291,22 +288,16 @@
deferred_inheritance_constraints_test/mixin: MissingCompileTimeError # Fasta/KernelVM bug: Deferred loading kernel issue 30273.
f_bounded_quantification2_test: CompileTimeError # Issue 34583
f_bounded_quantification4_test: CompileTimeError # Issue 34583
+issue31596_super_test/01: CompileTimeError
issue31596_super_test/02: MissingCompileTimeError # Issue 31596
+issue31596_super_test/03: CompileTimeError
issue31596_super_test/04: MissingCompileTimeError # Issue 31596
-issue34488_test/01: MissingCompileTimeError # Issue 34488
-issue34488_test/02: MissingCompileTimeError # Issue 34488
-issue34488_test/03: MissingCompileTimeError # Issue 34488
-issue34488_test/04: MissingCompileTimeError # Issue 34488
-issue34488_test/05: MissingCompileTimeError # Issue 34488
-issue34488_test/06: MissingCompileTimeError # Issue 34488
mixin_declaration/mixin_declaration_invalid_override_test/08: MissingCompileTimeError
mixin_declaration/mixin_declaration_superinvocation_application_test/04: MissingCompileTimeError
mixin_declaration/mixin_declaration_superinvocation_application_test/05: MissingCompileTimeError
mixin_declaration/mixin_declaration_superinvocation_application_test/06: MissingCompileTimeError
mixin_declaration/mixin_declaration_superinvocation_application_test/07: MissingCompileTimeError
mixin_declaration/mixin_declaration_superinvocation_application_test/08: MissingCompileTimeError
-mixin_method_override_test/G5: Crash # Issue 34354
-override_inheritance_field_test/42: MissingCompileTimeError
regress_22976_test/*: CompileTimeError # Issue 31935
set_literals/invalid_set_literal_test/08: MissingCompileTimeError # Requires constant evaluation
set_literals/invalid_set_literal_test/09: MissingCompileTimeError # Requires constant evaluation
@@ -838,8 +829,6 @@
invocation_mirror_invoke_on2_test: SkipByDesign
invocation_mirror_invoke_on_test: SkipByDesign
issue21079_test: SkipByDesign
-issue31596_super_test/01: CompileTimeError
-issue31596_super_test/03: CompileTimeError
issue31596_super_test/05: RuntimeError
least_upper_bound_expansive_test/none: RuntimeError
library_env_test/has_html_support: RuntimeError # KernelVM bug: Configurable imports.
@@ -957,8 +946,6 @@
generic_no_such_method_dispatcher_test: CompileTimeError
generic_tearoff_test: CompileTimeError
instantiate_tearoff_of_call_test: CompileTimeError
-issue31596_super_test/01: CompileTimeError
-issue31596_super_test/03: CompileTimeError
mixin_illegal_super_use_test/01: MissingCompileTimeError
mixin_illegal_super_use_test/04: MissingCompileTimeError
mixin_illegal_super_use_test/07: MissingCompileTimeError
@@ -1368,8 +1355,6 @@
generic_tearoff_test: CompileTimeError, RuntimeError
if_null_evaluation_order_test: Pass
instantiate_tearoff_of_call_test: CompileTimeError
-issue31596_super_test/01: CompileTimeError
-issue31596_super_test/03: CompileTimeError
issue31596_super_test/05: RuntimeError
least_upper_bound_expansive_test/none: CompileTimeError
library_env_test/has_html_support: RuntimeError # KernelVM bug: Configurable imports.
