add fasta.scanner support for lazy assignment operators

pkg/front_end/lib/src/fasta/scanner/abstract_scanner.dart

 // Copyright (c) 2012, 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.
 
 library fasta.scanner.abstract_scanner;
 
 import 'dart:collection' show ListMixin;
 
 import 'dart:typed_data' show Uint16List, Uint32List;
 
@@ skipping 16 matching lines @@
 abstract class AbstractScanner implements Scanner {
   final bool includeComments;
 
   /**
    * A flag indicating whether to parse generic method comments, of the form
    * `/*=T*/` and `/*<T>*/`.  The flag [includeComments] must be set to `true`.
    */
   bool scanGenericMethodComments = false;
 
   /**
+   * A flag indicating whether the lazy compound assignment operators '&&=' and
+   * '||=' are enabled.
+   */
+  // TODO(paulberry): once lazyAssignmentOperators are fully supported by
+  // Dart, remove this flag.
+  bool scanLazyAssignmentOperators = false;

[ahe, 2017/05/22 11:37:38]

Why are we adding this flag?

[danrubel, 2017/05/23 11:33:40]

AFAIK, the language does not yet support lazy assignment operators, thus the
flag. I'm updating the fasta scanner to provide the same functionality that the
analyzer scanner does so that I can delete the analyzer scanner.

That said, we could roll this back and remove this functionality until closer to
the time that these language features are supported.

[ahe, 2017/05/23 11:46:08]

I don't think the flag is necessary. The parser will report an error on &&= or
||= regardless of how they're tokenized.

+
+  /**
    * The string offset for the next token that will be created.
    *
    * Note that in the [Utf8BytesScanner], [stringOffset] and [scanOffset] values
    * are different. One string character can be encoded using multiple UTF-8
    * bytes.
    */
   int tokenStart = -1;
 
   /**
    * A pointer to the token stream created by this scanner. The first token
@@ skipping 17 matching lines @@
   CommentToken comments;
 
   /**
    * A pointer to the last scanned comment token or `null` if none.
    */
   Token commentsTail;
 
   final List<int> lineStarts;
 
   AbstractScanner(this.includeComments, this.scanGenericMethodComments,
+      this.scanLazyAssignmentOperators,
       {int numberOfBytesHint})
       : lineStarts = new LineStarts(numberOfBytesHint) {
     this.tail = this.tokens;
   }
 
   /**
    * Advances and returns the next character.
    *
    * If the next character is non-ASCII, then the returned value depends on the
    * scanner implementation. The [Utf8BytesScanner] returns a UTF-8 byte, while
@@ skipping 395 matching lines @@
     } else if (identical(next, $PERIOD)) {
       appendPrecedenceToken(TokenType.QUESTION_PERIOD);
       return advance();
     } else {
       appendPrecedenceToken(TokenType.QUESTION);
       return next;
     }
   }
 
   int tokenizeBar(int next) {
-    // | || |=
+    // | || |= ||=
     next = advance();
     if (identical(next, $BAR)) {
+      next = advance();
+      if (scanLazyAssignmentOperators && identical(next, $EQ)) {
+        appendPrecedenceToken(TokenType.BAR_BAR_EQ);
+        return advance();
+      }
       appendPrecedenceToken(TokenType.BAR_BAR);
-      return advance();
+      return next;
     } else if (identical(next, $EQ)) {
       appendPrecedenceToken(TokenType.BAR_EQ);
       return advance();
     } else {
       appendPrecedenceToken(TokenType.BAR);
       return next;
     }
   }
 
   int tokenizeAmpersand(int next) {
-    // && &= &
+    // && &= & &&=
     next = advance();
     if (identical(next, $AMPERSAND)) {
+      next = advance();
+      if (scanLazyAssignmentOperators && identical(next, $EQ)) {
+        appendPrecedenceToken(TokenType.AMPERSAND_AMPERSAND_EQ);
+        return advance();
+      }
       appendPrecedenceToken(TokenType.AMPERSAND_AMPERSAND);
-      return advance();
+      return next;
     } else if (identical(next, $EQ)) {
       appendPrecedenceToken(TokenType.AMPERSAND_EQ);
       return advance();
     } else {
       appendPrecedenceToken(TokenType.AMPERSAND);
       return next;
     }
   }
 
   int tokenizePercent(int next) {
@@ skipping 769 matching lines @@
       switchToUint32(newLength);
     }
   }
 
   void switchToUint32(int newLength) {
     final newArray = new Uint32List(newLength);
     newArray.setRange(0, arrayLength, array);
     array = newArray;
   }
 }