mirror of
https://github.com/dart-lang/sdk
synced 2024-09-16 00:58:29 +00:00
[CFE] Add constant replacer
Adds a replacement visitor for Constant types using null as a sentinel value for whether a subnode has changed or not (except in the case of TreeNodes in order to match existing Visitor semantics). Change-Id: Iaaab1b1c608af07f36ece08071b3d703884cd91b Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/248944 Reviewed-by: Johnni Winther <johnniwinther@google.com> Commit-Queue: Srujan Gaddam <srujzs@google.com>
This commit is contained in:
parent
837bb22581
commit
0036dc7c57
208
pkg/kernel/lib/src/constant_replacer.dart
Normal file
208
pkg/kernel/lib/src/constant_replacer.dart
Normal file
|
@ -0,0 +1,208 @@
|
|||
// Copyright (c) 2022, 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 '../ast.dart';
|
||||
|
||||
/// Replacement visitor to clone a Constant if a subnode is replaced, and
|
||||
/// otherwise returns `null`.
|
||||
class ConstantReplacer implements ConstantVisitor<Constant?> {
|
||||
ConstantReplacer();
|
||||
final Map<Constant, Constant?> cache = {};
|
||||
|
||||
/// Like with Constants, `null` is used to signal that the [type] has not
|
||||
/// changed.
|
||||
DartType? visitDartType(DartType type) => null;
|
||||
|
||||
/// Unlike Constants and DartTypes, TreeNodes' equality checks are not
|
||||
/// structural and therefore can be checked directly without needing `null`.
|
||||
TreeNode visitTreeNode(TreeNode node) => node;
|
||||
|
||||
/// Returns a new type list that contains the recursively visited [types].
|
||||
///
|
||||
/// Returns `null` if a recursive visit of [types] does not change the list.
|
||||
List<DartType>? visitDartTypeList(List<DartType> types) {
|
||||
List<DartType>? newTypes;
|
||||
for (int i = 0; i < types.length; i++) {
|
||||
DartType? result = visitDartType(types[i]);
|
||||
if (result != null) {
|
||||
(newTypes ??= List.of(types))[i] = result;
|
||||
}
|
||||
}
|
||||
return newTypes;
|
||||
}
|
||||
|
||||
/// Returns a new Constant list that contains the recursively visited
|
||||
/// [constants].
|
||||
///
|
||||
/// Returns `null` if a recursive visit of [constants] does not change the
|
||||
/// list.
|
||||
List<Constant>? visitConstantList(List<Constant> constants) {
|
||||
List<Constant>? newConstants;
|
||||
for (int i = 0; i < constants.length; i++) {
|
||||
Constant? result = visitConstant(constants[i]);
|
||||
if (result != null) {
|
||||
(newConstants ??= List.of(constants))[i] = result;
|
||||
}
|
||||
}
|
||||
return newConstants;
|
||||
}
|
||||
|
||||
/// By default, don't change the [node].
|
||||
@override
|
||||
Constant? defaultConstant(Constant node) => null;
|
||||
|
||||
/// Visits [node] if not already visited to compute a value for [node].
|
||||
///
|
||||
/// If the value has already been computed the cached value is returned
|
||||
/// immediately.
|
||||
///
|
||||
/// Call this method to compute values for subnodes recursively, while only
|
||||
/// visiting each subnode once.
|
||||
Constant? visitConstant(Constant node) {
|
||||
return cache[node] ??= node.accept(this);
|
||||
}
|
||||
|
||||
@override
|
||||
Constant? visitBoolConstant(BoolConstant node) => defaultConstant(node);
|
||||
|
||||
@override
|
||||
Constant? visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
|
||||
defaultConstant(node);
|
||||
|
||||
@override
|
||||
Constant? visitDoubleConstant(DoubleConstant node) => defaultConstant(node);
|
||||
|
||||
@override
|
||||
Constant? visitIntConstant(IntConstant node) => defaultConstant(node);
|
||||
|
||||
@override
|
||||
Constant? visitNullConstant(NullConstant node) => defaultConstant(node);
|
||||
|
||||
@override
|
||||
Constant? visitRedirectingFactoryTearOffConstant(
|
||||
RedirectingFactoryTearOffConstant node) =>
|
||||
defaultConstant(node);
|
||||
|
||||
@override
|
||||
Constant? visitStaticTearOffConstant(StaticTearOffConstant node) =>
|
||||
defaultConstant(node);
|
||||
|
||||
@override
|
||||
Constant? visitStringConstant(StringConstant node) => defaultConstant(node);
|
||||
|
||||
@override
|
||||
Constant? visitSymbolConstant(SymbolConstant node) => defaultConstant(node);
|
||||
|
||||
@override
|
||||
Constant? visitInstanceConstant(InstanceConstant node) {
|
||||
List<DartType>? typeArguments = visitDartTypeList(node.typeArguments);
|
||||
Map<Reference, Constant>? fieldValues;
|
||||
for (Reference reference in node.fieldValues.keys) {
|
||||
Constant? result = visitConstant(node.fieldValues[reference]!);
|
||||
if (result != null) {
|
||||
(fieldValues ??= Map.of(node.fieldValues))[reference] = result;
|
||||
}
|
||||
}
|
||||
if (typeArguments == null && fieldValues == null) {
|
||||
return null;
|
||||
} else {
|
||||
return InstanceConstant(node.classReference,
|
||||
typeArguments ?? node.typeArguments, fieldValues ?? node.fieldValues);
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Constant? visitInstantiationConstant(InstantiationConstant node) {
|
||||
List<DartType>? types = visitDartTypeList(node.types);
|
||||
Constant? tearOffConstant = visitConstant(node.tearOffConstant);
|
||||
if (types == null && tearOffConstant == null) {
|
||||
return null;
|
||||
} else {
|
||||
return InstantiationConstant(
|
||||
tearOffConstant ?? node.tearOffConstant, types ?? node.types);
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Constant? visitListConstant(ListConstant node) {
|
||||
DartType? typeArgument = visitDartType(node.typeArgument);
|
||||
List<Constant>? entries = visitConstantList(node.entries);
|
||||
if (typeArgument == null && entries == null) {
|
||||
return null;
|
||||
} else {
|
||||
return ListConstant(
|
||||
typeArgument ?? node.typeArgument, entries ?? node.entries);
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Constant? visitMapConstant(MapConstant node) {
|
||||
DartType? keyType = visitDartType(node.keyType);
|
||||
DartType? valueType = visitDartType(node.valueType);
|
||||
List<ConstantMapEntry>? entries;
|
||||
for (int i = 0; i < node.entries.length; i++) {
|
||||
ConstantMapEntry entry = node.entries[i];
|
||||
Constant? key = visitConstant(entry.key);
|
||||
Constant? value = visitConstant(entry.value);
|
||||
if (key != null || value != null) {
|
||||
(entries ??= List.of(node.entries))[i] =
|
||||
ConstantMapEntry(key ?? entry.key, value ?? entry.value);
|
||||
}
|
||||
}
|
||||
if (keyType == null && valueType == null && entries == null) {
|
||||
return null;
|
||||
} else {
|
||||
return MapConstant(keyType ?? node.keyType, valueType ?? node.valueType,
|
||||
entries ?? node.entries);
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Constant? visitSetConstant(SetConstant node) {
|
||||
DartType? typeArgument = visitDartType(node.typeArgument);
|
||||
List<Constant>? entries = visitConstantList(node.entries);
|
||||
if (typeArgument == null && entries == null) {
|
||||
return null;
|
||||
} else {
|
||||
return SetConstant(
|
||||
typeArgument ?? node.typeArgument, entries ?? node.entries);
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Constant? visitTypeLiteralConstant(TypeLiteralConstant node) {
|
||||
DartType? type = visitDartType(node.type);
|
||||
return type == null ? null : TypeLiteralConstant(type);
|
||||
}
|
||||
|
||||
@override
|
||||
Constant? visitTypedefTearOffConstant(TypedefTearOffConstant node) {
|
||||
TearOffConstant? tearOffConstant =
|
||||
visitConstant(node.tearOffConstant) as TearOffConstant?;
|
||||
List<DartType>? types = visitDartTypeList(node.types);
|
||||
List<TypeParameter>? parameters;
|
||||
for (int i = 0; i < node.parameters.length; i++) {
|
||||
TypeParameter result = visitTreeNode(node.parameters[i]) as TypeParameter;
|
||||
if (result != node.parameters[i]) {
|
||||
(parameters ??= List.of(node.parameters))[i] = result;
|
||||
}
|
||||
}
|
||||
if (tearOffConstant == null && types == null && parameters == null) {
|
||||
return null;
|
||||
} else {
|
||||
return TypedefTearOffConstant(parameters ?? node.parameters,
|
||||
tearOffConstant ?? node.tearOffConstant, types ?? node.types);
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Constant? visitUnevaluatedConstant(UnevaluatedConstant node) {
|
||||
Expression expression = visitTreeNode(node.expression) as Expression;
|
||||
if (expression == node.expression) {
|
||||
return null;
|
||||
} else {
|
||||
return UnevaluatedConstant(expression);
|
||||
}
|
||||
}
|
||||
}
|
Loading…
Reference in a new issue