Share operator names

pkg/front_end/lib/src/fasta/kernel/frontend_accessors.dart

 // 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.
 
 // Note: copied from package:kernel at revision 7346348.
 
 /// A library to help transform compounds and null-aware accessors into
 /// let expressions.
 library kernel.frontend.accessors;
 
 import 'package:kernel/ast.dart';
 
+import '../names.dart' show indexGetName, indexSetName;
+
 /// 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
@@ skipping 218 matching lines @@
   _makeWrite(Expression value, bool voidContext) {
     if (setter == null) return makeInvalidWrite(value);
     // TODO(ahe): Use [DirectPropertySet] when possible.
     Expression result = new DirectPropertySet(
         new ThisExpression(), setter, value)..fileOffset = charOffset;
     result = new SuperPropertySet(name, value, setter)..fileOffset = charOffset;
     return result;
   }
 }
 
-final Name _indexGet = new Name('[]');
-final Name _indexSet = new Name('[]=');
-
 class IndexAccessor extends Accessor {
   Expression receiver;
   Expression index;
   VariableDeclaration receiverVariable;
   VariableDeclaration indexVariable;
   Procedure getter, setter;
   int charOffset;
 
   static Accessor make(Expression receiver, Expression index, Procedure getter,
       Procedure setter, int charOffset) {
     if (receiver is ThisExpression) {
       return new ThisIndexAccessor(index, getter, setter);
     } else {
       return new IndexAccessor.internal(
           receiver, index, getter, setter, charOffset);
     }
   }
 
   IndexAccessor.internal(
       this.receiver, this.index, this.getter, this.setter, this.charOffset);
 
   _makeSimpleRead() => new MethodInvocation(
-      receiver, _indexGet, new Arguments(<Expression>[index]), getter)
+      receiver, indexGetName, new Arguments(<Expression>[index]), getter)
     ..fileOffset = charOffset;
 
   _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new MethodInvocation(
-        receiver, _indexSet, new Arguments(<Expression>[index, value]), setter)
-      ..fileOffset = charOffset;
+        receiver,
+        indexSetName,
+        new Arguments(<Expression>[index, value]),
+        setter)..fileOffset = charOffset;
   }
 
   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 = charOffset;
   }
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable)..fileOffset = charOffset;
   }
 
   _makeRead() {
     return new MethodInvocation(
         receiverAccess(),
-        _indexGet,
+        indexGetName,
         new Arguments(<Expression>[indexAccess()]),
         getter)..fileOffset = charOffset;
   }
 
   _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new MethodInvocation(
         receiverAccess(),
-        _indexSet,
+        indexSetName,
         new Arguments(<Expression>[indexAccess(), value]),
         setter)..fileOffset = charOffset;
   }
 
   _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(new MethodInvocation(
         receiverAccess(),
-        _indexSet,
+        indexSetName,
         new Arguments(
             <Expression>[indexAccess(), new VariableGet(valueVariable)]),
         setter)..fileOffset = charOffset);
     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(this.index, this.getter, this.setter);
 
   _makeSimpleRead() {
-    return new MethodInvocation(new ThisExpression(), _indexGet,
+    return new MethodInvocation(new ThisExpression(), indexGetName,
         new Arguments(<Expression>[index]), getter);
   }
 
   _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
-    return new MethodInvocation(new ThisExpression(), _indexSet,
+    return new MethodInvocation(new ThisExpression(), indexSetName,
         new Arguments(<Expression>[index, value]), setter);
   }
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable);
   }
 
-  _makeRead() => new MethodInvocation(new ThisExpression(), _indexGet,
+  _makeRead() => new MethodInvocation(new ThisExpression(), indexGetName,
       new Arguments(<Expression>[indexAccess()]), getter);
 
   _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
-    return new MethodInvocation(new ThisExpression(), _indexSet,
+    return new MethodInvocation(new ThisExpression(), indexSetName,
         new Arguments(<Expression>[indexAccess(), value]), setter);
   }
 
   _makeWriteAndReturn(Expression value) {
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(new MethodInvocation(
         new ThisExpression(),
-        _indexSet,
+        indexSetName,
         new 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(this.index, this.getter, this.setter);
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable);
   }
 
   _makeSimpleRead() => new SuperMethodInvocation(
-      _indexGet, new Arguments(<Expression>[index]), getter);
+      indexGetName, new Arguments(<Expression>[index]), getter);
 
   _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new SuperMethodInvocation(
-        _indexSet, new Arguments(<Expression>[index, value]), setter);
+        indexSetName, new Arguments(<Expression>[index, value]), setter);
   }
 
   _makeRead() {
     return new SuperMethodInvocation(
-        _indexGet, new Arguments(<Expression>[indexAccess()]), getter);
+        indexGetName, new Arguments(<Expression>[indexAccess()]), getter);
   }
 
   _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
-    return new SuperMethodInvocation(
-        _indexSet, new Arguments(<Expression>[indexAccess(), value]), setter);
+    return new SuperMethodInvocation(indexSetName,
+        new Arguments(<Expression>[indexAccess(), value]), setter);
   }
 
   _makeWriteAndReturn(Expression value) {
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(new SuperMethodInvocation(
-        _indexSet,
+        indexSetName,
         new Arguments(
             <Expression>[indexAccess(), new VariableGet(valueVariable)]),
         setter));
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
   Expression _finish(Expression body) {
     return makeLet(indexVariable, body);
   }
@@ skipping 56 matching lines @@
 
 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());
 }