Rename MethodInvocation.period to MethodInvocation.operator.

pkg/analyzer/lib/src/generated/ast.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast;
 
 import 'dart:collection';
@@ skipping 1414 matching lines @@
   MethodDeclaration visitMethodDeclaration(MethodDeclaration node) =>
       new MethodDeclaration(cloneNode(node.documentationComment),
           cloneNodeList(node.metadata), cloneToken(node.externalKeyword),
           cloneToken(node.modifierKeyword), cloneNode(node.returnType),
           cloneToken(node.propertyKeyword), cloneToken(node.operatorKeyword),
           cloneNode(node.name), cloneNode(node.parameters),
           cloneNode(node.body));
 
   @override
   MethodInvocation visitMethodInvocation(MethodInvocation node) =>
-      new MethodInvocation(cloneNode(node.target), cloneToken(node.period),
+      new MethodInvocation(cloneNode(node.target), cloneToken(node.operator),
           cloneNode(node.methodName), cloneNode(node.argumentList));
 
   @override
   NamedExpression visitNamedExpression(NamedExpression node) =>
       new NamedExpression(cloneNode(node.name), cloneNode(node.expression));
 
   @override
   AstNode visitNativeClause(NativeClause node) =>
       new NativeClause(cloneToken(node.nativeKeyword), cloneNode(node.name));
 
@@ skipping 870 matching lines @@
         isEqualTokens(node.propertyKeyword, other.propertyKeyword) &&
         isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.parameters, other.parameters) &&
         isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitMethodInvocation(MethodInvocation node) {
     MethodInvocation other = _other as MethodInvocation;
     return isEqualNodes(node.target, other.target) &&
-        isEqualTokens(node.period, other.period) &&
+        isEqualTokens(node.operator, other.operator) &&
         isEqualNodes(node.methodName, other.methodName) &&
         isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitNamedExpression(NamedExpression node) {
     NamedExpression other = _other as NamedExpression;
     return isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.expression, other.expression);
   }
@@ skipping 7625 matching lines @@
       new MethodDeclaration(_cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata), _mapToken(node.externalKeyword),
           _mapToken(node.modifierKeyword), _cloneNode(node.returnType),
           _mapToken(node.propertyKeyword), _mapToken(node.operatorKeyword),
           _cloneNode(node.name), _cloneNode(node.parameters),
           _cloneNode(node.body));
 
   @override
   MethodInvocation visitMethodInvocation(MethodInvocation node) {
     MethodInvocation copy = new MethodInvocation(_cloneNode(node.target),
-        _mapToken(node.period), _cloneNode(node.methodName),
+        _mapToken(node.operator), _cloneNode(node.methodName),
         _cloneNode(node.argumentList));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   NamedExpression visitNamedExpression(NamedExpression node) {
     NamedExpression copy =
         new NamedExpression(_cloneNode(node.name), _cloneNode(node.expression));
@@ skipping 1770 matching lines @@
  * >     ([Expression] '.')? [SimpleIdentifier] [ArgumentList]
  */
 class MethodInvocation extends Expression {
   /**
    * The expression producing the object on which the method is defined, or
    * `null` if there is no target (that is, the target is implicitly `this`).
    */
   Expression _target;
 
   /**
-   * The period that separates the target from the method name, or `null` if
-   * there is no target.
+   * The period that separates the target from the method name in an ordinary

[Brian Wilkerson, 2015/03/27 16:26:24]

I'd prefer the following (because it will expand to other cases more easily):

The operator that separates the target from the method name, or `null` if there
is no target. In an ordinary method invocation this will be a period ('.'). In a
cascade section this will be the cascade operator ('..').

[Paul Berry, 2015/03/27 16:38:57]

Done.

+   * method invocation, or the `..` operator before the method name in a
+   * cascade section, or `null` if there is no target.
    */
-  Token period;
+  Token operator;
 
   /**
    * The name of the method being invoked.
    */
   SimpleIdentifier _methodName;
 
   /**
    * The list of arguments to the method.
    */
   ArgumentList _argumentList;
 
   /**
-   * Initialize a newly created method invocation. The [target] and [period] can
-   * be `null` if there is no target.
+   * Initialize a newly created method invocation. The [target] and [operator]
+   * can be `null` if there is no target.
    */
-  MethodInvocation(Expression target, this.period, SimpleIdentifier methodName,
-      ArgumentList argumentList) {
+  MethodInvocation(Expression target, this.operator,
+      SimpleIdentifier methodName, ArgumentList argumentList) {
     _target = _becomeParentOf(target);
     _methodName = _becomeParentOf(methodName);
     _argumentList = _becomeParentOf(argumentList);
   }
 
   /**
    * Return the list of arguments to the method.
    */
   ArgumentList get argumentList => _argumentList;
 
   /**
    * Set the list of arguments to the method to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList) {
     _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
-    } else if (period != null) {
-      return period;
+    } else if (operator != null) {
+      return operator;
     }
     return _methodName.beginToken;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(_target)
-    ..add(period)
+    ..add(operator)
     ..add(_methodName)
     ..add(_argumentList);
 
   @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of
    * this expression is not stored locally but is stored in the nearest ancestor
    * that is a [CascadeExpression].
    */
   bool get isCascaded =>
-      period != null && period.type == TokenType.PERIOD_PERIOD;
+      operator != null && operator.type == TokenType.PERIOD_PERIOD;
 
   /**
    * Return the name of the method being invoked.
    */
   SimpleIdentifier get methodName => _methodName;
 
   /**
    * Set the name of the method being invoked to the given [identifier].
    */
   void set methodName(SimpleIdentifier identifier) {
     _methodName = _becomeParentOf(identifier);
   }
 
+  /**
+   * The period that separates the target from the method name in an ordinary
+   * method invocation, or the `..` operator before the method name in a
+   * cascade section, or `null` if there is no target.
+   *
+   * Deprecated: use [operator] instead.
+   */
+  @deprecated
+  Token get period => operator;
+
+  /**
+   * The period that separates the target from the method name in an ordinary
+   * method invocation, or the `..` operator before the method name in a
+   * cascade section, or `null` if there is no target.
+   *
+   * Deprecated: use [operator] instead.
+   */
+  @deprecated
+  void set period(Token value) {
+    operator = value;
+  }
+
   @override
   int get precedence => 15;
 
   /**
    * Return the expression used to compute the receiver of the invocation. If
    * this invocation is not part of a cascade expression, then this is the same
    * as [target]. If this invocation is part of a cascade expression, then the
    * target stored with the cascade expression is returned.
    */
   Expression get realTarget {
@@ skipping 8207 matching lines @@
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }