blob: 8ac5f4ffa3ef0f2713c5e8fc1aff55e11eb1264f [file] [log] [blame]
// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'package:analyzer/dart/ast/ast.dart';
import 'package:analyzer/dart/ast/token.dart';
import 'package:analyzer/dart/element/type.dart' show DartType;
import 'package:analyzer/src/summary/format.dart';
import 'package:analyzer/src/summary/idl.dart';
/**
* Serialize the given constructor initializer [node].
*/
UnlinkedConstructorInitializerBuilder serializeConstructorInitializer(
ConstructorInitializer node,
UnlinkedExprBuilder serializeConstExpr(Expression expr)) {
if (node is ConstructorFieldInitializer) {
return new UnlinkedConstructorInitializerBuilder(
kind: UnlinkedConstructorInitializerKind.field,
name: node.fieldName.name,
expression: serializeConstExpr(node.expression));
}
List<UnlinkedExprBuilder> arguments = <UnlinkedExprBuilder>[];
List<String> argumentNames = <String>[];
void serializeArguments(List<Expression> args) {
for (Expression arg in args) {
if (arg is NamedExpression) {
NamedExpression namedExpression = arg;
argumentNames.add(namedExpression.name.label.name);
arg = namedExpression.expression;
}
arguments.add(serializeConstExpr(arg));
}
}
if (node is AssertInitializer) {
serializeArguments(node.message != null
? [node.condition, node.message]
: [node.condition]);
return new UnlinkedConstructorInitializerBuilder(
kind: UnlinkedConstructorInitializerKind.assertInvocation,
arguments: arguments);
}
if (node is RedirectingConstructorInvocation) {
serializeArguments(node.argumentList.arguments);
return new UnlinkedConstructorInitializerBuilder(
kind: UnlinkedConstructorInitializerKind.thisInvocation,
name: node?.constructorName?.name,
arguments: arguments,
argumentNames: argumentNames);
}
if (node is SuperConstructorInvocation) {
serializeArguments(node.argumentList.arguments);
return new UnlinkedConstructorInitializerBuilder(
kind: UnlinkedConstructorInitializerKind.superInvocation,
name: node?.constructorName?.name,
arguments: arguments,
argumentNames: argumentNames);
}
throw new StateError('Unexpected initializer type ${node.runtimeType}');
}
/**
* Instances of this class keep track of intermediate state during
* serialization of a single constant [Expression].
*/
abstract class AbstractConstExprSerializer {
/**
* Whether an expression that should be a constant is being serialized.
*
* For constants we need to store more than we need just for type inference,
* because we need to be able to restore these AST to evaluate actual values
* of constants. So, we need to store constructor arguments, elements for
* list and map literals even if these literals are typed.
*/
final bool forConst;
/**
* See [UnlinkedExprBuilder.isValidConst].
*/
bool isValidConst = true;
/**
* See [UnlinkedExprBuilder.name].
*/
String name = null;
/**
* See [UnlinkedExprBuilder.operations].
*/
final List<UnlinkedExprOperation> operations = <UnlinkedExprOperation>[];
/**
* See [UnlinkedExprBuilder.assignmentOperators].
*/
final List<UnlinkedExprAssignOperator> assignmentOperators =
<UnlinkedExprAssignOperator>[];
/**
* See [UnlinkedExprBuilder.ints].
*/
final List<int> ints = <int>[];
/**
* See [UnlinkedExprBuilder.doubles].
*/
final List<double> doubles = <double>[];
/**
* See [UnlinkedExprBuilder.strings].
*/
final List<String> strings = <String>[];
/**
* See [UnlinkedExprBuilder.references].
*/
final List<EntityRefBuilder> references = <EntityRefBuilder>[];
AbstractConstExprSerializer(this.forConst);
/**
* Return `true` if the given [name] is a parameter reference.
*/
bool isParameterName(String name);
/**
* Serialize the given [expr] expression into this serializer state.
*/
void serialize(Expression expr) {
try {
if (expr is NamedExpression) {
NamedExpression namedExpression = expr;
name = namedExpression.name.label.name;
expr = namedExpression.expression;
}
_serialize(expr);
} on StateError {
isValidConst = false;
operations.clear();
assignmentOperators.clear();
ints.clear();
doubles.clear();
strings.clear();
references.clear();
}
}
/**
* Serialize the given [annotation] into this serializer state.
*/
void serializeAnnotation(Annotation annotation);
/**
* Return [EntityRefBuilder] that corresponds to the constructor having name
* [name] in the class identified by [typeName]. It is expected that [type]
* corresponds to the given [typeName] and [typeArguments]. The parameter
* [type] might be `null` if the type is not resolved.
*/
EntityRefBuilder serializeConstructorRef(DartType type, Identifier typeName,
TypeArgumentList typeArguments, SimpleIdentifier name);
/**
* Return a pair of ints showing how the given [functionExpression] is nested
* within the constant currently being serialized. The first int indicates
* how many levels of function nesting must be popped in order to reach the
* parent of the [functionExpression]. The second int is the index of the
* [functionExpression] within its parent element.
*
* If the constant being summarized is in a context where local function
* references are not allowed, return `null`.
*/
List<int> serializeFunctionExpression(FunctionExpression functionExpression);
/**
* Return [EntityRefBuilder] that corresponds to the [type], which is defined
* using generic function type syntax. These may appear as the type arguments
* of a const list, etc.
*/
EntityRefBuilder serializeGenericFunctionType(GenericFunctionType type);
/**
* Return [EntityRefBuilder] that corresponds to the given [identifier].
*/
EntityRefBuilder serializeIdentifier(Identifier identifier);
/**
* Return [EntityRefBuilder] that corresponds to the given [expr], which
* must be a sequence of identifiers.
*/
EntityRefBuilder serializeIdentifierSequence(Expression expr);
void serializeInstanceCreation(EntityRefBuilder constructor,
ArgumentList argumentList, bool typeArgumentsProvided) {
_serializeArguments(argumentList, typeArgumentsProvided);
references.add(constructor);
operations.add(UnlinkedExprOperation.invokeConstructor);
}
/**
* Return [EntityRefBuilder] that corresponds to the given [type].
*/
EntityRefBuilder serializeType(TypeAnnotation type) {
if (type is TypeName) {
return serializeTypeName(type?.type, type?.name, type?.typeArguments);
}
if (type is GenericFunctionType) {
return serializeGenericFunctionType(type);
}
throw new ArgumentError(
'Cannot serialize an instance of ${type.runtimeType}');
}
/**
* Return [EntityRefBuilder] that corresponds to the [type] with the given
* [name] and [arguments]. It is expected that [type] corresponds to the
* given [name] and [arguments]. The parameter [type] might be `null` if the
* type is not resolved.
*/
EntityRefBuilder serializeTypeName(
DartType type, Identifier name, TypeArgumentList arguments);
/**
* Return the [UnlinkedExprBuilder] that corresponds to the state of this
* serializer.
*/
UnlinkedExprBuilder toBuilder() {
return new UnlinkedExprBuilder(
isValidConst: isValidConst,
operations: operations,
assignmentOperators: assignmentOperators,
ints: ints,
doubles: doubles,
strings: strings,
references: references);
}
/**
* Return `true` if the given [expr] is a sequence of identifiers.
*/
bool _isIdentifierSequence(Expression expr) {
while (expr != null) {
if (expr is SimpleIdentifier) {
AstNode parent = expr.parent;
if (parent is MethodInvocation && parent.methodName == expr) {
if (parent.isCascaded) {
return false;
}
return parent.target == null || _isIdentifierSequence(parent.target);
}
if (isParameterName(expr.name)) {
return false;
}
return true;
} else if (expr is PrefixedIdentifier) {
expr = (expr as PrefixedIdentifier).prefix;
} else if (expr is PropertyAccess) {
expr = (expr as PropertyAccess).target;
} else {
return false;
}
}
return false;
}
/**
* Push the operation for the given assignable [expr].
*/
void _pushAssignable(Expression expr) {
if (_isIdentifierSequence(expr)) {
EntityRefBuilder ref = serializeIdentifierSequence(expr);
references.add(ref);
operations.add(UnlinkedExprOperation.assignToRef);
} else if (expr is PropertyAccess) {
if (!expr.isCascaded) {
_serialize(expr.target);
}
strings.add(expr.propertyName.name);
operations.add(UnlinkedExprOperation.assignToProperty);
} else if (expr is IndexExpression) {
if (!expr.isCascaded) {
_serialize(expr.target);
}
_serialize(expr.index);
operations.add(UnlinkedExprOperation.assignToIndex);
} else if (expr is PrefixedIdentifier) {
strings.add(expr.prefix.name);
operations.add(UnlinkedExprOperation.pushParameter);
strings.add(expr.identifier.name);
operations.add(UnlinkedExprOperation.assignToProperty);
} else {
throw new StateError('Unsupported assignable: $expr');
}
}
void _pushInt(int value) {
value ??= 0;
assert(value >= 0);
if (value >= 0x100000000) {
int numOfComponents = 0;
ints.add(numOfComponents);
void pushComponents(int value) {
if (value >= 0x100000000) {
pushComponents(value ~/ 0x100000000);
}
numOfComponents++;
ints.add(value & 0xFFFFFFFF);
}
pushComponents(value);
ints[ints.length - 1 - numOfComponents] = numOfComponents;
operations.add(UnlinkedExprOperation.pushLongInt);
} else {
operations.add(UnlinkedExprOperation.pushInt);
ints.add(value);
}
}
/**
* Serialize the given [expr] expression into this serializer state.
*/
void _serialize(Expression expr) {
if (expr is IntegerLiteral) {
int value = expr.value ?? 0;
if (value >= 0) {
_pushInt(value);
} else {
_pushInt(-value);
operations.add(UnlinkedExprOperation.negate);
}
} else if (expr is DoubleLiteral) {
operations.add(UnlinkedExprOperation.pushDouble);
doubles.add(expr.value);
} else if (expr is BooleanLiteral) {
if (expr.value) {
operations.add(UnlinkedExprOperation.pushTrue);
} else {
operations.add(UnlinkedExprOperation.pushFalse);
}
} else if (expr is StringLiteral) {
_serializeString(expr);
} else if (expr is SymbolLiteral) {
strings.add(expr.components.map((token) => token.lexeme).join('.'));
operations.add(UnlinkedExprOperation.makeSymbol);
} else if (expr is NullLiteral) {
operations.add(UnlinkedExprOperation.pushNull);
} else if (expr is Identifier) {
if (expr is SimpleIdentifier && isParameterName(expr.name)) {
strings.add(expr.name);
operations.add(UnlinkedExprOperation.pushParameter);
} else if (expr is PrefixedIdentifier &&
isParameterName(expr.prefix.name)) {
strings.add(expr.prefix.name);
operations.add(UnlinkedExprOperation.pushParameter);
strings.add(expr.identifier.name);
operations.add(UnlinkedExprOperation.extractProperty);
} else {
references.add(serializeIdentifier(expr));
operations.add(UnlinkedExprOperation.pushReference);
}
} else if (expr is InstanceCreationExpression) {
if (!expr.isConst) {
isValidConst = false;
}
TypeName typeName = expr.constructorName.type;
serializeInstanceCreation(
serializeConstructorRef(typeName.type, typeName.name,
typeName.typeArguments, expr.constructorName.name),
expr.argumentList,
typeName.typeArguments != null);
} else if (expr is ListLiteral) {
_serializeListLiteral(expr);
} else if (expr is MapLiteral) {
_serializeMapLiteral(expr);
} else if (expr is MethodInvocation) {
_serializeMethodInvocation(expr);
} else if (expr is BinaryExpression) {
_serializeBinaryExpression(expr);
} else if (expr is ConditionalExpression) {
_serialize(expr.condition);
_serialize(expr.thenExpression);
_serialize(expr.elseExpression);
operations.add(UnlinkedExprOperation.conditional);
} else if (expr is PrefixExpression) {
_serializePrefixExpression(expr);
} else if (expr is PostfixExpression) {
_serializePostfixExpression(expr);
} else if (expr is PropertyAccess) {
_serializePropertyAccess(expr);
} else if (expr is ParenthesizedExpression) {
_serialize(expr.expression);
} else if (expr is IndexExpression) {
isValidConst = false;
_serialize(expr.target);
_serialize(expr.index);
operations.add(UnlinkedExprOperation.extractIndex);
} else if (expr is AssignmentExpression) {
_serializeAssignment(expr);
} else if (expr is CascadeExpression) {
isValidConst = false;
_serialize(expr.target);
} else if (expr is FunctionExpression) {
isValidConst = false;
List<int> indices = serializeFunctionExpression(expr);
if (indices != null) {
ints.addAll(serializeFunctionExpression(expr));
operations.add(UnlinkedExprOperation.pushLocalFunctionReference);
} else {
// Invalid expression; just push null.
operations.add(UnlinkedExprOperation.pushNull);
}
} else if (expr is FunctionExpressionInvocation) {
isValidConst = false;
// TODO(scheglov) implement
operations.add(UnlinkedExprOperation.pushNull);
} else if (expr is AsExpression) {
isValidConst = false;
_serialize(expr.expression);
references.add(serializeType(expr.type));
operations.add(UnlinkedExprOperation.typeCast);
} else if (expr is IsExpression) {
isValidConst = false;
_serialize(expr.expression);
references.add(serializeType(expr.type));
operations.add(UnlinkedExprOperation.typeCheck);
if (expr.notOperator != null) {
operations.add(UnlinkedExprOperation.not);
}
} else if (expr is SuperExpression) {
operations.add(UnlinkedExprOperation.pushSuper);
} else if (expr is ThisExpression) {
operations.add(UnlinkedExprOperation.pushThis);
} else if (expr is ThrowExpression) {
isValidConst = false;
_serialize(expr.expression);
operations.add(UnlinkedExprOperation.throwException);
} else if (expr is AwaitExpression) {
isValidConst = false;
_serialize(expr.expression);
operations.add(UnlinkedExprOperation.await);
} else {
throw new StateError('Unknown expression type: $expr');
}
}
void _serializeArguments(
ArgumentList argumentList, bool typeArgumentsProvided) {
if (forConst || !typeArgumentsProvided) {
List<Expression> arguments = argumentList.arguments;
// Serialize the arguments.
List<String> argumentNames = <String>[];
arguments.forEach((arg) {
if (arg is NamedExpression) {
argumentNames.add(arg.name.label.name);
_serialize(arg.expression);
} else {
_serialize(arg);
}
});
// Add numbers of named and positional arguments, and the op-code.
ints.add(argumentNames.length);
strings.addAll(argumentNames);
ints.add(arguments.length - argumentNames.length);
} else {
ints.add(0);
ints.add(0);
}
}
void _serializeAssignment(AssignmentExpression expr) {
isValidConst = false;
// Push the value.
_serialize(expr.rightHandSide);
// Push the assignment operator.
TokenType operator = expr.operator.type;
UnlinkedExprAssignOperator assignmentOperator;
if (operator == TokenType.EQ) {
assignmentOperator = UnlinkedExprAssignOperator.assign;
} else if (operator == TokenType.QUESTION_QUESTION_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.ifNull;
} else if (operator == TokenType.STAR_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.multiply;
} else if (operator == TokenType.SLASH_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.divide;
} else if (operator == TokenType.TILDE_SLASH_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.floorDivide;
} else if (operator == TokenType.PERCENT_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.modulo;
} else if (operator == TokenType.PLUS_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.plus;
} else if (operator == TokenType.MINUS_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.minus;
} else if (operator == TokenType.LT_LT_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.shiftLeft;
} else if (operator == TokenType.GT_GT_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.shiftRight;
} else if (operator == TokenType.AMPERSAND_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.bitAnd;
} else if (operator == TokenType.CARET_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.bitXor;
} else if (operator == TokenType.BAR_EQ) {
assignmentOperator = UnlinkedExprAssignOperator.bitOr;
} else {
throw new StateError('Unknown assignment operator: $operator');
}
assignmentOperators.add(assignmentOperator);
// Push the assignment to the LHS.
_pushAssignable(expr.leftHandSide);
}
void _serializeBinaryExpression(BinaryExpression expr) {
_serialize(expr.leftOperand);
_serialize(expr.rightOperand);
TokenType operator = expr.operator.type;
if (operator == TokenType.EQ_EQ) {
operations.add(UnlinkedExprOperation.equal);
} else if (operator == TokenType.BANG_EQ) {
operations.add(UnlinkedExprOperation.notEqual);
} else if (operator == TokenType.AMPERSAND_AMPERSAND) {
operations.add(UnlinkedExprOperation.and);
} else if (operator == TokenType.BAR_BAR) {
operations.add(UnlinkedExprOperation.or);
} else if (operator == TokenType.CARET) {
operations.add(UnlinkedExprOperation.bitXor);
} else if (operator == TokenType.AMPERSAND) {
operations.add(UnlinkedExprOperation.bitAnd);
} else if (operator == TokenType.BAR) {
operations.add(UnlinkedExprOperation.bitOr);
} else if (operator == TokenType.GT_GT) {
operations.add(UnlinkedExprOperation.bitShiftRight);
} else if (operator == TokenType.LT_LT) {
operations.add(UnlinkedExprOperation.bitShiftLeft);
} else if (operator == TokenType.PLUS) {
operations.add(UnlinkedExprOperation.add);
} else if (operator == TokenType.MINUS) {
operations.add(UnlinkedExprOperation.subtract);
} else if (operator == TokenType.STAR) {
operations.add(UnlinkedExprOperation.multiply);
} else if (operator == TokenType.SLASH) {
operations.add(UnlinkedExprOperation.divide);
} else if (operator == TokenType.TILDE_SLASH) {
operations.add(UnlinkedExprOperation.floorDivide);
} else if (operator == TokenType.GT) {
operations.add(UnlinkedExprOperation.greater);
} else if (operator == TokenType.LT) {
operations.add(UnlinkedExprOperation.less);
} else if (operator == TokenType.GT_EQ) {
operations.add(UnlinkedExprOperation.greaterEqual);
} else if (operator == TokenType.LT_EQ) {
operations.add(UnlinkedExprOperation.lessEqual);
} else if (operator == TokenType.PERCENT) {
operations.add(UnlinkedExprOperation.modulo);
} else if (operator == TokenType.QUESTION_QUESTION) {
operations.add(UnlinkedExprOperation.ifNull);
} else {
throw new StateError('Unknown operator: $operator');
}
}
void _serializeListLiteral(ListLiteral expr) {
if (forConst || expr.typeArguments == null) {
List<Expression> elements = expr.elements;
elements.forEach(_serialize);
ints.add(elements.length);
} else {
ints.add(0);
}
if (expr.typeArguments != null &&
expr.typeArguments.arguments.length == 1) {
references.add(serializeType(expr.typeArguments.arguments[0]));
operations.add(UnlinkedExprOperation.makeTypedList);
} else {
operations.add(UnlinkedExprOperation.makeUntypedList);
}
}
void _serializeMapLiteral(MapLiteral expr) {
if (forConst || expr.typeArguments == null) {
for (MapLiteralEntry entry in expr.entries) {
_serialize(entry.key);
_serialize(entry.value);
}
ints.add(expr.entries.length);
} else {
ints.add(0);
}
if (expr.typeArguments != null &&
expr.typeArguments.arguments.length == 2) {
references.add(serializeType(expr.typeArguments.arguments[0]));
references.add(serializeType(expr.typeArguments.arguments[1]));
operations.add(UnlinkedExprOperation.makeTypedMap);
} else {
operations.add(UnlinkedExprOperation.makeUntypedMap);
}
}
void _serializeMethodInvocation(MethodInvocation invocation) {
Expression target = invocation.target;
SimpleIdentifier methodName = invocation.methodName;
ArgumentList argumentList = invocation.argumentList;
if (_isIdentifierSequence(methodName)) {
EntityRefBuilder ref = serializeIdentifierSequence(methodName);
_serializeArguments(argumentList, invocation.typeArguments != null);
references.add(ref);
_serializeTypeArguments(invocation.typeArguments);
operations.add(UnlinkedExprOperation.invokeMethodRef);
} else {
if (!invocation.isCascaded) {
_serialize(target);
}
_serializeArguments(argumentList, invocation.typeArguments != null);
strings.add(methodName.name);
_serializeTypeArguments(invocation.typeArguments);
operations.add(UnlinkedExprOperation.invokeMethod);
}
}
void _serializePostfixExpression(PostfixExpression expr) {
TokenType operator = expr.operator.type;
Expression operand = expr.operand;
if (operator == TokenType.PLUS_PLUS) {
_serializePrefixPostfixIncDec(
operand, UnlinkedExprAssignOperator.postfixIncrement);
} else if (operator == TokenType.MINUS_MINUS) {
_serializePrefixPostfixIncDec(
operand, UnlinkedExprAssignOperator.postfixDecrement);
} else {
throw new StateError('Unknown operator: $operator');
}
}
void _serializePrefixExpression(PrefixExpression expr) {
TokenType operator = expr.operator.type;
Expression operand = expr.operand;
if (operator == TokenType.BANG) {
_serialize(operand);
operations.add(UnlinkedExprOperation.not);
} else if (operator == TokenType.MINUS) {
_serialize(operand);
operations.add(UnlinkedExprOperation.negate);
} else if (operator == TokenType.TILDE) {
_serialize(operand);
operations.add(UnlinkedExprOperation.complement);
} else if (operator == TokenType.PLUS_PLUS) {
_serializePrefixPostfixIncDec(
operand, UnlinkedExprAssignOperator.prefixIncrement);
} else if (operator == TokenType.MINUS_MINUS) {
_serializePrefixPostfixIncDec(
operand, UnlinkedExprAssignOperator.prefixDecrement);
} else {
throw new StateError('Unknown operator: $operator');
}
}
void _serializePrefixPostfixIncDec(
Expression operand, UnlinkedExprAssignOperator operator) {
isValidConst = false;
assignmentOperators.add(operator);
_pushAssignable(operand);
}
void _serializePropertyAccess(PropertyAccess expr) {
if (_isIdentifierSequence(expr)) {
EntityRefBuilder ref = serializeIdentifierSequence(expr);
references.add(ref);
operations.add(UnlinkedExprOperation.pushReference);
} else {
if (!expr.isCascaded) {
_serialize(expr.target);
}
strings.add(expr.propertyName.name);
operations.add(UnlinkedExprOperation.extractProperty);
}
}
void _serializeString(StringLiteral expr) {
if (expr is AdjacentStrings) {
if (expr.strings.every((string) => string is SimpleStringLiteral)) {
operations.add(UnlinkedExprOperation.pushString);
strings.add(expr.stringValue);
} else {
expr.strings.forEach(_serializeString);
operations.add(UnlinkedExprOperation.concatenate);
ints.add(expr.strings.length);
}
} else if (expr is SimpleStringLiteral) {
operations.add(UnlinkedExprOperation.pushString);
strings.add(expr.value);
} else {
StringInterpolation interpolation = expr as StringInterpolation;
for (InterpolationElement element in interpolation.elements) {
if (element is InterpolationString) {
operations.add(UnlinkedExprOperation.pushString);
strings.add(element.value);
} else {
_serialize((element as InterpolationExpression).expression);
}
}
operations.add(UnlinkedExprOperation.concatenate);
ints.add(interpolation.elements.length);
}
}
void _serializeTypeArguments(TypeArgumentList typeArguments) {
if (typeArguments == null) {
ints.add(0);
} else {
ints.add(typeArguments.arguments.length);
for (TypeAnnotation type in typeArguments.arguments) {
references.add(serializeType(type));
}
}
}
}