Change getters syntax in dart:io library.

runtime/bin/http_impl.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.
 
 class _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
@@ skipping 47 matching lines @@
 
   void forEach(void f(String name, List<String> values)) {
     _headers.forEach(f);
   }
 
   void noFolding(String name) {
     if (_noFoldingHeaders == null) _noFoldingHeaders = new List<String>();
     _noFoldingHeaders.add(name);
   }
 
-  String get host() => _host;
+  String get host => _host;
 
   void set host(String host) {
     _checkMutable();
     _host = host;
     _updateHostHeader();
   }
 
-  int get port() => _port;
+  int get port => _port;
 
   void set port(int port) {
     _checkMutable();
     _port = port;
     _updateHostHeader();
   }
 
-  Date get ifModifiedSince() {
+  Date get ifModifiedSince {
     List<String> values = _headers["if-modified-since"];
     if (values != null) {
       try {
         return _HttpUtils.parseDate(values[0]);
       } catch (Exception e) {
         return null;
       }
     }
     return null;
   }
 
   void set ifModifiedSince(Date ifModifiedSince) {
     _checkMutable();
     // Format "ifModifiedSince" header with date in Greenwich Mean Time (GMT).
     String formatted = _HttpUtils.formatDate(ifModifiedSince.toUtc());
     _set("if-modified-since", formatted);
   }
 
-  Date get date() {
+  Date get date {
     List<String> values = _headers["date"];
     if (values != null) {
       try {
         return _HttpUtils.parseDate(values[0]);
       } catch (Exception e) {
         return null;
       }
     }
     return null;
   }
 
   void set date(Date date) {
     _checkMutable();
     // Format "Date" header with date in Greenwich Mean Time (GMT).
     String formatted = _HttpUtils.formatDate(date.toUtc());
     _set("date", formatted);
   }
 
-  Date get expires() {
+  Date get expires {
     List<String> values = _headers["expires"];
     if (values != null) {
       try {
         return _HttpUtils.parseDate(values[0]);
       } catch (Exception e) {
         return null;
       }
     }
     return null;
   }
 
   void set expires(Date expires) {
     _checkMutable();
     // Format "Expires" header with date in Greenwich Mean Time (GMT).
     String formatted = _HttpUtils.formatDate(expires.toUtc());
     _set("expires", formatted);
   }
 
-  ContentType get contentType() {
+  ContentType get contentType {
     var values = _headers["content-type"];
     if (values != null) {
       return new ContentType.fromString(values[0]);
     } else {
       return new ContentType();
     }
   }
 
   void set contentType(ContentType contentType) {
     _checkMutable();
@@ skipping 154 matching lines @@
 
 
 class _HeaderValue implements HeaderValue {
   _HeaderValue([String this.value = ""]);
 
   _HeaderValue.fromString(String value) {
     // Parse the string.
     _parse(value);
   }
 
-  Map<String, String> get parameters() {
+  Map<String, String> get parameters {
     if (_parameters == null) _parameters = new Map<String, String>();
     return _parameters;
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.add(value);
     if (parameters != null && parameters.length > 0) {
       _parameters.forEach((String name, String value) {
         sb.add("; ");
@@ skipping 97 matching lines @@
   String value;
   Map<String, String> _parameters;
 }
 
 
 class _ContentType extends _HeaderValue implements ContentType {
   _ContentType([String this._primaryType = "", String this._subType = ""]);
 
   _ContentType.fromString(String value) : super.fromString(value);
 
-  String get value() => "$_primaryType/$_subType";
+  String get value => "$_primaryType/$_subType";
 
   void set value(String s) {
     int index = s.indexOf("/");
     if (index == -1 || index == (s.length - 1)) {
       primaryType = s.trim().toLowerCase();
       subType = "";
     } else {
       primaryType = s.substring(0, index).trim().toLowerCase();
       subType = s.substring(index + 1).trim().toLowerCase();
     }
   }
 
-  String get primaryType() => _primaryType;
+  String get primaryType => _primaryType;
 
   void set primaryType(String s) {
     _primaryType = s;
   }
 
-  String get subType() => _subType;
+  String get subType => _subType;
 
   void set subType(String s) {
     _subType = s;
   }
 
-  String get charset() => parameters["charset"];
+  String get charset => parameters["charset"];
 
   void set charset(String s) {
     parameters["charset"] = s;
   }
 
   String _primaryType = "";
   String _subType = "";
 }
 
 
@@ skipping 133 matching lines @@
   final int HEADER_SENT = 1;
   final int DONE = 2;
   final int UPGRADED = 3;
 
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _headers = new _HttpHeaders() {
     _state = START;
     _headResponse = false;
   }
 
-  int get contentLength() => _contentLength;
-  HttpHeaders get headers() => _headers;
+  int get contentLength => _contentLength;
+  HttpHeaders get headers => _headers;
 
-  bool get persistentConnection() {
+  bool get persistentConnection {
     List<String> connection = headers[HttpHeaders.CONNECTION];
     if (_protocolVersion == "1.1") {
       if (connection == null) return true;
       return !headers[HttpHeaders.CONNECTION].some(
           (value) => value.toLowerCase() == "close");
     } else {
       if (connection == null) return false;
       return headers[HttpHeaders.CONNECTION].some(
           (value) => value.toLowerCase() == "keep-alive");
     }
@@ skipping 104 matching lines @@
     }
   }
 
   void _updateContentLength(int bytes) {
     if (_bodyBytesWritten + bytes > _contentLength) {
       throw new HttpException("Writing more than specified content length");
     }
     _bodyBytesWritten += bytes;
   }
 
-  HttpConnectionInfo get connectionInfo() => _httpConnection.connectionInfo;
+  HttpConnectionInfo get connectionInfo => _httpConnection.connectionInfo;
 
-  bool get _done() => _state == DONE;
+  bool get _done => _state == DONE;
 
   int _state;
   bool _headResponse;
 
   _HttpConnectionBase _httpConnection;
   _HttpHeaders _headers;
   List<Cookie> _cookies;
   String _protocolVersion = "1.1";
 
   // Length of the content body. If this is set to -1 (default value)
   // when starting to send data chunked transfer encoding will be
   // used.
   int _contentLength = -1;
   // Number of body bytes written. This is only actual body data not
   // including headers or chunk information of using chinked transfer
   // encoding.
   int _bodyBytesWritten = 0;
 }
 
 
 // Parsed HTTP request providing information on the HTTP headers.
 class _HttpRequest extends _HttpRequestResponseBase implements HttpRequest {
   _HttpRequest(_HttpConnection connection) : super(connection);
 
-  String get method() => _method;
-  String get uri() => _uri;
-  String get path() => _path;
-  String get queryString() => _queryString;
-  Map get queryParameters() => _queryParameters;
+  String get method => _method;
+  String get uri => _uri;
+  String get path => _path;
+  String get queryString => _queryString;
+  Map get queryParameters => _queryParameters;
 
-  List<Cookie> get cookies() {
+  List<Cookie> get cookies {
     if (_cookies != null) return _cookies;
 
     // Parse a Cookie header value according to the rules in RFC 6265.
    void _parseCookieString(String s) {
       int index = 0;
 
       bool done() => index == s.length;
 
       void skipWS() {
         while (!done()) {
@@ skipping 46 matching lines @@
     }
 
     _cookies = new List<Cookie>();
     List<String> headerValues = headers["cookie"];
     if (headerValues != null) {
       headerValues.forEach((headerValue) => _parseCookieString(headerValue));
     }
     return _cookies;
   }
 
-  InputStream get inputStream() {
+  InputStream get inputStream {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
-  String get protocolVersion() => _protocolVersion;
+  String get protocolVersion => _protocolVersion;
 
   void _onRequestStart(String method, String uri, String version) {
     _method = method;
     _uri = uri;
     _parseRequestUri(uri);
   }
 
   void _onHeaderReceived(String name, String value) {
     _headers.add(name, value);
   }
@@ skipping 61 matching lines @@
 class _HttpResponse extends _HttpRequestResponseBase implements HttpResponse {
   _HttpResponse(_HttpConnection httpConnection)
       : super(httpConnection),
         _statusCode = HttpStatus.OK;
 
   void set contentLength(int contentLength) {
     if (_state >= HEADER_SENT) throw new HttpException("Header already sent");
     _contentLength = contentLength;
   }
 
-  int get statusCode() => _statusCode;
+  int get statusCode => _statusCode;
   void set statusCode(int statusCode) {
     if (_outputStream != null) throw new HttpException("Header already sent");
     _statusCode = statusCode;
   }
 
-  String get reasonPhrase() => _findReasonPhrase(_statusCode);
+  String get reasonPhrase => _findReasonPhrase(_statusCode);
   void set reasonPhrase(String reasonPhrase) {
     if (_outputStream != null) throw new HttpException("Header already sent");
     _reasonPhrase = reasonPhrase;
   }
 
-  List<Cookie> get cookies() {
+  List<Cookie> get cookies {
     if (_cookies == null) _cookies = new List<Cookie>();
     return _cookies;
   }
 
-  OutputStream get outputStream() {
+  OutputStream get outputStream {
     if (_state >= DONE) throw new HttpException("Response closed");
     if (_outputStream == null) {
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
   }
 
   DetachedSocket detachSocket() {
     if (_state >= DONE) throw new HttpException("Response closed");
     // Ensure that headers are written.
@@ skipping 205 matching lines @@
   }
 
   bool writeFrom(List<int> buffer, [int offset = 0, int len]) {
     return _requestOrResponse._streamWriteFrom(buffer, offset, len);
   }
 
   void close() {
     _requestOrResponse._streamClose();
   }
 
-  bool get closed() => _requestOrResponse._done;
+  bool get closed => _requestOrResponse._done;
 
   void destroy() {
     throw "Not implemented";
   }
 
   void set onNoPendingWrites(void callback()) {
     _requestOrResponse._streamSetNoPendingWriteHandler(callback);
   }
 
   void set onClosed(void callback()) {
@@ skipping 87 matching lines @@
     _socket.onData = null;
     _socket.onClosed = null;
     _socket.onError = null;
     _socket.outputStream.onNoPendingWrites = null;
     Socket socket = _socket;
     _socket = null;
     if (onDetach != null) onDetach();
     return new _DetachedSocket(socket, _httpParser.unparsedData);
   }
 
-  HttpConnectionInfo get connectionInfo() {
+  HttpConnectionInfo get connectionInfo {
     if (_socket == null || _closing || _error) return null;
     try {
       _HttpConnectionInfo info = new _HttpConnectionInfo();
       info.remoteHost = _socket.remoteHost;
       info.remotePort = _socket.remotePort;
       info.localPort = _socket.port;
       return info;
     } catch (var e) { }
     return null;
   }
@@ skipping 182 matching lines @@
     if (_server !== null && _closeServer) {
       _server.close();
     }
     _server = null;
     for (_HttpConnection connection in _connections) {
       connection._destroy();
     }
     _connections.clear();
   }
 
-  int get port() {
+  int get port {
     if (_server === null) {
       throw new HttpException("The HttpServer is not listening on a port.");
     }
     return _server.port;
   }
 
   void set onError(void callback(e)) {
     _onError = callback;
   }
 
@@ skipping 44 matching lines @@
     if (_method == "GET" || _method == "HEAD") {
       _contentLength = 0;
     }
   }
 
   void set contentLength(int contentLength) {
     if (_state >= HEADER_SENT) throw new HttpException("Header already sent");
     _contentLength = contentLength;
   }
 
-  List<Cookie> get cookies() {
+  List<Cookie> get cookies {
     if (_cookies == null) _cookies = new List<Cookie>();
     return _cookies;
   }
 
-  OutputStream get outputStream() {
+  OutputStream get outputStream {
     if (_done) throw new HttpException("Request closed");
     if (_outputStream == null) {
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
   }
 
   // Delegate functions for the HttpOutputStream implementation.
   bool _streamWrite(List<int> buffer, bool copyBuffer) {
     if (_done) throw new HttpException("Request closed");
@@ skipping 75 matching lines @@
 }
 
 
 class _HttpClientResponse
     extends _HttpRequestResponseBase implements HttpClientResponse {
   _HttpClientResponse(_HttpClientConnection connection)
       : super(connection) {
     _connection = connection;
   }
 
-  int get statusCode() => _statusCode;
-  String get reasonPhrase() => _reasonPhrase;
+  int get statusCode => _statusCode;
+  String get reasonPhrase => _reasonPhrase;
 
-  bool get isRedirect() {
+  bool get isRedirect {
     return statusCode == HttpStatus.MOVED_PERMANENTLY ||
            statusCode == HttpStatus.FOUND ||
            statusCode == HttpStatus.SEE_OTHER ||
            statusCode == HttpStatus.TEMPORARY_REDIRECT;
   }
 
-  List<Cookie> get cookies() {
+  List<Cookie> get cookies {
     if (_cookies != null) return _cookies;
     _cookies = new List<Cookie>();
     List<String> values = _headers["set-cookie"];
     if (values != null) {
       values.forEach((value) {
         _cookies.add(new Cookie.fromSetCookieValue(value));
       });
     }
     return _cookies;
   }
 
-  InputStream get inputStream() {
+  InputStream get inputStream {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
   void _onRequestStart(String method, String uri, String version) {
     // TODO(sgjesse): Error handling
   }
 
@@ skipping 199 matching lines @@
     if (_redirects == null) {
       _redirects = new List<_RedirectInfo>();
     }
     _redirects.add(new _RedirectInfo(_response.statusCode, method, url));
     _request = null;
     _response = null;
     // Open redirect URL using the same connection instance.
     _client._openUrl(method, url, this);
   }
 
-  List<RedirectInfo> get redirects() => _redirects;
+  List<RedirectInfo> get redirects => _redirects;
 
   Function _onRequest;
   Function _onResponse;
   Function _onErrorCallback;
 
   _HttpClient _client;
   _SocketConnection _socketConn;
   HttpClientRequest _request;
   HttpClientResponse _response;
   String _method;
@@ skipping 248 matching lines @@
 
 class _HttpConnectionInfo implements HttpConnectionInfo {
   String remoteHost;
   int remotePort;
   int localPort;
 }
 
 
 class _DetachedSocket implements DetachedSocket {
   _DetachedSocket(this._socket, this._unparsedData);
-  Socket get socket() => _socket;
-  List<int> get unparsedData() => _unparsedData;
+  Socket get socket => _socket;
+  List<int> get unparsedData => _unparsedData;
   Socket _socket;
   List<int> _unparsedData;
 }
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }