Remove Rust from the tree.

Part 4 for #58

1 files changed, 0 insertions, 1456 deletions

diff --git a/third_party/rust/url/src/lib.rs b/third_party/rust/url/src/lib.rs
deleted file mode 100644
index 9378318b4..000000000
--- a/third_party/rust/url/src/lib.rs
+++ /dev/null
@@ -1,1456 +0,0 @@
-// Copyright 2013-2015 The rust-url developers.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/*!
-
-rust-url is an implementation of the [URL Standard](http://url.spec.whatwg.org/)
-for the [Rust](http://rust-lang.org/) programming language.
-
-It builds with [Cargo](http://crates.io/).
-To use it in your project, add this to your `Cargo.toml` file:
-
-```Cargo
-[dependencies.url]
-git = "https://github.com/servo/rust-url"
-```
-
-Supporting encodings other than UTF-8 in query strings is an optional feature
-that requires [rust-encoding](https://github.com/lifthrasiir/rust-encoding)
-and is off by default.
-You can enable it with
-[Cargo’s *features* mechanism](http://doc.crates.io/manifest.html#the-[features]-section):
-
-```Cargo
-[dependencies.url]
-git = "https://github.com/servo/rust-url"
-features = ["query_encoding"]
-```
-
-… or by passing `--cfg 'feature="query_encoding"'` to rustc.
-
-
-# URL parsing and data structures
-
-First, URL parsing may fail for various reasons and therefore returns a `Result`.
-
-```
-use url::{Url, ParseError};
-
-assert!(Url::parse("http://[:::1]") == Err(ParseError::InvalidIpv6Address))
-```
-
-Let’s parse a valid URL and look at its components.
-
-```
-use url::{Url, Host};
-
-let issue_list_url = Url::parse(
-    "https://github.com/rust-lang/rust/issues?labels=E-easy&state=open"
-).unwrap();
-
-
-assert!(issue_list_url.scheme() == "https");
-assert!(issue_list_url.username() == "");
-assert!(issue_list_url.password() == None);
-assert!(issue_list_url.host_str() == Some("github.com"));
-assert!(issue_list_url.host() == Some(Host::Domain("github.com")));
-assert!(issue_list_url.port() == None);
-assert!(issue_list_url.path() == "/rust-lang/rust/issues");
-assert!(issue_list_url.path_segments().map(|c| c.collect::<Vec<_>>()) ==
-        Some(vec!["rust-lang", "rust", "issues"]));
-assert!(issue_list_url.query() == Some("labels=E-easy&state=open"));
-assert!(issue_list_url.fragment() == None);
-assert!(!issue_list_url.cannot_be_a_base());
-```
-
-Some URLs are said to be *cannot-be-a-base*:
-they don’t have a username, password, host, or port,
-and their "path" is an arbitrary string rather than slash-separated segments:
-
-```
-use url::Url;
-
-let data_url = Url::parse("data:text/plain,Hello?World#").unwrap();
-
-assert!(data_url.cannot_be_a_base());
-assert!(data_url.scheme() == "data");
-assert!(data_url.path() == "text/plain,Hello");
-assert!(data_url.path_segments().is_none());
-assert!(data_url.query() == Some("World"));
-assert!(data_url.fragment() == Some(""));
-```
-
-
-# Base URL
-
-Many contexts allow URL *references* that can be relative to a *base URL*:
-
-```html
-<link rel="stylesheet" href="../main.css">
-```
-
-Since parsed URL are absolute, giving a base is required for parsing relative URLs:
-
-```
-use url::{Url, ParseError};
-
-assert!(Url::parse("../main.css") == Err(ParseError::RelativeUrlWithoutBase))
-```
-
-Use the `join` method on an `Url` to use it as a base URL:
-
-```
-use url::Url;
-
-let this_document = Url::parse("http://servo.github.io/rust-url/url/index.html").unwrap();
-let css_url = this_document.join("../main.css").unwrap();
-assert_eq!(css_url.as_str(), "http://servo.github.io/rust-url/main.css")
-*/
-
-#[cfg(feature="rustc-serialize")] extern crate rustc_serialize;
-#[macro_use] extern crate matches;
-#[cfg(feature="serde")] extern crate serde;
-#[cfg(feature="heapsize")] #[macro_use] extern crate heapsize;
-
-pub extern crate idna;
-
-use encoding::EncodingOverride;
-#[cfg(feature = "heapsize")] use heapsize::HeapSizeOf;
-use host::HostInternal;
-use parser::{Parser, Context, SchemeType, to_u32};
-use percent_encoding::{PATH_SEGMENT_ENCODE_SET, USERINFO_ENCODE_SET,
-                       percent_encode, percent_decode, utf8_percent_encode};
-use std::cmp;
-use std::fmt::{self, Write};
-use std::hash;
-use std::io;
-use std::mem;
-use std::net::{ToSocketAddrs, IpAddr};
-use std::ops::{Range, RangeFrom, RangeTo};
-use std::path::{Path, PathBuf};
-use std::str;
-
-pub use origin::{Origin, OpaqueOrigin};
-pub use host::{Host, HostAndPort, SocketAddrs};
-pub use path_segments::PathSegmentsMut;
-pub use parser::ParseError;
-pub use slicing::Position;
-
-mod encoding;
-mod host;
-mod origin;
-mod path_segments;
-mod parser;
-mod slicing;
-
-pub mod form_urlencoded;
-pub mod percent_encoding;
-pub mod quirks;
-
-/// A parsed URL record.
-#[derive(Clone)]
-pub struct Url {
-    /// Syntax in pseudo-BNF:
-    ///
-    ///   url = scheme ":" [ hierarchical | non-hierarchical ] [ "?" query ]? [ "#" fragment ]?
-    ///   non-hierarchical = non-hierarchical-path
-    ///   non-hierarchical-path = /* Does not start with "/" */
-    ///   hierarchical = authority? hierarchical-path
-    ///   authority = "//" userinfo? host [ ":" port ]?
-    ///   userinfo = username [ ":" password ]? "@"
-    ///   hierarchical-path = [ "/" path-segment ]+
-    serialization: String,
-
-    // Components
-    scheme_end: u32,  // Before ':'
-    username_end: u32,  // Before ':' (if a password is given) or '@' (if not)
-    host_start: u32,
-    host_end: u32,
-    host: HostInternal,
-    port: Option<u16>,
-    path_start: u32,  // Before initial '/', if any
-    query_start: Option<u32>,  // Before '?', unlike Position::QueryStart
-    fragment_start: Option<u32>,  // Before '#', unlike Position::FragmentStart
-}
-
-#[cfg(feature = "heapsize")]
-impl HeapSizeOf for Url {
-    fn heap_size_of_children(&self) -> usize {
-        self.serialization.heap_size_of_children()
-    }
-}
-
-/// Full configuration for the URL parser.
-#[derive(Copy, Clone)]
-pub struct ParseOptions<'a> {
-    base_url: Option<&'a Url>,
-    encoding_override: encoding::EncodingOverride,
-    log_syntax_violation: Option<&'a Fn(&'static str)>,
-}
-
-impl<'a> ParseOptions<'a> {
-    /// Change the base URL
-    pub fn base_url(mut self, new: Option<&'a Url>) -> Self {
-        self.base_url = new;
-        self
-    }
-
-    /// Override the character encoding of query strings.
-    /// This is a legacy concept only relevant for HTML.
-    #[cfg(feature = "query_encoding")]
-    pub fn encoding_override(mut self, new: Option<encoding::EncodingRef>) -> Self {
-        self.encoding_override = EncodingOverride::from_opt_encoding(new).to_output_encoding();
-        self
-    }
-
-    /// Call the provided function or closure on non-fatal parse errors.
-    pub fn log_syntax_violation(mut self, new: Option<&'a Fn(&'static str)>) -> Self {
-        self.log_syntax_violation = new;
-        self
-    }
-
-    /// Parse an URL string with the configuration so far.
-    pub fn parse(self, input: &str) -> Result<Url, ::ParseError> {
-        Parser {
-            serialization: String::with_capacity(input.len()),
-            base_url: self.base_url,
-            query_encoding_override: self.encoding_override,
-            log_syntax_violation: self.log_syntax_violation,
-            context: Context::UrlParser,
-        }.parse_url(input)
-    }
-}
-
-impl Url {
-    /// Parse an absolute URL from a string.
-    #[inline]
-    pub fn parse(input: &str) -> Result<Url, ::ParseError> {
-        Url::options().parse(input)
-    }
-
-    /// Parse a string as an URL, with this URL as the base URL.
-    #[inline]
-    pub fn join(&self, input: &str) -> Result<Url, ::ParseError> {
-        Url::options().base_url(Some(self)).parse(input)
-    }
-
-    /// Return a default `ParseOptions` that can fully configure the URL parser.
-    pub fn options<'a>() -> ParseOptions<'a> {
-        ParseOptions {
-            base_url: None,
-            encoding_override: EncodingOverride::utf8(),
-            log_syntax_violation: None,
-        }
-    }
-
-    /// Return the serialization of this URL.
-    ///
-    /// This is fast since that serialization is already stored in the `Url` struct.
-    #[inline]
-    pub fn as_str(&self) -> &str {
-        &self.serialization
-    }
-
-    /// Return the serialization of this URL.
-    ///
-    /// This consumes the `Url` and takes ownership of the `String` stored in it.
-    #[inline]
-    pub fn into_string(self) -> String {
-        self.serialization
-    }
-
-    /// For internal testing, not part of the public API.
-    ///
-    /// Methods of the `Url` struct assume a number of invariants.
-    /// This checks each of these invariants and panic if one is not met.
-    /// This is for testing rust-url itself.
-    #[doc(hidden)]
-    pub fn assert_invariants(&self) {
-        macro_rules! assert {
-            ($x: expr) => {
-                if !$x {
-                    panic!("!( {} ) for URL {:?}", stringify!($x), self.serialization)
-                }
-            }
-        }
-
-        macro_rules! assert_eq {
-            ($a: expr, $b: expr) => {
-                {
-                    let a = $a;
-                    let b = $b;
-                    if a != b {
-                        panic!("{:?} != {:?} ({} != {}) for URL {:?}",
-                               a, b, stringify!($a), stringify!($b), self.serialization)
-                    }
-                }
-            }
-        }
-
-        assert!(self.scheme_end >= 1);
-        assert!(matches!(self.byte_at(0), b'a'...b'z' | b'A'...b'Z'));
-        assert!(self.slice(1..self.scheme_end).chars()
-                .all(|c| matches!(c, 'a'...'z' | 'A'...'Z' | '0'...'9' | '+' | '-' | '.')));
-        assert_eq!(self.byte_at(self.scheme_end), b':');
-
-        if self.slice(self.scheme_end + 1 ..).starts_with("//") {
-            // URL with authority
-            match self.byte_at(self.username_end) {
-                b':' => {
-                    assert!(self.host_start >= self.username_end + 2);
-                    assert_eq!(self.byte_at(self.host_start - 1), b'@');
-                }
-                b'@' => assert!(self.host_start == self.username_end + 1),
-                _ => assert_eq!(self.username_end, self.scheme_end + 3),
-            }
-            assert!(self.host_start >= self.username_end);
-            assert!(self.host_end >= self.host_start);
-            let host_str = self.slice(self.host_start..self.host_end);
-            match self.host {
-                HostInternal::None => assert_eq!(host_str, ""),
-                HostInternal::Ipv4(address) => assert_eq!(host_str, address.to_string()),
-                HostInternal::Ipv6(address) => assert_eq!(host_str, format!("[{}]", address)),
-                HostInternal::Domain => {
-                    if SchemeType::from(self.scheme()).is_special() {
-                        assert!(!host_str.is_empty())
-                    }
-                }
-            }
-            if self.path_start == self.host_end {
-                assert_eq!(self.port, None);
-            } else {
-                assert_eq!(self.byte_at(self.host_end), b':');
-                let port_str = self.slice(self.host_end + 1..self.path_start);
-                assert_eq!(self.port, Some(port_str.parse::<u16>().expect("Couldn't parse port?")));
-            }
-            assert_eq!(self.byte_at(self.path_start), b'/');
-        } else {
-            // Anarchist URL (no authority)
-            assert_eq!(self.username_end, self.scheme_end + 1);
-            assert_eq!(self.host_start, self.scheme_end + 1);
-            assert_eq!(self.host_end, self.scheme_end + 1);
-            assert_eq!(self.host, HostInternal::None);
-            assert_eq!(self.port, None);
-            assert_eq!(self.path_start, self.scheme_end + 1);
-        }
-        if let Some(start) = self.query_start {
-            assert!(start > self.path_start);
-            assert_eq!(self.byte_at(start), b'?');
-        }
-        if let Some(start) = self.fragment_start {
-            assert!(start > self.path_start);
-            assert_eq!(self.byte_at(start), b'#');
-        }
-        if let (Some(query_start), Some(fragment_start)) = (self.query_start, self.fragment_start) {
-            assert!(fragment_start > query_start);
-        }
-
-        let other = Url::parse(self.as_str()).expect("Failed to parse myself?");
-        assert_eq!(&self.serialization, &other.serialization);
-        assert_eq!(self.scheme_end, other.scheme_end);
-        assert_eq!(self.username_end, other.username_end);
-        assert_eq!(self.host_start, other.host_start);
-        assert_eq!(self.host_end, other.host_end);
-        assert!(self.host == other.host ||
-                // XXX No host round-trips to empty host.
-                // See https://github.com/whatwg/url/issues/79
-                (self.host_str(), other.host_str()) == (None, Some("")));
-        assert_eq!(self.port, other.port);
-        assert_eq!(self.path_start, other.path_start);
-        assert_eq!(self.query_start, other.query_start);
-        assert_eq!(self.fragment_start, other.fragment_start);
-    }
-
-    /// Return the origin of this URL (https://url.spec.whatwg.org/#origin)
-    ///
-    /// Note: this returns an opaque origin for `file:` URLs, which causes
-    /// `url.origin() != url.origin()`.
-    ///
-    /// # Examples
-    ///
-    /// URL with `ftp` scheme:
-    ///
-    /// ```rust
-    /// use url::{Host, Origin, Url};
-    ///
-    /// let url = Url::parse("ftp://example.com/foo").unwrap();
-    /// assert_eq!(url.origin(),
-    ///            Origin::Tuple("ftp".into(),
-    ///                          Host::Domain("example.com".into()),
-    ///                          21));
-    /// ```
-    ///
-    /// URL with `blob` scheme:
-    ///
-    /// ```rust
-    /// use url::{Host, Origin, Url};
-    ///
-    /// let url = Url::parse("blob:https://example.com/foo").unwrap();
-    /// assert_eq!(url.origin(),
-    ///            Origin::Tuple("https".into(),
-    ///                          Host::Domain("example.com".into()),
-    ///                          443));
-    /// ```
-    ///
-    /// URL with `file` scheme:
-    ///
-    /// ```rust
-    /// use url::{Host, Origin, Url};
-    ///
-    /// let url = Url::parse("file:///tmp/foo").unwrap();
-    /// assert!(!url.origin().is_tuple());
-    ///
-    /// let other_url = Url::parse("file:///tmp/foo").unwrap();
-    /// assert!(url.origin() != other_url.origin());
-    /// ```
-    ///
-    /// URL with other scheme:
-    ///
-    /// ```rust
-    /// use url::{Host, Origin, Url};
-    ///
-    /// let url = Url::parse("foo:bar").unwrap();
-    /// assert!(!url.origin().is_tuple());
-    /// ```
-    #[inline]
-    pub fn origin(&self) -> Origin {
-        origin::url_origin(self)
-    }
-
-    /// Return the scheme of this URL, lower-cased, as an ASCII string without the ':' delimiter.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use url::Url;
-    ///
-    /// let url = Url::parse("file:///tmp/foo").unwrap();
-    /// assert_eq!(url.scheme(), "file");
-    /// ```
-    #[inline]
-    pub fn scheme(&self) -> &str {
-        self.slice(..self.scheme_end)
-    }
-
-    /// Return whether the URL has an 'authority',
-    /// which can contain a username, password, host, and port number.
-    ///
-    /// URLs that do *not* are either path-only like `unix:/run/foo.socket`
-    /// or cannot-be-a-base like `data:text/plain,Stuff`.
-    #[inline]
-    pub fn has_authority(&self) -> bool {
-        debug_assert!(self.byte_at(self.scheme_end) == b':');
-        self.slice(self.scheme_end..).starts_with("://")
-    }
-
-    /// Return whether this URL is a cannot-be-a-base URL,
-    /// meaning that parsing a relative URL string with this URL as the base will return an error.
-    ///
-    /// This is the case if the scheme and `:` delimiter are not followed by a `/` slash,
-    /// as is typically the case of `data:` and `mailto:` URLs.
-    #[inline]
-    pub fn cannot_be_a_base(&self) -> bool {
-        self.byte_at(self.path_start) != b'/'
-    }
-
-    /// Return the username for this URL (typically the empty string)
-    /// as a percent-encoded ASCII string.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use url::Url;
-    ///
-    /// let url = Url::parse("ftp://rms@example.com").unwrap();
-    /// assert_eq!(url.username(), "rms");
-    ///
-    /// let url = Url::parse("ftp://:secret123@example.com").unwrap();
-    /// assert_eq!(url.username(), "");
-    ///
-    /// let url = Url::parse("https://example.com").unwrap();
-    /// assert_eq!(url.username(), "");
-    /// ```
-    pub fn username(&self) -> &str {
-        if self.has_authority() {
-            self.slice(self.scheme_end + ("://".len() as u32)..self.username_end)
-        } else {
-            ""
-        }
-    }
-
-    /// Return the password for this URL, if any, as a percent-encoded ASCII string.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use url::Url;
-    ///
-    /// let url = Url::parse("ftp://rms:secret123@example.com").unwrap();
-    /// assert_eq!(url.password(), Some("secret123"));
-    ///
-    /// let url = Url::parse("ftp://:secret123@example.com").unwrap();
-    /// assert_eq!(url.password(), Some("secret123"));
-    ///
-    /// let url = Url::parse("ftp://rms@example.com").unwrap();
-    /// assert_eq!(url.password(), None);
-    ///
-    /// let url = Url::parse("https://example.com").unwrap();
-    /// assert_eq!(url.password(), None);
-    /// ```
-    pub fn password(&self) -> Option<&str> {
-        // This ':' is not the one marking a port number since a host can not be empty.
-        // (Except for file: URLs, which do not have port numbers.)
-        if self.has_authority() && self.byte_at(self.username_end) == b':' {
-            debug_assert!(self.byte_at(self.host_start - 1) == b'@');
-            Some(self.slice(self.username_end + 1..self.host_start - 1))
-        } else {
-            None
-        }
-    }
-
-    /// Equivalent to `url.host().is_some()`.
-    pub fn has_host(&self) -> bool {
-        !matches!(self.host, HostInternal::None)
-    }
-
-    /// Return the string representation of the host (domain or IP address) for this URL, if any.
-    ///
-    /// Non-ASCII domains are punycode-encoded per IDNA.
-    /// IPv6 addresses are given between `[` and `]` brackets.
-    ///
-    /// Cannot-be-a-base URLs (typical of `data:` and `mailto:`) and some `file:` URLs
-    /// don’t have a host.
-    ///
-    /// See also the `host` method.
-    pub fn host_str(&self) -> Option<&str> {
-        if self.has_host() {
-            Some(self.slice(self.host_start..self.host_end))
-        } else {
-            None
-        }
-    }
-
-    /// Return the parsed representation of the host for this URL.
-    /// Non-ASCII domain labels are punycode-encoded per IDNA.
-    ///
-    /// Cannot-be-a-base URLs (typical of `data:` and `mailto:`) and some `file:` URLs
-    /// don’t have a host.
-    ///
-    /// See also the `host_str` method.
-    pub fn host(&self) -> Option<Host<&str>> {
-        match self.host {
-            HostInternal::None => None,
-            HostInternal::Domain => Some(Host::Domain(self.slice(self.host_start..self.host_end))),
-            HostInternal::Ipv4(address) => Some(Host::Ipv4(address)),
-            HostInternal::Ipv6(address) => Some(Host::Ipv6(address)),
-        }
-    }
-
-    /// If this URL has a host and it is a domain name (not an IP address), return it.
-    pub fn domain(&self) -> Option<&str> {
-        match self.host {
-            HostInternal::Domain => Some(self.slice(self.host_start..self.host_end)),
-            _ => None,
-        }
-    }
-
-    /// Return the port number for this URL, if any.
-    #[inline]
-    pub fn port(&self) -> Option<u16> {
-        self.port
-    }
-
-    /// Return the port number for this URL, or the default port number if it is known.
-    ///
-    /// This method only knows the default port number
-    /// of the `http`, `https`, `ws`, `wss`, `ftp`, and `gopher` schemes.
-    ///
-    /// For URLs in these schemes, this method always returns `Some(_)`.
-    /// For other schemes, it is the same as `Url::port()`.
-    #[inline]
-    pub fn port_or_known_default(&self) -> Option<u16> {
-        self.port.or_else(|| parser::default_port(self.scheme()))
-    }
-
-    /// If the URL has a host, return something that implements `ToSocketAddrs`.
-    ///
-    /// If the URL has no port number and the scheme’s default port number is not known
-    /// (see `Url::port_or_known_default`),
-    /// the closure is called to obtain a port number.
-    /// Typically, this closure can match on the result `Url::scheme`
-    /// to have per-scheme default port numbers,
-    /// and panic for schemes it’s not prepared to handle.
-    /// For example:
-    ///
-    /// ```rust
-    /// # use url::Url;
-    /// # use std::net::TcpStream;
-    /// # use std::io;
-    ///
-    /// fn connect(url: &Url) -> io::Result<TcpStream> {
-    ///     TcpStream::connect(try!(url.with_default_port(default_port)))
-    /// }
-    ///
-    /// fn default_port(url: &Url) -> Result<u16, ()> {
-    ///     match url.scheme() {
-    ///         "git" => Ok(9418),
-    ///         "git+ssh" => Ok(22),
-    ///         "git+https" => Ok(443),
-    ///         "git+http" => Ok(80),
-    ///         _ => Err(()),
-    ///     }
-    /// }
-    /// ```
-    pub fn with_default_port<F>(&self, f: F) -> io::Result<HostAndPort<&str>>
-    where F: FnOnce(&Url) -> Result<u16, ()> {
-        Ok(HostAndPort {
-            host: try!(self.host()
-                           .ok_or(())
-                           .or_else(|()| io_error("URL has no host"))),
-            port: try!(self.port_or_known_default()
-                           .ok_or(())
-                           .or_else(|()| f(self))
-                           .or_else(|()| io_error("URL has no port number")))
-        })
-    }
-
-    /// Return the path for this URL, as a percent-encoded ASCII string.
-    /// For cannot-be-a-base URLs, this is an arbitrary string that doesn’t start with '/'.
-    /// For other URLs, this starts with a '/' slash
-    /// and continues with slash-separated path segments.
-    pub fn path(&self) -> &str {
-        match (self.query_start, self.fragment_start) {
-            (None, None) => self.slice(self.path_start..),
-            (Some(next_component_start), _) |
-            (None, Some(next_component_start)) => {
-                self.slice(self.path_start..next_component_start)
-            }
-        }
-    }
-
-    /// Unless this URL is cannot-be-a-base,
-    /// return an iterator of '/' slash-separated path segments,
-    /// each as a percent-encoded ASCII string.
-    ///
-    /// Return `None` for cannot-be-a-base URLs.
-    ///
-    /// When `Some` is returned, the iterator always contains at least one string
-    /// (which may be empty).
-    pub fn path_segments(&self) -> Option<str::Split<char>> {
-        let path = self.path();
-        if path.starts_with('/') {
-            Some(path[1..].split('/'))
-        } else {
-            None
-        }
-    }
-
-    /// Return this URL’s query string, if any, as a percent-encoded ASCII string.
-    pub fn query(&self) -> Option<&str> {
-        match (self.query_start, self.fragment_start) {
-            (None, _) => None,
-            (Some(query_start), None) => {
-                debug_assert!(self.byte_at(query_start) == b'?');
-                Some(self.slice(query_start + 1..))
-            }
-            (Some(query_start), Some(fragment_start)) => {
-                debug_assert!(self.byte_at(query_start) == b'?');
-                Some(self.slice(query_start + 1..fragment_start))
-            }
-        }
-    }
-
-    /// Parse the URL’s query string, if any, as `application/x-www-form-urlencoded`
-    /// and return an iterator of (key, value) pairs.
-    #[inline]
-    pub fn query_pairs(&self) -> form_urlencoded::Parse {
-        form_urlencoded::parse(self.query().unwrap_or("").as_bytes())
-    }
-
-    /// Return this URL’s fragment identifier, if any.
-    ///
-    /// **Note:** the parser did *not* percent-encode this component,
-    /// but the input may have been percent-encoded already.
-    pub fn fragment(&self) -> Option<&str> {
-        self.fragment_start.map(|start| {
-            debug_assert!(self.byte_at(start) == b'#');
-            self.slice(start + 1..)
-        })
-    }
-
-    fn mutate<F: FnOnce(&mut Parser) -> R, R>(&mut self, f: F) -> R {
-        let mut parser = Parser::for_setter(mem::replace(&mut self.serialization, String::new()));
-        let result = f(&mut parser);
-        self.serialization = parser.serialization;
-        result
-    }
-
-    /// Change this URL’s fragment identifier.
-    pub fn set_fragment(&mut self, fragment: Option<&str>) {
-        // Remove any previous fragment
-        if let Some(start) = self.fragment_start {
-            debug_assert!(self.byte_at(start) == b'#');
-            self.serialization.truncate(start as usize);
-        }
-        // Write the new one
-        if let Some(input) = fragment {
-            self.fragment_start = Some(to_u32(self.serialization.len()).unwrap());
-            self.serialization.push('#');
-            self.mutate(|parser| parser.parse_fragment(parser::Input::new(input)))
-        } else {
-            self.fragment_start = None
-        }
-    }
-
-    fn take_fragment(&mut self) -> Option<String> {
-        self.fragment_start.take().map(|start| {
-            debug_assert!(self.byte_at(start) == b'#');
-            let fragment = self.slice(start + 1..).to_owned();
-            self.serialization.truncate(start as usize);
-            fragment
-        })
-    }
-
-    fn restore_already_parsed_fragment(&mut self, fragment: Option<String>) {
-        if let Some(ref fragment) = fragment {
-            assert!(self.fragment_start.is_none());
-            self.fragment_start = Some(to_u32(self.serialization.len()).unwrap());
-            self.serialization.push('#');
-            self.serialization.push_str(fragment);
-        }
-    }
-
-    /// Change this URL’s query string.
-    pub fn set_query(&mut self, query: Option<&str>) {
-        let fragment = self.take_fragment();
-
-        // Remove any previous query
-        if let Some(start) = self.query_start.take() {
-            debug_assert!(self.byte_at(start) == b'?');
-            self.serialization.truncate(start as usize);
-        }
-        // Write the new query, if any
-        if let Some(input) = query {
-            self.query_start = Some(to_u32(self.serialization.len()).unwrap());
-            self.serialization.push('?');
-            let scheme_end = self.scheme_end;
-            self.mutate(|parser| parser.parse_query(scheme_end, parser::Input::new(input)));
-        }
-
-        self.restore_already_parsed_fragment(fragment);
-    }
-
-    /// Manipulate this URL’s query string, viewed as a sequence of name/value pairs
-    /// in `application/x-www-form-urlencoded` syntax.
-    ///
-    /// The return value has a method-chaining API:
-    ///
-    /// ```rust
-    /// # use url::Url;
-    /// let mut url = Url::parse("https://example.net?lang=fr#nav").unwrap();
-    /// assert_eq!(url.query(), Some("lang=fr"));
-    ///
-    /// url.query_pairs_mut().append_pair("foo", "bar");
-    /// assert_eq!(url.query(), Some("lang=fr&foo=bar"));
-    /// assert_eq!(url.as_str(), "https://example.net/?lang=fr&foo=bar#nav");
-    ///
-    /// url.query_pairs_mut()
-    ///     .clear()
-    ///     .append_pair("foo", "bar & baz")
-    ///     .append_pair("saisons", "Été+hiver");
-    /// assert_eq!(url.query(), Some("foo=bar+%26+baz&saisons=%C3%89t%C3%A9%2Bhiver"));
-    /// assert_eq!(url.as_str(),
-    ///            "https://example.net/?foo=bar+%26+baz&saisons=%C3%89t%C3%A9%2Bhiver#nav");
-    /// ```
-    ///
-    /// Note: `url.query_pairs_mut().clear();` is equivalent to `url.set_query(Some(""))`,
-    /// not `url.set_query(None)`.
-    ///
-    /// The state of `Url` is unspecified if this return value is leaked without being dropped.
-    pub fn query_pairs_mut(&mut self) -> form_urlencoded::Serializer<UrlQuery> {
-        let fragment = self.take_fragment();
-
-        let query_start;
-        if let Some(start) = self.query_start {
-            debug_assert!(self.byte_at(start) == b'?');
-            query_start = start as usize;
-        } else {
-            query_start = self.serialization.len();
-            self.query_start = Some(to_u32(query_start).unwrap());
-            self.serialization.push('?');
-        }
-
-        let query = UrlQuery { url: self, fragment: fragment };
-        form_urlencoded::Serializer::for_suffix(query, query_start + "?".len())
-    }
-
-    fn take_after_path(&mut self) -> String {
-        match (self.query_start, self.fragment_start) {
-            (Some(i), _) | (None, Some(i)) => {
-                let after_path = self.slice(i..).to_owned();
-                self.serialization.truncate(i as usize);
-                after_path
-            },
-            (None, None) => String::new(),
-        }
-    }
-
-    /// Change this URL’s path.
-    pub fn set_path(&mut self, mut path: &str) {
-        let after_path = self.take_after_path();
-        let old_after_path_pos = to_u32(self.serialization.len()).unwrap();
-        let cannot_be_a_base = self.cannot_be_a_base();
-        let scheme_type = SchemeType::from(self.scheme());
-        self.serialization.truncate(self.path_start as usize);
-        self.mutate(|parser| {
-            if cannot_be_a_base {
-                if path.starts_with('/') {
-                    parser.serialization.push_str("%2F");
-                    path = &path[1..];
-                }
-                parser.parse_cannot_be_a_base_path(parser::Input::new(path));
-            } else {
-                let mut has_host = true;  // FIXME
-                parser.parse_path_start(scheme_type, &mut has_host, parser::Input::new(path));
-            }
-        });
-        self.restore_after_path(old_after_path_pos, &after_path);
-    }
-
-    /// Return an object with methods to manipulate this URL’s path segments.
-    ///
-    /// Return `Err(())` if this URl is cannot-be-a-base.
-    pub fn path_segments_mut(&mut self) -> Result<PathSegmentsMut, ()> {
-        if self.cannot_be_a_base() {
-            Err(())
-        } else {
-            Ok(path_segments::new(self))
-        }
-    }
-
-    fn restore_after_path(&mut self, old_after_path_position: u32, after_path: &str) {
-        let new_after_path_position = to_u32(self.serialization.len()).unwrap();
-        let adjust = |index: &mut u32| {
-            *index -= old_after_path_position;
-            *index += new_after_path_position;
-        };
-        if let Some(ref mut index) = self.query_start { adjust(index) }
-        if let Some(ref mut index) = self.fragment_start { adjust(index) }
-        self.serialization.push_str(after_path)
-    }
-
-    /// Change this URL’s port number.
-    ///
-    /// If this URL is cannot-be-a-base, does not have a host, or has the `file` scheme;
-    /// do nothing and return `Err`.
-    pub fn set_port(&mut self, mut port: Option<u16>) -> Result<(), ()> {
-        if !self.has_host() || self.scheme() == "file" {
-            return Err(())
-        }
-        if port.is_some() && port == parser::default_port(self.scheme()) {
-            port = None
-        }
-        self.set_port_internal(port);
-        Ok(())
-    }
-
-    fn set_port_internal(&mut self, port: Option<u16>) {
-        match (self.port, port) {
-            (None, None) => {}
-            (Some(_), None) => {
-                self.serialization.drain(self.host_end as usize .. self.path_start as usize);
-                let offset = self.path_start - self.host_end;
-                self.path_start = self.host_end;
-                if let Some(ref mut index) = self.query_start { *index -= offset }
-                if let Some(ref mut index) = self.fragment_start { *index -= offset }
-            }
-            (Some(old), Some(new)) if old == new => {}
-            (_, Some(new)) => {
-                let path_and_after = self.slice(self.path_start..).to_owned();
-                self.serialization.truncate(self.host_end as usize);
-                write!(&mut self.serialization, ":{}", new).unwrap();
-                let old_path_start = self.path_start;
-                let new_path_start = to_u32(self.serialization.len()).unwrap();
-                self.path_start = new_path_start;
-                let adjust = |index: &mut u32| {
-                    *index -= old_path_start;
-                    *index += new_path_start;
-                };
-                if let Some(ref mut index) = self.query_start { adjust(index) }
-                if let Some(ref mut index) = self.fragment_start { adjust(index) }
-                self.serialization.push_str(&path_and_after);
-            }
-        }
-        self.port = port;
-    }
-
-    /// Change this URL’s host.
-    ///
-    /// If this URL is cannot-be-a-base or there is an error parsing the given `host`,
-    /// do nothing and return `Err`.
-    ///
-    /// Removing the host (calling this with `None`)
-    /// will also remove any username, password, and port number.
-    pub fn set_host(&mut self, host: Option<&str>) -> Result<(), ParseError> {
-        if self.cannot_be_a_base() {
-            return Err(ParseError::SetHostOnCannotBeABaseUrl)
-        }
-
-        if let Some(host) = host {
-            self.set_host_internal(try!(Host::parse(host)), None)
-        } else if self.has_host() {
-            debug_assert!(self.byte_at(self.scheme_end) == b':');
-            debug_assert!(self.byte_at(self.path_start) == b'/');
-            let new_path_start = self.scheme_end + 1;
-            self.serialization.drain(self.path_start as usize..new_path_start as usize);
-            let offset = self.path_start - new_path_start;
-            self.path_start = new_path_start;
-            self.username_end = new_path_start;
-            self.host_start = new_path_start;
-            self.host_end = new_path_start;
-            self.port = None;
-            if let Some(ref mut index) = self.query_start { *index -= offset }
-            if let Some(ref mut index) = self.fragment_start { *index -= offset }
-        }
-        Ok(())
-    }
-
-    /// opt_new_port: None means leave unchanged, Some(None) means remove any port number.
-    fn set_host_internal(&mut self, host: Host<String>, opt_new_port: Option<Option<u16>>) {
-        let old_suffix_pos = if opt_new_port.is_some() { self.path_start } else { self.host_end };
-        let suffix = self.slice(old_suffix_pos..).to_owned();
-        self.serialization.truncate(self.host_start as usize);
-        if !self.has_authority() {
-            debug_assert!(self.slice(self.scheme_end..self.host_start) == ":");
-            debug_assert!(self.username_end == self.host_start);
-            self.serialization.push('/');
-            self.serialization.push('/');
-            self.username_end += 2;
-            self.host_start += 2;
-        }
-        write!(&mut self.serialization, "{}", host).unwrap();
-        self.host_end = to_u32(self.serialization.len()).unwrap();
-        self.host = host.into();
-
-        if let Some(new_port) = opt_new_port {
-            self.port = new_port;
-            if let Some(port) = new_port {
-                write!(&mut self.serialization, ":{}", port).unwrap();
-            }
-        }
-        let new_suffix_pos = to_u32(self.serialization.len()).unwrap();
-        self.serialization.push_str(&suffix);
-
-        let adjust = |index: &mut u32| {
-            *index -= old_suffix_pos;
-            *index += new_suffix_pos;
-        };
-        adjust(&mut self.path_start);
-        if let Some(ref mut index) = self.query_start { adjust(index) }
-        if let Some(ref mut index) = self.fragment_start { adjust(index) }
-    }
-
-    /// Change this URL’s host to the given IP address.
-    ///
-    /// If this URL is cannot-be-a-base, do nothing and return `Err`.
-    ///
-    /// Compared to `Url::set_host`, this skips the host parser.
-    pub fn set_ip_host(&mut self, address: IpAddr) -> Result<(), ()> {
-        if self.cannot_be_a_base() {
-            return Err(())
-        }
-
-        let address = match address {
-            IpAddr::V4(address) => Host::Ipv4(address),
-            IpAddr::V6(address) => Host::Ipv6(address),
-        };
-        self.set_host_internal(address, None);
-        Ok(())
-    }
-
-    /// Change this URL’s password.
-    ///
-    /// If this URL is cannot-be-a-base or does not have a host, do nothing and return `Err`.
-    pub fn set_password(&mut self, password: Option<&str>) -> Result<(), ()> {
-        if !self.has_host() {
-            return Err(())
-        }
-        if let Some(password) = password {
-            let host_and_after = self.slice(self.host_start..).to_owned();
-            self.serialization.truncate(self.username_end as usize);
-            self.serialization.push(':');
-            self.serialization.extend(utf8_percent_encode(password, USERINFO_ENCODE_SET));
-            self.serialization.push('@');
-
-            let old_host_start = self.host_start;
-            let new_host_start = to_u32(self.serialization.len()).unwrap();
-            let adjust = |index: &mut u32| {
-                *index -= old_host_start;
-                *index += new_host_start;
-            };
-            self.host_start = new_host_start;
-            adjust(&mut self.host_end);
-            adjust(&mut self.path_start);
-            if let Some(ref mut index) = self.query_start { adjust(index) }
-            if let Some(ref mut index) = self.fragment_start { adjust(index) }
-
-            self.serialization.push_str(&host_and_after);
-        } else if self.byte_at(self.username_end) == b':' {  // If there is a password to remove
-            let has_username_or_password = self.byte_at(self.host_start - 1) == b'@';
-            debug_assert!(has_username_or_password);
-            let username_start = self.scheme_end + 3;
-            let empty_username = username_start == self.username_end;
-            let start = self.username_end;  // Remove the ':'
-            let end = if empty_username {
-                self.host_start // Remove the '@' as well
-            } else {
-                self.host_start - 1  // Keep the '@' to separate the username from the host
-            };
-            self.serialization.drain(start as usize .. end as usize);
-            let offset = end - start;
-            self.host_start -= offset;
-            self.host_end -= offset;
-            self.path_start -= offset;
-            if let Some(ref mut index) = self.query_start { *index -= offset }
-            if let Some(ref mut index) = self.fragment_start { *index -= offset }
-        }
-        Ok(())
-    }
-
-    /// Change this URL’s username.
-    ///
-    /// If this URL is cannot-be-a-base or does not have a host, do nothing and return `Err`.
-    pub fn set_username(&mut self, username: &str) -> Result<(), ()> {
-        if !self.has_host() {
-            return Err(())
-        }
-        let username_start = self.scheme_end + 3;
-        debug_assert!(self.slice(self.scheme_end..username_start) == "://");
-        if self.slice(username_start..self.username_end) == username {
-            return Ok(())
-        }
-        let after_username = self.slice(self.username_end..).to_owned();
-        self.serialization.truncate(username_start as usize);
-        self.serialization.extend(utf8_percent_encode(username, USERINFO_ENCODE_SET));
-
-        let mut removed_bytes = self.username_end;
-        self.username_end = to_u32(self.serialization.len()).unwrap();
-        let mut added_bytes = self.username_end;
-
-        let new_username_is_empty = self.username_end == username_start;
-        match (new_username_is_empty, after_username.chars().next()) {
-            (true, Some('@')) => {
-                removed_bytes += 1;
-                self.serialization.push_str(&after_username[1..]);
-            }
-            (false, Some('@')) | (_, Some(':')) | (true, _) => {
-                self.serialization.push_str(&after_username);
-            }
-            (false, _) => {
-                added_bytes += 1;
-                self.serialization.push('@');
-                self.serialization.push_str(&after_username);
-            }
-        }
-
-        let adjust = |index: &mut u32| {
-            *index -= removed_bytes;
-            *index += added_bytes;
-        };
-        adjust(&mut self.host_start);
-        adjust(&mut self.host_end);
-        adjust(&mut self.path_start);
-        if let Some(ref mut index) = self.query_start { adjust(index) }
-        if let Some(ref mut index) = self.fragment_start { adjust(index) }
-        Ok(())
-    }
-
-    /// Change this URL’s scheme.
-    ///
-    /// Do nothing and return `Err` if:
-    /// * The new scheme is not in `[a-zA-Z][a-zA-Z0-9+.-]+`
-    /// * This URL is cannot-be-a-base and the new scheme is one of
-    ///   `http`, `https`, `ws`, `wss`, `ftp`, or `gopher`
-    pub fn set_scheme(&mut self, scheme: &str) -> Result<(), ()> {
-        let mut parser = Parser::for_setter(String::new());
-        let remaining = try!(parser.parse_scheme(parser::Input::new(scheme)));
-        if !remaining.is_empty() ||
-                (!self.has_host() && SchemeType::from(&parser.serialization).is_special()) {
-            return Err(())
-        }
-        let old_scheme_end = self.scheme_end;
-        let new_scheme_end = to_u32(parser.serialization.len()).unwrap();
-        let adjust = |index: &mut u32| {
-            *index -= old_scheme_end;
-            *index += new_scheme_end;
-        };
-
-        self.scheme_end = new_scheme_end;
-        adjust(&mut self.username_end);
-        adjust(&mut self.host_start);
-        adjust(&mut self.host_end);
-        adjust(&mut self.path_start);
-        if let Some(ref mut index) = self.query_start { adjust(index) }
-        if let Some(ref mut index) = self.fragment_start { adjust(index) }
-
-        parser.serialization.push_str(self.slice(old_scheme_end..));
-        self.serialization = parser.serialization;
-        Ok(())
-    }
-
-    /// Convert a file name as `std::path::Path` into an URL in the `file` scheme.
-    ///
-    /// This returns `Err` if the given path is not absolute or,
-    /// on Windows, if the prefix is not a disk prefix (e.g. `C:`).
-    pub fn from_file_path<P: AsRef<Path>>(path: P) -> Result<Url, ()> {
-        let mut serialization = "file://".to_owned();
-        let path_start = serialization.len() as u32;
-        try!(path_to_file_url_segments(path.as_ref(), &mut serialization));
-        Ok(Url {
-            serialization: serialization,
-            scheme_end: "file".len() as u32,
-            username_end: path_start,
-            host_start: path_start,
-            host_end: path_start,
-            host: HostInternal::None,
-            port: None,
-            path_start: path_start,
-            query_start: None,
-            fragment_start: None,
-        })
-    }
-
-    /// Convert a directory name as `std::path::Path` into an URL in the `file` scheme.
-    ///
-    /// This returns `Err` if the given path is not absolute or,
-    /// on Windows, if the prefix is not a disk prefix (e.g. `C:`).
-    ///
-    /// Compared to `from_file_path`, this ensure that URL’s the path has a trailing slash
-    /// so that the entire path is considered when using this URL as a base URL.
-    ///
-    /// For example:
-    ///
-    /// * `"index.html"` parsed with `Url::from_directory_path(Path::new("/var/www"))`
-    ///   as the base URL is `file:///var/www/index.html`
-    /// * `"index.html"` parsed with `Url::from_file_path(Path::new("/var/www"))`
-    ///   as the base URL is `file:///var/index.html`, which might not be what was intended.
-    ///
-    /// Note that `std::path` does not consider trailing slashes significant
-    /// and usually does not include them (e.g. in `Path::parent()`).
-    pub fn from_directory_path<P: AsRef<Path>>(path: P) -> Result<Url, ()> {
-        let mut url = try!(Url::from_file_path(path));
-        if !url.serialization.ends_with('/') {
-            url.serialization.push('/')
-        }
-        Ok(url)
-    }
-
-    /// Assuming the URL is in the `file` scheme or similar,
-    /// convert its path to an absolute `std::path::Path`.
-    ///
-    /// **Note:** This does not actually check the URL’s `scheme`,
-    /// and may give nonsensical results for other schemes.
-    /// It is the user’s responsibility to check the URL’s scheme before calling this.
-    ///
-    /// ```
-    /// # use url::Url;
-    /// # let url = Url::parse("file:///etc/passwd").unwrap();
-    /// let path = url.to_file_path();
-    /// ```
-    ///
-    /// Returns `Err` if the host is neither empty nor `"localhost"`,
-    /// or if `Path::new_opt()` returns `None`.
-    /// (That is, if the percent-decoded path contains a NUL byte or,
-    /// for a Windows path, is not UTF-8.)
-    #[inline]
-    pub fn to_file_path(&self) -> Result<PathBuf, ()> {
-        // FIXME: Figure out what to do w.r.t host.
-        if matches!(self.host(), None | Some(Host::Domain("localhost"))) {
-            if let Some(segments) = self.path_segments() {
-                return file_url_segments_to_pathbuf(segments)
-            }
-        }
-        Err(())
-    }
-
-    // Private helper methods:
-
-    #[inline]
-    fn slice<R>(&self, range: R) -> &str where R: RangeArg {
-        range.slice_of(&self.serialization)
-    }
-
-    #[inline]
-    fn byte_at(&self, i: u32) -> u8 {
-        self.serialization.as_bytes()[i as usize]
-    }
-}
-
-/// Return an error if `Url::host` or `Url::port_or_known_default` return `None`.
-impl ToSocketAddrs for Url {
-    type Iter = SocketAddrs;
-
-    fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
-        try!(self.with_default_port(|_| Err(()))).to_socket_addrs()
-    }
-}
-
-/// Parse a string as an URL, without a base URL or encoding override.
-impl str::FromStr for Url {
-    type Err = ParseError;
-
-    #[inline]
-    fn from_str(input: &str) -> Result<Url, ::ParseError> {
-        Url::parse(input)
-    }
-}
-
-/// Display the serialization of this URL.
-impl fmt::Display for Url {
-    #[inline]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.serialization, formatter)
-    }
-}
-
-/// Debug the serialization of this URL.
-impl fmt::Debug for Url {
-    #[inline]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self.serialization, formatter)
-    }
-}
-
-/// URLs compare like their serialization.
-impl Eq for Url {}
-
-/// URLs compare like their serialization.
-impl PartialEq for Url {
-    #[inline]
-    fn eq(&self, other: &Self) -> bool {
-        self.serialization == other.serialization
-    }
-}
-
-/// URLs compare like their serialization.
-impl Ord for Url {
-    #[inline]
-    fn cmp(&self, other: &Self) -> cmp::Ordering {
-        self.serialization.cmp(&other.serialization)
-    }
-}
-
-/// URLs compare like their serialization.
-impl PartialOrd for Url {
-    #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
-        self.serialization.partial_cmp(&other.serialization)
-    }
-}
-
-/// URLs hash like their serialization.
-impl hash::Hash for Url {
-    #[inline]
-    fn hash<H>(&self, state: &mut H) where H: hash::Hasher {
-        hash::Hash::hash(&self.serialization, state)
-    }
-}
-
-/// Return the serialization of this URL.
-impl AsRef<str> for Url {
-    #[inline]
-    fn as_ref(&self) -> &str {
-        &self.serialization
-    }
-}
-
-trait RangeArg {
-    fn slice_of<'a>(&self, s: &'a str) -> &'a str;
-}
-
-impl RangeArg for Range<u32> {
-    #[inline]
-    fn slice_of<'a>(&self, s: &'a str) -> &'a str {
-        &s[self.start as usize .. self.end as usize]
-    }
-}
-
-impl RangeArg for RangeFrom<u32> {
-    #[inline]
-    fn slice_of<'a>(&self, s: &'a str) -> &'a str {
-        &s[self.start as usize ..]
-    }
-}
-
-impl RangeArg for RangeTo<u32> {
-    #[inline]
-    fn slice_of<'a>(&self, s: &'a str) -> &'a str {
-        &s[.. self.end as usize]
-    }
-}
-
-#[cfg(feature="rustc-serialize")]
-impl rustc_serialize::Encodable for Url {
-    fn encode<S: rustc_serialize::Encoder>(&self, encoder: &mut S) -> Result<(), S::Error> {
-        encoder.emit_str(self.as_str())
-    }
-}
-
-
-#[cfg(feature="rustc-serialize")]
-impl rustc_serialize::Decodable for Url {
-    fn decode<D: rustc_serialize::Decoder>(decoder: &mut D) -> Result<Url, D::Error> {
-        Url::parse(&*try!(decoder.read_str())).map_err(|error| {
-            decoder.error(&format!("URL parsing error: {}", error))
-        })
-    }
-}
-
-/// Serializes this URL into a `serde` stream.
-///
-/// This implementation is only available if the `serde` Cargo feature is enabled.
-#[cfg(feature="serde")]
-impl serde::Serialize for Url {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: serde::Serializer {
-        format!("{}", self).serialize(serializer)
-    }
-}
-
-/// Deserializes this URL from a `serde` stream.
-///
-/// This implementation is only available if the `serde` Cargo feature is enabled.
-#[cfg(feature="serde")]
-impl serde::Deserialize for Url {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Url, D::Error> where D: serde::Deserializer {
-        let string_representation: String = try!(serde::Deserialize::deserialize(deserializer));
-        Ok(Url::parse(&string_representation).unwrap())
-    }
-}
-
-#[cfg(unix)]
-fn path_to_file_url_segments(path: &Path, serialization: &mut String) -> Result<(), ()> {
-    use std::os::unix::prelude::OsStrExt;
-    if !path.is_absolute() {
-        return Err(())
-    }
-    let mut empty = true;
-    // skip the root component
-    for component in path.components().skip(1) {
-        empty = false;
-        serialization.push('/');
-        serialization.extend(percent_encode(
-            component.as_os_str().as_bytes(), PATH_SEGMENT_ENCODE_SET));
-    }
-    if empty {
-        // An URL’s path must not be empty.
-        serialization.push('/');
-    }
-    Ok(())
-}
-
-#[cfg(windows)]
-fn path_to_file_url_segments(path: &Path, serialization: &mut String) -> Result<(), ()> {
-    path_to_file_url_segments_windows(path, serialization)
-}
-
-// Build this unconditionally to alleviate https://github.com/servo/rust-url/issues/102
-#[cfg_attr(not(windows), allow(dead_code))]
-fn path_to_file_url_segments_windows(path: &Path, serialization: &mut String) -> Result<(), ()> {
-    use std::path::{Prefix, Component};
-    if !path.is_absolute() {
-        return Err(())
-    }
-    let mut components = path.components();
-    let disk = match components.next() {
-        Some(Component::Prefix(ref p)) => match p.kind() {
-            Prefix::Disk(byte) => byte,
-            Prefix::VerbatimDisk(byte) => byte,
-            _ => return Err(()),
-        },
-
-        // FIXME: do something with UNC and other prefixes?
-        _ => return Err(())
-    };
-
-    // Start with the prefix, e.g. "C:"
-    serialization.push('/');
-    serialization.push(disk as char);
-    serialization.push(':');
-
-    for component in components {
-        if component == Component::RootDir { continue }
-        // FIXME: somehow work with non-unicode?
-        let component = try!(component.as_os_str().to_str().ok_or(()));
-        serialization.push('/');
-        serialization.extend(percent_encode(component.as_bytes(), PATH_SEGMENT_ENCODE_SET));
-    }
-    Ok(())
-}
-
-#[cfg(unix)]
-fn file_url_segments_to_pathbuf(segments: str::Split<char>) -> Result<PathBuf, ()> {
-    use std::ffi::OsStr;
-    use std::os::unix::prelude::OsStrExt;
-    use std::path::PathBuf;
-
-    let mut bytes = Vec::new();
-    for segment in segments {
-        bytes.push(b'/');
-        bytes.extend(percent_decode(segment.as_bytes()));
-    }
-    let os_str = OsStr::from_bytes(&bytes);
-    let path = PathBuf::from(os_str);
-    debug_assert!(path.is_absolute(),
-                  "to_file_path() failed to produce an absolute Path");
-    Ok(path)
-}
-
-#[cfg(windows)]
-fn file_url_segments_to_pathbuf(segments: str::Split<char>) -> Result<PathBuf, ()> {
-    file_url_segments_to_pathbuf_windows(segments)
-}
-
-// Build this unconditionally to alleviate https://github.com/servo/rust-url/issues/102
-#[cfg_attr(not(windows), allow(dead_code))]
-fn file_url_segments_to_pathbuf_windows(mut segments: str::Split<char>) -> Result<PathBuf, ()> {
-    let first = try!(segments.next().ok_or(()));
-    if first.len() != 2 || !first.starts_with(parser::ascii_alpha)
-            || first.as_bytes()[1] != b':' {
-        return Err(())
-    }
-    let mut string = first.to_owned();
-    for segment in segments {
-        string.push('\\');
-
-        // Currently non-unicode windows paths cannot be represented
-        match String::from_utf8(percent_decode(segment.as_bytes()).collect()) {
-            Ok(s) => string.push_str(&s),
-            Err(..) => return Err(()),
-        }
-    }
-    let path = PathBuf::from(string);
-    debug_assert!(path.is_absolute(),
-                  "to_file_path() failed to produce an absolute Path");
-    Ok(path)
-}
-
-fn io_error<T>(reason: &str) -> io::Result<T> {
-    Err(io::Error::new(io::ErrorKind::InvalidData, reason))
-}
-
-/// Implementation detail of `Url::query_pairs_mut`. Typically not used directly.
-pub struct UrlQuery<'a> {
-    url: &'a mut Url,
-    fragment: Option<String>,
-}
-
-impl<'a> Drop for UrlQuery<'a> {
-    fn drop(&mut self) {
-        self.url.restore_already_parsed_fragment(self.fragment.take())
-    }
-}