[Intl] Cleanup some code

pkg/intl/lib/number_format.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.
 
 part of intl;
 /**
  * Provides the ability to format a number in a locale-specific way. The
  * format is specified as a pattern using a subset of the ICU formatting
  * patterns.
  *
@@ skipping 70 matching lines @@
    * single-threaded and unless we do an asynchronous operation in the process
    * of formatting then there will only ever be one number being formatted
    * at a time. In languages with threads we'd need to pass this on the stack.
    */
   StringBuffer _buffer;
 
   /**
    * Create a number format that prints using [newPattern] as it applies in
    * [locale].
    */
-  factory NumberFormat([String newPattern, String locale]) {
-    return new NumberFormat._forPattern(locale, (x) => newPattern);
-  }
+  factory NumberFormat([String newPattern, String locale]) =>
+      new NumberFormat._forPattern(locale, (x) => newPattern);
 
   /** Create a number format that prints as DECIMAL_PATTERN. */
   NumberFormat.decimalPattern([String locale]) :
       this._forPattern(locale, (x) => x.DECIMAL_PATTERN);
 
   /** Create a number format that prints as PERCENT_PATTERN. */
   NumberFormat.percentPattern([String locale]) :
     this._forPattern(locale, (x) => x.PERCENT_PATTERN);
 
   /** Create a number format that prints as SCIENTIFIC_PATTERN. */
@@ skipping 25 matching lines @@
    */
   static bool localeExists(localeName) {
     if (localeName == null) return false;
     return numberFormatSymbols.containsKey(localeName);
   }
 
   /**
    * Return the symbols which are used in our locale. Cache them to avoid
    * repeated lookup.
    */
-  NumberSymbols get symbols {
-    return _symbols;
-  }
+  NumberSymbols get symbols => _symbols;
 
   /**
    * Format [number] according to our pattern and return the formatted string.
    */
   String format(num number) {
     // TODO(alanknight): Do we have to do anything for printing numbers bidi?
     // Or are they always printed left to right?
     if (number.isNaN) return symbols.NAN;
     if (number.isInfinite) return "${_signPrefix(number)}${symbols.INFINITY}";
 
@@ skipping 148 matching lines @@
     if (_decimalSeparatorAlwaysShown || fractionPresent) {
       _add(symbols.DECIMAL_SEP);
     }
   }
 
   /**
    * Return true if we have a main integer part which is printable, either
    * because we have digits left of the decimal point, or because there are
    * a minimum number of printable digits greater than 1.
    */
-  bool _hasPrintableIntegerPart(int intValue) {
-    return intValue > 0 || minimumIntegerDigits > 0;
-  }
+  bool _hasPrintableIntegerPart(int intValue) =>
+      intValue > 0 || minimumIntegerDigits > 0;
 
   /**
    * Create a new empty buffer. See comment on [_buffer] variable for why
    * we have it as an instance variable rather than passing it on the stack.
    */
   void _newBuffer() { _buffer = new StringBuffer(); }
 
   /** A group of methods that provide support for writing digits and other
    * required characters into [_buffer] easily.
    */
@@ skipping 34 matching lines @@
   // Note that there is a slight risk of a locale's zero digit not fitting
   // into a single code unit, but it seems very unlikely, and if it did,
   // there's a pretty good chance that our assumptions about being able to do
   // arithmetic on it would also be invalid.
   get _localeZero => symbols.ZERO_DIGIT.codeUnits.first;
 
   /**
    * Returns the prefix for [x] based on whether it's positive or negative.
    * In en_US this would be '' and '-' respectively.
    */
-  String _signPrefix(num x) {
-    return x.isNegative ? _negativePrefix : _positivePrefix;
-  }
+  String _signPrefix(num x) => x.isNegative ? _negativePrefix : _positivePrefix;
 
   /**
    * Returns the suffix for [x] based on wether it's positive or negative.
    * In en_US there are no suffixes for positive or negative.
    */
-  String _signSuffix(num x) {
-    return x.isNegative ? _negativeSuffix : _positiveSuffix;
-  }
+  String _signSuffix(num x) => x.isNegative ? _negativeSuffix : _positiveSuffix;
 
   void _setPattern(String newPattern) {
     if (newPattern == null) return;
     // Make spaces non-breaking
     _pattern = newPattern.replaceAll(' ', '\u00a0');
     var parser = new _NumberFormatParser(this, newPattern);
     parser.parse();
   }
 
   String toString() => "NumberFormat($_locale, $_pattern)";
