Make isEmpty a getter.

runtime/bin/string_stream.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.
 
 // Interface for decoders decoding binary data into string data. The
 // decoder keeps track of line breaks during decoding.
 abstract class _StringDecoder {
   // Add more binary data to be decoded. The ownership of the buffer
   // is transfered to the decoder and the caller most not modify it any more.
   int write(List<int> buffer);
 
   // Returns whether any decoded data is available.
-  bool isEmpty();
+  bool get isEmpty;
 
   // Returns the number of available decoded characters.
   int available();
 
   // Get the number of line breaks present in the current decoded
   // data.
   int get lineBreaks;
 
   // Get up to [len] characters of string data decoded since the last
   // call to [decode] or [decodeLine]. Returns null if no decoded data
@@ skipping 47 matching lines @@
     _bufferList.add(buffer);
     // Decode as many bytes into characters as possible.
     while (_bufferList.length > 0) {
       if (!_processNext()) {
         break;
       }
     }
     return buffer.length;
   }
 
-  bool isEmpty() => _result.isEmpty();
+  bool get isEmpty => _result.isEmpty;
 
   int get lineBreaks => _lineBreaks;
 
   String decoded([int len]) {
-    if (isEmpty()) return null;
+    if (isEmpty) return null;
 
     String result;
     if (len !== null && len < available()) {
       result = new String.fromCharCodes(_result.getRange(_resultOffset, len));
     } else {
       if (_resultOffset == 0) {
         result = new String.fromCharCodes(_result);
       } else {
         result =
             new String.fromCharCodes(
                 _result.getRange(_resultOffset,
                                  _result.length - _resultOffset));
       }
     }
     _resultOffset += result.length;
-    while (!_lineBreakEnds.isEmpty() &&
+    while (!_lineBreakEnds.isEmpty &&
            _lineBreakEnds.first() < _charOffset + _resultOffset) {
       _lineBreakEnds.removeFirst();
       _lineBreaks--;
     }
     if (_result.length == _resultOffset) _resetResult();
     return result;
   }
 
   String get decodedLine {
-    if (_lineBreakEnds.isEmpty()) return null;
+    if (_lineBreakEnds.isEmpty) return null;
     int lineEnd = _lineBreakEnds.removeFirst();
     int terminationSequenceLength = 1;
     if (_result[lineEnd - _charOffset] == LF &&
         lineEnd > _charOffset &&
         _resultOffset < lineEnd &&
         _result[lineEnd - _charOffset - 1] == CR) {
       terminationSequenceLength = 2;
     }
     var lineLength =
         lineEnd - _charOffset - _resultOffset - terminationSequenceLength + 1;
@@ skipping 257 matching lines @@
       }
     }
     _checkInstallDataHandler();
     return decodedLine;
   }
 
   int available() => _decoder.available();
 
   Encoding get encoding => _encoding;
 
-  bool get closed => _inputClosed && _decoder.isEmpty();
+  bool get closed => _inputClosed && _decoder.isEmpty;
 
   void set onData(void callback()) {
     _clientDataHandler = callback;
     _clientLineHandler = null;
     _checkInstallDataHandler();
     _checkScheduleCallback();
   }
 
   void set onLine(void callback()) {
     _clientLineHandler = callback;
     _clientDataHandler = null;
     _checkInstallDataHandler();
     _checkScheduleCallback();
   }
 
   void set onClosed(void callback()) {
     _clientCloseHandler = callback;
   }
 
   void set onError(void callback(e)) {
     _input.onError = callback;
   }
 
   void _onData() {
     _readData();
-    if (!_decoder.isEmpty() && _clientDataHandler !== null) {
+    if (!_decoder.isEmpty && _clientDataHandler !== null) {
       _clientDataHandler();
     }
     if (_decoder.lineBreaks > 0 && _clientLineHandler !== null) {
       _clientLineHandler();
     }
     _checkScheduleCallback();
     _checkInstallDataHandler();
   }
 
   void _onClosed() {
     _inputClosed = true;
-    if (_decoder.isEmpty() && _clientCloseHandler != null) {
+    if (_decoder.isEmpty && _clientCloseHandler != null) {
       _clientCloseHandler();
       _closed = true;
     } else {
       _checkScheduleCallback();
     }
   }
 
   void _readData() {
     List<int> data = _input.read();
     if (data !== null) {
       _decoder.write(data);
     }
   }
 
   void _checkInstallDataHandler() {
     if (_inputClosed ||
         (_clientDataHandler === null && _clientLineHandler === null)) {
       _input.onData = null;
     } else if (_clientDataHandler !== null) {
-      if (_decoder.isEmpty()) {
+      if (_decoder.isEmpty) {
         _input.onData = _onData;
       } else {
         _input.onData = null;
       }
     } else {
       assert(_clientLineHandler !== null);
       if (_decoder.lineBreaks == 0) {
         _input.onData = _onData;
       } else {
         _input.onData = null;
@@ skipping 24 matching lines @@
       _scheduledCloseCallback = null;
       if (!_closed) {
         if (_clientCloseHandler !== null) _clientCloseHandler();
         _closed = true;
       }
     }
 
     if (!_closed) {
       // Schedule data callback if string data available.
       if (_clientDataHandler != null &&
-          !_decoder.isEmpty() &&
+          !_decoder.isEmpty &&
           _scheduledDataCallback == null) {
         if (_scheduledLineCallback != null) {
           _scheduledLineCallback.cancel();
         }
         _scheduledDataCallback = new Timer(0, issueDataCallback);
       }
 
       // Schedule line callback if a line is available.
       if (_clientLineHandler != null &&
-          (_decoder.lineBreaks > 0 || (!_decoder.isEmpty() && _inputClosed)) &&
+          (_decoder.lineBreaks > 0 || (!_decoder.isEmpty && _inputClosed)) &&
           _scheduledLineCallback == null) {
         if (_scheduledDataCallback != null) {
           _scheduledDataCallback.cancel();
         }
         _scheduledLineCallback = new Timer(0, issueLineCallback);
       }
 
       // Schedule close callback if no more data and input is closed.
-      if (_decoder.isEmpty() &&
+      if (_decoder.isEmpty &&
           _inputClosed &&
           _scheduledCloseCallback == null) {
         _scheduledCloseCallback = new Timer(0, issueCloseCallback);
       }
     }
   }
 
   InputStream _input;
   Encoding _encoding;
   _StringDecoder _decoder;
   bool _inputClosed = false;  // Is the underlying input stream closed?
   bool _closed = false;  // Is this stream closed.
   bool _eof = false;  // Has all data been read from the decoder?
   Timer _scheduledDataCallback;
   Timer _scheduledLineCallback;
   Timer _scheduledCloseCallback;
   Function _clientDataHandler;
   Function _clientLineHandler;
   Function _clientCloseHandler;
 }