Version 2.14.0-261.0.dev
Merge commit 'f65d4b829c7abcaaee900e975a944dcca2dc4beb' into 'dev'
diff --git a/DEPS b/DEPS
index e569bfd..e7492f9 100644
--- a/DEPS
+++ b/DEPS
@@ -73,7 +73,7 @@
# Revisions of /third_party/* dependencies.
"args_rev": "d8fea36c10ef96797be02e3d132d572445cd86f4",
- "async_rev": "b8850b3851026676083413c67fa0a22f63a8edbc",
+ "async_rev": "92e7119aa068bfb86a6a9519d44037ffff5eece8",
"bazel_worker_rev": "0885637b037979afbf5bcd05fd748b309fd669c0",
"benchmark_harness_rev": "c546dbd9f639f75cd2f75de8df2eb9f8ea15e8e7",
"boolean_selector_rev": "665e6921ab246569420376f827bff4585dff0b14",
diff --git a/pkg/compiler/lib/src/inferrer/builder_kernel.dart b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
index d6def19..40e1ebe 100644
--- a/pkg/compiler/lib/src/inferrer/builder_kernel.dart
+++ b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
@@ -2284,14 +2284,13 @@
}
@override
- TypeInformation visitPartialInstantiationConstant(
- ir.PartialInstantiationConstant node) {
+ TypeInformation visitInstantiationConstant(ir.InstantiationConstant node) {
return builder.createInstantiationTypeInformation(
visitConstant(node.tearOffConstant));
}
@override
- TypeInformation visitTearOffConstant(ir.TearOffConstant node) {
+ TypeInformation visitStaticTearOffConstant(ir.StaticTearOffConstant node) {
return builder.createStaticGetTypeInformation(node, node.procedure);
}
diff --git a/pkg/compiler/lib/src/ir/constants.dart b/pkg/compiler/lib/src/ir/constants.dart
index c951716..4a936f6 100644
--- a/pkg/compiler/lib/src/ir/constants.dart
+++ b/pkg/compiler/lib/src/ir/constants.dart
@@ -124,7 +124,7 @@
bool visitUnevaluatedConstant(ir.UnevaluatedConstant node) => true;
@override
- bool visitPartialInstantiationConstant(ir.PartialInstantiationConstant node) {
+ bool visitInstantiationConstant(ir.InstantiationConstant node) {
return node.tearOffConstant.accept(this);
}
diff --git a/pkg/compiler/lib/src/ir/impact.dart b/pkg/compiler/lib/src/ir/impact.dart
index 7fabac6..33640a7 100644
--- a/pkg/compiler/lib/src/ir/impact.dart
+++ b/pkg/compiler/lib/src/ir/impact.dart
@@ -748,20 +748,30 @@
}
@override
- void visitTearOffConstant(ir.TearOffConstant node) {
- registry.registerStaticTearOff(node.procedure, import);
+ void visitStaticTearOffConstant(ir.StaticTearOffConstant node) {
+ ir.Member member = node.procedure;
+ if (member is ir.Procedure) {
+ registry.registerStaticTearOff(member, import);
+ } else {
+ throw new UnsupportedError("Unexpected member (${member.runtimeType}).");
+ }
}
@override
- void visitPartialInstantiationConstant(ir.PartialInstantiationConstant node) {
+ void visitInstantiationConstant(ir.InstantiationConstant node) {
registry.registerGenericInstantiation(
- node.tearOffConstant.procedure.function.computeFunctionType(
- node.tearOffConstant.procedure.enclosingLibrary.nonNullable),
+ node.tearOffConstant.function.computeFunctionType(
+ node.tearOffConstant.member.enclosingLibrary.nonNullable),
node.types);
visitConstant(node.tearOffConstant);
}
@override
+ void visitTypedefTearOffConstant(ir.TypedefTearOffConstant node) {
+ defaultConstant(node);
+ }
+
+ @override
void visitInstanceConstant(ir.InstanceConstant node) {
registry.registerConstInstantiation(
node.classNode, node.typeArguments, import);
diff --git a/pkg/compiler/lib/src/ir/visitors.dart b/pkg/compiler/lib/src/ir/visitors.dart
index 31b5158..0335a73 100644
--- a/pkg/compiler/lib/src/ir/visitors.dart
+++ b/pkg/compiler/lib/src/ir/visitors.dart
@@ -212,15 +212,20 @@
}
@override
- ConstantValue visitTearOffConstant(ir.TearOffConstant node) {
- FunctionEntity function = elementMap.getMethod(node.procedure);
- DartType type = elementMap.getFunctionType(node.procedure.function);
- return new FunctionConstantValue(function, type);
+ ConstantValue visitStaticTearOffConstant(ir.StaticTearOffConstant node) {
+ ir.Member member = node.procedure;
+ if (member is ir.Procedure) {
+ FunctionEntity function = elementMap.getMethod(member);
+ DartType type = elementMap.getFunctionType(member.function);
+ return new FunctionConstantValue(function, type);
+ } else {
+ throw new UnsupportedError(
+ "Unexpected torn off member kind (${member.runtimeType}).");
+ }
}
@override
- ConstantValue visitPartialInstantiationConstant(
- ir.PartialInstantiationConstant node) {
+ ConstantValue visitInstantiationConstant(ir.InstantiationConstant node) {
List<DartType> typeArguments = [];
for (ir.DartType type in node.types) {
typeArguments.add(elementMap.getDartType(type));
diff --git a/pkg/compiler/lib/src/serialization/node_indexer.dart b/pkg/compiler/lib/src/serialization/node_indexer.dart
index 663e593..e0c56a2 100644
--- a/pkg/compiler/lib/src/serialization/node_indexer.dart
+++ b/pkg/compiler/lib/src/serialization/node_indexer.dart
@@ -307,10 +307,18 @@
void visitTypeLiteralConstant(ir.TypeLiteralConstant node) {}
@override
- void visitTearOffConstant(ir.TearOffConstant node) {}
+ void visitStaticTearOffConstant(ir.StaticTearOffConstant node) {}
@override
- void visitPartialInstantiationConstant(ir.PartialInstantiationConstant node) {
+ void visitConstructorTearOffConstant(ir.ConstructorTearOffConstant node) {}
+
+ @override
+ void visitInstantiationConstant(ir.InstantiationConstant node) {
+ node.tearOffConstant.accept(this);
+ }
+
+ @override
+ void visitTypedefTearOffConstant(ir.TypedefTearOffConstant node) {
node.tearOffConstant.accept(this);
}
diff --git a/pkg/compiler/lib/src/ssa/builder_kernel.dart b/pkg/compiler/lib/src/ssa/builder_kernel.dart
index ad8f434..765039b 100644
--- a/pkg/compiler/lib/src/ssa/builder_kernel.dart
+++ b/pkg/compiler/lib/src/ssa/builder_kernel.dart
@@ -4489,9 +4489,10 @@
}
}
} else if (closure is ir.ConstantExpression &&
- closure.constant is ir.TearOffConstant) {
- ir.TearOffConstant tearOff = closure.constant;
- if (handleTarget(tearOff.procedure)) {
+ closure.constant is ir.StaticTearOffConstant) {
+ ir.StaticTearOffConstant tearOff = closure.constant;
+ ir.Member member = tearOff.procedure;
+ if (member is ir.Procedure && handleTarget(member)) {
return;
}
}
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index c384ce9..3bd5de9 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -5851,6 +5851,11 @@
}
@override
+ js_ast.Expression visitTypedefTearOff(TypedefTearOff node) {
+ throw UnsupportedError('Typedef instantiation');
+ }
+
+ @override
js_ast.Expression visitIsExpression(IsExpression node) {
return _emitIsExpression(node.operand, node.type);
}
@@ -6232,7 +6237,7 @@
@override
js_ast.Expression visitConstant(Constant node) {
- if (node is TearOffConstant) {
+ if (node is StaticTearOffConstant) {
// JS() or external JS consts should not be lazily loaded.
var isSdk = node.procedure.enclosingLibrary.importUri.scheme == 'dart';
if (_isInForeignJS) {
@@ -6418,7 +6423,7 @@
}
@override
- js_ast.Expression visitTearOffConstant(TearOffConstant node) {
+ js_ast.Expression visitStaticTearOffConstant(StaticTearOffConstant node) {
_declareBeforeUse(node.procedure.enclosingClass);
return _emitStaticGet(node.procedure);
}
@@ -6428,8 +6433,7 @@
_emitTypeLiteral(node.type);
@override
- js_ast.Expression visitPartialInstantiationConstant(
- PartialInstantiationConstant node) =>
+ js_ast.Expression visitInstantiationConstant(InstantiationConstant node) =>
canonicalizeConstObject(runtimeCall('gbind(#, #)', [
visitConstant(node.tearOffConstant),
node.types.map(_emitType).toList()
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index 737f649..fa2b398 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -328,8 +328,7 @@
}
@override
- Constant? visitPartialInstantiationConstant(
- PartialInstantiationConstant node) {
+ Constant? visitInstantiationConstant(InstantiationConstant node) {
List<DartType>? types;
for (int index = 0; index < node.types.length; index++) {
DartType? type = computeConstCanonicalType(
@@ -341,13 +340,13 @@
}
}
if (types != null) {
- return new PartialInstantiationConstant(node.tearOffConstant, types);
+ return new InstantiationConstant(node.tearOffConstant, types);
}
return null;
}
@override
- Constant? visitTearOffConstant(TearOffConstant node) => null;
+ Constant? visitStaticTearOffConstant(StaticTearOffConstant node) => null;
@override
Constant? visitTypeLiteralConstant(TypeLiteralConstant node) {
@@ -2917,7 +2916,7 @@
.withArguments(target.name.text));
} else if (target is Procedure) {
if (target.kind == ProcedureKind.Method) {
- return canonicalize(new TearOffConstant(target));
+ return canonicalize(new StaticTearOffConstant(target));
}
return createErrorConstant(
node,
@@ -2936,7 +2935,7 @@
final Member target = node.target;
if (target is Procedure) {
if (target.kind == ProcedureKind.Method) {
- return canonicalize(new TearOffConstant(target));
+ return canonicalize(new StaticTearOffConstant(target));
}
return createErrorConstant(
node,
@@ -3402,28 +3401,42 @@
new Instantiation(extract(constant),
node.typeArguments.map((t) => env.substituteType(t)).toList()));
}
- if (constant is TearOffConstant) {
- if (node.typeArguments.length ==
- constant.procedure.function.typeParameters.length) {
- List<DartType>? types = _evaluateDartTypes(node, node.typeArguments);
- if (types == null) {
- AbortConstant error = _gotError!;
- _gotError = null;
- return error;
- }
- assert(_gotError == null);
- // ignore: unnecessary_null_comparison
- assert(types != null);
+ if (constant is StaticTearOffConstant) {
+ Member constantMember = constant.procedure;
+ if (constantMember is Procedure) {
+ if (node.typeArguments.length ==
+ constantMember.function.typeParameters.length) {
+ List<DartType>? types = _evaluateDartTypes(node, node.typeArguments);
+ if (types == null) {
+ AbortConstant error = _gotError!;
+ _gotError = null;
+ return error;
+ }
+ assert(_gotError == null);
+ // ignore: unnecessary_null_comparison
+ assert(types != null);
- final List<DartType> typeArguments = convertTypes(types);
- return canonicalize(
- new PartialInstantiationConstant(constant, typeArguments));
+ final List<DartType> typeArguments = convertTypes(types);
+ return canonicalize(
+ new InstantiationConstant(constant, typeArguments));
+ } else {
+ // Probably unreachable.
+ return createInvalidExpressionConstant(
+ node,
+ 'The number of type arguments supplied in the partial '
+ 'instantiation does not match the number of type arguments '
+ 'of the $constant.');
+ }
+ } else if (constantMember is Constructor) {
+ // TODO(dmitryas): Add support for instantiated constructor tear-offs.
+ return defaultExpression(node);
+ } else {
+ // Probably unreachable.
+ return createInvalidExpressionConstant(
+ node,
+ "Unsupported kind of a torn off member: "
+ "'${constantMember.runtimeType}'.");
}
- // Probably unreachable.
- return createInvalidExpressionConstant(
- node,
- 'The number of type arguments supplied in the partial instantiation '
- 'does not match the number of type arguments of the $constant.');
}
// The inner expression in an instantiation can never be null, since
// instantiations are only inferred on direct references to declarations.
@@ -3438,6 +3451,11 @@
}
@override
+ Constant visitTypedefTearOff(TypedefTearOff node) {
+ return defaultExpression(node);
+ }
+
+ @override
Constant visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) {
return createErrorConstant(node,
templateConstEvalDeferredLibrary.withArguments(node.import.name!));
diff --git a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
index 3ff0062..d8265a8 100644
--- a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
@@ -221,6 +221,12 @@
}
@override
+ ExpressionInferenceResult visitTypedefTearOff(
+ TypedefTearOff node, DartType typeContext) {
+ return _unhandledExpression(node, typeContext);
+ }
+
+ @override
ExpressionInferenceResult visitListConcatenation(
ListConcatenation node, DartType typeContext) {
return _unhandledExpression(node, typeContext);
diff --git a/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart b/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
index 9ac22d9..aeb1696 100644
--- a/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
@@ -360,7 +360,7 @@
result.add("}");
}
- void visitTearOffConstant(TearOffConstant node) {
+ void visitStaticTearOffConstant(StaticTearOffConstant node) {
Procedure procedure = node.procedure;
Class? classNode = procedure.enclosingClass;
if (classNode != null) {
@@ -374,7 +374,19 @@
result.add(procedure.name.text);
}
- void visitPartialInstantiationConstant(PartialInstantiationConstant node) {
+ void visitConstructorTearOffConstant(ConstructorTearOffConstant node) {
+ Constructor constructor = node.constructor;
+ Class? classNode = constructor.enclosingClass;
+ result.add(nameForEntity(
+ classNode,
+ classNode.name,
+ classNode.enclosingLibrary.importUri,
+ classNode.enclosingLibrary.fileUri));
+ result.add(".");
+ result.add(constructor.name.text);
+ }
+
+ void visitInstantiationConstant(InstantiationConstant node) {
node.tearOffConstant.accept(this);
if (node.types.isNotEmpty) {
result.add("<");
@@ -388,6 +400,36 @@
}
}
+ void visitTypedefTearOffConstant(TypedefTearOffConstant node) {
+ node.tearOffConstant.accept(this);
+ if (node.parameters.isNotEmpty) {
+ result.add("<");
+ bool first = true;
+ for (TypeParameter param in node.parameters) {
+ if (!first) result.add(", ");
+ result.add(param.name ?? '');
+ if (isObject(param.bound) && param.defaultType is DynamicType) {
+ // Bound was not specified, and therefore should not be printed.
+ } else {
+ result.add(" extends ");
+ param.bound.accept(this);
+ }
+ first = false;
+ }
+ result.add(">");
+ }
+ if (node.types.isNotEmpty) {
+ result.add("<");
+ bool first = true;
+ for (DartType typeArg in node.types) {
+ if (!first) result.add(", ");
+ typeArg.accept(this);
+ first = false;
+ }
+ result.add(">");
+ }
+ }
+
void visitTypeLiteralConstant(TypeLiteralConstant node) {
node.type.accept(this);
}
diff --git a/pkg/front_end/lib/src/testing/id_testing_utils.dart b/pkg/front_end/lib/src/testing/id_testing_utils.dart
index 68cbf92..eaba8c7 100644
--- a/pkg/front_end/lib/src/testing/id_testing_utils.dart
+++ b/pkg/front_end/lib/src/testing/id_testing_utils.dart
@@ -401,20 +401,54 @@
sb.write(')');
}
- void visitPartialInstantiationConstant(PartialInstantiationConstant node) {
+ void visitInstantiationConstant(InstantiationConstant node) {
sb.write('Instantiation(');
- sb.write(getMemberName(node.tearOffConstant.procedure));
+ sb.write(getMemberName(node.tearOffConstant.member));
sb.write('<');
typeToText.visitList(node.types);
sb.write('>)');
}
- void visitTearOffConstant(TearOffConstant node) {
+ void visitTypedefTearOffConstant(TypedefTearOffConstant node) {
+ sb.write('TypedefTearOff(');
+ sb.write(getMemberName(node.tearOffConstant.member));
+ if (node.parameters.isNotEmpty) {
+ sb.write('<');
+ for (int i = 0; i < node.parameters.length; i++) {
+ if (i > 0) {
+ sb.write(',');
+ if (typeToText.typeRepresentation ==
+ TypeRepresentation.analyzerNonNullableByDefault) {
+ sb.write(' ');
+ }
+ }
+ TypeParameter typeParameter = node.parameters[i];
+ sb.write(typeParameter.name);
+ DartType bound = typeParameter.bound;
+ if (!(bound is InterfaceType && bound.classNode.name == 'Object')) {
+ sb.write(' extends ');
+ typeToText.visit(bound);
+ }
+ }
+ sb.write('>');
+ }
+ sb.write('<');
+ typeToText.visitList(node.types);
+ sb.write('>)');
+ }
+
+ void visitStaticTearOffConstant(StaticTearOffConstant node) {
sb.write('Function(');
sb.write(getMemberName(node.procedure));
sb.write(')');
}
+ void visitConstructorTearOffConstant(ConstructorTearOffConstant node) {
+ sb.write('Constructor(');
+ sb.write(getMemberName(node.constructor));
+ sb.write(')');
+ }
+
void visitTypeLiteralConstant(TypeLiteralConstant node) {
sb.write('TypeLiteral(');
typeToText.visit(node.type);
diff --git a/pkg/front_end/test/incremental_bulk_compiler_full.dart b/pkg/front_end/test/incremental_bulk_compiler_full.dart
index ac018cb..b067117 100644
--- a/pkg/front_end/test/incremental_bulk_compiler_full.dart
+++ b/pkg/front_end/test/incremental_bulk_compiler_full.dart
@@ -97,6 +97,7 @@
bulkSerialized = util.postProcess(bulkCompiledComponent);
} catch (e) {
bulkFailed = true;
+ context.compiler = null;
}
// Compile again - the serialized output should be the same.
@@ -112,6 +113,7 @@
bulkSerialized2 = util.postProcess(bulkCompiledComponent);
} catch (e) {
bulk2Failed = true;
+ context.compiler = null;
}
if (bulkFailed || oneShotFailed) {
diff --git a/pkg/front_end/test/type_labeler_test.dart b/pkg/front_end/test/type_labeler_test.dart
index 3acfa34..cde0695 100644
--- a/pkg/front_end/test/type_labeler_test.dart
+++ b/pkg/front_end/test/type_labeler_test.dart
@@ -285,11 +285,11 @@
]);
check({mapConst: "<bool, num>{true: 2, false: 2.5}"}, 0);
- Constant tearOffConst = new TearOffConstant(gooMethod);
+ Constant tearOffConst = new StaticTearOffConstant(gooMethod);
check({tearOffConst: "Foo.goo"}, 1);
Constant partialInstantiationConst =
- new PartialInstantiationConstant(tearOffConst, [intType]);
+ new InstantiationConstant(tearOffConst, [intType]);
check({partialInstantiationConst: "Foo.goo<int>"}, 1);
Constant typeLiteralConst = new TypeLiteralConstant(foo);
diff --git a/pkg/front_end/testcases/constructor_tearoffs/identical_instantiated_function_tearoffs.dart.weak.outline.expect b/pkg/front_end/testcases/constructor_tearoffs/identical_instantiated_function_tearoffs.dart.weak.outline.expect
index d3f2e88..4ccf7ac 100644
--- a/pkg/front_end/testcases/constructor_tearoffs/identical_instantiated_function_tearoffs.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/constructor_tearoffs/identical_instantiated_function_tearoffs.dart.weak.outline.expect
@@ -17,6 +17,6 @@
Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:9:54 -> PartialInstantiationConstant(id<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:10:38 -> PartialInstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:9:54 -> InstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:10:38 -> InstantiationConstant(id<int*>)
Extra constant evaluation: evaluated: 2, effectively constant: 2
diff --git a/pkg/front_end/testcases/general/constants/various.dart.weak.outline.expect b/pkg/front_end/testcases/general/constants/various.dart.weak.outline.expect
index 4722f57..1023df5 100644
--- a/pkg/front_end/testcases/general/constants/various.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/constants/various.dart.weak.outline.expect
@@ -445,7 +445,7 @@
Evaluated: EqualsCall @ org-dartlang-testcase:///various.dart:195:24 -> BoolConstant(false)
Evaluated: ConditionalExpression @ org-dartlang-testcase:///various.dart:200:66 -> NullConstant(null)
Evaluated: AsExpression @ org-dartlang-testcase:///various.dart:203:39 -> NullConstant(null)
-Evaluated: AsExpression @ org-dartlang-testcase:///various.dart:205:39 -> PartialInstantiationConstant(id1<int*>)
+Evaluated: AsExpression @ org-dartlang-testcase:///various.dart:205:39 -> InstantiationConstant(id1<int*>)
Evaluated: Not @ org-dartlang-testcase:///various.dart:208:20 -> BoolConstant(false)
Evaluated: ConditionalExpression @ org-dartlang-testcase:///various.dart:210:46 -> BoolConstant(true)
Evaluated: ConditionalExpression @ org-dartlang-testcase:///various.dart:211:38 -> BoolConstant(false)
diff --git a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.outline.expect b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.outline.expect
index 91fb49a..373d6b4 100644
--- a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.outline.expect
@@ -78,7 +78,7 @@
Extra constant evaluation status:
Evaluated: TypeLiteral @ org-dartlang-testcase:///various_2.dart:10:27 -> TypeLiteralConstant(Object*)
-Evaluated: Instantiation @ org-dartlang-testcase:///various_2.dart:11:52 -> PartialInstantiationConstant(id1<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///various_2.dart:11:52 -> InstantiationConstant(id1<int*>)
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///various_2.dart:12:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///various_2.dart:13:25 -> InstanceConstant(const Class<dynamic>{Class.field: const <int*>[42]})
Evaluated: TypeLiteral @ org-dartlang-testcase:///various_2.dart:15:29 -> TypeLiteralConstant(dynamic Function(dynamic)*)
@@ -94,8 +94,8 @@
Evaluated: MapConcatenation @ org-dartlang-testcase:///various_2.dart:32:7 -> MapConstant(const <int*, String*>{0: "foo"})
Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:35:5 -> BoolConstant(true)
Evaluated with empty environment: StaticInvocation @ org-dartlang-testcase:///various_2.dart:37:5 -> BoolConstant(false)
-Evaluated: StaticGet @ org-dartlang-testcase:///various_2.dart:37:15 -> PartialInstantiationConstant(id1<int*>)
-Evaluated with empty environment: StaticGet @ org-dartlang-testcase:///various_2.dart:37:41 -> PartialInstantiationConstant(id2<int*>)
+Evaluated: StaticGet @ org-dartlang-testcase:///various_2.dart:37:15 -> InstantiationConstant(id1<int*>)
+Evaluated with empty environment: StaticGet @ org-dartlang-testcase:///various_2.dart:37:41 -> InstantiationConstant(id2<int*>)
Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:38:27 -> BoolConstant(true)
Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:39:28 -> BoolConstant(true)
Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:41:5 -> BoolConstant(true)
@@ -110,13 +110,13 @@
Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:53:5 -> BoolConstant(true)
Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:55:5 -> BoolConstant(true)
Evaluated: TypeLiteral @ org-dartlang-testcase:///various_2_lib.dart:17:27 -> TypeLiteralConstant(Object*)
-Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:18:12 -> TearOffConstant(identical)
-Evaluated with empty environment: ConditionalExpression @ org-dartlang-testcase:///various_2_lib.dart:20:39 -> PartialInstantiationConstant(id2<int*>)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:18:12 -> StaticTearOffConstant(identical)
+Evaluated with empty environment: ConditionalExpression @ org-dartlang-testcase:///various_2_lib.dart:20:39 -> InstantiationConstant(id2<int*>)
Evaluated with empty environment: FactoryConstructorInvocationJudgment @ org-dartlang-testcase:///various_2_lib.dart:20:11 -> BoolConstant(false)
-Evaluated with empty environment: Instantiation @ org-dartlang-testcase:///various_2_lib.dart:20:41 -> PartialInstantiationConstant(id1<int*>)
-Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:20:41 -> TearOffConstant(id1)
-Evaluated with empty environment: Instantiation @ org-dartlang-testcase:///various_2_lib.dart:20:47 -> PartialInstantiationConstant(id2<int*>)
-Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:20:47 -> TearOffConstant(id2)
+Evaluated with empty environment: Instantiation @ org-dartlang-testcase:///various_2_lib.dart:20:41 -> InstantiationConstant(id1<int*>)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:20:41 -> StaticTearOffConstant(id1)
+Evaluated with empty environment: Instantiation @ org-dartlang-testcase:///various_2_lib.dart:20:47 -> InstantiationConstant(id2<int*>)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:20:47 -> StaticTearOffConstant(id2)
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///various_2_lib.dart:21:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///various_2_lib.dart:22:25 -> InstanceConstant(const Class<dynamic>{Class.field: const <int*>[42]})
Evaluated: TypeLiteral @ org-dartlang-testcase:///various_2_lib.dart:23:29 -> TypeLiteralConstant(dynamic Function(dynamic)*)
diff --git a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.transformed.expect b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.transformed.expect
index 3e10527..2830193 100644
--- a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.transformed.expect
@@ -130,10 +130,10 @@
}
Extra constant evaluation status:
-Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2.dart:15:28 -> PartialInstantiationConstant(id2<int*>)
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2.dart:15:28 -> InstantiationConstant(id2<int*>)
Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2.dart:37:5 -> BoolConstant(false)
Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2.dart:37:5 -> BoolConstant(false)
-Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2_lib.dart:20:39 -> PartialInstantiationConstant(id2<int*>)
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2_lib.dart:20:39 -> InstantiationConstant(id2<int*>)
Extra constant evaluation: evaluated: 41, effectively constant: 4
diff --git a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.outline.expect b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.outline.expect
index 02a352f..9e4506e 100644
--- a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.outline.expect
@@ -15,5 +15,5 @@
Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:17:54 -> PartialInstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:17:54 -> InstantiationConstant(id<int*>)
Extra constant evaluation: evaluated: 1, effectively constant: 1
diff --git a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.transformed.expect b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.transformed.expect
index ad67316..e0f574c 100644
--- a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.transformed.expect
@@ -28,5 +28,5 @@
Extra constant evaluation status:
Evaluated: StaticInvocation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:28:13 -> BoolConstant(true)
-Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:16:43 -> PartialInstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:16:43 -> InstantiationConstant(id<int*>)
Extra constant evaluation: evaluated: 30, effectively constant: 2
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.transformed.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.transformed.expect
index d465ca9..9dc6b9b 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.transformed.expect
@@ -181,32 +181,32 @@
}
Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:16:16 -> PartialInstantiationConstant(max<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:17:16 -> PartialInstantiationConstant(max<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:18:16 -> PartialInstantiationConstant(max<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:19:16 -> PartialInstantiationConstant(max<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:20:16 -> PartialInstantiationConstant(max<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:21:16 -> PartialInstantiationConstant(max<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:22:16 -> PartialInstantiationConstant(max<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:23:16 -> PartialInstantiationConstant(max<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:24:16 -> PartialInstantiationConstant(max<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:26:70 -> PartialInstantiationConstant(max<Object*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:28:73 -> PartialInstantiationConstant(max<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:30:73 -> PartialInstantiationConstant(max<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:31:70 -> PartialInstantiationConstant(max<Object*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:32:70 -> PartialInstantiationConstant(max<Object*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:35:11 -> PartialInstantiationConstant(min<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:36:11 -> PartialInstantiationConstant(min<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:37:11 -> PartialInstantiationConstant(min<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:38:11 -> PartialInstantiationConstant(min<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:39:11 -> PartialInstantiationConstant(min<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:40:11 -> PartialInstantiationConstant(min<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:41:11 -> PartialInstantiationConstant(min<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:42:11 -> PartialInstantiationConstant(min<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:43:11 -> PartialInstantiationConstant(min<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:45:65 -> PartialInstantiationConstant(min<Object*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:46:72 -> PartialInstantiationConstant(min<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:47:72 -> PartialInstantiationConstant(min<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:48:65 -> PartialInstantiationConstant(min<Object*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:49:65 -> PartialInstantiationConstant(min<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:16:16 -> InstantiationConstant(max<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:17:16 -> InstantiationConstant(max<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:18:16 -> InstantiationConstant(max<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:19:16 -> InstantiationConstant(max<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:20:16 -> InstantiationConstant(max<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:21:16 -> InstantiationConstant(max<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:22:16 -> InstantiationConstant(max<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:23:16 -> InstantiationConstant(max<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:24:16 -> InstantiationConstant(max<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:26:70 -> InstantiationConstant(max<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:28:73 -> InstantiationConstant(max<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:30:73 -> InstantiationConstant(max<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:31:70 -> InstantiationConstant(max<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:32:70 -> InstantiationConstant(max<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:35:11 -> InstantiationConstant(min<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:36:11 -> InstantiationConstant(min<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:37:11 -> InstantiationConstant(min<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:38:11 -> InstantiationConstant(min<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:39:11 -> InstantiationConstant(min<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:40:11 -> InstantiationConstant(min<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:41:11 -> InstantiationConstant(min<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:42:11 -> InstantiationConstant(min<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:43:11 -> InstantiationConstant(min<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:45:65 -> InstantiationConstant(min<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:46:72 -> InstantiationConstant(min<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:47:72 -> InstantiationConstant(min<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:48:65 -> InstantiationConstant(min<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:49:65 -> InstantiationConstant(min<Object*>)
Extra constant evaluation: evaluated: 133, effectively constant: 28
diff --git a/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.transformed.expect b/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.transformed.expect
index 947bd81..8af73b0 100644
--- a/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.transformed.expect
@@ -48,6 +48,6 @@
}
Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_nested_generic_instantiation.dart:28:71 -> PartialInstantiationConstant(max<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_nested_generic_instantiation.dart:29:67 -> PartialInstantiationConstant(max<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_nested_generic_instantiation.dart:28:71 -> InstantiationConstant(max<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_nested_generic_instantiation.dart:29:67 -> InstantiationConstant(max<int*>)
Extra constant evaluation: evaluated: 16, effectively constant: 2
diff --git a/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.transformed.expect b/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.transformed.expect
index 8efaf12..4c5080b 100644
--- a/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.transformed.expect
@@ -49,6 +49,6 @@
}
Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///instantiate_tearoff.dart:25:10 -> PartialInstantiationConstant(f<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///instantiate_tearoff.dart:27:12 -> PartialInstantiationConstant(C.g<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///instantiate_tearoff.dart:25:10 -> InstantiationConstant(f<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///instantiate_tearoff.dart:27:12 -> InstantiationConstant(C.g<int*>)
Extra constant evaluation: evaluated: 18, effectively constant: 2
diff --git a/pkg/front_end/testcases/inference/static_method_tear_off.dart.weak.outline.expect b/pkg/front_end/testcases/inference/static_method_tear_off.dart.weak.outline.expect
index b473f71..b2c575b 100644
--- a/pkg/front_end/testcases/inference/static_method_tear_off.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/inference/static_method_tear_off.dart.weak.outline.expect
@@ -24,5 +24,5 @@
Extra constant evaluation status:
-Evaluated: StaticTearOff @ org-dartlang-testcase:///static_method_tear_off.dart:8:13 -> TearOffConstant(C.f)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///static_method_tear_off.dart:8:13 -> StaticTearOffConstant(C.f)
Extra constant evaluation: evaluated: 1, effectively constant: 1
diff --git a/pkg/front_end/testcases/nnbd/constants.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/constants.dart.weak.outline.expect
index b25d8c4..1d425f6 100644
--- a/pkg/front_end/testcases/nnbd/constants.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/constants.dart.weak.outline.expect
@@ -64,7 +64,7 @@
Extra constant evaluation status:
Evaluated: TypeLiteral @ org-dartlang-testcase:///constants.dart:10:27 -> TypeLiteralConstant(Object*)
-Evaluated: Instantiation @ org-dartlang-testcase:///constants.dart:11:52 -> PartialInstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///constants.dart:11:52 -> InstantiationConstant(id<int*>)
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///constants.dart:12:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
Evaluated: TypeLiteral @ org-dartlang-testcase:///constants.dart:13:29 -> TypeLiteralConstant(dynamic Function(dynamic)*)
Evaluated: TypeLiteral @ org-dartlang-testcase:///constants.dart:14:36 -> TypeLiteralConstant(T* Function<T>(T*)*)
@@ -86,8 +86,8 @@
Evaluated: StaticInvocation @ org-dartlang-testcase:///constants.dart:37:5 -> BoolConstant(true)
Evaluated: StaticInvocation @ org-dartlang-testcase:///constants.dart:39:5 -> BoolConstant(true)
Evaluated: TypeLiteral @ org-dartlang-testcase:///constants_lib.dart:16:27 -> TypeLiteralConstant(Object*)
-Evaluated: StaticTearOff @ org-dartlang-testcase:///constants_lib.dart:17:12 -> TearOffConstant(identical)
-Evaluated: Instantiation @ org-dartlang-testcase:///constants_lib.dart:18:48 -> PartialInstantiationConstant(id<int*>)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///constants_lib.dart:17:12 -> StaticTearOffConstant(identical)
+Evaluated: Instantiation @ org-dartlang-testcase:///constants_lib.dart:18:48 -> InstantiationConstant(id<int*>)
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///constants_lib.dart:19:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
Evaluated: TypeLiteral @ org-dartlang-testcase:///constants_lib.dart:20:29 -> TypeLiteralConstant(dynamic Function(dynamic)*)
Evaluated: TypeLiteral @ org-dartlang-testcase:///constants_lib.dart:21:36 -> TypeLiteralConstant(T* Function<T>(T*)*)
diff --git a/pkg/front_end/testcases/nnbd/issue42433.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/issue42433.dart.strong.transformed.expect
index bb2b62a..62a035b 100644
--- a/pkg/front_end/testcases/nnbd/issue42433.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42433.dart.strong.transformed.expect
@@ -18,5 +18,5 @@
}
Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///issue42433.dart:11:16 -> PartialInstantiationConstant(checkme<X>)
+Evaluated: Instantiation @ org-dartlang-testcase:///issue42433.dart:11:16 -> InstantiationConstant(checkme<X>)
Extra constant evaluation: evaluated: 1, effectively constant: 1
diff --git a/pkg/front_end/testcases/nnbd/issue42433.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/issue42433.dart.weak.transformed.expect
index 4754890..0fd30a8 100644
--- a/pkg/front_end/testcases/nnbd/issue42433.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42433.dart.weak.transformed.expect
@@ -18,5 +18,5 @@
}
Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///issue42433.dart:11:16 -> PartialInstantiationConstant(checkme<X*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///issue42433.dart:11:16 -> InstantiationConstant(checkme<X*>)
Extra constant evaluation: evaluated: 1, effectively constant: 1
diff --git a/pkg/front_end/testcases/nnbd/potentially_constant_type_as.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/potentially_constant_type_as.dart.weak.outline.expect
index b3e41d5..c031ded 100644
--- a/pkg/front_end/testcases/nnbd/potentially_constant_type_as.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/potentially_constant_type_as.dart.weak.outline.expect
@@ -49,5 +49,5 @@
Extra constant evaluation status:
Evaluated: StaticGet @ org-dartlang-testcase:///potentially_constant_type_as.dart:22:36 -> IntConstant(3)
-Evaluated: Instantiation @ org-dartlang-testcase:///potentially_constant_type_as.dart:11:43 -> PartialInstantiationConstant(idFunction<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///potentially_constant_type_as.dart:11:43 -> InstantiationConstant(idFunction<int*>)
Extra constant evaluation: evaluated: 11, effectively constant: 2
diff --git a/pkg/front_end/testcases/nnbd/potentially_constant_type_is.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/potentially_constant_type_is.dart.weak.outline.expect
index ba55100..b22c34f 100644
--- a/pkg/front_end/testcases/nnbd/potentially_constant_type_is.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/potentially_constant_type_is.dart.weak.outline.expect
@@ -45,5 +45,5 @@
Extra constant evaluation status:
Evaluated: StaticGet @ org-dartlang-testcase:///potentially_constant_type_is.dart:22:36 -> IntConstant(3)
-Evaluated: Instantiation @ org-dartlang-testcase:///potentially_constant_type_is.dart:11:43 -> PartialInstantiationConstant(idFunction<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///potentially_constant_type_is.dart:11:43 -> InstantiationConstant(idFunction<int*>)
Extra constant evaluation: evaluated: 11, effectively constant: 2
diff --git a/pkg/front_end/testcases/nnbd_mixed/constants.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd_mixed/constants.dart.weak.outline.expect
index 9f91d26..6e8783d 100644
--- a/pkg/front_end/testcases/nnbd_mixed/constants.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/constants.dart.weak.outline.expect
@@ -62,7 +62,7 @@
Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///constants.dart:7:52 -> PartialInstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///constants.dart:7:52 -> InstantiationConstant(id<int*>)
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///constants.dart:8:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
Evaluated: ListLiteral @ org-dartlang-testcase:///constants.dart:9:26 -> ListConstant(const <int*>[0])
Evaluated: SetLiteral @ org-dartlang-testcase:///constants.dart:10:25 -> InstanceConstant(const _UnmodifiableSet<int*>{_UnmodifiableSet._map: const _ImmutableMap<int*, Null>{_ImmutableMap._kvPairs: const <dynamic>[0, null]}})
@@ -78,8 +78,8 @@
Evaluated: StaticInvocation @ org-dartlang-testcase:///constants.dart:23:5 -> BoolConstant(true)
Evaluated: StaticInvocation @ org-dartlang-testcase:///constants.dart:25:5 -> BoolConstant(true)
Evaluated: StaticInvocation @ org-dartlang-testcase:///constants.dart:27:5 -> BoolConstant(true)
-Evaluated: StaticTearOff @ org-dartlang-testcase:///constants_lib.dart:18:12 -> TearOffConstant(identical)
-Evaluated: Instantiation @ org-dartlang-testcase:///constants_lib.dart:19:48 -> PartialInstantiationConstant(id<int*>)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///constants_lib.dart:18:12 -> StaticTearOffConstant(identical)
+Evaluated: Instantiation @ org-dartlang-testcase:///constants_lib.dart:19:48 -> InstantiationConstant(id<int*>)
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///constants_lib.dart:20:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
Evaluated: ListLiteral @ org-dartlang-testcase:///constants_lib.dart:21:26 -> ListConstant(const <int*>[0])
Evaluated: SetLiteral @ org-dartlang-testcase:///constants_lib.dart:22:25 -> InstanceConstant(const _UnmodifiableSet<int*>{_UnmodifiableSet._map: const _ImmutableMap<int*, Null>{_ImmutableMap._kvPairs: const <dynamic>[0, null]}})
diff --git a/pkg/front_end/testcases/rasta/static.dart.weak.transformed.expect b/pkg/front_end/testcases/rasta/static.dart.weak.transformed.expect
index fd27fff..f510042 100644
--- a/pkg/front_end/testcases/rasta/static.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/rasta/static.dart.weak.transformed.expect
@@ -340,9 +340,9 @@
Extra constant evaluation status:
Evaluated: VariableGet @ org-dartlang-testcase:///static.dart:32:13 -> IntConstant(42)
-Evaluated: VariableGet @ org-dartlang-testcase:///static.dart:36:13 -> TearOffConstant(Foo.staticFunction)
+Evaluated: VariableGet @ org-dartlang-testcase:///static.dart:36:13 -> StaticTearOffConstant(Foo.staticFunction)
Evaluated: ConditionalExpression @ org-dartlang-testcase:///static.dart:75:24 -> NullConstant(null)
Evaluated: Let @ org-dartlang-testcase:///static.dart:76:28 -> IntConstant(42)
Evaluated: ConditionalExpression @ org-dartlang-testcase:///static.dart:79:24 -> NullConstant(null)
-Evaluated: Let @ org-dartlang-testcase:///static.dart:80:28 -> TearOffConstant(Foo.staticFunction)
+Evaluated: Let @ org-dartlang-testcase:///static.dart:80:28 -> StaticTearOffConstant(Foo.staticFunction)
Extra constant evaluation: evaluated: 122, effectively constant: 6
diff --git a/pkg/kernel/binary.md b/pkg/kernel/binary.md
index dfed538..4dd9aa7 100644
--- a/pkg/kernel/binary.md
+++ b/pkg/kernel/binary.md
@@ -147,7 +147,7 @@
type ComponentFile {
UInt32 magic = 0x90ABCDEF;
- UInt32 formatVersion = 66;
+ UInt32 formatVersion = 67;
Byte[10] shortSdkHash;
List<String> problemsAsJson; // Described in problems.md.
Library[] libraries;
@@ -707,6 +707,13 @@
Option<List<DartType>> typeArguments;
}
+type TypedefTearOff extends Expression {
+ Byte tag = 83;
+ List<TypeParameter> typeParameters;
+ Expression expression;
+ List<DartType> typeArguments;
+}
+
type StaticSet extends Expression {
Byte tag = 27;
FileOffset fileOffset;
@@ -1179,13 +1186,13 @@
List<Pair<FieldReference, ConstantReference>> values;
}
-type PartialInstantiationConstant extends Constant {
+type InstantiationConstant extends Constant {
Byte tag = 9;
ConstantReference tearOffConstant;
List<DartType> typeArguments;
}
-type TearOffConstant extends Constant {
+type StaticTearOffConstant extends Constant {
Byte tag = 10;
CanonicalNameReference staticProcedureReference;
}
@@ -1200,6 +1207,18 @@
Expression expression;
}
+type TypedefTearOffConstant extends Constant {
+ Byte tag = 14;
+ List<TypeParameter> parameters;
+ CanonicalNameReference staticProcedureReference;
+ List<DartType> types;
+}
+
+type ConstructorTearOffConstant extends Constant {
+ Byte tag = 15;
+ CanonicalNameReference constructorReference;
+}
+
abstract type Statement extends Node {}
type ExpressionStatement extends Statement {
diff --git a/pkg/kernel/lib/ast.dart b/pkg/kernel/lib/ast.dart
index 3e8f7b2..4a2284a 100644
--- a/pkg/kernel/lib/ast.dart
+++ b/pkg/kernel/lib/ast.dart
@@ -8659,6 +8659,82 @@
}
}
+class TypedefTearOff extends Expression {
+ final List<TypeParameter> typeParameters;
+ Expression expression;
+ final List<DartType> typeArguments;
+
+ TypedefTearOff(this.typeParameters, this.expression, this.typeArguments) {
+ expression.parent = this;
+ setParents(typeParameters, this);
+ }
+
+ @override
+ DartType getStaticTypeInternal(StaticTypeContext context) {
+ FreshTypeParameters freshTypeParameters =
+ getFreshTypeParameters(typeParameters);
+ FunctionType type = expression.getStaticType(context) as FunctionType;
+ type = Substitution.combine(
+ Substitution.fromPairs(type.typeParameters, typeArguments),
+ freshTypeParameters.substitution)
+ .substituteType(type.withoutTypeParameters) as FunctionType;
+ return new FunctionType(
+ type.positionalParameters, type.returnType, type.declaredNullability,
+ namedParameters: type.namedParameters,
+ typeParameters: freshTypeParameters.freshTypeParameters,
+ requiredParameterCount: type.requiredParameterCount,
+ typedefType: null);
+ }
+
+ @override
+ R accept<R>(ExpressionVisitor<R> v) => v.visitTypedefTearOff(this);
+
+ @override
+ R accept1<R, A>(ExpressionVisitor1<R, A> v, A arg) =>
+ v.visitTypedefTearOff(this, arg);
+
+ @override
+ void visitChildren(Visitor v) {
+ expression.accept(v);
+ visitList(typeParameters, v);
+ visitList(typeArguments, v);
+ }
+
+ @override
+ void transformChildren(Transformer v) {
+ // ignore: unnecessary_null_comparison
+ if (expression != null) {
+ expression = v.transform(expression);
+ expression.parent = this;
+ }
+ v.transformList(typeParameters, this);
+ v.transformDartTypeList(typeArguments);
+ }
+
+ @override
+ void transformOrRemoveChildren(RemovingTransformer v) {
+ // ignore: unnecessary_null_comparison
+ if (expression != null) {
+ expression = v.transform(expression);
+ expression.parent = this;
+ }
+ v.transformList(typeParameters, this, dummyTypeParameter);
+ v.transformDartTypeList(typeArguments);
+ }
+
+ @override
+ String toString() {
+ return "TypedefTearOff(${toStringInternal()})";
+ }
+
+ @override
+ void toTextInternal(AstPrinter printer) {
+ printer.writeExpression(expression);
+ printer.writeTypeParameters(typeParameters);
+ printer.writeTypeArguments(typeArguments);
+ }
+}
+
// ------------------------------------------------------------------------
// STATEMENTS
// ------------------------------------------------------------------------
@@ -12777,21 +12853,20 @@
new InterfaceType(classNode, context.nonNullable, typeArguments);
}
-class PartialInstantiationConstant extends Constant {
+class InstantiationConstant extends Constant {
final TearOffConstant tearOffConstant;
final List<DartType> types;
- PartialInstantiationConstant(this.tearOffConstant, this.types);
+ InstantiationConstant(this.tearOffConstant, this.types);
visitChildren(Visitor v) {
tearOffConstant.acceptReference(v);
visitList(types, v);
}
- R accept<R>(ConstantVisitor<R> v) =>
- v.visitPartialInstantiationConstant(this);
+ R accept<R>(ConstantVisitor<R> v) => v.visitInstantiationConstant(this);
R acceptReference<R>(Visitor<R> v) =>
- v.visitPartialInstantiationConstantReference(this);
+ v.visitInstantiationConstantReference(this);
@override
void toTextInternal(AstPrinter printer) {
@@ -12800,19 +12875,19 @@
}
@override
- String toString() => 'PartialInstantiationConstant(${toStringInternal()})';
+ String toString() => 'InstantiationConstant(${toStringInternal()})';
int get hashCode => _Hash.combineFinish(
tearOffConstant.hashCode, _Hash.combineListHash(types));
bool operator ==(Object other) {
- return other is PartialInstantiationConstant &&
+ return other is InstantiationConstant &&
other.tearOffConstant == tearOffConstant &&
listEquals(other.types, types);
}
DartType getType(StaticTypeContext context) {
- final FunctionType type = tearOffConstant.getType(context);
+ final FunctionType type = tearOffConstant.getType(context) as FunctionType;
final Map<TypeParameter, DartType> mapping = <TypeParameter, DartType>{};
for (final TypeParameter parameter in type.typeParameters) {
mapping[parameter] = types[mapping.length];
@@ -12821,38 +12896,52 @@
}
}
-class TearOffConstant extends Constant {
- final Reference procedureReference;
+abstract class TearOffConstant implements Constant {
+ Reference get memberReference;
+ Member get member;
+ FunctionNode get function;
+}
- TearOffConstant(Procedure procedure)
- : procedureReference = procedure.reference {
+class StaticTearOffConstant extends Constant implements TearOffConstant {
+ @override
+ final Reference memberReference;
+
+ StaticTearOffConstant(Procedure procedure)
+ : memberReference = procedure.reference {
assert(procedure.isStatic);
}
- TearOffConstant.byReference(this.procedureReference);
+ StaticTearOffConstant.byReference(this.memberReference);
- Procedure get procedure => procedureReference.asProcedure;
+ @override
+ Member get member => memberReference.asMember;
+
+ @override
+ FunctionNode get function => procedure.function;
+
+ Procedure get procedure => memberReference.asProcedure;
visitChildren(Visitor v) {
- procedureReference.asProcedure.acceptReference(v);
+ memberReference.asProcedure.acceptReference(v);
}
- R accept<R>(ConstantVisitor<R> v) => v.visitTearOffConstant(this);
- R acceptReference<R>(Visitor<R> v) => v.visitTearOffConstantReference(this);
+ R accept<R>(ConstantVisitor<R> v) => v.visitStaticTearOffConstant(this);
+ R acceptReference<R>(Visitor<R> v) =>
+ v.visitStaticTearOffConstantReference(this);
@override
void toTextInternal(AstPrinter printer) {
- printer.writeMemberName(procedureReference);
+ printer.writeMemberName(memberReference);
}
@override
- String toString() => 'TearOffConstant(${toStringInternal()})';
+ String toString() => 'StaticTearOffConstant(${toStringInternal()})';
- int get hashCode => procedureReference.hashCode;
+ int get hashCode => memberReference.hashCode;
bool operator ==(Object other) {
- return other is TearOffConstant &&
- other.procedureReference == procedureReference;
+ return other is StaticTearOffConstant &&
+ other.memberReference == memberReference;
}
FunctionType getType(StaticTypeContext context) {
@@ -12860,6 +12949,114 @@
}
}
+class ConstructorTearOffConstant extends Constant implements TearOffConstant {
+ @override
+ final Reference memberReference;
+
+ ConstructorTearOffConstant(Constructor constructor)
+ : memberReference = constructor.reference;
+
+ ConstructorTearOffConstant.byReference(this.memberReference);
+
+ @override
+ Member get member => memberReference.asMember;
+
+ @override
+ FunctionNode get function => constructor.function;
+
+ Constructor get constructor => memberReference.asConstructor;
+
+ visitChildren(Visitor v) {
+ memberReference.asProcedure.acceptReference(v);
+ }
+
+ R accept<R>(ConstantVisitor<R> v) => v.visitConstructorTearOffConstant(this);
+ R acceptReference<R>(Visitor<R> v) =>
+ v.visitConstructorTearOffConstantReference(this);
+
+ @override
+ void toTextInternal(AstPrinter printer) {
+ printer.writeMemberName(memberReference);
+ }
+
+ @override
+ String toString() => 'ConstructorTearOffConstant(${toStringInternal()})';
+
+ int get hashCode => memberReference.hashCode;
+
+ bool operator ==(Object other) {
+ return other is StaticTearOffConstant &&
+ other.memberReference == memberReference;
+ }
+
+ FunctionType getType(StaticTypeContext context) {
+ return constructor.function.computeFunctionType(context.nonNullable);
+ }
+}
+
+class TypedefTearOffConstant extends Constant {
+ final List<TypeParameter> parameters;
+ final TearOffConstant tearOffConstant;
+ final List<DartType> types;
+
+ TypedefTearOffConstant(this.parameters, this.tearOffConstant, this.types);
+
+ visitChildren(Visitor v) {
+ visitList(parameters, v);
+ tearOffConstant.acceptReference(v);
+ visitList(types, v);
+ }
+
+ R accept<R>(ConstantVisitor<R> v) => v.visitTypedefTearOffConstant(this);
+ R acceptReference<R>(Visitor<R> v) => v.visitTypedefTearOffConstant(this);
+
+ @override
+ void toTextInternal(AstPrinter printer) {
+ printer.writeConstant(tearOffConstant);
+ printer.writeTypeParameters(parameters);
+ printer.writeTypeArguments(types);
+ }
+
+ @override
+ String toString() => 'TypedefTearOffConstant(${toStringInternal()})';
+
+ bool operator ==(Object other) {
+ if (other is! TypedefTearOffConstant) return false;
+ if (other.tearOffConstant != tearOffConstant) return false;
+ if (other.parameters.length != parameters.length) return false;
+ if (parameters.isNotEmpty) {
+ Map<TypeParameter, DartType> substitutionMap =
+ <TypeParameter, DartType>{};
+ for (int i = 0; i < parameters.length; ++i) {
+ substitutionMap[parameters[i]] = new TypeParameterType.forAlphaRenaming(
+ other.parameters[i], parameters[i]);
+ }
+ Substitution substitution = Substitution.fromMap(substitutionMap);
+ for (int i = 0; i < parameters.length; ++i) {
+ if (types[i] != substitution.substituteType(other.types[i])) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ DartType getType(StaticTypeContext context) {
+ FunctionType type = tearOffConstant.getType(context) as FunctionType;
+ FreshTypeParameters freshTypeParameters =
+ getFreshTypeParameters(parameters);
+ type = freshTypeParameters.substitute(
+ Substitution.fromPairs(parameters, types).substituteType(type))
+ as FunctionType;
+ return new FunctionType(
+ type.positionalParameters, type.returnType, type.declaredNullability,
+ namedParameters: type.namedParameters,
+ typeParameters: freshTypeParameters.freshTypeParameters,
+ requiredParameterCount: type.requiredParameterCount,
+ typedefType: null);
+ }
+}
+
class TypeLiteralConstant extends Constant {
final DartType type;
diff --git a/pkg/kernel/lib/binary/ast_from_binary.dart b/pkg/kernel/lib/binary/ast_from_binary.dart
index 54b51cc..a257708 100644
--- a/pkg/kernel/lib/binary/ast_from_binary.dart
+++ b/pkg/kernel/lib/binary/ast_from_binary.dart
@@ -365,10 +365,14 @@
return _readSetConstant();
case ConstantTag.InstanceConstant:
return _readInstanceConstant();
- case ConstantTag.PartialInstantiationConstant:
- return _readPartialInstantiationConstant();
- case ConstantTag.TearOffConstant:
- return _readTearOffConstant();
+ case ConstantTag.InstantiationConstant:
+ return _readInstantiationConstant();
+ case ConstantTag.TypedefTearOffConstant:
+ return _readTypedefTearOffConstant();
+ case ConstantTag.StaticTearOffConstant:
+ return _readStaticTearOffConstant();
+ case ConstantTag.ConstructorTearOffConstant:
+ return _readConstructorTearOffConstant();
case ConstantTag.TypeLiteralConstant:
return _readTypeLiteralConstant();
case ConstantTag.UnevaluatedConstant:
@@ -441,16 +445,29 @@
return new InstanceConstant(classReference, typeArguments, fieldValues);
}
- Constant _readPartialInstantiationConstant() {
- final TearOffConstant tearOffConstant =
- readConstantReference() as TearOffConstant;
+ Constant _readInstantiationConstant() {
+ final StaticTearOffConstant tearOffConstant =
+ readConstantReference() as StaticTearOffConstant;
final List<DartType> types = readDartTypeList();
- return new PartialInstantiationConstant(tearOffConstant, types);
+ return new InstantiationConstant(tearOffConstant, types);
}
- Constant _readTearOffConstant() {
+ Constant _readTypedefTearOffConstant() {
+ final List<TypeParameter> parameters = readAndPushTypeParameterList();
+ final StaticTearOffConstant tearOffConstant =
+ readConstantReference() as StaticTearOffConstant;
+ final List<DartType> types = readDartTypeList();
+ return new TypedefTearOffConstant(parameters, tearOffConstant, types);
+ }
+
+ Constant _readStaticTearOffConstant() {
final Reference reference = readNonNullCanonicalNameReference().reference;
- return new TearOffConstant.byReference(reference);
+ return new StaticTearOffConstant.byReference(reference);
+ }
+
+ Constant _readConstructorTearOffConstant() {
+ final Reference reference = readNonNullCanonicalNameReference().reference;
+ return new ConstructorTearOffConstant.byReference(reference);
}
Constant _readTypeLiteralConstant() {
@@ -1968,6 +1985,8 @@
return _readStaticSet();
case Tag.ConstructorTearOff:
return _readConstructorTearOff();
+ case Tag.TypedefTearOff:
+ return _readTypedefTearOff();
case Tag.MethodInvocation:
return _readMethodInvocation();
case Tag.InstanceInvocation:
@@ -2204,6 +2223,14 @@
..fileOffset = offset;
}
+ Expression _readTypedefTearOff() {
+ List<TypeParameter> typeParameters = readAndPushTypeParameterList();
+ Expression expression = readExpression();
+ List<DartType> typeArguments = readDartTypeList();
+ typeParameterStack.length -= typeParameters.length;
+ return new TypedefTearOff(typeParameters, expression, typeArguments);
+ }
+
Expression _readStaticTearOff() {
int offset = readOffset();
return new StaticTearOff.byReference(readNonNullMemberReference())
diff --git a/pkg/kernel/lib/binary/ast_to_binary.dart b/pkg/kernel/lib/binary/ast_to_binary.dart
index 01e46ba..5460a6e 100644
--- a/pkg/kernel/lib/binary/ast_to_binary.dart
+++ b/pkg/kernel/lib/binary/ast_to_binary.dart
@@ -253,24 +253,39 @@
writeNonNullCanonicalNameReference(fieldRef.canonicalName!);
writeConstantReference(value);
});
- } else if (constant is PartialInstantiationConstant) {
- writeByte(ConstantTag.PartialInstantiationConstant);
+ } else if (constant is InstantiationConstant) {
+ writeByte(ConstantTag.InstantiationConstant);
writeConstantReference(constant.tearOffConstant);
final int length = constant.types.length;
writeUInt30(length);
for (int i = 0; i < length; ++i) {
writeDartType(constant.types[i]);
}
- } else if (constant is TearOffConstant) {
- writeByte(ConstantTag.TearOffConstant);
+ } else if (constant is StaticTearOffConstant) {
+ writeByte(ConstantTag.StaticTearOffConstant);
writeNonNullCanonicalNameReference(
constant.procedure.reference.canonicalName!);
+ } else if (constant is ConstructorTearOffConstant) {
+ writeByte(ConstantTag.ConstructorTearOffConstant);
+ writeNonNullCanonicalNameReference(
+ constant.constructor.reference.canonicalName!);
} else if (constant is TypeLiteralConstant) {
writeByte(ConstantTag.TypeLiteralConstant);
writeDartType(constant.type);
} else if (constant is UnevaluatedConstant) {
writeByte(ConstantTag.UnevaluatedConstant);
writeNode(constant.expression);
+ } else if (constant is TypedefTearOffConstant) {
+ writeByte(ConstantTag.TypedefTearOffConstant);
+ enterScope(typeParameters: constant.parameters);
+ writeNodeList(constant.parameters);
+ writeConstantReference(constant.tearOffConstant);
+ final int length = constant.types.length;
+ writeUInt30(length);
+ for (int i = 0; i < length; ++i) {
+ writeDartType(constant.types[i]);
+ }
+ leaveScope(typeParameters: constant.parameters);
} else {
throw new ArgumentError('Unsupported constant $constant');
}
@@ -1598,6 +1613,14 @@
}
@override
+ void visitTypedefTearOff(TypedefTearOff node) {
+ writeByte(Tag.TypedefTearOff);
+ writeNodeList(node.typeParameters);
+ writeNode(node.expression);
+ writeNodeList(node.typeArguments);
+ }
+
+ @override
void visitStaticTearOff(StaticTearOff node) {
writeByte(Tag.StaticTearOff);
writeOffset(node.fileOffset);
@@ -2689,26 +2712,42 @@
}
@override
- void visitPartialInstantiationConstant(PartialInstantiationConstant node) {
+ void visitInstantiationConstant(InstantiationConstant node) {
+ throw new UnsupportedError('serialization of InstantiationConstants ');
+ }
+
+ @override
+ void visitInstantiationConstantReference(InstantiationConstant node) {
throw new UnsupportedError(
- 'serialization of PartialInstantiationConstants ');
+ 'serialization of InstantiationConstant references');
}
@override
- void visitPartialInstantiationConstantReference(
- PartialInstantiationConstant node) {
+ void visitTypedefTearOffConstant(TypedefTearOffConstant node) {
+ throw new UnsupportedError('serialization of TypedefTearOffConstants ');
+ }
+
+ @override
+ void visitStaticTearOffConstant(StaticTearOffConstant node) {
+ throw new UnsupportedError('serialization of StaticTearOffConstants ');
+ }
+
+ @override
+ void visitConstructorTearOffConstant(ConstructorTearOffConstant node) {
+ throw new UnsupportedError('serialization of ConstructorTearOffConstants ');
+ }
+
+ @override
+ void visitStaticTearOffConstantReference(StaticTearOffConstant node) {
throw new UnsupportedError(
- 'serialization of PartialInstantiationConstant references');
+ 'serialization of StaticTearOffConstant references');
}
@override
- void visitTearOffConstant(TearOffConstant node) {
- throw new UnsupportedError('serialization of TearOffConstants ');
- }
-
- @override
- void visitTearOffConstantReference(TearOffConstant node) {
- throw new UnsupportedError('serialization of TearOffConstant references');
+ void visitConstructorTearOffConstantReference(
+ ConstructorTearOffConstant node) {
+ throw new UnsupportedError(
+ 'serialization of ConstructorTearOffConstant references');
}
@override
diff --git a/pkg/kernel/lib/binary/tag.dart b/pkg/kernel/lib/binary/tag.dart
index 9c0d0f9..e5291c5 100644
--- a/pkg/kernel/lib/binary/tag.dart
+++ b/pkg/kernel/lib/binary/tag.dart
@@ -77,6 +77,7 @@
static const int ConstListLiteral = 58;
static const int ConstMapLiteral = 59;
static const int ConstructorTearOff = 60;
+ static const int TypedefTearOff = 83;
static const int SetLiteral = 109;
static const int ConstSetLiteral = 110;
@@ -123,6 +124,7 @@
static const int AsyncForInStatement = 80;
static const int AssertBlock = 81;
// 82 is occupied by [BlockExpression] (expression).
+ // 83 is occupied by [TypedefTearOff] (expression).
// Types
static const int TypedefType = 87;
@@ -175,7 +177,7 @@
/// Internal version of kernel binary format.
/// Bump it when making incompatible changes in kernel binaries.
/// Keep in sync with runtime/vm/kernel_binary.h, pkg/kernel/binary.md.
- static const int BinaryFormatVersion = 66;
+ static const int BinaryFormatVersion = 67;
}
abstract class ConstantTag {
@@ -189,11 +191,13 @@
static const int ListConstant = 7;
static const int SetConstant = 13;
static const int InstanceConstant = 8;
- static const int PartialInstantiationConstant = 9;
- static const int TearOffConstant = 10;
+ static const int InstantiationConstant = 9;
+ static const int StaticTearOffConstant = 10;
static const int TypeLiteralConstant = 11;
static const int UnevaluatedConstant = 12;
// 13 is occupied by [SetConstant]
+ static const int TypedefTearOffConstant = 14;
+ static const int ConstructorTearOffConstant = 15;
}
const int sdkHashLength = 10; // Bytes, a Git "short hash".
diff --git a/pkg/kernel/lib/clone.dart b/pkg/kernel/lib/clone.dart
index efbe399..86e78d6 100644
--- a/pkg/kernel/lib/clone.dart
+++ b/pkg/kernel/lib/clone.dart
@@ -507,7 +507,7 @@
}
}
- visitTypeParameter(TypeParameter node) {
+ TypeParameter visitTypeParameter(TypeParameter node) {
TypeParameter newNode = typeParams[node]!;
newNode.bound = visitType(node.bound);
// ignore: unnecessary_null_comparison
@@ -740,6 +740,15 @@
TreeNode visitConstructorTearOff(ConstructorTearOff node) {
return new ConstructorTearOff.byReference(node.constructorReference);
}
+
+ @override
+ TreeNode visitTypedefTearOff(TypedefTearOff node) {
+ prepareTypeParameters(node.typeParameters);
+ return new TypedefTearOff(
+ node.typeParameters.map(visitTypeParameter).toList(),
+ clone(node.expression),
+ node.typeArguments.map(visitType).toList());
+ }
}
/// Visitor that return a clone of a tree, maintaining references to cloned
diff --git a/pkg/kernel/lib/text/ast_to_text.dart b/pkg/kernel/lib/text/ast_to_text.dart
index 0017fd4..b9ab3da 100644
--- a/pkg/kernel/lib/text/ast_to_text.dart
+++ b/pkg/kernel/lib/text/ast_to_text.dart
@@ -49,7 +49,7 @@
// Name everything in post-order visit of DAG.
getName(value);
}
- } else if (constant is TearOffConstant) {
+ } else if (constant is StaticTearOffConstant) {
// We only care about naming the constants themselves. [TearOffConstant]
// has no Constant children.
// Avoid visiting `TearOffConstant.procedureReference`.
@@ -2659,13 +2659,13 @@
endLine('}');
}
- visitPartialInstantiationConstant(PartialInstantiationConstant node) {
+ visitInstantiationConstant(InstantiationConstant node) {
writeIndentation();
writeConstantReference(node);
writeSpaced('=');
writeWord('partial-instantiation');
writeSpace();
- writeMemberReferenceFromReference(node.tearOffConstant.procedureReference);
+ writeMemberReferenceFromReference(node.tearOffConstant.memberReference);
writeSpace();
writeSymbol('<');
writeList(node.types, writeType);
@@ -2680,13 +2680,13 @@
endLine('"${escapeString(node.value)}"');
}
- visitTearOffConstant(TearOffConstant node) {
+ visitStaticTearOffConstant(StaticTearOffConstant node) {
writeIndentation();
writeConstantReference(node);
writeSpaced('=');
writeWord('tearoff');
writeSpace();
- writeMemberReferenceFromReference(node.procedureReference);
+ writeMemberReferenceFromReference(node.memberReference);
endLine();
}
@@ -2906,6 +2906,9 @@
int visitConstructorTearOff(ConstructorTearOff node) => PRIMARY;
@override
+ int visitTypedefTearOff(TypedefTearOff node) => EXPRESSION;
+
+ @override
int visitLet(Let node) => EXPRESSION;
@override
diff --git a/pkg/kernel/lib/text/text_serializer.dart b/pkg/kernel/lib/text/text_serializer.dart
index c96bed2..0c4f26e 100644
--- a/pkg/kernel/lib/text/text_serializer.dart
+++ b/pkg/kernel/lib/text/text_serializer.dart
@@ -2204,12 +2204,13 @@
String visitListConstant(ListConstant node) => "const-list";
String visitMapConstant(MapConstant node) => "const-map";
String visitNullConstant(NullConstant node) => "const-null";
- String visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
+ String visitInstantiationConstant(InstantiationConstant node) =>
"const-apply";
String visitSetConstant(SetConstant node) => "const-set";
String visitStringConstant(StringConstant node) => "const-string";
String visitSymbolConstant(SymbolConstant node) => "const-symbol";
- String visitTearOffConstant(TearOffConstant node) => "const-tearoff";
+ String visitStaticTearOffConstant(StaticTearOffConstant node) =>
+ "const-tearoff";
String visitTypeLiteralConstant(TypeLiteralConstant node) => "const-type";
String visitUnevaluatedConstant(UnevaluatedConstant node) => "const-expr";
@@ -2254,12 +2255,10 @@
TextSerializer<NullConstant> nullConstantSerializer =
Wrapped<void, NullConstant>((w) => null, (u) => NullConstant(), Nothing());
-TextSerializer<PartialInstantiationConstant>
- partialInstantiationConstantSerializer = Wrapped<
- Tuple2<TearOffConstant, List<DartType>>,
- PartialInstantiationConstant>(
+TextSerializer<InstantiationConstant> instantiationConstantSerializer =
+ Wrapped<Tuple2<TearOffConstant, List<DartType>>, InstantiationConstant>(
(w) => Tuple2(w.tearOffConstant, w.types),
- (u) => PartialInstantiationConstant(u.first, u.second),
+ (u) => InstantiationConstant(u.first, u.second),
Tuple2Serializer(
tearOffConstantSerializer, ListSerializer(dartTypeSerializer)));
@@ -2280,10 +2279,10 @@
(u) => SymbolConstant(u.first, u.second?.reference),
Tuple2Serializer(DartString(), Optional(CanonicalNameSerializer())));
-TextSerializer<TearOffConstant> tearOffConstantSerializer =
- Wrapped<CanonicalName, TearOffConstant>(
- (w) => w.procedureReference.canonicalName!,
- (u) => TearOffConstant.byReference(u.reference),
+TextSerializer<StaticTearOffConstant> tearOffConstantSerializer =
+ Wrapped<CanonicalName, StaticTearOffConstant>(
+ (w) => w.memberReference.canonicalName!,
+ (u) => StaticTearOffConstant.byReference(u.reference),
CanonicalNameSerializer());
TextSerializer<TypeLiteralConstant> typeLiteralConstantSerializer =
@@ -2656,7 +2655,7 @@
"const-list": listConstantSerializer,
"const-map": mapConstantSerializer,
"const-null": nullConstantSerializer,
- "const-apply": partialInstantiationConstantSerializer,
+ "const-apply": instantiationConstantSerializer,
"const-set": setConstantSerializer,
"const-string": stringConstantSerializer,
"const-symbol": symbolConstantSerializer,
diff --git a/pkg/kernel/lib/type_checker.dart b/pkg/kernel/lib/type_checker.dart
index 777875d..af4d5e3 100644
--- a/pkg/kernel/lib/type_checker.dart
+++ b/pkg/kernel/lib/type_checker.dart
@@ -526,6 +526,31 @@
}
@override
+ DartType visitTypedefTearOff(TypedefTearOff node) {
+ DartType type = visitExpression(node.expression);
+ if (type is! FunctionType) {
+ fail(node, 'Not a function type: $type');
+ return NeverType.fromNullability(currentLibrary!.nonNullable);
+ }
+ FunctionType functionType = type;
+ if (functionType.typeParameters.length != node.typeArguments.length) {
+ fail(node, 'Wrong number of type arguments');
+ return NeverType.fromNullability(currentLibrary!.nonNullable);
+ }
+ FreshTypeParameters freshTypeParameters =
+ getFreshTypeParameters(node.typeParameters);
+ FunctionType result = freshTypeParameters.substitute(_instantiateFunction(
+ functionType.typeParameters, node.typeArguments, node)
+ .substituteType(functionType.withoutTypeParameters)) as FunctionType;
+ return new FunctionType(result.positionalParameters, result.returnType,
+ result.declaredNullability,
+ namedParameters: result.namedParameters,
+ typeParameters: freshTypeParameters.freshTypeParameters,
+ requiredParameterCount: result.requiredParameterCount,
+ typedefType: null);
+ }
+
+ @override
DartType visitListLiteral(ListLiteral node) {
for (int i = 0; i < node.expressions.length; ++i) {
node.expressions[i] =
diff --git a/pkg/kernel/lib/visitor.dart b/pkg/kernel/lib/visitor.dart
index ae31864b..1f71e2c 100644
--- a/pkg/kernel/lib/visitor.dart
+++ b/pkg/kernel/lib/visitor.dart
@@ -82,6 +82,7 @@
R visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) =>
defaultExpression(node);
R visitConstructorTearOff(ConstructorTearOff node) => defaultExpression(node);
+ R visitTypedefTearOff(TypedefTearOff node) => defaultExpression(node);
}
abstract class StatementVisitor<R> {
@@ -257,6 +258,7 @@
R visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) =>
defaultExpression(node);
R visitConstructorTearOff(ConstructorTearOff node) => defaultExpression(node);
+ R visitTypedefTearOff(TypedefTearOff node) => defaultExpression(node);
// Statements
R defaultStatement(Statement node) => defaultTreeNode(node);
@@ -434,6 +436,8 @@
defaultExpression(node, arg);
R visitConstructorTearOff(ConstructorTearOff node, A arg) =>
defaultExpression(node, arg);
+ R visitTypedefTearOff(TypedefTearOff node, A arg) =>
+ defaultExpression(node, arg);
// Statements
R defaultStatement(Statement node, A arg) => defaultTreeNode(node, arg);
@@ -577,9 +581,14 @@
R visitListConstant(ListConstant node) => defaultConstant(node);
R visitSetConstant(SetConstant node) => defaultConstant(node);
R visitInstanceConstant(InstanceConstant node) => defaultConstant(node);
- R visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
+ R visitInstantiationConstant(InstantiationConstant node) =>
defaultConstant(node);
- R visitTearOffConstant(TearOffConstant node) => defaultConstant(node);
+ R visitTypedefTearOffConstant(TypedefTearOffConstant node) =>
+ defaultConstant(node);
+ R visitStaticTearOffConstant(StaticTearOffConstant node) =>
+ defaultConstant(node);
+ R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
+ defaultConstant(node);
R visitTypeLiteralConstant(TypeLiteralConstant node) => defaultConstant(node);
R visitUnevaluatedConstant(UnevaluatedConstant node) => defaultConstant(node);
}
@@ -597,8 +606,10 @@
R visitListConstant(ListConstant node);
R visitSetConstant(SetConstant node);
R visitInstanceConstant(InstanceConstant node);
- R visitPartialInstantiationConstant(PartialInstantiationConstant node);
- R visitTearOffConstant(TearOffConstant node);
+ R visitInstantiationConstant(InstantiationConstant node);
+ R visitTypedefTearOffConstant(TypedefTearOffConstant node);
+ R visitStaticTearOffConstant(StaticTearOffConstant node);
+ R visitConstructorTearOffConstant(ConstructorTearOffConstant node);
R visitTypeLiteralConstant(TypeLiteralConstant node);
R visitUnevaluatedConstant(UnevaluatedConstant node);
}
@@ -617,12 +628,20 @@
_callback.visitTypeLiteralConstant(node);
@override
- R visitTearOffConstant(TearOffConstant node) =>
- _callback.visitTearOffConstant(node);
+ R visitStaticTearOffConstant(StaticTearOffConstant node) =>
+ _callback.visitStaticTearOffConstant(node);
@override
- R visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
- _callback.visitPartialInstantiationConstant(node);
+ R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
+ _callback.visitConstructorTearOffConstant(node);
+
+ @override
+ R visitInstantiationConstant(InstantiationConstant node) =>
+ _callback.visitInstantiationConstant(node);
+
+ @override
+ R visitTypedefTearOffConstant(TypedefTearOffConstant node) =>
+ _callback.visitTypedefTearOffConstant(node);
@override
R visitInstanceConstant(InstanceConstant node) =>
@@ -703,9 +722,14 @@
R visitListConstant(ListConstant node) => defaultConstant(node);
R visitSetConstant(SetConstant node) => defaultConstant(node);
R visitInstanceConstant(InstanceConstant node) => defaultConstant(node);
- R visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
+ R visitInstantiationConstant(InstantiationConstant node) =>
defaultConstant(node);
- R visitTearOffConstant(TearOffConstant node) => defaultConstant(node);
+ R visitTypedefTearOffConstant(TypedefTearOffConstant node) =>
+ defaultConstant(node);
+ R visitStaticTearOffConstant(StaticTearOffConstant node) =>
+ defaultConstant(node);
+ R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
+ defaultConstant(node);
R visitTypeLiteralConstant(TypeLiteralConstant node) => defaultConstant(node);
R visitUnevaluatedConstant(UnevaluatedConstant node) => defaultConstant(node);
}
@@ -744,9 +768,12 @@
void visitListConstant(ListConstant node) => defaultConstant(node);
void visitSetConstant(SetConstant node) => defaultConstant(node);
void visitInstanceConstant(InstanceConstant node) => defaultConstant(node);
- void visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
+ void visitInstantiationConstant(InstantiationConstant node) =>
defaultConstant(node);
- void visitTearOffConstant(TearOffConstant node) => defaultConstant(node);
+ void visitStaticTearOffConstant(StaticTearOffConstant node) =>
+ defaultConstant(node);
+ void visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
+ defaultConstant(node);
void visitTypeLiteralConstant(TypeLiteralConstant node) =>
defaultConstant(node);
void visitUnevaluatedConstant(UnevaluatedConstant node) =>
@@ -804,9 +831,14 @@
R visitListConstant(ListConstant node) => defaultConstant(node);
R visitSetConstant(SetConstant node) => defaultConstant(node);
R visitInstanceConstant(InstanceConstant node) => defaultConstant(node);
- R visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
+ R visitInstantiationConstant(InstantiationConstant node) =>
defaultConstant(node);
- R visitTearOffConstant(TearOffConstant node) => defaultConstant(node);
+ R visitTypedefTearOffConstant(TypedefTearOffConstant node) =>
+ defaultConstant(node);
+ R visitStaticTearOffConstant(StaticTearOffConstant node) =>
+ defaultConstant(node);
+ R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
+ defaultConstant(node);
R visitTypeLiteralConstant(TypeLiteralConstant node) => defaultConstant(node);
R visitUnevaluatedConstant(UnevaluatedConstant node) => defaultConstant(node);
@@ -840,10 +872,11 @@
defaultConstantReference(node);
R visitInstanceConstantReference(InstanceConstant node) =>
defaultConstantReference(node);
- R visitPartialInstantiationConstantReference(
- PartialInstantiationConstant node) =>
+ R visitInstantiationConstantReference(InstantiationConstant node) =>
defaultConstantReference(node);
- R visitTearOffConstantReference(TearOffConstant node) =>
+ R visitStaticTearOffConstantReference(StaticTearOffConstant node) =>
+ defaultConstantReference(node);
+ R visitConstructorTearOffConstantReference(ConstructorTearOffConstant node) =>
defaultConstantReference(node);
R visitTypeLiteralConstantReference(TypeLiteralConstant node) =>
defaultConstantReference(node);
@@ -1548,6 +1581,8 @@
defaultExpression(node, arg);
R visitConstructorTearOff(ConstructorTearOff node, T arg) =>
defaultExpression(node, arg);
+ R visitTypedefTearOff(TypedefTearOff node, T arg) =>
+ defaultExpression(node, arg);
}
abstract class StatementVisitor1<R, T> {
diff --git a/pkg/vm/lib/transformations/ffi_use_sites.dart b/pkg/vm/lib/transformations/ffi_use_sites.dart
index 8cce3b0..4600fde 100644
--- a/pkg/vm/lib/transformations/ffi_use_sites.dart
+++ b/pkg/vm/lib/transformations/ffi_use_sites.dart
@@ -770,7 +770,8 @@
void _ensureIsStaticFunction(Expression node) {
if ((node is StaticGet && node.target is Procedure) ||
- (node is ConstantExpression && node.constant is TearOffConstant)) {
+ (node is ConstantExpression &&
+ node.constant is StaticTearOffConstant)) {
return;
}
diagnosticReporter.report(
diff --git a/pkg/vm/lib/transformations/type_flow/summary_collector.dart b/pkg/vm/lib/transformations/type_flow/summary_collector.dart
index 0986d7e..fac8e00 100644
--- a/pkg/vm/lib/transformations/type_flow/summary_collector.dart
+++ b/pkg/vm/lib/transformations/type_flow/summary_collector.dart
@@ -2474,17 +2474,20 @@
}
@override
- Type visitTearOffConstant(TearOffConstant constant) {
- final Procedure procedure = constant.procedure;
+ Type visitStaticTearOffConstant(StaticTearOffConstant constant) {
+ final Member member = constant.procedure;
summaryCollector._entryPointsListener
- .addRawCall(new DirectSelector(procedure));
- summaryCollector._entryPointsListener.recordTearOff(procedure);
+ .addRawCall(new DirectSelector(member));
+ if (member is Constructor) {
+ summaryCollector._entryPointsListener
+ .addAllocatedClass(member.enclosingClass);
+ }
+ summaryCollector._entryPointsListener.recordTearOff(member);
return _getStaticType(constant);
}
@override
- Type visitPartialInstantiationConstant(
- PartialInstantiationConstant constant) {
+ Type visitInstantiationConstant(InstantiationConstant constant) {
constant.tearOffConstant.accept(this);
return _getStaticType(constant);
}
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index 47cce1b..e9473dd 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -1794,12 +1794,12 @@
}
@override
- visitTearOffConstant(TearOffConstant constant) {
+ visitStaticTearOffConstant(StaticTearOffConstant constant) {
shaker.addUsedMember(constant.procedure);
}
@override
- visitPartialInstantiationConstant(PartialInstantiationConstant constant) {
+ visitInstantiationConstant(InstantiationConstant constant) {
analyzeConstant(constant.tearOffConstant);
}
diff --git a/runtime/vm/compiler/frontend/constant_reader.cc b/runtime/vm/compiler/frontend/constant_reader.cc
index a9bd54f..f2c7656 100644
--- a/runtime/vm/compiler/frontend/constant_reader.cc
+++ b/runtime/vm/compiler/frontend/constant_reader.cc
@@ -310,7 +310,7 @@
}
break;
}
- case kPartialInstantiationConstant: {
+ case kInstantiationConstant: {
// Recurse into lazily evaluating the "sub" constant
// needed to evaluate the current constant.
const intptr_t entry_index = reader.ReadUInt();
@@ -345,7 +345,7 @@
type_arguments, function, context, Heap::kOld);
break;
}
- case kTearOffConstant: {
+ case kStaticTearOffConstant: {
const NameIndex index = reader.ReadCanonicalNameReference();
Function& function =
Function::Handle(Z, H.LookupStaticMethodByKernelProcedure(index));
diff --git a/runtime/vm/kernel_binary.h b/runtime/vm/kernel_binary.h
index 1c55440..57b229a 100644
--- a/runtime/vm/kernel_binary.h
+++ b/runtime/vm/kernel_binary.h
@@ -20,8 +20,8 @@
static const uint32_t kMagicProgramFile = 0x90ABCDEFu;
// Both version numbers are inclusive.
-static const uint32_t kMinSupportedKernelFormatVersion = 66;
-static const uint32_t kMaxSupportedKernelFormatVersion = 66;
+static const uint32_t kMinSupportedKernelFormatVersion = 67;
+static const uint32_t kMaxSupportedKernelFormatVersion = 67;
// Keep in sync with package:kernel/lib/binary/tag.dart
#define KERNEL_TAG_LIST(V) \
@@ -97,6 +97,7 @@
V(ConstSetLiteral, 110) \
V(ConstMapLiteral, 59) \
V(ConstructorTearOff, 60) \
+ V(TypedefTearOff, 83) \
V(ExpressionStatement, 61) \
V(Block, 62) \
V(EmptyStatement, 63) \
@@ -166,12 +167,14 @@
kListConstant = 7,
kSetConstant = 13,
kInstanceConstant = 8,
- kPartialInstantiationConstant = 9,
- kTearOffConstant = 10,
+ kInstantiationConstant = 9,
+ kStaticTearOffConstant = 10,
kTypeLiteralConstant = 11,
// These constants are not expected to be seen by the VM, because all
// constants are fully evaluated.
kUnevaluatedConstant = 12,
+ kTypedefTearOffConstant = 14,
+ kConstructorTearOffConstant = 15,
};
// Keep in sync with package:kernel/lib/ast.dart
diff --git a/tools/VERSION b/tools/VERSION
index 4a7410b..d53fa3f 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 14
PATCH 0
-PRERELEASE 260
+PRERELEASE 261
PRERELEASE_PATCH 0
\ No newline at end of file
