| // 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:front_end/src/fasta/builder/ast_factory.dart'; |
| |
| /// A library to help transform compounds and null-aware accessors into |
| /// let expressions. |
| |
| import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken; |
| |
| import 'package:front_end/src/scanner/token.dart' show Token; |
| |
| import 'package:front_end/src/fasta/kernel/fasta_accessors.dart' |
| show BuilderHelper; |
| |
| import 'package:kernel/ast.dart' hide MethodInvocation; |
| |
| final Name indexGetName = new Name("[]"); |
| |
| final Name indexSetName = new Name("[]="); |
| |
| /// An [Accessor] represents a subexpression for which we can't yet build a |
| /// kernel [Expression] because we don't yet know the context in which it is |
| /// used. |
| /// |
| /// Once the context is known, an [Accessor] can be converted into an |
| /// [Expression] by calling a "build" method. |
| /// |
| /// For example, when building a kernel representation for `a[x] = b`, after |
| /// parsing `a[x]` but before parsing `= b`, we don't yet know whether to |
| /// generate an invocation of `operator[]` or `operator[]=`, so we generate an |
| /// [Accessor] object. Later, after `= b` is parsed, [buildAssignment] will be |
| /// called. |
| abstract class Accessor { |
| final BuilderHelper helper; |
| final Token token; |
| |
| // [builtBinary] and [builtGetter] capture the inner nodes. Used by |
| // dart2js+rasta for determining how subexpressions map to legacy dart2js Ast |
| // nodes. This will be removed once dart2js type analysis (aka inference) is |
| // reimplemented on kernel. |
| Expression builtBinary; |
| Expression builtGetter; |
| |
| Accessor(this.helper, this.token); |
| |
| /// Builds an [Expression] representing a read from the accessor. |
| Expression buildSimpleRead() { |
| return _finish(_makeSimpleRead()); |
| } |
| |
| /// Builds an [Expression] representing an assignment with the accessor on |
| /// the LHS and [value] on the RHS. |
| /// |
| /// The returned expression evaluates to the assigned value, unless |
| /// [voidContext] is true, in which case it may evaluate to anything. |
| Expression buildAssignment(Expression value, {bool voidContext: false}) { |
| return _finish(_makeSimpleWrite(value, voidContext)); |
| } |
| |
| /// Returns an [Expression] representing a null-aware assignment (`??=`) with |
| /// the accessor on the LHS and [value] on the RHS. |
| /// |
| /// The returned expression evaluates to the assigned value, unless |
| /// [voidContext] is true, in which case it may evaluate to anything. |
| /// |
| /// [type] is the static type of the RHS. |
| Expression buildNullAwareAssignment(Expression value, DartType type, |
| {bool voidContext: false}) { |
| if (voidContext) { |
| return _finish(new ConditionalExpression( |
| buildIsNull(helper.astFactory, _makeRead()), |
| _makeWrite(value, false), |
| new NullLiteral(), |
| type)); |
| } |
| var tmp = new VariableDeclaration.forValue(_makeRead()); |
| return _finish(makeLet( |
| tmp, |
| new ConditionalExpression( |
| buildIsNull(helper.astFactory, new VariableGet(tmp)), |
| _makeWrite(value, false), |
| new VariableGet(tmp), |
| type))); |
| } |
| |
| /// Returns an [Expression] representing a compound assignment (e.g. `+=`) |
| /// with the accessor on the LHS and [value] on the RHS. |
| Expression buildCompoundAssignment(Name binaryOperator, Expression value, |
| {int offset: TreeNode.noOffset, |
| bool voidContext: false, |
| Procedure interfaceTarget}) { |
| return _finish(_makeWrite( |
| builtBinary = makeBinary(helper.astFactory, _makeRead(), binaryOperator, |
| interfaceTarget, value, |
| offset: offset), |
| voidContext)); |
| } |
| |
| /// Returns an [Expression] representing a pre-increment or pre-decrement |
| /// of the accessor. |
| Expression buildPrefixIncrement(Name binaryOperator, |
| {int offset: TreeNode.noOffset, |
| bool voidContext: false, |
| Procedure interfaceTarget}) { |
| return buildCompoundAssignment(binaryOperator, new IntLiteral(1), |
| offset: offset, |
| voidContext: voidContext, |
| interfaceTarget: interfaceTarget); |
| } |
| |
| /// Returns an [Expression] representing a post-increment or post-decrement |
| /// of the accessor. |
| Expression buildPostfixIncrement(Name binaryOperator, |
| {int offset: TreeNode.noOffset, |
| bool voidContext: false, |
| Procedure interfaceTarget}) { |
| if (voidContext) { |
| return buildPrefixIncrement(binaryOperator, |
| offset: offset, voidContext: true, interfaceTarget: interfaceTarget); |
| } |
| var value = new VariableDeclaration.forValue(_makeRead()); |
| valueAccess() => new VariableGet(value); |
| var dummy = new VariableDeclaration.forValue(_makeWrite( |
| builtBinary = makeBinary(helper.astFactory, valueAccess(), |
| binaryOperator, interfaceTarget, new IntLiteral(1), |
| offset: offset), |
| true)); |
| return _finish(makeLet(value, makeLet(dummy, valueAccess()))); |
| } |
| |
| Expression _makeSimpleRead() => _makeRead(); |
| |
| Expression _makeSimpleWrite(Expression value, bool voidContext) { |
| return _makeWrite(value, voidContext); |
| } |
| |
| Expression _makeRead(); |
| |
| Expression _makeWrite(Expression value, bool voidContext); |
| |
| Expression _finish(Expression body) => body; |
| |
| /// Returns an [Expression] representing a compile-time error. |
| /// |
| /// At runtime, an exception will be thrown. |
| makeInvalidRead() => new InvalidExpression(); |
| |
| /// Returns an [Expression] representing a compile-time error wrapping |
| /// [value]. |
| /// |
| /// At runtime, [value] will be evaluated before throwing an exception. |
| makeInvalidWrite(Expression value) => wrapInvalid(value); |
| } |
| |
| abstract class VariableAccessor extends Accessor { |
| VariableDeclaration variable; |
| DartType promotedType; |
| |
| VariableAccessor( |
| BuilderHelper helper, this.variable, this.promotedType, Token token) |
| : super(helper, token); |
| |
| Expression _makeRead() { |
| var fact = helper.typePromoter |
| .getFactForAccess(variable, helper.functionNestingLevel); |
| var scope = helper.typePromoter.currentScope; |
| return helper.astFactory.variableGet(variable, fact, scope, token); |
| } |
| |
| Expression _makeWrite(Expression value, bool voidContext) { |
| helper.typePromoter.mutateVariable(variable, helper.functionNestingLevel); |
| return variable.isFinal || variable.isConst |
| ? makeInvalidWrite(value) |
| : helper.astFactory.variableSet(variable, value) |
| ..fileOffset = offsetForToken(token); |
| } |
| } |
| |
| class PropertyAccessor extends Accessor { |
| VariableDeclaration _receiverVariable; |
| Expression receiver; |
| Name name; |
| Member getter, setter; |
| |
| static Accessor make(BuilderHelper helper, Expression receiver, Name name, |
| Member getter, Member setter, |
| {Token token}) { |
| if (receiver is ThisExpression) { |
| return new ThisPropertyAccessor(helper, name, getter, setter, token); |
| } else { |
| return new PropertyAccessor.internal( |
| helper, receiver, name, getter, setter, token); |
| } |
| } |
| |
| PropertyAccessor.internal(BuilderHelper helper, this.receiver, this.name, |
| this.getter, this.setter, Token token) |
| : super(helper, token); |
| |
| Expression _makeSimpleRead() => |
| helper.astFactory.propertyGet(receiver, name, getter) |
| ..fileOffset = offsetForToken(token); |
| |
| Expression _makeSimpleWrite(Expression value, bool voidContext) { |
| return helper.astFactory.propertySet(receiver, name, value, setter) |
| ..fileOffset = offsetForToken(token); |
| } |
| |
| receiverAccess() { |
| _receiverVariable ??= new VariableDeclaration.forValue(receiver); |
| return new VariableGet(_receiverVariable) |
| ..fileOffset = offsetForToken(token); |
| } |
| |
| Expression _makeRead() => builtGetter = helper.astFactory |
| .propertyGet(receiverAccess(), name, getter) |
| ..fileOffset = offsetForToken(token); |
| |
| Expression _makeWrite(Expression value, bool voidContext) { |
| return helper.astFactory.propertySet(receiverAccess(), name, value, setter) |
| ..fileOffset = offsetForToken(token); |
| } |
| |
| Expression _finish(Expression body) => makeLet(_receiverVariable, body); |
| } |
| |
| /// Special case of [PropertyAccessor] to avoid creating an indirect access to |
| /// 'this'. |
| class ThisPropertyAccessor extends Accessor { |
| Name name; |
| Member getter, setter; |
| |
| ThisPropertyAccessor( |
| BuilderHelper helper, this.name, this.getter, this.setter, Token token) |
| : super(helper, token); |
| |
| Expression _makeRead() => builtGetter = helper.astFactory |
| .propertyGet(new ThisExpression(), name, getter) |
| ..fileOffset = offsetForToken(token); |
| |
| Expression _makeWrite(Expression value, bool voidContext) { |
| return helper.astFactory |
| .propertySet(new ThisExpression(), name, value, setter) |
| ..fileOffset = offsetForToken(token); |
| } |
| } |
| |
| class NullAwarePropertyAccessor extends Accessor { |
| VariableDeclaration receiver; |
| Name name; |
| Member getter, setter; |
| DartType type; |
| |
| NullAwarePropertyAccessor(BuilderHelper helper, Expression receiver, |
| this.name, this.getter, this.setter, this.type, Token token) |
| : this.receiver = makeOrReuseVariable(receiver), |
| super(helper, token); |
| |
| receiverAccess() => new VariableGet(receiver); |
| |
| Expression _makeRead() => builtGetter = |
| helper.astFactory.propertyGet(receiverAccess(), name, getter); |
| |
| Expression _makeWrite(Expression value, bool voidContext) { |
| return helper.astFactory.propertySet(receiverAccess(), name, value, setter); |
| } |
| |
| Expression _finish(Expression body) => makeLet( |
| receiver, |
| new ConditionalExpression( |
| buildIsNull(helper.astFactory, receiverAccess()), |
| new NullLiteral(), |
| body, |
| type)); |
| } |
| |
| class SuperPropertyAccessor extends Accessor { |
| Name name; |
| Member getter, setter; |
| |
| SuperPropertyAccessor( |
| BuilderHelper helper, this.name, this.getter, this.setter, Token token) |
| : super(helper, token); |
| |
| Expression _makeRead() { |
| if (getter == null) return makeInvalidRead(); |
| // TODO(ahe): Use [DirectPropertyGet] when possible. |
| return builtGetter = new SuperPropertyGet(name, getter) |
| ..fileOffset = offsetForToken(token); |
| } |
| |
| Expression _makeWrite(Expression value, bool voidContext) { |
| if (setter == null) return makeInvalidWrite(value); |
| // TODO(ahe): Use [DirectPropertySet] when possible. |
| return new SuperPropertySet(name, value, setter) |
| ..fileOffset = offsetForToken(token); |
| } |
| } |
| |
| class IndexAccessor extends Accessor { |
| Expression receiver; |
| Expression index; |
| VariableDeclaration receiverVariable; |
| VariableDeclaration indexVariable; |
| Procedure getter, setter; |
| |
| static Accessor make(BuilderHelper helper, Expression receiver, |
| Expression index, Procedure getter, Procedure setter, |
| {Token token}) { |
| if (receiver is ThisExpression) { |
| return new ThisIndexAccessor(helper, index, getter, setter, token); |
| } else { |
| return new IndexAccessor.internal( |
| helper, receiver, index, getter, setter, token); |
| } |
| } |
| |
| IndexAccessor.internal(BuilderHelper helper, this.receiver, this.index, |
| this.getter, this.setter, Token token) |
| : super(helper, token); |
| |
| Expression _makeSimpleRead() => helper.astFactory.methodInvocation(receiver, |
| indexGetName, helper.astFactory.arguments(<Expression>[index]), getter) |
| ..fileOffset = offsetForToken(token); |
| |
| Expression _makeSimpleWrite(Expression value, bool voidContext) { |
| if (!voidContext) return _makeWriteAndReturn(value); |
| return helper.astFactory.methodInvocation(receiver, indexSetName, |
| helper.astFactory.arguments(<Expression>[index, value]), setter) |
| ..fileOffset = offsetForToken(token); |
| } |
| |
| receiverAccess() { |
| // We cannot reuse the receiver if it is a variable since it might be |
| // reassigned in the index expression. |
| receiverVariable ??= new VariableDeclaration.forValue(receiver); |
| return new VariableGet(receiverVariable) |
| ..fileOffset = offsetForToken(token); |
| } |
| |
| indexAccess() { |
| indexVariable ??= new VariableDeclaration.forValue(index); |
| return new VariableGet(indexVariable)..fileOffset = offsetForToken(token); |
| } |
| |
| Expression _makeRead() { |
| return builtGetter = helper.astFactory.methodInvocation( |
| receiverAccess(), |
| indexGetName, |
| helper.astFactory.arguments(<Expression>[indexAccess()]), |
| getter) |
| ..fileOffset = offsetForToken(token); |
| } |
| |
| Expression _makeWrite(Expression value, bool voidContext) { |
| if (!voidContext) return _makeWriteAndReturn(value); |
| return helper.astFactory.methodInvocation(receiverAccess(), indexSetName, |
| helper.astFactory.arguments(<Expression>[indexAccess(), value]), setter) |
| ..fileOffset = offsetForToken(token); |
| } |
| |
| // TODO(dmitryas): remove this method after the "[]=" operator of the Context |
| // class is made to return a value. |
| _makeWriteAndReturn(Expression value) { |
| // The call to []= does not return the value like direct-style assignments |
| // do. We need to bind the value in a let. |
| var valueVariable = new VariableDeclaration.forValue(value); |
| var dummy = new VariableDeclaration.forValue(helper.astFactory |
| .methodInvocation( |
| receiverAccess(), |
| indexSetName, |
| helper.astFactory.arguments( |
| <Expression>[indexAccess(), new VariableGet(valueVariable)]), |
| setter) |
| ..fileOffset = offsetForToken(token)); |
| return makeLet( |
| valueVariable, makeLet(dummy, new VariableGet(valueVariable))); |
| } |
| |
| Expression _finish(Expression body) { |
| return makeLet(receiverVariable, makeLet(indexVariable, body)); |
| } |
| } |
| |
| /// Special case of [IndexAccessor] to avoid creating an indirect access to |
| /// 'this'. |
| class ThisIndexAccessor extends Accessor { |
| Expression index; |
| VariableDeclaration indexVariable; |
| Procedure getter, setter; |
| |
| ThisIndexAccessor( |
| BuilderHelper helper, this.index, this.getter, this.setter, Token token) |
| : super(helper, token); |
| |
| Expression _makeSimpleRead() { |
| return helper.astFactory.methodInvocation(new ThisExpression(), |
| indexGetName, helper.astFactory.arguments(<Expression>[index]), getter); |
| } |
| |
| Expression _makeSimpleWrite(Expression value, bool voidContext) { |
| if (!voidContext) return _makeWriteAndReturn(value); |
| return helper.astFactory.methodInvocation( |
| new ThisExpression(), |
| indexSetName, |
| helper.astFactory.arguments(<Expression>[index, value]), |
| setter); |
| } |
| |
| indexAccess() { |
| indexVariable ??= new VariableDeclaration.forValue(index); |
| return new VariableGet(indexVariable); |
| } |
| |
| Expression _makeRead() => builtGetter = helper.astFactory.methodInvocation( |
| new ThisExpression(), |
| indexGetName, |
| helper.astFactory.arguments(<Expression>[indexAccess()]), |
| getter); |
| |
| Expression _makeWrite(Expression value, bool voidContext) { |
| if (!voidContext) return _makeWriteAndReturn(value); |
| return helper.astFactory.methodInvocation( |
| new ThisExpression(), |
| indexSetName, |
| helper.astFactory.arguments(<Expression>[indexAccess(), value]), |
| setter); |
| } |
| |
| _makeWriteAndReturn(Expression value) { |
| var valueVariable = new VariableDeclaration.forValue(value); |
| var dummy = new VariableDeclaration.forValue(helper.astFactory |
| .methodInvocation( |
| new ThisExpression(), |
| indexSetName, |
| helper.astFactory.arguments( |
| <Expression>[indexAccess(), new VariableGet(valueVariable)]), |
| setter)); |
| return makeLet( |
| valueVariable, makeLet(dummy, new VariableGet(valueVariable))); |
| } |
| |
| Expression _finish(Expression body) => makeLet(indexVariable, body); |
| } |
| |
| class SuperIndexAccessor extends Accessor { |
| Expression index; |
| VariableDeclaration indexVariable; |
| Member getter, setter; |
| |
| SuperIndexAccessor( |
| BuilderHelper helper, this.index, this.getter, this.setter, Token token) |
| : super(helper, token); |
| |
| indexAccess() { |
| indexVariable ??= new VariableDeclaration.forValue(index); |
| return new VariableGet(indexVariable); |
| } |
| |
| Expression _makeSimpleRead() => new SuperMethodInvocation( |
| indexGetName, helper.astFactory.arguments(<Expression>[index]), getter); |
| |
| Expression _makeSimpleWrite(Expression value, bool voidContext) { |
| if (!voidContext) return _makeWriteAndReturn(value); |
| return new SuperMethodInvocation(indexSetName, |
| helper.astFactory.arguments(<Expression>[index, value]), setter); |
| } |
| |
| Expression _makeRead() { |
| return builtGetter = new SuperMethodInvocation(indexGetName, |
| helper.astFactory.arguments(<Expression>[indexAccess()]), getter); |
| } |
| |
| Expression _makeWrite(Expression value, bool voidContext) { |
| if (!voidContext) return _makeWriteAndReturn(value); |
| return new SuperMethodInvocation( |
| indexSetName, |
| helper.astFactory.arguments(<Expression>[indexAccess(), value]), |
| setter); |
| } |
| |
| _makeWriteAndReturn(Expression value) { |
| var valueVariable = new VariableDeclaration.forValue(value); |
| var dummy = new VariableDeclaration.forValue(new SuperMethodInvocation( |
| indexSetName, |
| helper.astFactory.arguments( |
| <Expression>[indexAccess(), new VariableGet(valueVariable)]), |
| setter)); |
| return makeLet( |
| valueVariable, makeLet(dummy, new VariableGet(valueVariable))); |
| } |
| |
| Expression _finish(Expression body) { |
| return makeLet(indexVariable, body); |
| } |
| } |
| |
| class StaticAccessor extends Accessor { |
| Member readTarget; |
| Member writeTarget; |
| |
| StaticAccessor( |
| BuilderHelper helper, this.readTarget, this.writeTarget, Token token) |
| : super(helper, token); |
| |
| Expression _makeRead() => builtGetter = readTarget == null |
| ? makeInvalidRead() |
| : helper.makeStaticGet(readTarget, token); |
| |
| Expression _makeWrite(Expression value, bool voidContext) { |
| return writeTarget == null |
| ? makeInvalidWrite(value) |
| : new StaticSet(writeTarget, value) |
| ..fileOffset = offsetForToken(token); |
| } |
| } |
| |
| class ReadOnlyAccessor extends Accessor { |
| Expression expression; |
| VariableDeclaration value; |
| |
| ReadOnlyAccessor(BuilderHelper helper, this.expression, Token token) |
| : super(helper, token); |
| |
| Expression _makeSimpleRead() => expression; |
| |
| Expression _makeRead() { |
| value ??= new VariableDeclaration.forValue(expression); |
| return new VariableGet(value); |
| } |
| |
| Expression _makeWrite(Expression value, bool voidContext) => |
| makeInvalidWrite(value); |
| |
| Expression _finish(Expression body) => makeLet(value, body); |
| } |
| |
| Expression makeLet(VariableDeclaration variable, Expression body) { |
| if (variable == null) return body; |
| return new Let(variable, body); |
| } |
| |
| Expression makeBinary(AstFactory astFactory, Expression left, Name operator, |
| Procedure interfaceTarget, Expression right, |
| {int offset: TreeNode.noOffset}) { |
| return astFactory.methodInvocation(left, operator, |
| astFactory.arguments(<Expression>[right]), interfaceTarget) |
| ..fileOffset = offset; |
| } |
| |
| final Name _equalOperator = new Name('=='); |
| |
| Expression buildIsNull(AstFactory astFactory, Expression value, |
| {int offset: TreeNode.noOffset}) { |
| return makeBinary(astFactory, value, _equalOperator, null, new NullLiteral(), |
| offset: offset); |
| } |
| |
| VariableDeclaration makeOrReuseVariable(Expression value) { |
| // TODO: Devise a way to remember if a variable declaration was reused |
| // or is fresh (hence needs a let binding). |
| return new VariableDeclaration.forValue(value); |
| } |
| |
| Expression wrapInvalid(Expression e) { |
| return new Let(new VariableDeclaration.forValue(e), new InvalidExpression()); |
| } |