@@ skipping 71 matching lines @@
    * whether or not we are in a quoted region. */
   bool inQuote = false;
 
   /**
    * Parse a prefix or suffix and return the prefix/suffix string. Note that
    * this also may modify the state of [format].
    */
   String _parseAffix() {
     var affix = new StringBuffer();
     inQuote = false;
-    var loop = true;
-    while (loop) {
-      loop = parseCharacterAffix(affix) && pattern.moveNext();
-    }
+    while (parseCharacterAffix(affix) && pattern.moveNext());
     return affix.toString();
   }
 
   /**
    * Parse an individual character as part of a prefix or suffix.  Return true
    * if we should continue to look for more affix characters, and false if
    * we have reached the end.
    */
   bool parseCharacterAffix(StringBuffer affix) {
     var ch = pattern.current;
     if (ch == null) return false;
     if (ch == _QUOTE) {
-      var nextChar = pattern.peek;
-      if (nextChar == _QUOTE) {
+      if (pattern.peek == _QUOTE) {
         pattern.moveNext();
         affix.write(_QUOTE); // 'don''t'
       } else {
         inQuote = !inQuote;
       }
       return true;
     }
 
     if (inQuote) {
       affix.write(ch);
@@ skipping 50 matching lines @@
     groupingCount = -1;
 
     var loop = true;
     trunk = new StringBuffer();
     while (pattern.current != null && loop) {
       loop = parseTrunkCharacter();
     }
 
     if (zeroDigitCount == 0 && digitLeftCount > 0 && decimalPos >= 0) {
       // Handle '###.###' and '###.' and '.###'
-      var n = decimalPos;
-      if (n == 0) { // Handle '.###'
-        n++;
-      }
+      // Handle '.###'
+      var n = decimalPos == 0 ? 1 : decimalPos;
       digitRightCount = digitLeftCount - n;
       digitLeftCount = n - 1;
       zeroDigitCount = 1;
     }
 
     // Do syntax checking on the digits.
     if (decimalPos < 0 && digitRightCount > 0 ||
         decimalPos >= 0 && (decimalPos < digitLeftCount ||
             decimalPos > digitLeftCount + zeroDigitCount) ||
             groupingCount == 0) {
@@ skipping 124 matching lines @@
 Iterator _iterator(String s) => new _StringIterator(s);
 
 // TODO(nweiz): remove this when issue 3780 is fixed.
 /**
  * Provides an Iterable that wraps [_iterator] so it can be used in a `for`
  * loop.
  */
 class _StringIterable extends IterableBase<String> {
   final Iterator<String> iterator;
 
-  _StringIterable(String s)
-      : iterator = _iterator(s);
+  _StringIterable(String s) : iterator = _iterator(s);
 }
 
 /**
  * Provides an iterator over a string as a list of substrings, and also
  * gives us a lookahead of one via the [peek] method.
  */
 class _StringIterator implements Iterator<String> {
-  String input;
-  var index = -1;
-  inBounds(i) => i >= 0 && i < input.length;
-  _StringIterator(this.input);
+  final String input;
+  final int length;
+  int index = -1;
+  inBounds(i) => i >= 0 && i < length;
+  _StringIterator(String input): input = input, length = input.length;

[Alan Knight, 2014/01/28 01:33:46]

Why move the assignment of input out of the constructor arguments? 

Also, what's the point of having the length field? If the compiler can't
optimize the input.length calls away for a final string, we need new compiler
people :-)

[vicb, 2014/01/28 07:52:45]

"input" was moved out of the constructor args because it was used in the
initializer list.

I have reverted the addition of "length" as it could probably be automatically
optimized now with the input being final. 

[Alan Knight, 2014/01/29 01:27:58]

Interesting, I didn't realize that wasn't permitted.

   String get current => inBounds(index) ? input[index] : null;
 
   bool moveNext() => inBounds(++index);
   String get peek => inBounds(index + 1) ? input[index + 1] : null;
   Iterator<String> get iterator => this;
 }