dartfmt pkg/compiler

pkg/compiler/lib/src/tokens/token.dart

 // Copyright (c) 2011, 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 dart2js.tokens;
 
-import 'dart:convert' show
-    UTF8;
-import 'dart:collection' show
-    HashSet;
+import 'dart:convert' show UTF8;
+import 'dart:collection' show HashSet;
 
 import '../common.dart';
-import '../util/util.dart' show
-    computeHashCode;
+import '../util/util.dart' show computeHashCode;
 
-import 'keyword.dart' show
-    Keyword;
-import 'precedence.dart' show
-    PrecedenceInfo;
-import 'precedence_constants.dart' as Precedence show
-    BAD_INPUT_INFO;
-import 'token_constants.dart' as Tokens show
-    IDENTIFIER_TOKEN;
+import 'keyword.dart' show Keyword;
+import 'precedence.dart' show PrecedenceInfo;
+import 'precedence_constants.dart' as Precedence show BAD_INPUT_INFO;
+import 'token_constants.dart' as Tokens show IDENTIFIER_TOKEN;
 
 /**
  * A token that doubles as a linked list.
  */
 abstract class Token implements Spannable {
   /**
    * The character offset of the start of this token within the source text.
    */
   final int charOffset;
 
@@ skipping 91 matching lines @@
   final Token end;
 
   TokenPair(this.begin, this.end);
 }
 
 /**
  * A [SymbolToken] represents the symbol in its precendence info.
  * Also used for end of file with EOF_INFO.
  */
 class SymbolToken extends Token {
-
   final PrecedenceInfo info;
 
   SymbolToken(this.info, int charOffset) : super(charOffset);
 
   String get value => info.value;
 
   String get stringValue => info.value;
 
   bool isIdentifier() => false;
 
@@ skipping 26 matching lines @@
   String get value => keyword.syntax;
 
   String get stringValue => keyword.syntax;
 
   bool isIdentifier() => keyword.isPseudo || keyword.isBuiltIn;
 
   String toString() => "KeywordToken($value)";
 }
 
 abstract class ErrorToken extends Token {
-  ErrorToken(int charOffset)
-      : super(charOffset);
+  ErrorToken(int charOffset) : super(charOffset);
 
   PrecedenceInfo get info => Precedence.BAD_INPUT_INFO;
 
   String get value {
     throw new SpannableAssertionFailure(this, assertionMessage);
   }
 
   String get stringValue => null;
 
   bool isIdentifier() => false;
 
   String get assertionMessage;
 }
 
 class BadInputToken extends ErrorToken {
   final int character;
 
-  BadInputToken(this.character, int charOffset)
-      : super(charOffset);
+  BadInputToken(this.character, int charOffset) : super(charOffset);
 
   String toString() => "BadInputToken($character)";
 
   String get assertionMessage {
     return 'Character U+${character.toRadixString(16)} not allowed here.';
   }
 }
 
 class UnterminatedToken extends ErrorToken {
   final String start;
@@ skipping 39 matching lines @@
 
   var /* String | LazySubtring */ valueOrLazySubstring;
 
   final PrecedenceInfo info;
 
   /**
    * Creates a non-lazy string token. If [canonicalize] is true, the string
    * is canonicalized before the token is created.
    */
   StringToken.fromString(this.info, String value, int charOffset,
-                         {bool canonicalize : false})
+      {bool canonicalize: false})
       : valueOrLazySubstring = canonicalizedString(value, canonicalize),
         super(charOffset);
 
   /**
    * Creates a lazy string token. If [canonicalize] is true, the string
    * is canonicalized before the token is created.
    */
-  StringToken.fromSubstring(this.info, String data, int start, int end,
-                            int charOffset, {bool canonicalize : false})
+  StringToken.fromSubstring(
+      this.info, String data, int start, int end, int charOffset,
+      {bool canonicalize: false})
       : super(charOffset) {
     int length = end - start;
     if (length <= LAZY_THRESHOLD) {
-      valueOrLazySubstring = canonicalizedString(data.substring(start, end),
-                                                 canonicalize);
+      valueOrLazySubstring =
+          canonicalizedString(data.substring(start, end), canonicalize);
     } else {
       valueOrLazySubstring =
           new LazySubstring(data, start, length, canonicalize);
     }
   }
 
   /**
    * Creates a lazy string token. If [asciiOnly] is false, the byte array
    * is passed through a UTF-8 decoder.
    */
   StringToken.fromUtf8Bytes(this.info, List<int> data, int start, int end,
-                            bool asciiOnly, int charOffset)
+      bool asciiOnly, int charOffset)
       : super(charOffset) {
     int length = end - start;
     if (length <= LAZY_THRESHOLD) {
       valueOrLazySubstring = decodeUtf8(data, start, end, asciiOnly);
     } else {
       valueOrLazySubstring = new LazySubstring(data, start, length, asciiOnly);
     }
   }
 
   String get value {
     if (valueOrLazySubstring is String) {
       return valueOrLazySubstring;
     } else {
       assert(valueOrLazySubstring is LazySubstring);
       var data = valueOrLazySubstring.data;
       int start = valueOrLazySubstring.start;
       int end = start + valueOrLazySubstring.length;
       if (data is String) {
         valueOrLazySubstring = canonicalizedString(
             data.substring(start, end), valueOrLazySubstring.boolValue);
       } else {
-        valueOrLazySubstring = decodeUtf8(
-            data, start, end, valueOrLazySubstring.boolValue);
+        valueOrLazySubstring =
+            decodeUtf8(data, start, end, valueOrLazySubstring.boolValue);
       }
       return valueOrLazySubstring;
     }
   }
 
   /// See [Token.stringValue] for an explanation.
   String get stringValue => null;
 
   bool isIdentifier() => identical(kind, Tokens.IDENTIFIER_TOKEN);
 
   String toString() => "StringToken($value)";
 
-  static final HashSet<String> canonicalizedSubstrings =
-      new HashSet<String>();
+  static final HashSet<String> canonicalizedSubstrings = new HashSet<String>();
 
   static String canonicalizedString(String s, bool canonicalize) {
     if (!canonicalize) return s;
     var result = canonicalizedSubstrings.lookup(s);
     if (result != null) return result;
     canonicalizedSubstrings.add(s);
     return s;
   }
 
   static String decodeUtf8(List<int> data, int start, int end, bool asciiOnly) {
@@ skipping 66 matching lines @@
 class FullLazySubstring extends LazySubstring {
   final data;
   final int start;
   final int length;
   final bool boolValue;
   FullLazySubstring(this.data, this.start, this.length, this.boolValue)
       : super.internal();
 }
 
 bool isUserDefinableOperator(String value) {
-  return
-      isBinaryOperator(value) ||
+  return isBinaryOperator(value) ||
       isMinusOperator(value) ||
       isTernaryOperator(value) ||
       isUnaryOperator(value);
 }
 
 bool isUnaryOperator(String value) => value == '~';
 
 bool isBinaryOperator(String value) {
-  return
-      value == '==' ||
+  return value == '==' ||
       value == '[]' ||
       value == '*' ||
       value == '/' ||
       value == '%' ||
       value == '~/' ||
       value == '+' ||
       value == '<<' ||
       value == '>>' ||
       value == '>=' ||
       value == '>' ||
       value == '<=' ||
       value == '<' ||
       value == '&' ||
       value == '^' ||
       value == '|';
 }
 
 bool isTernaryOperator(String value) => value == '[]=';
 
 bool isMinusOperator(String value) => value == '-';