diff --git a/.cargo/config b/.cargo/config
index c1ea8d02bf4a..aabd82dd6c1c 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -2,10 +2,8 @@
 [build]
 rustflags = [
     "--cfg", "procmacro2_semver_exempt",
-    "--cfg", "parallel_queries",
 ]
  
 rustdocflags = [
     "--cfg", "procmacro2_semver_exempt",
-    "--cfg", "parallel_queries",
 ]
diff --git a/common/Cargo.toml b/common/Cargo.toml
index ff5b260ac2e6..8d28f795b5f2 100644
--- a/common/Cargo.toml
+++ b/common/Cargo.toml
@@ -1,17 +1,30 @@
 [package]
 name = "swc_common"
-version = "0.1.4"
+version = "0.2.0"
 authors = ["강동윤 <kdy1@outlook.kr>"]
 license = "Apache-2.0/MIT"
 repository = "https://github.com/swc-project/swc.git"
 documentation = "https://swc-project.github.io/rustdoc/swc_common/"
 description = "Common utilities for the swc project."
 
+[features]
+default = []
+# Enable folder and visitor. Requires nightly compiler.
+fold = ["ast_node/fold"]
+
+
 [dependencies]
-ast_node = { version = "0.2", path = "../macros/ast_node" }
+ast_node = { version = "0.3", path = "../macros/ast_node" }
 string_cache = "0.7"
 either = "1.5"
-rustc-ap-rustc_errors = "313"
-rustc-ap-syntax = "313"
-rustc-ap-rustc_data_structures = "313"
-rustc-ap-syntax_pos = "313"
\ No newline at end of file
+scoped-tls = { version = "0.1.1", features = ["nightly"] }
+unicode-width = "0.1.4"
+cfg-if = "0.1.2"
+log = "0.4"
+atty = "0.2"
+parking_lot = "0.6"
+fxhash = "0.2"
+termcolor = "1.0"
+rayon = "1"
+rayon-core = "1"
+owning_ref = "0.4"
diff --git a/common/src/errors/diagnostic.rs b/common/src/errors/diagnostic.rs
index 9a1247ab7b1c..5abdfecaff4c 100644
--- a/common/src/errors/diagnostic.rs
+++ b/common/src/errors/diagnostic.rs
@@ -1,62 +1,107 @@
-use super::Handler;
-use rustc_errors::{Diagnostic as RustcDiagnostic, Level};
-pub use rustc_errors::{DiagnosticId, DiagnosticStyledString};
+use super::{snippet::Style, Applicability, CodeSuggestion, Level, Substitution, SubstitutionPart};
 use std::fmt;
-use MultiSpan;
-use Span;
+use syntax_pos::{MultiSpan, Span};
 
 #[must_use]
+#[derive(Clone, Debug, PartialEq, Hash)]
 pub struct Diagnostic {
-    pub(crate) inner: Box<RustcDiagnostic>,
+    pub level: Level,
+    pub message: Vec<(String, Style)>,
+    pub code: Option<DiagnosticId>,
+    pub span: MultiSpan,
+    pub children: Vec<SubDiagnostic>,
+    pub suggestions: Vec<CodeSuggestion>,
 }
 
-impl Diagnostic {
-    #[inline(always)]
-    pub fn new(level: Level, msg: &str) -> Self {
-        Self::new_with_code(level, None, msg)
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum DiagnosticId {
+    Error(String),
+    Lint(String),
+}
+
+/// For example a note attached to an error.
+#[derive(Clone, Debug, PartialEq, Hash)]
+pub struct SubDiagnostic {
+    pub level: Level,
+    pub message: Vec<(String, Style)>,
+    pub span: MultiSpan,
+    pub render_span: Option<MultiSpan>,
+}
+
+#[derive(PartialEq, Eq)]
+pub struct DiagnosticStyledString(pub Vec<StringPart>);
+
+impl DiagnosticStyledString {
+    pub fn new() -> DiagnosticStyledString {
+        DiagnosticStyledString(vec![])
+    }
+    pub fn push_normal<S: Into<String>>(&mut self, t: S) {
+        self.0.push(StringPart::Normal(t.into()));
+    }
+    pub fn push_highlighted<S: Into<String>>(&mut self, t: S) {
+        self.0.push(StringPart::Highlighted(t.into()));
+    }
+    pub fn normal<S: Into<String>>(t: S) -> DiagnosticStyledString {
+        DiagnosticStyledString(vec![StringPart::Normal(t.into())])
     }
 
-    #[inline(always)]
-    pub fn new_with_code(level: Level, code: Option<DiagnosticId>, msg: &str) -> Self {
-        Diagnostic {
-            inner: box RustcDiagnostic::new_with_code(level, code, msg),
-        }
+    pub fn highlighted<S: Into<String>>(t: S) -> DiagnosticStyledString {
+        DiagnosticStyledString(vec![StringPart::Highlighted(t.into())])
     }
 
-    #[inline(always)]
-    pub fn new_note(msg: &str) -> Self {
-        Self::new(Level::Note, msg)
+    pub fn content(&self) -> String {
+        self.0.iter().map(|x| x.content()).collect::<String>()
     }
+}
 
-    #[inline(always)]
-    pub fn new_warn(msg: &str) -> Self {
-        Self::new(Level::Warning, msg)
+#[derive(PartialEq, Eq)]
+pub enum StringPart {
+    Normal(String),
+    Highlighted(String),
+}
+
+impl StringPart {
+    pub fn content(&self) -> &str {
+        match self {
+            &StringPart::Normal(ref s) | &StringPart::Highlighted(ref s) => s,
+        }
     }
+}
 
-    #[inline(always)]
-    pub fn new_error(msg: &str) -> Self {
-        Self::new(Level::Error, msg)
+impl Diagnostic {
+    pub fn new(level: Level, message: &str) -> Self {
+        Diagnostic::new_with_code(level, None, message)
     }
 
-    #[inline(always)]
-    pub fn new_fatal(msg: &str) -> Self {
-        Self::new(Level::Fatal, msg)
+    pub fn new_with_code(level: Level, code: Option<DiagnosticId>, message: &str) -> Self {
+        Diagnostic {
+            level,
+            message: vec![(message.to_owned(), Style::NoStyle)],
+            code,
+            span: MultiSpan::new(),
+            children: vec![],
+            suggestions: vec![],
+        }
     }
 
-    #[inline(always)]
-    pub fn emit_to(self, handler: &Handler) {
-        handler.emit(self)
+    pub fn is_error(&self) -> bool {
+        match self.level {
+            Level::Bug | Level::Fatal | Level::PhaseFatal | Level::Error | Level::FailureNote => {
+                true
+            }
+
+            Level::Warning | Level::Note | Level::Help | Level::Cancelled => false,
+        }
     }
 
     /// Cancel the diagnostic (a structured diagnostic must either be emitted or
     /// canceled or it will panic when dropped).
-    #[inline(always)]
-    pub fn cancel(mut self) -> Self {
-        self.inner.cancel();
-        self
+    pub fn cancel(&mut self) {
+        self.level = Level::Cancelled;
     }
+
     pub fn cancelled(&self) -> bool {
-        self.inner.cancelled()
+        self.level == Level::Cancelled
     }
 
     /// Add a span/label to be included in the resulting snippet.
@@ -65,75 +110,98 @@ impl Diagnostic {
     /// all, and you just supplied a `Span` to create the diagnostic,
     /// then the snippet will just include that `Span`, which is
     /// called the primary span.
-    #[inline(always)]
-    pub fn span_label<T: Into<String>>(mut self, span: Span, label: T) -> Self {
-        self.inner.span_label(span, label.into());
+    pub fn span_label<T: Into<String>>(&mut self, span: Span, label: T) -> &mut Self {
+        self.span.push_span_label(span, label.into());
+        self
+    }
+
+    pub fn replace_span_with(&mut self, after: Span) -> &mut Self {
+        let before = self.span.clone();
+        self.set_span(after);
+        for span_label in before.span_labels() {
+            if let Some(label) = span_label.label {
+                self.span_label(after, label);
+            }
+        }
         self
     }
 
-    #[inline(always)]
     pub fn note_expected_found(
-        mut self,
-        label: &fmt::Display,
+        &mut self,
+        label: &dyn fmt::Display,
         expected: DiagnosticStyledString,
         found: DiagnosticStyledString,
-    ) -> Self {
-        self.inner.note_expected_found(label, expected, found);
-        self
+    ) -> &mut Self {
+        self.note_expected_found_extra(label, expected, found, &"", &"")
     }
 
-    #[inline(always)]
     pub fn note_expected_found_extra(
-        mut self,
-        label: &fmt::Display,
+        &mut self,
+        label: &dyn fmt::Display,
         expected: DiagnosticStyledString,
         found: DiagnosticStyledString,
-        expected_extra: &fmt::Display,
-        found_extra: &fmt::Display,
-    ) -> Self {
-        self.inner
-            .note_expected_found_extra(label, expected, found, expected_extra, found_extra);
+        expected_extra: &dyn fmt::Display,
+        found_extra: &dyn fmt::Display,
+    ) -> &mut Self {
+        let mut msg: Vec<_> = vec![(format!("expected {} `", label), Style::NoStyle)];
+        msg.extend(expected.0.iter().map(|x| match *x {
+            StringPart::Normal(ref s) => (s.to_owned(), Style::NoStyle),
+            StringPart::Highlighted(ref s) => (s.to_owned(), Style::Highlight),
+        }));
+        msg.push((format!("`{}\n", expected_extra), Style::NoStyle));
+        msg.push((format!("   found {} `", label), Style::NoStyle));
+        msg.extend(found.0.iter().map(|x| match *x {
+            StringPart::Normal(ref s) => (s.to_owned(), Style::NoStyle),
+            StringPart::Highlighted(ref s) => (s.to_owned(), Style::Highlight),
+        }));
+        msg.push((format!("`{}", found_extra), Style::NoStyle));
+
+        // For now, just attach these as notes
+        self.highlighted_note(msg);
         self
     }
 
-    #[inline(always)]
-    pub fn note(mut self, msg: &str) -> Self {
-        self.inner.note(msg);
+    pub fn note_trait_signature(&mut self, name: String, signature: String) -> &mut Self {
+        self.highlighted_note(vec![
+            (format!("`{}` from trait: `", name), Style::NoStyle),
+            (signature, Style::Highlight),
+            ("`".to_string(), Style::NoStyle),
+        ]);
         self
     }
 
-    // pub fn highlighted_note(mut self, msg: Vec<(String, Style)>) -> Self {
-    //     self.inner.highlighted_note(msg);
-    //     self
-    // }
+    pub fn note(&mut self, msg: &str) -> &mut Self {
+        self.sub(Level::Note, msg, MultiSpan::new(), None);
+        self
+    }
 
-    #[inline(always)]
-    pub fn span_note<S: Into<MultiSpan>>(mut self, sp: S, msg: &str) -> Self {
-        self.inner.span_note(sp, msg);
+    pub fn highlighted_note(&mut self, msg: Vec<(String, Style)>) -> &mut Self {
+        self.sub_with_highlights(Level::Note, msg, MultiSpan::new(), None);
         self
     }
 
-    #[inline(always)]
-    pub fn warn(mut self, msg: &str) -> Self {
-        self.inner.warn(msg);
+    pub fn span_note<S: Into<MultiSpan>>(&mut self, sp: S, msg: &str) -> &mut Self {
+        self.sub(Level::Note, msg, sp.into(), None);
         self
     }
 
-    #[inline(always)]
-    pub fn span_warn<S: Into<MultiSpan>>(mut self, sp: S, msg: &str) -> Self {
-        self.inner.span_warn(sp, msg);
+    pub fn warn(&mut self, msg: &str) -> &mut Self {
+        self.sub(Level::Warning, msg, MultiSpan::new(), None);
         self
     }
 
-    #[inline(always)]
-    pub fn help(mut self, msg: &str) -> Self {
-        self.inner.help(msg);
+    pub fn span_warn<S: Into<MultiSpan>>(&mut self, sp: S, msg: &str) -> &mut Self {
+        self.sub(Level::Warning, msg, sp.into(), None);
         self
     }
 
-    #[inline(always)]
-    pub fn span_help<S: Into<MultiSpan>>(mut self, sp: S, msg: &str) -> Self {
-        self.inner.span_help(sp, msg);
+    pub fn help(&mut self, msg: &str) -> &mut Self {
+        self.sub(Level::Help, msg, MultiSpan::new(), None);
+        self
+    }
+
+    pub fn span_help<S: Into<MultiSpan>>(&mut self, sp: S, msg: &str) -> &mut Self {
+        self.sub(Level::Help, msg, sp.into(), None);
         self
     }
 
@@ -142,9 +210,19 @@ impl Diagnostic {
     /// and not the text.
     ///
     /// See `CodeSuggestion` for more information.
-    #[inline(always)]
-    pub fn span_suggestion_short(mut self, sp: Span, msg: &str, suggestion: String) -> Self {
-        self.inner.span_suggestion_short(sp, msg, suggestion);
+    #[deprecated(note = "Use `span_suggestion_short_with_applicability`")]
+    pub fn span_suggestion_short(&mut self, sp: Span, msg: &str, suggestion: String) -> &mut Self {
+        self.suggestions.push(CodeSuggestion {
+            substitutions: vec![Substitution {
+                parts: vec![SubstitutionPart {
+                    snippet: suggestion,
+                    span: sp,
+                }],
+            }],
+            msg: msg.to_owned(),
+            show_code_when_inline: false,
+            applicability: Applicability::Unspecified,
+        });
         self
     }
 
@@ -162,46 +240,214 @@ impl Diagnostic {
     /// * should not contain any parts like "the following", "as shown"
     /// * may look like "to do xyz, use" or "to do xyz, use abc"
     /// * may contain a name of a function, variable or type, but not whole
-    /// expressions
+    ///   expressions
     ///
     /// See `CodeSuggestion` for more information.
-    #[inline(always)]
-    pub fn span_suggestion(mut self, sp: Span, msg: &str, suggestion: String) -> Self {
-        self.inner.span_suggestion(sp, msg, suggestion);
+    #[deprecated(note = "Use `span_suggestion_with_applicability`")]
+    pub fn span_suggestion(&mut self, sp: Span, msg: &str, suggestion: String) -> &mut Self {
+        self.suggestions.push(CodeSuggestion {
+            substitutions: vec![Substitution {
+                parts: vec![SubstitutionPart {
+                    snippet: suggestion,
+                    span: sp,
+                }],
+            }],
+            msg: msg.to_owned(),
+            show_code_when_inline: true,
+            applicability: Applicability::Unspecified,
+        });
+        self
+    }
+
+    pub fn multipart_suggestion_with_applicability(
+        &mut self,
+        msg: &str,
+        suggestion: Vec<(Span, String)>,
+        applicability: Applicability,
+    ) -> &mut Self {
+        self.suggestions.push(CodeSuggestion {
+            substitutions: vec![Substitution {
+                parts: suggestion
+                    .into_iter()
+                    .map(|(span, snippet)| SubstitutionPart { snippet, span })
+                    .collect(),
+            }],
+            msg: msg.to_owned(),
+            show_code_when_inline: true,
+            applicability,
+        });
         self
     }
 
+    #[deprecated(note = "Use `multipart_suggestion_with_applicability`")]
+    pub fn multipart_suggestion(
+        &mut self,
+        msg: &str,
+        suggestion: Vec<(Span, String)>,
+    ) -> &mut Self {
+        self.multipart_suggestion_with_applicability(msg, suggestion, Applicability::Unspecified)
+    }
+
     /// Prints out a message with multiple suggested edits of the code.
-    #[inline(always)]
-    pub fn span_suggestions(mut self, sp: Span, msg: &str, suggestions: Vec<String>) -> Self {
-        self.inner.span_suggestions(sp, msg, suggestions);
+    #[deprecated(note = "Use `span_suggestions_with_applicability`")]
+    pub fn span_suggestions(&mut self, sp: Span, msg: &str, suggestions: Vec<String>) -> &mut Self {
+        self.suggestions.push(CodeSuggestion {
+            substitutions: suggestions
+                .into_iter()
+                .map(|snippet| Substitution {
+                    parts: vec![SubstitutionPart { snippet, span: sp }],
+                })
+                .collect(),
+            msg: msg.to_owned(),
+            show_code_when_inline: true,
+            applicability: Applicability::Unspecified,
+        });
+        self
+    }
+
+    /// This is a suggestion that may contain mistakes or fillers and should
+    /// be read and understood by a human.
+    pub fn span_suggestion_with_applicability(
+        &mut self,
+        sp: Span,
+        msg: &str,
+        suggestion: String,
+        applicability: Applicability,
+    ) -> &mut Self {
+        self.suggestions.push(CodeSuggestion {
+            substitutions: vec![Substitution {
+                parts: vec![SubstitutionPart {
+                    snippet: suggestion,
+                    span: sp,
+                }],
+            }],
+            msg: msg.to_owned(),
+            show_code_when_inline: true,
+            applicability,
+        });
+        self
+    }
+
+    pub fn span_suggestions_with_applicability(
+        &mut self,
+        sp: Span,
+        msg: &str,
+        suggestions: impl Iterator<Item = String>,
+        applicability: Applicability,
+    ) -> &mut Self {
+        self.suggestions.push(CodeSuggestion {
+            substitutions: suggestions
+                .map(|snippet| Substitution {
+                    parts: vec![SubstitutionPart { snippet, span: sp }],
+                })
+                .collect(),
+            msg: msg.to_owned(),
+            show_code_when_inline: true,
+            applicability,
+        });
+        self
+    }
+
+    pub fn span_suggestion_short_with_applicability(
+        &mut self,
+        sp: Span,
+        msg: &str,
+        suggestion: String,
+        applicability: Applicability,
+    ) -> &mut Self {
+        self.suggestions.push(CodeSuggestion {
+            substitutions: vec![Substitution {
+                parts: vec![SubstitutionPart {
+                    snippet: suggestion,
+                    span: sp,
+                }],
+            }],
+            msg: msg.to_owned(),
+            show_code_when_inline: false,
+            applicability,
+        });
         self
     }
 
-    #[inline(always)]
-    pub fn span<S: Into<MultiSpan>>(mut self, sp: S) -> Self {
-        self.inner.set_span(sp);
+    pub fn set_span<S: Into<MultiSpan>>(&mut self, sp: S) -> &mut Self {
+        self.span = sp.into();
         self
     }
 
-    #[inline(always)]
-    pub fn code(mut self, s: DiagnosticId) -> Self {
-        self.inner.code(s);
+    pub fn code(&mut self, s: DiagnosticId) -> &mut Self {
+        self.code = Some(s);
         self
     }
 
-    // /// Used by a lint. Copies over all details *but* the "main
-    // /// message".
-    // pub fn copy_details_not_message(mut self, from: &Diagnostic) {
-    //     self.span = from.span.clone();
-    //     self.code = from.code.clone();
-    //     self.children.extend(from.children.iter().cloned())
-    // }
+    pub fn get_code(&self) -> Option<DiagnosticId> {
+        self.code.clone()
+    }
+
+    pub fn message(&self) -> String {
+        self.message
+            .iter()
+            .map(|i| i.0.as_str())
+            .collect::<String>()
+    }
+
+    pub fn styled_message(&self) -> &Vec<(String, Style)> {
+        &self.message
+    }
+
+    /// Used by a lint. Copies over all details *but* the "main
+    /// message".
+    pub fn copy_details_not_message(&mut self, from: &Diagnostic) {
+        self.span = from.span.clone();
+        self.code = from.code.clone();
+        self.children.extend(from.children.iter().cloned())
+    }
+
+    /// Convenience function for internal use, clients should use one of the
+    /// public methods above.
+    pub fn sub(
+        &mut self,
+        level: Level,
+        message: &str,
+        span: MultiSpan,
+        render_span: Option<MultiSpan>,
+    ) {
+        let sub = SubDiagnostic {
+            level,
+            message: vec![(message.to_owned(), Style::NoStyle)],
+            span,
+            render_span,
+        };
+        self.children.push(sub);
+    }
+
+    /// Convenience function for internal use, clients should use one of the
+    /// public methods above.
+    fn sub_with_highlights(
+        &mut self,
+        level: Level,
+        message: Vec<(String, Style)>,
+        span: MultiSpan,
+        render_span: Option<MultiSpan>,
+    ) {
+        let sub = SubDiagnostic {
+            level,
+            message,
+            span,
+            render_span,
+        };
+        self.children.push(sub);
+    }
 }
 
-impl From<RustcDiagnostic> for Diagnostic {
-    #[inline(always)]
-    fn from(inner: RustcDiagnostic) -> Self {
-        Diagnostic { inner: box inner }
+impl SubDiagnostic {
+    pub fn message(&self) -> String {
+        self.message
+            .iter()
+            .map(|i| i.0.as_str())
+            .collect::<String>()
+    }
+
+    pub fn styled_message(&self) -> &Vec<(String, Style)> {
+        &self.message
     }
 }
diff --git a/common/src/errors/diagnostic_builder.rs b/common/src/errors/diagnostic_builder.rs
index 01144ee8b96e..43c5863e0366 100644
--- a/common/src/errors/diagnostic_builder.rs
+++ b/common/src/errors/diagnostic_builder.rs
@@ -1,48 +1,139 @@
-use super::Handler;
-use rustc_errors::{
-    Diagnostic as RustcDiagnostic, DiagnosticBuilder as Builder, DiagnosticId,
-    DiagnosticStyledString, Level,
+use super::{Applicability, Diagnostic, DiagnosticId, DiagnosticStyledString, Handler, Level};
+use std::{
+    fmt::{self, Debug},
+    ops::{Deref, DerefMut},
+    thread::panicking,
 };
-use std::fmt;
-use MultiSpan;
-use Span;
+use syntax_pos::{MultiSpan, Span};
 
+/// Used for emitting structured error messages and other diagnostic
+/// information.
+///
+/// If there is some state in a downstream crate you would like to
+/// access in the methods of `DiagnosticBuilder` here, consider
+/// extending `HandlerFlags`, accessed via `self.handler.flags`.
 #[must_use]
+#[derive(Clone)]
 pub struct DiagnosticBuilder<'a> {
-    db: Box<Builder<'a>>,
+    pub handler: &'a Handler,
+    diagnostic: Diagnostic,
+    allow_suggestions: bool,
 }
 
-impl<'a> DiagnosticBuilder<'a> {
-    pub fn new(handler: &'a Handler, level: Level, msg: &str) -> Self {
-        Self::new_with_code(handler, level, None, msg)
+/// In general, the `DiagnosticBuilder` uses deref to allow access to
+/// the fields and methods of the embedded `diagnostic` in a
+/// transparent way.  *However,* many of the methods are intended to
+/// be used in a chained way, and hence ought to return `self`. In
+/// that case, we can't just naively forward to the method on the
+/// `diagnostic`, because the return type would be a `&Diagnostic`
+/// instead of a `&DiagnosticBuilder<'a>`. This `forward!` macro makes
+/// it easy to declare such methods on the builder.
+macro_rules! forward {
+    // Forward pattern for &self -> &Self
+    (pub fn $n:ident(&self, $($name:ident: $ty:ty),* $(,)*) -> &Self) => {
+        pub fn $n(&self, $($name: $ty),*) -> &Self {
+            #[allow(deprecated)]
+            self.diagnostic.$n($($name),*);
+            self
+        }
+    };
+
+    // Forward pattern for &mut self -> &mut Self
+    (pub fn $n:ident(&mut self, $($name:ident: $ty:ty),* $(,)*) -> &mut Self) => {
+        pub fn $n(&mut self, $($name: $ty),*) -> &mut Self {
+            #[allow(deprecated)]
+            self.diagnostic.$n($($name),*);
+            self
+        }
+    };
+
+    // Forward pattern for &mut self -> &mut Self, with S: Into<MultiSpan>
+    // type parameter. No obvious way to make this more generic.
+    (pub fn $n:ident<S: Into<MultiSpan>>(
+                    &mut self,
+                    $($name:ident: $ty:ty),*
+                    $(,)*) -> &mut Self) => {
+        pub fn $n<S: Into<MultiSpan>>(&mut self, $($name: $ty),*) -> &mut Self {
+            #[allow(deprecated)]
+            self.diagnostic.$n($($name),*);
+            self
+        }
+    };
+}
+
+impl<'a> Deref for DiagnosticBuilder<'a> {
+    type Target = Diagnostic;
+
+    fn deref(&self) -> &Diagnostic {
+        &self.diagnostic
     }
+}
 
-    pub fn new_with_code(
-        handler: &'a Handler,
-        level: Level,
-        code: Option<DiagnosticId>,
-        msg: &str,
-    ) -> Self {
-        DiagnosticBuilder {
-            db: box Builder::new_diagnostic(
-                &handler.inner,
-                RustcDiagnostic::new_with_code(level, code, msg),
-            ),
+impl<'a> DerefMut for DiagnosticBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Diagnostic {
+        &mut self.diagnostic
+    }
+}
+
+impl<'a> DiagnosticBuilder<'a> {
+    /// Emit the diagnostic.
+    pub fn emit(&mut self) {
+        if self.cancelled() {
+            return;
         }
+
+        self.handler.emit_db(&self);
+        self.cancel();
     }
 
-    pub fn emit(mut self) {
-        self.db.emit()
+    /// Buffers the diagnostic for later emission, unless handler
+    /// has disabled such buffering.
+    pub fn buffer(mut self, buffered_diagnostics: &mut Vec<Diagnostic>) {
+        if self.handler.flags.dont_buffer_diagnostics || self.handler.flags.treat_err_as_bug {
+            self.emit();
+            return;
+        }
+
+        // We need to use `ptr::read` because `DiagnosticBuilder`
+        // implements `Drop`.
+        let diagnostic;
+        unsafe {
+            diagnostic = ::std::ptr::read(&self.diagnostic);
+            ::std::mem::forget(self);
+        };
+        // Logging here is useful to help track down where in logs an error was
+        // actually emitted.
+        debug!("buffer: diagnostic={:?}", diagnostic);
+        buffered_diagnostics.push(diagnostic);
     }
 
-    /// Cancel the diagnostic (a structured diagnostic must either be emitted or
-    /// canceled or it will panic when dropped).
-    pub fn cancel(mut self) -> Self {
-        self.db.cancel();
+    /// Convenience function for internal use, clients should use one of the
+    /// span_* methods instead.
+    pub fn sub<S: Into<MultiSpan>>(
+        &mut self,
+        level: Level,
+        message: &str,
+        span: Option<S>,
+    ) -> &mut Self {
+        let span = span.map(|s| s.into()).unwrap_or_else(|| MultiSpan::new());
+        self.diagnostic.sub(level, message, span, None);
         self
     }
-    pub fn cancelled(&self) -> bool {
-        self.db.cancelled()
+
+    /// Delay emission of this diagnostic as a bug.
+    ///
+    /// This can be useful in contexts where an error indicates a bug but
+    /// typically this only happens when other compilation errors have already
+    /// happened. In those cases this can be used to defer emission of this
+    /// diagnostic as a bug in the compiler only if no other errors have been
+    /// emitted.
+    ///
+    /// In the meantime, though, callsites are required to deal with the "bug"
+    /// locally in whichever way makes the most sense.
+    pub fn delay_as_bug(&mut self) {
+        self.level = Level::Bug;
+        self.handler.delay_as_bug(self.diagnostic.clone());
+        self.cancel();
     }
 
     /// Add a span/label to be included in the resulting snippet.
@@ -51,129 +142,184 @@ impl<'a> DiagnosticBuilder<'a> {
     /// all, and you just supplied a `Span` to create the diagnostic,
     /// then the snippet will just include that `Span`, which is
     /// called the primary span.
-    pub fn span_label<T: Into<String>>(mut self, span: Span, label: T) -> Self {
-        self.db.span_label(span, label.into());
+    pub fn span_label<T: Into<String>>(&mut self, span: Span, label: T) -> &mut Self {
+        self.diagnostic.span_label(span, label);
         self
     }
 
-    pub fn note_expected_found(
-        mut self,
-        label: &fmt::Display,
-        expected: DiagnosticStyledString,
-        found: DiagnosticStyledString,
-    ) -> Self {
-        self.db.note_expected_found(label, expected, found);
-        self
-    }
+    forward!(pub fn note_expected_found(&mut self,
+                                        label: &dyn fmt::Display,
+                                        expected: DiagnosticStyledString,
+                                        found: DiagnosticStyledString,
+                                        ) -> &mut Self);
 
-    pub fn note_expected_found_extra(
-        mut self,
-        label: &fmt::Display,
-        expected: DiagnosticStyledString,
-        found: DiagnosticStyledString,
-        expected_extra: &fmt::Display,
-        found_extra: &fmt::Display,
-    ) -> Self {
-        self.db
-            .note_expected_found_extra(label, expected, found, expected_extra, found_extra);
-        self
-    }
+    forward!(pub fn note_expected_found_extra(&mut self,
+                                              label: &dyn fmt::Display,
+                                              expected: DiagnosticStyledString,
+                                              found: DiagnosticStyledString,
+                                              expected_extra: &dyn fmt::Display,
+                                              found_extra: &dyn fmt::Display,
+                                              ) -> &mut Self);
 
-    pub fn note(mut self, msg: &str) -> Self {
-        self.db.note(msg);
-        self
-    }
+    forward!(pub fn note(&mut self, msg: &str) -> &mut Self);
+    forward!(pub fn span_note<S: Into<MultiSpan>>(&mut self,
+                                                  sp: S,
+                                                  msg: &str,
+                                                  ) -> &mut Self);
+    forward!(pub fn warn(&mut self, msg: &str) -> &mut Self);
+    forward!(pub fn span_warn<S: Into<MultiSpan>>(&mut self, sp: S, msg: &str) -> &mut Self);
+    forward!(pub fn help(&mut self , msg: &str) -> &mut Self);
+    forward!(pub fn span_help<S: Into<MultiSpan>>(&mut self,
+                                                  sp: S,
+                                                  msg: &str,
+                                                  ) -> &mut Self);
 
-    // pub fn highlighted_note(mut self, msg: Vec<(String, Style)>) -> Self {
-    //     self.db.highlighted_note(msg);
-    //     self
-    // }
+    #[deprecated(note = "Use `span_suggestion_short_with_applicability`")]
+    forward!(pub fn span_suggestion_short(
+                                      &mut self,
+                                      sp: Span,
+                                      msg: &str,
+                                      suggestion: String,
+                                      ) -> &mut Self);
 
-    pub fn span_note<S: Into<MultiSpan>>(mut self, sp: S, msg: &str) -> Self {
-        self.db.span_note(sp, msg);
-        self
-    }
+    #[deprecated(note = "Use `multipart_suggestion_with_applicability`")]
+    forward!(pub fn multipart_suggestion(
+        &mut self,
+        msg: &str,
+        suggestion: Vec<(Span, String)>,
+    ) -> &mut Self);
 
-    pub fn warn(mut self, msg: &str) -> Self {
-        self.db.warn(msg);
-        self
-    }
+    #[deprecated(note = "Use `span_suggestion_with_applicability`")]
+    forward!(pub fn span_suggestion(&mut self,
+                                    sp: Span,
+                                    msg: &str,
+                                    suggestion: String,
+                                    ) -> &mut Self);
+
+    #[deprecated(note = "Use `span_suggestions_with_applicability`")]
+    forward!(pub fn span_suggestions(&mut self,
+                                     sp: Span,
+                                     msg: &str,
+                                     suggestions: Vec<String>,
+                                     ) -> &mut Self);
 
-    pub fn span_warn<S: Into<MultiSpan>>(mut self, sp: S, msg: &str) -> Self {
-        self.db.span_warn(sp, msg);
+    pub fn multipart_suggestion_with_applicability(
+        &mut self,
+        msg: &str,
+        suggestion: Vec<(Span, String)>,
+        applicability: Applicability,
+    ) -> &mut Self {
+        if !self.allow_suggestions {
+            return self;
+        }
+        self.diagnostic
+            .multipart_suggestion_with_applicability(msg, suggestion, applicability);
         self
     }
 
-    pub fn help(mut self, msg: &str) -> Self {
-        self.db.help(msg);
+    pub fn span_suggestion_with_applicability(
+        &mut self,
+        sp: Span,
+        msg: &str,
+        suggestion: String,
+        applicability: Applicability,
+    ) -> &mut Self {
+        if !self.allow_suggestions {
+            return self;
+        }
+        self.diagnostic
+            .span_suggestion_with_applicability(sp, msg, suggestion, applicability);
         self
     }
 
-    pub fn span_help<S: Into<MultiSpan>>(mut self, sp: S, msg: &str) -> Self {
-        self.db.span_help(sp, msg);
+    pub fn span_suggestions_with_applicability(
+        &mut self,
+        sp: Span,
+        msg: &str,
+        suggestions: impl Iterator<Item = String>,
+        applicability: Applicability,
+    ) -> &mut Self {
+        if !self.allow_suggestions {
+            return self;
+        }
+        self.diagnostic
+            .span_suggestions_with_applicability(sp, msg, suggestions, applicability);
         self
     }
 
-    /// Prints out a message with a suggested edit of the code. If the
-    /// suggestion is presented inline it will only show the text message
-    /// and not the text.
-    ///
-    /// See `CodeSuggestion` for more information.
-    pub fn span_suggestion_short(mut self, sp: Span, msg: &str, suggestion: String) -> Self {
-        self.db.span_suggestion_short(sp, msg, suggestion);
+    pub fn span_suggestion_short_with_applicability(
+        &mut self,
+        sp: Span,
+        msg: &str,
+        suggestion: String,
+        applicability: Applicability,
+    ) -> &mut Self {
+        if !self.allow_suggestions {
+            return self;
+        }
+        self.diagnostic.span_suggestion_short_with_applicability(
+            sp,
+            msg,
+            suggestion,
+            applicability,
+        );
         self
     }
+    forward!(pub fn set_span<S: Into<MultiSpan>>(&mut self, sp: S) -> &mut Self);
+    forward!(pub fn code(&mut self, s: DiagnosticId) -> &mut Self);
 
-    /// Prints out a message with a suggested edit of the code.
-    ///
-    /// In case of short messages and a simple suggestion,
-    /// rustc displays it as a label like
-    ///
-    /// "try adding parentheses: `(tup.0).1`"
-    ///
-    /// The message
-    ///
-    /// * should not end in any punctuation (a `:` is added automatically)
-    /// * should not be a question
-    /// * should not contain any parts like "the following", "as shown"
-    /// * may look like "to do xyz, use" or "to do xyz, use abc"
-    /// * may contain a name of a function, variable or type, but not whole
-    /// expressions
-    ///
-    /// See `CodeSuggestion` for more information.
-    pub fn span_suggestion(mut self, sp: Span, msg: &str, suggestion: String) -> Self {
-        self.db.span_suggestion(sp, msg, suggestion);
+    pub fn allow_suggestions(&mut self, allow: bool) -> &mut Self {
+        self.allow_suggestions = allow;
         self
     }
 
-    /// Prints out a message with multiple suggested edits of the code.
-    pub fn span_suggestions(mut self, sp: Span, msg: &str, suggestions: Vec<String>) -> Self {
-        self.db.span_suggestions(sp, msg, suggestions);
-        self
+    /// Convenience function for internal use, clients should use one of the
+    /// struct_* methods on Handler.
+    pub fn new(handler: &'a Handler, level: Level, message: &str) -> DiagnosticBuilder<'a> {
+        DiagnosticBuilder::new_with_code(handler, level, None, message)
     }
 
-    pub fn span<S: Into<MultiSpan>>(mut self, sp: S) -> Self {
-        self.db.set_span(sp);
-        self
+    /// Convenience function for internal use, clients should use one of the
+    /// struct_* methods on Handler.
+    pub fn new_with_code(
+        handler: &'a Handler,
+        level: Level,
+        code: Option<DiagnosticId>,
+        message: &str,
+    ) -> DiagnosticBuilder<'a> {
+        let diagnostic = Diagnostic::new_with_code(level, code, message);
+        DiagnosticBuilder::new_diagnostic(handler, diagnostic)
     }
 
-    pub fn code(mut self, s: DiagnosticId) -> Self {
-        self.db.code(s);
-        self
+    /// Creates a new `DiagnosticBuilder` with an already constructed
+    /// diagnostic.
+    pub fn new_diagnostic(handler: &'a Handler, diagnostic: Diagnostic) -> DiagnosticBuilder<'a> {
+        DiagnosticBuilder {
+            handler,
+            diagnostic,
+            allow_suggestions: true,
+        }
     }
+}
 
-    // /// Used by a lint. Copies over all details *but* the "main
-    // /// message".
-    // pub fn copy_details_not_message(mut self, from: &Diagnostic) {
-    //     self.span = from.span.clone();
-    //     self.code = from.code.clone();
-    //     self.children.extend(from.children.iter().cloned())
-    // }
+impl<'a> Debug for DiagnosticBuilder<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.diagnostic.fmt(f)
+    }
 }
 
-impl<'a> From<Builder<'a>> for DiagnosticBuilder<'a> {
-    #[inline(always)]
-    fn from(db: Builder<'a>) -> Self {
-        DiagnosticBuilder { db: box db }
+/// Destructor bomb - a `DiagnosticBuilder` must be either emitted or canceled
+/// or we emit a bug.
+impl<'a> Drop for DiagnosticBuilder<'a> {
+    fn drop(&mut self) {
+        if !panicking() && !self.cancelled() {
+            let mut db = DiagnosticBuilder::new(
+                self.handler,
+                Level::Bug,
+                "Error constructed but not emitted",
+            );
+            db.emit();
+            panic!();
+        }
     }
 }
diff --git a/common/src/errors/emitter.rs b/common/src/errors/emitter.rs
new file mode 100644
index 000000000000..46b30398062e
--- /dev/null
+++ b/common/src/errors/emitter.rs
@@ -0,0 +1,1618 @@
+use self::Destination::*;
+use super::{
+    snippet::{Annotation, AnnotationType, Line, MultilineAnnotation, Style, StyledString},
+    styled_buffer::StyledBuffer,
+    CodeSuggestion, DiagnosticBuilder, DiagnosticId, Level, SourceMapperDyn, SubDiagnostic,
+};
+use crate::sync::Lrc;
+use atty;
+use fxhash::FxHashMap;
+use std::{
+    borrow::Cow,
+    cmp::{min, Reverse},
+    io::{self, prelude::*},
+    ops::Range,
+};
+use syntax_pos::{MultiSpan, SourceFile, Span};
+use termcolor::{Buffer, BufferWriter, Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
+use unicode_width;
+
+const ANONYMIZED_LINE_NUM: &str = "LL";
+
+/// Emitter trait for emitting errors.
+pub trait Emitter {
+    /// Emit a structured diagnostic.
+    fn emit(&mut self, db: &DiagnosticBuilder);
+
+    /// Check if should show explanations about "rustc --explain"
+    fn should_show_explain(&self) -> bool {
+        true
+    }
+}
+
+impl Emitter for EmitterWriter {
+    fn emit(&mut self, db: &DiagnosticBuilder) {
+        let mut primary_span = db.span.clone();
+        let mut children = db.children.clone();
+        let mut suggestions: &[_] = &[];
+
+        if let Some((sugg, rest)) = db.suggestions.split_first() {
+            if rest.is_empty() &&
+               // don't display multi-suggestions as labels
+               sugg.substitutions.len() == 1 &&
+               // don't display multipart suggestions as labels
+               sugg.substitutions[0].parts.len() == 1 &&
+               // don't display long messages as labels
+               sugg.msg.split_whitespace().count() < 10 &&
+               // don't display multiline suggestions as labels
+               !sugg.substitutions[0].parts[0].snippet.contains('\n')
+            {
+                let substitution = &sugg.substitutions[0].parts[0].snippet.trim();
+                let msg = if substitution.len() == 0 || !sugg.show_code_when_inline {
+                    // This substitution is only removal or we explicitly don't want to show the
+                    // code inline, don't show it
+                    format!("help: {}", sugg.msg)
+                } else {
+                    format!("help: {}: `{}`", sugg.msg, substitution)
+                };
+                primary_span.push_span_label(sugg.substitutions[0].parts[0].span, msg);
+            } else {
+                // if there are multiple suggestions, print them all in full
+                // to be consistent. We could try to figure out if we can
+                // make one (or the first one) inline, but that would give
+                // undue importance to a semi-random suggestion
+                suggestions = &db.suggestions;
+            }
+        }
+
+        self.fix_multispans_in_std_macros(
+            &mut primary_span,
+            &mut children,
+            db.handler.flags.external_macro_backtrace,
+        );
+
+        self.emit_messages_default(
+            &db.level,
+            &db.styled_message(),
+            &db.code,
+            &primary_span,
+            &children,
+            &suggestions,
+        );
+    }
+
+    fn should_show_explain(&self) -> bool {
+        !self.short_message
+    }
+}
+
+/// maximum number of lines we will print for each error; arbitrary.
+pub const MAX_HIGHLIGHT_LINES: usize = 6;
+/// maximum number of suggestions to be shown
+///
+/// Arbitrary, but taken from trait import suggestion limit
+pub const MAX_SUGGESTIONS: usize = 4;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ColorConfig {
+    Auto,
+    Always,
+    Never,
+}
+
+impl ColorConfig {
+    fn to_color_choice(&self) -> ColorChoice {
+        match *self {
+            ColorConfig::Always => {
+                if atty::is(atty::Stream::Stderr) {
+                    ColorChoice::Always
+                } else {
+                    ColorChoice::AlwaysAnsi
+                }
+            }
+            ColorConfig::Never => ColorChoice::Never,
+            ColorConfig::Auto if atty::is(atty::Stream::Stderr) => ColorChoice::Auto,
+            ColorConfig::Auto => ColorChoice::Never,
+        }
+    }
+}
+
+pub struct EmitterWriter {
+    dst: Destination,
+    sm: Option<Lrc<SourceMapperDyn>>,
+    short_message: bool,
+    teach: bool,
+    ui_testing: bool,
+}
+
+struct FileWithAnnotatedLines {
+    file: Lrc<SourceFile>,
+    lines: Vec<Line>,
+    multiline_depth: usize,
+}
+
+impl EmitterWriter {
+    pub fn stderr(
+        color_config: ColorConfig,
+        source_map: Option<Lrc<SourceMapperDyn>>,
+        short_message: bool,
+        teach: bool,
+    ) -> EmitterWriter {
+        let dst = Destination::from_stderr(color_config);
+        EmitterWriter {
+            dst,
+            sm: source_map,
+            short_message,
+            teach,
+            ui_testing: false,
+        }
+    }
+
+    pub fn new(
+        dst: Box<dyn Write + Send>,
+        source_map: Option<Lrc<SourceMapperDyn>>,
+        short_message: bool,
+        teach: bool,
+    ) -> EmitterWriter {
+        EmitterWriter {
+            dst: Raw(dst),
+            sm: source_map,
+            short_message,
+            teach,
+            ui_testing: false,
+        }
+    }
+
+    pub fn ui_testing(mut self, ui_testing: bool) -> Self {
+        self.ui_testing = ui_testing;
+        self
+    }
+
+    fn maybe_anonymized(&self, line_num: usize) -> String {
+        if self.ui_testing {
+            ANONYMIZED_LINE_NUM.to_string()
+        } else {
+            line_num.to_string()
+        }
+    }
+
+    fn preprocess_annotations(&mut self, msp: &MultiSpan) -> Vec<FileWithAnnotatedLines> {
+        fn add_annotation_to_file(
+            file_vec: &mut Vec<FileWithAnnotatedLines>,
+            file: Lrc<SourceFile>,
+            line_index: usize,
+            ann: Annotation,
+        ) {
+            for slot in file_vec.iter_mut() {
+                // Look through each of our files for the one we're adding to
+                if slot.file.name == file.name {
+                    // See if we already have a line for it
+                    for line_slot in &mut slot.lines {
+                        if line_slot.line_index == line_index {
+                            line_slot.annotations.push(ann);
+                            return;
+                        }
+                    }
+                    // We don't have a line yet, create one
+                    slot.lines.push(Line {
+                        line_index,
+                        annotations: vec![ann],
+                    });
+                    slot.lines.sort();
+                    return;
+                }
+            }
+            // This is the first time we're seeing the file
+            file_vec.push(FileWithAnnotatedLines {
+                file,
+                lines: vec![Line {
+                    line_index,
+                    annotations: vec![ann],
+                }],
+                multiline_depth: 0,
+            });
+        }
+
+        let mut output = vec![];
+        let mut multiline_annotations = vec![];
+
+        if let Some(ref sm) = self.sm {
+            for span_label in msp.span_labels() {
+                if span_label.span.is_dummy() {
+                    continue;
+                }
+
+                let lo = sm.lookup_char_pos(span_label.span.lo());
+                let mut hi = sm.lookup_char_pos(span_label.span.hi());
+
+                // Watch out for "empty spans". If we get a span like 6..6, we
+                // want to just display a `^` at 6, so convert that to
+                // 6..7. This is degenerate input, but it's best to degrade
+                // gracefully -- and the parser likes to supply a span like
+                // that for EOF, in particular.
+                if lo.col_display == hi.col_display && lo.line == hi.line {
+                    hi.col_display += 1;
+                }
+
+                let ann_type = if lo.line != hi.line {
+                    let ml = MultilineAnnotation {
+                        depth: 1,
+                        line_start: lo.line,
+                        line_end: hi.line,
+                        start_col: lo.col_display,
+                        end_col: hi.col_display,
+                        is_primary: span_label.is_primary,
+                        label: span_label.label.clone(),
+                    };
+                    multiline_annotations.push((lo.file.clone(), ml.clone()));
+                    AnnotationType::Multiline(ml)
+                } else {
+                    AnnotationType::Singleline
+                };
+                let ann = Annotation {
+                    start_col: lo.col_display,
+                    end_col: hi.col_display,
+                    is_primary: span_label.is_primary,
+                    label: span_label.label.clone(),
+                    annotation_type: ann_type,
+                };
+
+                if !ann.is_multiline() {
+                    add_annotation_to_file(&mut output, lo.file, lo.line, ann);
+                }
+            }
+        }
+
+        // Find overlapping multiline annotations, put them at different depths
+        multiline_annotations.sort_by_key(|&(_, ref ml)| (ml.line_start, ml.line_end));
+        for item in multiline_annotations.clone() {
+            let ann = item.1;
+            for item in multiline_annotations.iter_mut() {
+                let ref mut a = item.1;
+                // Move all other multiline annotations overlapping with this one
+                // one level to the right.
+                if &ann != a
+                    && num_overlap(ann.line_start, ann.line_end, a.line_start, a.line_end, true)
+                {
+                    a.increase_depth();
+                } else {
+                    break;
+                }
+            }
+        }
+
+        let mut max_depth = 0; // max overlapping multiline spans
+        for (file, ann) in multiline_annotations {
+            if ann.depth > max_depth {
+                max_depth = ann.depth;
+            }
+            add_annotation_to_file(&mut output, file.clone(), ann.line_start, ann.as_start());
+            let middle = min(ann.line_start + 4, ann.line_end);
+            for line in ann.line_start + 1..middle {
+                add_annotation_to_file(&mut output, file.clone(), line, ann.as_line());
+            }
+            if middle < ann.line_end - 1 {
+                for line in ann.line_end - 1..ann.line_end {
+                    add_annotation_to_file(&mut output, file.clone(), line, ann.as_line());
+                }
+            }
+            add_annotation_to_file(&mut output, file, ann.line_end, ann.as_end());
+        }
+        for file_vec in output.iter_mut() {
+            file_vec.multiline_depth = max_depth;
+        }
+        output
+    }
+
+    fn render_source_line(
+        &self,
+        buffer: &mut StyledBuffer,
+        file: Lrc<SourceFile>,
+        line: &Line,
+        width_offset: usize,
+        code_offset: usize,
+    ) -> Vec<(usize, Style)> {
+        if line.line_index == 0 {
+            return Vec::new();
+        }
+
+        let source_string = match file.get_line(line.line_index - 1) {
+            Some(s) => s,
+            None => return Vec::new(),
+        };
+
+        let line_offset = buffer.num_lines();
+
+        // First create the source line we will highlight.
+        buffer.puts(line_offset, code_offset, &source_string, Style::Quotation);
+        buffer.puts(
+            line_offset,
+            0,
+            &self.maybe_anonymized(line.line_index),
+            Style::LineNumber,
+        );
+
+        draw_col_separator(buffer, line_offset, width_offset - 2);
+
+        // Special case when there's only one annotation involved, it is the start of a
+        // multiline span and there's no text at the beginning of the code line.
+        // Instead of doing the whole graph:
+        //
+        // 2 |   fn foo() {
+        //   |  _^
+        // 3 | |
+        // 4 | | }
+        //   | |_^ test
+        //
+        // we simplify the output to:
+        //
+        // 2 | / fn foo() {
+        // 3 | |
+        // 4 | | }
+        //   | |_^ test
+        if line.annotations.len() == 1 {
+            if let Some(ref ann) = line.annotations.get(0) {
+                if let AnnotationType::MultilineStart(depth) = ann.annotation_type {
+                    if source_string
+                        .chars()
+                        .take(ann.start_col)
+                        .all(|c| c.is_whitespace())
+                    {
+                        let style = if ann.is_primary {
+                            Style::UnderlinePrimary
+                        } else {
+                            Style::UnderlineSecondary
+                        };
+                        buffer.putc(line_offset, width_offset + depth - 1, '/', style);
+                        return vec![(depth, style)];
+                    }
+                }
+            }
+        }
+
+        // We want to display like this:
+        //
+        //      vec.push(vec.pop().unwrap());
+        //      ---      ^^^               - previous borrow ends here
+        //      |        |
+        //      |        error occurs here
+        //      previous borrow of `vec` occurs here
+        //
+        // But there are some weird edge cases to be aware of:
+        //
+        //      vec.push(vec.pop().unwrap());
+        //      --------                    - previous borrow ends here
+        //      ||
+        //      |this makes no sense
+        //      previous borrow of `vec` occurs here
+        //
+        // For this reason, we group the lines into "highlight lines"
+        // and "annotations lines", where the highlight lines have the `^`.
+
+        // Sort the annotations by (start, end col)
+        // The labels are reversed, sort and then reversed again.
+        // Consider a list of annotations (A1, A2, C1, C2, B1, B2) where
+        // the letter signifies the span. Here we are only sorting by the
+        // span and hence, the order of the elements with the same span will
+        // not change. On reversing the ordering (|a, b| but b.cmp(a)), you get
+        // (C1, C2, B1, B2, A1, A2). All the elements with the same span are
+        // still ordered first to last, but all the elements with different
+        // spans are ordered by their spans in last to first order. Last to
+        // first order is important, because the jiggly lines and | are on
+        // the left, so the rightmost span needs to be rendered first,
+        // otherwise the lines would end up needing to go over a message.
+
+        let mut annotations = line.annotations.clone();
+        annotations.sort_by_key(|a| Reverse(a.start_col));
+
+        // First, figure out where each label will be positioned.
+        //
+        // In the case where you have the following annotations:
+        //
+        //      vec.push(vec.pop().unwrap());
+        //      --------                    - previous borrow ends here [C]
+        //      ||
+        //      |this makes no sense [B]
+        //      previous borrow of `vec` occurs here [A]
+        //
+        // `annotations_position` will hold [(2, A), (1, B), (0, C)].
+        //
+        // We try, when possible, to stick the rightmost annotation at the end
+        // of the highlight line:
+        //
+        //      vec.push(vec.pop().unwrap());
+        //      ---      ---               - previous borrow ends here
+        //
+        // But sometimes that's not possible because one of the other
+        // annotations overlaps it. For example, from the test
+        // `span_overlap_label`, we have the following annotations
+        // (written on distinct lines for clarity):
+        //
+        //      fn foo(x: u32) {
+        //      --------------
+        //             -
+        //
+        // In this case, we can't stick the rightmost-most label on
+        // the highlight line, or we would get:
+        //
+        //      fn foo(x: u32) {
+        //      -------- x_span
+        //      |
+        //      fn_span
+        //
+        // which is totally weird. Instead we want:
+        //
+        //      fn foo(x: u32) {
+        //      --------------
+        //      |      |
+        //      |      x_span
+        //      fn_span
+        //
+        // which is...less weird, at least. In fact, in general, if
+        // the rightmost span overlaps with any other span, we should
+        // use the "hang below" version, so we can at least make it
+        // clear where the span *starts*. There's an exception for this
+        // logic, when the labels do not have a message:
+        //
+        //      fn foo(x: u32) {
+        //      --------------
+        //             |
+        //             x_span
+        //
+        // instead of:
+        //
+        //      fn foo(x: u32) {
+        //      --------------
+        //      |      |
+        //      |      x_span
+        //      <EMPTY LINE>
+        //
+        let mut annotations_position = vec![];
+        let mut line_len = 0;
+        let mut p = 0;
+        for (i, annotation) in annotations.iter().enumerate() {
+            for (j, next) in annotations.iter().enumerate() {
+                if overlaps(next, annotation, 0)  // This label overlaps with another one and both
+                    && annotation.has_label()     // take space (they have text and are not
+                    && j > i                      // multiline lines).
+                    && p == 0
+                // We're currently on the first line, move the label one line down
+                {
+                    // This annotation needs a new line in the output.
+                    p += 1;
+                    break;
+                }
+            }
+            annotations_position.push((p, annotation));
+            for (j, next) in annotations.iter().enumerate() {
+                if j > i {
+                    let l = if let Some(ref label) = next.label {
+                        label.len() + 2
+                    } else {
+                        0
+                    };
+                    if (overlaps(next, annotation, l) // Do not allow two labels to be in the same
+                                                     // line if they overlap including padding, to
+                                                     // avoid situations like:
+                                                     //
+                                                     //      fn foo(x: u32) {
+                                                     //      -------^------
+                                                     //      |      |
+                                                     //      fn_spanx_span
+                                                     //
+                        && annotation.has_label()    // Both labels must have some text, otherwise
+                        && next.has_label())         // they are not overlapping.
+                                                     // Do not add a new line if this annotation
+                                                     // or the next are vertical line placeholders.
+                        || (annotation.takes_space() // If either this or the next annotation is
+                            && next.has_label())     // multiline start/end, move it to a new line
+                        || (annotation.has_label()   // so as not to overlap the orizontal lines.
+                            && next.takes_space())
+                        || (annotation.takes_space() && next.takes_space())
+                        || (overlaps(next, annotation, l)
+                            && next.end_col <= annotation.end_col
+                            && next.has_label()
+                            && p == 0)
+                    // Avoid #42595.
+                    {
+                        // This annotation needs a new line in the output.
+                        p += 1;
+                        break;
+                    }
+                }
+            }
+            if line_len < p {
+                line_len = p;
+            }
+        }
+
+        if line_len != 0 {
+            line_len += 1;
+        }
+
+        // If there are no annotations or the only annotations on this line are
+        // MultilineLine, then there's only code being shown, stop processing.
+        if line.annotations.iter().all(|a| a.is_line()) {
+            return vec![];
+        }
+
+        // Write the colunmn separator.
+        //
+        // After this we will have:
+        //
+        // 2 |   fn foo() {
+        //   |
+        //   |
+        //   |
+        // 3 |
+        // 4 |   }
+        //   |
+        for pos in 0..=line_len {
+            draw_col_separator(buffer, line_offset + pos + 1, width_offset - 2);
+            buffer.putc(
+                line_offset + pos + 1,
+                width_offset - 2,
+                '|',
+                Style::LineNumber,
+            );
+        }
+
+        // Write the horizontal lines for multiline annotations
+        // (only the first and last lines need this).
+        //
+        // After this we will have:
+        //
+        // 2 |   fn foo() {
+        //   |  __________
+        //   |
+        //   |
+        // 3 |
+        // 4 |   }
+        //   |  _
+        for &(pos, annotation) in &annotations_position {
+            let style = if annotation.is_primary {
+                Style::UnderlinePrimary
+            } else {
+                Style::UnderlineSecondary
+            };
+            let pos = pos + 1;
+            match annotation.annotation_type {
+                AnnotationType::MultilineStart(depth) | AnnotationType::MultilineEnd(depth) => {
+                    draw_range(
+                        buffer,
+                        '_',
+                        line_offset + pos,
+                        width_offset + depth,
+                        code_offset + annotation.start_col,
+                        style,
+                    );
+                }
+                _ if self.teach => {
+                    buffer.set_style_range(
+                        line_offset,
+                        code_offset + annotation.start_col,
+                        code_offset + annotation.end_col,
+                        style,
+                        annotation.is_primary,
+                    );
+                }
+                _ => {}
+            }
+        }
+
+        // Write the vertical lines for labels that are on a different line as the
+        // underline.
+        //
+        // After this we will have:
+        //
+        // 2 |   fn foo() {
+        //   |  __________
+        //   | |    |
+        //   | |
+        // 3 |
+        // 4 | | }
+        //   | |_
+        for &(pos, annotation) in &annotations_position {
+            let style = if annotation.is_primary {
+                Style::UnderlinePrimary
+            } else {
+                Style::UnderlineSecondary
+            };
+            let pos = pos + 1;
+
+            if pos > 1 && (annotation.has_label() || annotation.takes_space()) {
+                for p in line_offset + 1..=line_offset + pos {
+                    buffer.putc(p, code_offset + annotation.start_col, '|', style);
+                }
+            }
+            match annotation.annotation_type {
+                AnnotationType::MultilineStart(depth) => {
+                    for p in line_offset + pos + 1..line_offset + line_len + 2 {
+                        buffer.putc(p, width_offset + depth - 1, '|', style);
+                    }
+                }
+                AnnotationType::MultilineEnd(depth) => {
+                    for p in line_offset..=line_offset + pos {
+                        buffer.putc(p, width_offset + depth - 1, '|', style);
+                    }
+                }
+                _ => (),
+            }
+        }
+
+        // Write the labels on the annotations that actually have a label.
+        //
+        // After this we will have:
+        //
+        // 2 |   fn foo() {
+        //   |  __________
+        //   |      |
+        //   |      something about `foo`
+        // 3 |
+        // 4 |   }
+        //   |  _  test
+        for &(pos, annotation) in &annotations_position {
+            let style = if annotation.is_primary {
+                Style::LabelPrimary
+            } else {
+                Style::LabelSecondary
+            };
+            let (pos, col) = if pos == 0 {
+                (pos + 1, annotation.end_col + 1)
+            } else {
+                (pos + 2, annotation.start_col)
+            };
+            if let Some(ref label) = annotation.label {
+                buffer.puts(line_offset + pos, code_offset + col, &label, style);
+            }
+        }
+
+        // Sort from biggest span to smallest span so that smaller spans are
+        // represented in the output:
+        //
+        // x | fn foo()
+        //   | ^^^---^^
+        //   | |  |
+        //   | |  something about `foo`
+        //   | something about `fn foo()`
+        annotations_position.sort_by(|a, b| {
+            // Decreasing order
+            a.1.len().cmp(&b.1.len()).reverse()
+        });
+
+        // Write the underlines.
+        //
+        // After this we will have:
+        //
+        // 2 |   fn foo() {
+        //   |  ____-_____^
+        //   |      |
+        //   |      something about `foo`
+        // 3 |
+        // 4 |   }
+        //   |  _^  test
+        for &(_, annotation) in &annotations_position {
+            let (underline, style) = if annotation.is_primary {
+                ('^', Style::UnderlinePrimary)
+            } else {
+                ('-', Style::UnderlineSecondary)
+            };
+            for p in annotation.start_col..annotation.end_col {
+                buffer.putc(line_offset + 1, code_offset + p, underline, style);
+            }
+        }
+        annotations_position
+            .iter()
+            .filter_map(|&(_, annotation)| match annotation.annotation_type {
+                AnnotationType::MultilineStart(p) | AnnotationType::MultilineEnd(p) => {
+                    let style = if annotation.is_primary {
+                        Style::LabelPrimary
+                    } else {
+                        Style::LabelSecondary
+                    };
+                    Some((p, style))
+                }
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+    }
+
+    fn get_multispan_max_line_num(&mut self, msp: &MultiSpan) -> usize {
+        let mut max = 0;
+        if let Some(ref sm) = self.sm {
+            for primary_span in msp.primary_spans() {
+                if !primary_span.is_dummy() {
+                    let hi = sm.lookup_char_pos(primary_span.hi());
+                    if hi.line > max {
+                        max = hi.line;
+                    }
+                }
+            }
+            if !self.short_message {
+                for span_label in msp.span_labels() {
+                    if !span_label.span.is_dummy() {
+                        let hi = sm.lookup_char_pos(span_label.span.hi());
+                        if hi.line > max {
+                            max = hi.line;
+                        }
+                    }
+                }
+            }
+        }
+        max
+    }
+
+    fn get_max_line_num(&mut self, span: &MultiSpan, children: &[SubDiagnostic]) -> usize {
+        let mut max = 0;
+
+        let primary = self.get_multispan_max_line_num(span);
+        max = if primary > max { primary } else { max };
+
+        for sub in children {
+            let sub_result = self.get_multispan_max_line_num(&sub.span);
+            max = if sub_result > max { primary } else { max };
+        }
+        max
+    }
+
+    // This "fixes" MultiSpans that contain Spans that are pointing to locations
+    // inside of <*macros>. Since these locations are often difficult to read,
+    // we move these Spans from <*macros> to their corresponding use site.
+    fn fix_multispan_in_std_macros(
+        &mut self,
+        span: &mut MultiSpan,
+        always_backtrace: bool,
+    ) -> bool {
+        let mut spans_updated = false;
+
+        if let Some(ref sm) = self.sm {
+            let mut before_after: Vec<(Span, Span)> = vec![];
+            let mut new_labels: Vec<(Span, String)> = vec![];
+
+            // First, find all the spans in <*macros> and point instead at their use site
+            for sp in span.primary_spans() {
+                if sp.is_dummy() {
+                    continue;
+                }
+                let call_sp = sm.call_span_if_macro(*sp);
+                if call_sp != *sp && !always_backtrace {
+                    before_after.push((*sp, call_sp));
+                }
+            }
+            for (label_span, label_text) in new_labels {
+                span.push_span_label(label_span, label_text);
+            }
+            for sp_label in span.span_labels() {
+                if sp_label.span.is_dummy() {
+                    continue;
+                }
+                // if sm.span_to_filename(sp_label.span.clone()).is_macros() &&
+                // !always_backtrace {     let v =
+                // sp_label.span.macro_backtrace();     if let Some(use_site) =
+                // v.last() {         before_after.push((sp_label.span.clone(),
+                // use_site.call_site.clone()));     }
+                // }
+            }
+            // After we have them, make sure we replace these 'bad' def sites with their use
+            // sites
+            for (before, after) in before_after {
+                span.replace(before, after);
+                spans_updated = true;
+            }
+        }
+
+        spans_updated
+    }
+
+    // This does a small "fix" for multispans by looking to see if it can find any
+    // that point directly at <*macros>. Since these are often difficult to
+    // read, this will change the span to point at the use site.
+    fn fix_multispans_in_std_macros(
+        &mut self,
+        span: &mut MultiSpan,
+        children: &mut Vec<SubDiagnostic>,
+        backtrace: bool,
+    ) {
+        let mut spans_updated = self.fix_multispan_in_std_macros(span, backtrace);
+        for child in children.iter_mut() {
+            spans_updated |= self.fix_multispan_in_std_macros(&mut child.span, backtrace);
+        }
+        if spans_updated {
+            children.push(SubDiagnostic {
+                level: Level::Note,
+                message: vec![(
+                    "this error originates in a macro outside of the current crate (in Nightly \
+                     builds, run with -Z external-macro-backtrace for more info)"
+                        .to_string(),
+                    Style::NoStyle,
+                )],
+                span: MultiSpan::new(),
+                render_span: None,
+            });
+        }
+    }
+
+    /// Add a left margin to every line but the first, given a padding length
+    /// and the label being displayed, keeping the provided highlighting.
+    fn msg_to_buffer(
+        &self,
+        buffer: &mut StyledBuffer,
+        msg: &[(String, Style)],
+        padding: usize,
+        label: &str,
+        override_style: Option<Style>,
+    ) {
+        // The extra 5 ` ` is padding that's always needed to align to the `note: `:
+        //
+        //   error: message
+        //     --> file.rs:13:20
+        //      |
+        //   13 |     <CODE>
+        //      |      ^^^^
+        //      |
+        //      = note: multiline
+        //              message
+        //   ++^^^----xx
+        //    |  |   | |
+        //    |  |   | magic `2`
+        //    |  |   length of label
+        //    |  magic `3`
+        //    `max_line_num_len`
+        let padding = " ".repeat(padding + label.len() + 5);
+
+        /// Return whether `style`, or the override if present and the style is
+        /// `NoStyle`.
+        fn style_or_override(style: Style, override_style: Option<Style>) -> Style {
+            if let Some(o) = override_style {
+                if style == Style::NoStyle {
+                    return o;
+                }
+            }
+            style
+        }
+
+        let mut line_number = 0;
+
+        // Provided the following diagnostic message:
+        //
+        //     let msg = vec![
+        //       ("
+        //       ("highlighted multiline\nstring to\nsee how it ", Style::NoStyle),
+        //       ("looks", Style::Highlight),
+        //       ("with\nvery ", Style::NoStyle),
+        //       ("weird", Style::Highlight),
+        //       (" formats\n", Style::NoStyle),
+        //       ("see?", Style::Highlight),
+        //     ];
+        //
+        // the expected output on a note is (* surround the highlighted text)
+        //
+        //        = note: highlighted multiline
+        //                string to
+        //                see how it *looks* with
+        //                very *weird* formats
+        //                see?
+        for &(ref text, ref style) in msg.iter() {
+            let lines = text.split('\n').collect::<Vec<_>>();
+            if lines.len() > 1 {
+                for (i, line) in lines.iter().enumerate() {
+                    if i != 0 {
+                        line_number += 1;
+                        buffer.append(line_number, &padding, Style::NoStyle);
+                    }
+                    buffer.append(line_number, line, style_or_override(*style, override_style));
+                }
+            } else {
+                buffer.append(line_number, text, style_or_override(*style, override_style));
+            }
+        }
+    }
+
+    fn emit_message_default(
+        &mut self,
+        msp: &MultiSpan,
+        msg: &[(String, Style)],
+        code: &Option<DiagnosticId>,
+        level: &Level,
+        max_line_num_len: usize,
+        is_secondary: bool,
+    ) -> io::Result<()> {
+        let mut buffer = StyledBuffer::new();
+        let header_style = if is_secondary {
+            Style::HeaderMsg
+        } else {
+            Style::MainHeaderMsg
+        };
+
+        if msp.primary_spans().is_empty()
+            && msp.span_labels().is_empty()
+            && is_secondary
+            && !self.short_message
+        {
+            // This is a secondary message with no span info
+            for _ in 0..max_line_num_len {
+                buffer.prepend(0, " ", Style::NoStyle);
+            }
+            draw_note_separator(&mut buffer, 0, max_line_num_len + 1);
+            let level_str = level.to_string();
+            if !level_str.is_empty() {
+                buffer.append(0, &level_str, Style::MainHeaderMsg);
+                buffer.append(0, ": ", Style::NoStyle);
+            }
+            self.msg_to_buffer(&mut buffer, msg, max_line_num_len, "note", None);
+        } else {
+            let level_str = level.to_string();
+            if !level_str.is_empty() {
+                buffer.append(0, &level_str, Style::Level(level.clone()));
+            }
+            // only render error codes, not lint codes
+            if let Some(DiagnosticId::Error(ref code)) = *code {
+                buffer.append(0, "[", Style::Level(level.clone()));
+                buffer.append(0, &code, Style::Level(level.clone()));
+                buffer.append(0, "]", Style::Level(level.clone()));
+            }
+            if !level_str.is_empty() {
+                buffer.append(0, ": ", header_style);
+            }
+            for &(ref text, _) in msg.iter() {
+                buffer.append(0, text, header_style);
+            }
+        }
+
+        // Preprocess all the annotations so that they are grouped by file and by line
+        // number This helps us quickly iterate over the whole message
+        // (including secondary file spans)
+        let mut annotated_files = self.preprocess_annotations(msp);
+
+        // Make sure our primary file comes first
+        let (primary_lo, sm) = if let (Some(sm), Some(ref primary_span)) =
+            (self.sm.as_ref(), msp.primary_span().as_ref())
+        {
+            if !primary_span.is_dummy() {
+                (sm.lookup_char_pos(primary_span.lo()), sm)
+            } else {
+                emit_to_destination(&buffer.render(), level, &mut self.dst, self.short_message)?;
+                return Ok(());
+            }
+        } else {
+            // If we don't have span information, emit and exit
+            emit_to_destination(&buffer.render(), level, &mut self.dst, self.short_message)?;
+            return Ok(());
+        };
+        if let Ok(pos) =
+            annotated_files.binary_search_by(|x| x.file.name.cmp(&primary_lo.file.name))
+        {
+            annotated_files.swap(0, pos);
+        }
+
+        // Print out the annotate source lines that correspond with the error
+        for annotated_file in annotated_files {
+            // // we can't annotate anything if the source is unavailable.
+            // if !sm.ensure_source_file_source_present(annotated_file.file.clone()) {
+            //     continue;
+            // }
+
+            // print out the span location and spacer before we print the annotated source
+            // to do this, we need to know if this span will be primary
+            let is_primary = primary_lo.file.name == annotated_file.file.name;
+            if is_primary {
+                let loc = primary_lo.clone();
+                if !self.short_message {
+                    // remember where we are in the output buffer for easy reference
+                    let buffer_msg_line_offset = buffer.num_lines();
+
+                    buffer.prepend(buffer_msg_line_offset, "--> ", Style::LineNumber);
+                    buffer.append(
+                        buffer_msg_line_offset,
+                        &format!(
+                            "{}:{}:{}",
+                            loc.file.name,
+                            sm.doctest_offset_line(&loc.file.name, loc.line),
+                            loc.col.0 + 1
+                        ),
+                        Style::LineAndColumn,
+                    );
+                    for _ in 0..max_line_num_len {
+                        buffer.prepend(buffer_msg_line_offset, " ", Style::NoStyle);
+                    }
+                } else {
+                    buffer.prepend(
+                        0,
+                        &format!(
+                            "{}:{}:{}: ",
+                            loc.file.name,
+                            sm.doctest_offset_line(&loc.file.name, loc.line),
+                            loc.col.0 + 1
+                        ),
+                        Style::LineAndColumn,
+                    );
+                }
+            } else if !self.short_message {
+                // remember where we are in the output buffer for easy reference
+                let buffer_msg_line_offset = buffer.num_lines();
+
+                // Add spacing line
+                draw_col_separator(&mut buffer, buffer_msg_line_offset, max_line_num_len + 1);
+
+                // Then, the secondary file indicator
+                buffer.prepend(buffer_msg_line_offset + 1, "::: ", Style::LineNumber);
+                let loc = if let Some(first_line) = annotated_file.lines.first() {
+                    let col = if let Some(first_annotation) = first_line.annotations.first() {
+                        format!(":{}", first_annotation.start_col + 1)
+                    } else {
+                        String::new()
+                    };
+                    format!(
+                        "{}:{}{}",
+                        annotated_file.file.name,
+                        sm.doctest_offset_line(&annotated_file.file.name, first_line.line_index),
+                        col
+                    )
+                } else {
+                    annotated_file.file.name.to_string()
+                };
+                buffer.append(buffer_msg_line_offset + 1, &loc, Style::LineAndColumn);
+                for _ in 0..max_line_num_len {
+                    buffer.prepend(buffer_msg_line_offset + 1, " ", Style::NoStyle);
+                }
+            }
+
+            if !self.short_message {
+                // Put in the spacer between the location and annotated source
+                let buffer_msg_line_offset = buffer.num_lines();
+                draw_col_separator_no_space(
+                    &mut buffer,
+                    buffer_msg_line_offset,
+                    max_line_num_len + 1,
+                );
+
+                // Contains the vertical lines' positions for active multiline annotations
+                let mut multilines = FxHashMap::default();
+
+                // Next, output the annotate source for this file
+                for line_idx in 0..annotated_file.lines.len() {
+                    let previous_buffer_line = buffer.num_lines();
+
+                    let width_offset = 3 + max_line_num_len;
+                    let code_offset = if annotated_file.multiline_depth == 0 {
+                        width_offset
+                    } else {
+                        width_offset + annotated_file.multiline_depth + 1
+                    };
+
+                    let depths = self.render_source_line(
+                        &mut buffer,
+                        annotated_file.file.clone(),
+                        &annotated_file.lines[line_idx],
+                        width_offset,
+                        code_offset,
+                    );
+
+                    let mut to_add = FxHashMap::default();
+
+                    for (depth, style) in depths {
+                        if multilines.get(&depth).is_some() {
+                            multilines.remove(&depth);
+                        } else {
+                            to_add.insert(depth, style);
+                        }
+                    }
+
+                    // Set the multiline annotation vertical lines to the left of
+                    // the code in this line.
+                    for (depth, style) in &multilines {
+                        for line in previous_buffer_line..buffer.num_lines() {
+                            draw_multiline_line(&mut buffer, line, width_offset, *depth, *style);
+                        }
+                    }
+                    // check to see if we need to print out or elide lines that come between
+                    // this annotated line and the next one.
+                    if line_idx < (annotated_file.lines.len() - 1) {
+                        let line_idx_delta = annotated_file.lines[line_idx + 1].line_index
+                            - annotated_file.lines[line_idx].line_index;
+                        if line_idx_delta > 2 {
+                            let last_buffer_line_num = buffer.num_lines();
+                            buffer.puts(last_buffer_line_num, 0, "...", Style::LineNumber);
+
+                            // Set the multiline annotation vertical lines on `...` bridging line.
+                            for (depth, style) in &multilines {
+                                draw_multiline_line(
+                                    &mut buffer,
+                                    last_buffer_line_num,
+                                    width_offset,
+                                    *depth,
+                                    *style,
+                                );
+                            }
+                        } else if line_idx_delta == 2 {
+                            let unannotated_line = annotated_file
+                                .file
+                                .get_line(annotated_file.lines[line_idx].line_index)
+                                .unwrap_or_else(|| Cow::from(""));
+
+                            let last_buffer_line_num = buffer.num_lines();
+
+                            buffer.puts(
+                                last_buffer_line_num,
+                                0,
+                                &self.maybe_anonymized(
+                                    annotated_file.lines[line_idx + 1].line_index - 1,
+                                ),
+                                Style::LineNumber,
+                            );
+                            draw_col_separator(
+                                &mut buffer,
+                                last_buffer_line_num,
+                                1 + max_line_num_len,
+                            );
+                            buffer.puts(
+                                last_buffer_line_num,
+                                code_offset,
+                                &unannotated_line,
+                                Style::Quotation,
+                            );
+
+                            for (depth, style) in &multilines {
+                                draw_multiline_line(
+                                    &mut buffer,
+                                    last_buffer_line_num,
+                                    width_offset,
+                                    *depth,
+                                    *style,
+                                );
+                            }
+                        }
+                    }
+
+                    multilines.extend(&to_add);
+                }
+            }
+        }
+
+        // final step: take our styled buffer, render it, then output it
+        emit_to_destination(&buffer.render(), level, &mut self.dst, self.short_message)?;
+
+        Ok(())
+    }
+
+    fn emit_suggestion_default(
+        &mut self,
+        suggestion: &CodeSuggestion,
+        level: &Level,
+        max_line_num_len: usize,
+    ) -> io::Result<()> {
+        if let Some(ref sm) = self.sm {
+            let mut buffer = StyledBuffer::new();
+
+            // Render the suggestion message
+            let level_str = level.to_string();
+            if !level_str.is_empty() {
+                buffer.append(0, &level_str, Style::Level(level.clone()));
+                buffer.append(0, ": ", Style::HeaderMsg);
+            }
+            self.msg_to_buffer(
+                &mut buffer,
+                &[(suggestion.msg.to_owned(), Style::NoStyle)],
+                max_line_num_len,
+                "suggestion",
+                Some(Style::HeaderMsg),
+            );
+
+            // Render the replacements for each suggestion
+            let suggestions = suggestion.splice_lines(&**sm);
+
+            let mut row_num = 2;
+            for &(ref complete, ref parts) in suggestions.iter().take(MAX_SUGGESTIONS) {
+                // Only show underline if the suggestion spans a single line and doesn't cover
+                // the entirety of the code output. If you have multiple
+                // replacements in the same line of code, show the underline.
+                let show_underline = !(parts.len() == 1
+                    && parts[0].snippet.trim() == complete.trim())
+                    && complete.lines().count() == 1;
+
+                let lines = sm.span_to_lines(parts[0].span).unwrap();
+
+                assert!(!lines.lines.is_empty());
+
+                let line_start = sm.lookup_char_pos(parts[0].span.lo()).line;
+                draw_col_separator_no_space(&mut buffer, 1, max_line_num_len + 1);
+                let mut line_pos = 0;
+                let mut lines = complete.lines();
+                for line in lines.by_ref().take(MAX_HIGHLIGHT_LINES) {
+                    // Print the span column to avoid confusion
+                    buffer.puts(
+                        row_num,
+                        0,
+                        &self.maybe_anonymized(line_start + line_pos),
+                        Style::LineNumber,
+                    );
+                    // print the suggestion
+                    draw_col_separator(&mut buffer, row_num, max_line_num_len + 1);
+                    buffer.append(row_num, line, Style::NoStyle);
+                    line_pos += 1;
+                    row_num += 1;
+                }
+
+                // This offset and the ones below need to be signed to account for replacement
+                // code that is shorter than the original code.
+                let mut offset: isize = 0;
+                // Only show an underline in the suggestions if the suggestion is not the
+                // entirety of the code being shown and the displayed code is not multiline.
+                if show_underline {
+                    draw_col_separator(&mut buffer, row_num, max_line_num_len + 1);
+                    for part in parts {
+                        let span_start_pos = sm.lookup_char_pos(part.span.lo()).col_display;
+                        let span_end_pos = sm.lookup_char_pos(part.span.hi()).col_display;
+
+                        // Do not underline the leading...
+                        let start = part
+                            .snippet
+                            .len()
+                            .saturating_sub(part.snippet.trim_start().len());
+                        // ...or trailing spaces. Account for substitutions containing unicode
+                        // characters.
+                        let sub_len = part.snippet.trim().chars().fold(0, |acc, ch| {
+                            acc + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0)
+                        });
+
+                        let underline_start = (span_start_pos + start) as isize + offset;
+                        let underline_end = (span_start_pos + start + sub_len) as isize + offset;
+                        for p in underline_start..underline_end {
+                            buffer.putc(
+                                row_num,
+                                max_line_num_len + 3 + p as usize,
+                                '^',
+                                Style::UnderlinePrimary,
+                            );
+                        }
+                        // underline removals too
+                        if underline_start == underline_end {
+                            for p in underline_start - 1..underline_start + 1 {
+                                buffer.putc(
+                                    row_num,
+                                    max_line_num_len + 3 + p as usize,
+                                    '-',
+                                    Style::UnderlineSecondary,
+                                );
+                            }
+                        }
+
+                        // length of the code after substitution
+                        let full_sub_len = part.snippet.chars().fold(0, |acc, ch| {
+                            acc + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0) as isize
+                        });
+
+                        // length of the code to be substituted
+                        let snippet_len = span_end_pos as isize - span_start_pos as isize;
+                        // For multiple substitutions, use the position *after* the previous
+                        // substitutions have happened.
+                        offset += full_sub_len - snippet_len;
+                    }
+                    row_num += 1;
+                }
+
+                // if we elided some lines, add an ellipsis
+                if lines.next().is_some() {
+                    buffer.puts(row_num, max_line_num_len - 1, "...", Style::LineNumber);
+                } else if !show_underline {
+                    draw_col_separator_no_space(&mut buffer, row_num, max_line_num_len + 1);
+                    row_num += 1;
+                }
+            }
+            if suggestions.len() > MAX_SUGGESTIONS {
+                let msg = format!(
+                    "and {} other candidates",
+                    suggestions.len() - MAX_SUGGESTIONS
+                );
+                buffer.puts(row_num, 0, &msg, Style::NoStyle);
+            }
+            emit_to_destination(&buffer.render(), level, &mut self.dst, self.short_message)?;
+        }
+        Ok(())
+    }
+
+    fn emit_messages_default(
+        &mut self,
+        level: &Level,
+        message: &[(String, Style)],
+        code: &Option<DiagnosticId>,
+        span: &MultiSpan,
+        children: &[SubDiagnostic],
+        suggestions: &[CodeSuggestion],
+    ) {
+        let max_line_num_len = if self.ui_testing {
+            ANONYMIZED_LINE_NUM.len()
+        } else {
+            self.get_max_line_num(span, children).to_string().len()
+        };
+
+        match self.emit_message_default(span, message, code, level, max_line_num_len, false) {
+            Ok(()) => {
+                if !children.is_empty() {
+                    let mut buffer = StyledBuffer::new();
+                    if !self.short_message {
+                        draw_col_separator_no_space(&mut buffer, 0, max_line_num_len + 1);
+                    }
+                    match emit_to_destination(
+                        &buffer.render(),
+                        level,
+                        &mut self.dst,
+                        self.short_message,
+                    ) {
+                        Ok(()) => (),
+                        Err(e) => panic!("failed to emit error: {}", e),
+                    }
+                }
+                if !self.short_message {
+                    for child in children {
+                        let span = child.render_span.as_ref().unwrap_or(&child.span);
+                        match self.emit_message_default(
+                            &span,
+                            &child.styled_message(),
+                            &None,
+                            &child.level,
+                            max_line_num_len,
+                            true,
+                        ) {
+                            Err(e) => panic!("failed to emit error: {}", e),
+                            _ => (),
+                        }
+                    }
+                    for sugg in suggestions {
+                        match self.emit_suggestion_default(sugg, &Level::Help, max_line_num_len) {
+                            Err(e) => panic!("failed to emit error: {}", e),
+                            _ => (),
+                        }
+                    }
+                }
+            }
+            Err(e) => panic!("failed to emit error: {}", e),
+        }
+
+        let mut dst = self.dst.writable();
+        match write!(dst, "\n") {
+            Err(e) => panic!("failed to emit error: {}", e),
+            _ => match dst.flush() {
+                Err(e) => panic!("failed to emit error: {}", e),
+                _ => (),
+            },
+        }
+    }
+}
+
+fn draw_col_separator(buffer: &mut StyledBuffer, line: usize, col: usize) {
+    buffer.puts(line, col, "| ", Style::LineNumber);
+}
+
+fn draw_col_separator_no_space(buffer: &mut StyledBuffer, line: usize, col: usize) {
+    draw_col_separator_no_space_with_style(buffer, line, col, Style::LineNumber);
+}
+
+fn draw_col_separator_no_space_with_style(
+    buffer: &mut StyledBuffer,
+    line: usize,
+    col: usize,
+    style: Style,
+) {
+    buffer.putc(line, col, '|', style);
+}
+
+fn draw_range(
+    buffer: &mut StyledBuffer,
+    symbol: char,
+    line: usize,
+    col_from: usize,
+    col_to: usize,
+    style: Style,
+) {
+    for col in col_from..col_to {
+        buffer.putc(line, col, symbol, style);
+    }
+}
+
+fn draw_note_separator(buffer: &mut StyledBuffer, line: usize, col: usize) {
+    buffer.puts(line, col, "= ", Style::LineNumber);
+}
+
+fn draw_multiline_line(
+    buffer: &mut StyledBuffer,
+    line: usize,
+    offset: usize,
+    depth: usize,
+    style: Style,
+) {
+    buffer.putc(line, offset + depth - 1, '|', style);
+}
+
+fn num_overlap(
+    a_start: usize,
+    a_end: usize,
+    b_start: usize,
+    b_end: usize,
+    inclusive: bool,
+) -> bool {
+    let extra = if inclusive { 1 } else { 0 };
+    fn contains(r: Range<usize>, value: usize) -> bool {
+        r.start < value && value <= r.end
+    }
+    contains(b_start..b_end + extra, a_start) || contains(a_start..a_end + extra, b_start)
+}
+fn overlaps(a1: &Annotation, a2: &Annotation, padding: usize) -> bool {
+    num_overlap(
+        a1.start_col,
+        a1.end_col + padding,
+        a2.start_col,
+        a2.end_col,
+        false,
+    )
+}
+
+fn emit_to_destination(
+    rendered_buffer: &[Vec<StyledString>],
+    lvl: &Level,
+    dst: &mut Destination,
+    short_message: bool,
+) -> io::Result<()> {
+    use super::lock;
+
+    let mut dst = dst.writable();
+
+    // In order to prevent error message interleaving, where multiple error lines
+    // get intermixed when multiple compiler processes error simultaneously, we
+    // emit errors with additional steps.
+    //
+    // On Unix systems, we write into a buffered terminal rather than directly to a
+    // terminal. When the .flush() is called we take the buffer created from the
+    // buffered writes and write it at one shot.  Because the Unix systems use
+    // ANSI for the colors, which is a text-based styling scheme, this buffered
+    // approach works and maintains the styling.
+    //
+    // On Windows, styling happens through calls to a terminal API. This prevents us
+    // from using the same buffering approach.  Instead, we use a global Windows
+    // mutex, which we acquire long enough to output the full error message,
+    // then we release.
+    let _buffer_lock = lock::acquire_global_lock("rustc_errors");
+    for (pos, line) in rendered_buffer.iter().enumerate() {
+        for part in line {
+            dst.apply_style(lvl.clone(), part.style)?;
+            write!(dst, "{}", part.text)?;
+            dst.reset()?;
+        }
+        if !short_message && (!lvl.is_failure_note() || pos != rendered_buffer.len() - 1) {
+            write!(dst, "\n")?;
+        }
+    }
+    dst.flush()?;
+    Ok(())
+}
+
+pub enum Destination {
+    Terminal(StandardStream),
+    Buffered(BufferWriter),
+    Raw(Box<dyn Write + Send>),
+}
+
+pub enum WritableDst<'a> {
+    Terminal(&'a mut StandardStream),
+    Buffered(&'a mut BufferWriter, Buffer),
+    Raw(&'a mut Box<dyn Write + Send>),
+}
+
+impl Destination {
+    fn from_stderr(color: ColorConfig) -> Destination {
+        let choice = color.to_color_choice();
+        // On Windows we'll be performing global synchronization on the entire
+        // system for emitting rustc errors, so there's no need to buffer
+        // anything.
+        //
+        // On non-Windows we rely on the atomicity of `write` to ensure errors
+        // don't get all jumbled up.
+        if cfg!(windows) {
+            Terminal(StandardStream::stderr(choice))
+        } else {
+            Buffered(BufferWriter::stderr(choice))
+        }
+    }
+
+    fn writable<'a>(&'a mut self) -> WritableDst<'a> {
+        match *self {
+            Destination::Terminal(ref mut t) => WritableDst::Terminal(t),
+            Destination::Buffered(ref mut t) => {
+                let buf = t.buffer();
+                WritableDst::Buffered(t, buf)
+            }
+            Destination::Raw(ref mut t) => WritableDst::Raw(t),
+        }
+    }
+}
+
+impl<'a> WritableDst<'a> {
+    fn apply_style(&mut self, lvl: Level, style: Style) -> io::Result<()> {
+        let mut spec = ColorSpec::new();
+        match style {
+            Style::LineAndColumn => {}
+            Style::LineNumber => {
+                spec.set_bold(true);
+                spec.set_intense(true);
+                if cfg!(windows) {
+                    spec.set_fg(Some(Color::Cyan));
+                } else {
+                    spec.set_fg(Some(Color::Blue));
+                }
+            }
+            Style::Quotation => {}
+            Style::OldSchoolNoteText | Style::MainHeaderMsg => {
+                spec.set_bold(true);
+                if cfg!(windows) {
+                    spec.set_intense(true).set_fg(Some(Color::White));
+                }
+            }
+            Style::UnderlinePrimary | Style::LabelPrimary => {
+                spec = lvl.color();
+                spec.set_bold(true);
+            }
+            Style::UnderlineSecondary | Style::LabelSecondary => {
+                spec.set_bold(true).set_intense(true);
+                if cfg!(windows) {
+                    spec.set_fg(Some(Color::Cyan));
+                } else {
+                    spec.set_fg(Some(Color::Blue));
+                }
+            }
+            Style::HeaderMsg | Style::NoStyle => {}
+            Style::Level(lvl) => {
+                spec = lvl.color();
+                spec.set_bold(true);
+            }
+            Style::Highlight => {
+                spec.set_bold(true);
+            }
+        }
+        self.set_color(&spec)
+    }
+
+    fn set_color(&mut self, color: &ColorSpec) -> io::Result<()> {
+        match *self {
+            WritableDst::Terminal(ref mut t) => t.set_color(color),
+            WritableDst::Buffered(_, ref mut t) => t.set_color(color),
+            WritableDst::Raw(_) => Ok(()),
+        }
+    }
+
+    fn reset(&mut self) -> io::Result<()> {
+        match *self {
+            WritableDst::Terminal(ref mut t) => t.reset(),
+            WritableDst::Buffered(_, ref mut t) => t.reset(),
+            WritableDst::Raw(_) => Ok(()),
+        }
+    }
+}
+
+impl<'a> Write for WritableDst<'a> {
+    fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
+        match *self {
+            WritableDst::Terminal(ref mut t) => t.write(bytes),
+            WritableDst::Buffered(_, ref mut buf) => buf.write(bytes),
+            WritableDst::Raw(ref mut w) => w.write(bytes),
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        match *self {
+            WritableDst::Terminal(ref mut t) => t.flush(),
+            WritableDst::Buffered(_, ref mut buf) => buf.flush(),
+            WritableDst::Raw(ref mut w) => w.flush(),
+        }
+    }
+}
+
+impl<'a> Drop for WritableDst<'a> {
+    fn drop(&mut self) {
+        match *self {
+            WritableDst::Buffered(ref mut dst, ref mut buf) => {
+                drop(dst.print(buf));
+            }
+            _ => {}
+        }
+    }
+}
diff --git a/common/src/errors/handler.rs b/common/src/errors/handler.rs
deleted file mode 100644
index ecad92fcd858..000000000000
--- a/common/src/errors/handler.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use super::{Diagnostic, DiagnosticBuilder};
-use crate::sync::{Lrc, Send, Sync};
-pub use rustc_errors::{
-    emitter::{Emitter, EmitterWriter},
-    HandlerFlags,
-};
-use rustc_errors::{
-    ColorConfig, DiagnosticBuilder as RustcDiagnosticBuilder, Handler as RustcHandler, Level,
-    SourceMapper,
-};
-
-/// A handler deals with errors.
-pub struct Handler {
-    pub(crate) inner: RustcHandler,
-}
-
-impl Handler {
-    pub fn with_tty_emitter(
-        color_config: ColorConfig,
-        can_emit_warnings: bool,
-        treat_err_as_bug: bool,
-        cm: Option<Lrc<SourceMapper + Send + Sync>>,
-    ) -> Self {
-        RustcHandler::with_tty_emitter(color_config, can_emit_warnings, treat_err_as_bug, cm).into()
-    }
-
-    pub fn with_tty_emitter_and_flags(
-        color_config: ColorConfig,
-        cm: Option<Lrc<SourceMapper + Send + Sync>>,
-        flags: HandlerFlags,
-    ) -> Self {
-        RustcHandler::with_tty_emitter_and_flags(color_config, cm, flags).into()
-    }
-
-    pub fn with_emitter(e: Box<Emitter + Send>, flags: HandlerFlags) -> Self {
-        RustcHandler::with_emitter_and_flags(e, flags).into()
-    }
-
-    pub(crate) fn emit(&self, d: Diagnostic) {
-        RustcDiagnosticBuilder::new_diagnostic(&self.inner, *d.inner).emit()
-    }
-
-    pub fn note<'a, 'b>(&'a self, msg: &'b str) -> DiagnosticBuilder<'a> {
-        DiagnosticBuilder::new(self, Level::Note, msg)
-    }
-
-    pub fn warn<'a, 'b>(&'a self, msg: &'b str) -> DiagnosticBuilder<'a> {
-        self.inner.struct_warn(msg).into()
-    }
-
-    pub fn error<'a, 'b>(&'a self, msg: &'b str) -> DiagnosticBuilder<'a> {
-        DiagnosticBuilder::new(self, Level::Error, msg)
-    }
-
-    pub fn fatal<'a, 'b>(&'a self, msg: &'b str) -> DiagnosticBuilder<'a> {
-        DiagnosticBuilder::new(self, Level::Fatal, msg)
-    }
-
-    pub fn has_errors(&self) -> bool {
-        self.inner.has_errors()
-    }
-
-    pub fn abort_if_errors(&self) {
-        self.inner.abort_if_errors()
-    }
-
-    // pub fn track_diagnostics<F, R>(&self, f: F) -> (R, Vec<Diagnostic>)
-    // where
-    //     F: FnOnce() -> R,
-    // {
-    //     let (result, errors) = self.inner.track_diagnostics(f);
-    //     (result, errors.into_iter().map(From::from).collect())
-    // }
-}
-
-impl From<RustcHandler> for Handler {
-    fn from(inner: RustcHandler) -> Self {
-        Handler { inner }
-    }
-}
diff --git a/common/src/errors/lock.rs b/common/src/errors/lock.rs
new file mode 100644
index 000000000000..0801800c6b2a
--- /dev/null
+++ b/common/src/errors/lock.rs
@@ -0,0 +1,108 @@
+//! Bindings to acquire a global named lock.
+//!
+//! This is intended to be used to synchronize multiple compiler processes to
+//! ensure that we can output complete errors without interleaving on Windows.
+//! Note that this is currently only needed for allowing only one 32-bit MSVC
+//! linker to execute at once on MSVC hosts, so this is only implemented for
+//! `cfg(windows)`. Also note that this may not always be used on Windows,
+//! only when targeting 32-bit MSVC.
+//!
+//! For more information about why this is necessary, see where this is called.
+
+use std::any::Any;
+
+#[cfg(windows)]
+#[allow(nonstandard_style)]
+pub fn acquire_global_lock(name: &str) -> Box<dyn Any> {
+    use std::{ffi::CString, io};
+
+    type LPSECURITY_ATTRIBUTES = *mut u8;
+    type BOOL = i32;
+    type LPCSTR = *const u8;
+    type HANDLE = *mut u8;
+    type DWORD = u32;
+
+    const INFINITE: DWORD = !0;
+    const WAIT_OBJECT_0: DWORD = 0;
+    const WAIT_ABANDONED: DWORD = 0x00000080;
+
+    extern "system" {
+        fn CreateMutexA(
+            lpMutexAttributes: LPSECURITY_ATTRIBUTES,
+            bInitialOwner: BOOL,
+            lpName: LPCSTR,
+        ) -> HANDLE;
+        fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD;
+        fn ReleaseMutex(hMutex: HANDLE) -> BOOL;
+        fn CloseHandle(hObject: HANDLE) -> BOOL;
+    }
+
+    struct Handle(HANDLE);
+
+    impl Drop for Handle {
+        fn drop(&mut self) {
+            unsafe {
+                CloseHandle(self.0);
+            }
+        }
+    }
+
+    struct Guard(Handle);
+
+    impl Drop for Guard {
+        fn drop(&mut self) {
+            unsafe {
+                ReleaseMutex((self.0).0);
+            }
+        }
+    }
+
+    let cname = CString::new(name).unwrap();
+    unsafe {
+        // Create a named mutex, with no security attributes and also not
+        // acquired when we create it.
+        //
+        // This will silently create one if it doesn't already exist, or it'll
+        // open up a handle to one if it already exists.
+        let mutex = CreateMutexA(0 as *mut _, 0, cname.as_ptr() as *const u8);
+        if mutex.is_null() {
+            panic!(
+                "failed to create global mutex named `{}`: {}",
+                name,
+                io::Error::last_os_error()
+            );
+        }
+        let mutex = Handle(mutex);
+
+        // Acquire the lock through `WaitForSingleObject`.
+        //
+        // A return value of `WAIT_OBJECT_0` means we successfully acquired it.
+        //
+        // A return value of `WAIT_ABANDONED` means that the previous holder of
+        // the thread exited without calling `ReleaseMutex`. This can happen,
+        // for example, when the compiler crashes or is interrupted via ctrl-c
+        // or the like. In this case, however, we are still transferred
+        // ownership of the lock so we continue.
+        //
+        // If an error happens.. well... that's surprising!
+        match WaitForSingleObject(mutex.0, INFINITE) {
+            WAIT_OBJECT_0 | WAIT_ABANDONED => {}
+            code => {
+                panic!(
+                    "WaitForSingleObject failed on global mutex named `{}`: {} (ret={:x})",
+                    name,
+                    io::Error::last_os_error(),
+                    code
+                );
+            }
+        }
+
+        // Return a guard which will call `ReleaseMutex` when dropped.
+        Box::new(Guard(mutex))
+    }
+}
+
+#[cfg(not(windows))]
+pub fn acquire_global_lock(_name: &str) -> Box<dyn Any> {
+    Box::new(())
+}
diff --git a/common/src/errors/mod.rs b/common/src/errors/mod.rs
index baf3f0c02189..17b41f6e2e91 100644
--- a/common/src/errors/mod.rs
+++ b/common/src/errors/mod.rs
@@ -1,19 +1,796 @@
-//! Error reporting for the swc project.
-//!
-//! -----
-//!
-//! This module use [`::rustc_errors`][] internally.
-
-pub use self::{diagnostic::*, diagnostic_builder::DiagnosticBuilder, handler::*};
-#[doc(inline)]
-pub use rustc_errors::{
-    ColorConfig,
-    Level::{self, *},
-    SourceMapper, SourceMapperDyn,
+pub use self::{
+    diagnostic::{Diagnostic, DiagnosticId, DiagnosticStyledString, SubDiagnostic},
+    diagnostic_builder::DiagnosticBuilder,
+    emitter::{ColorConfig, EmitterWriter},
 };
+use self::{emitter::Emitter, Level::*};
+use crate::sync::{self, AtomicUsize, Lock, Lrc};
+use fxhash::FxHashSet;
+use rustc_data_structures::stable_hasher::StableHasher;
+use std::{
+    borrow::Cow,
+    cell::Cell,
+    error, fmt, panic,
+    sync::atomic::{AtomicBool, Ordering::SeqCst},
+};
+use syntax_pos::{BytePos, FileLinesResult, FileName, Loc, MultiSpan, Span, NO_EXPANSION};
+use termcolor::{Color, ColorSpec};
 
 mod diagnostic;
 mod diagnostic_builder;
-mod handler;
-#[cfg(test)]
-mod tests;
+pub mod emitter;
+mod lock;
+pub mod registry;
+mod snippet;
+mod styled_buffer;
+
+#[derive(Copy, Clone, Debug, PartialEq, Hash)]
+pub enum Applicability {
+    MachineApplicable,
+    HasPlaceholders,
+    MaybeIncorrect,
+    Unspecified,
+}
+
+#[derive(Clone, Debug, PartialEq, Hash)]
+pub struct CodeSuggestion {
+    /// Each substitute can have multiple variants due to multiple
+    /// applicable suggestions
+    ///
+    /// `foo.bar` might be replaced with `a.b` or `x.y` by replacing
+    /// `foo` and `bar` on their own:
+    ///
+    /// ```ignore
+    /// vec![
+    ///     Substitution {
+    ///         parts: vec![(0..3, "a"), (4..7, "b")],
+    ///     },
+    ///     Substitution {
+    ///         parts: vec![(0..3, "x"), (4..7, "y")],
+    ///     },
+    /// ]
+    /// ```
+    ///
+    /// or by replacing the entire span:
+    ///
+    /// ```ignore
+    /// vec![
+    ///     Substitution {
+    ///         parts: vec![(0..7, "a.b")],
+    ///     },
+    ///     Substitution {
+    ///         parts: vec![(0..7, "x.y")],
+    ///     },
+    /// ]
+    /// ```
+    pub substitutions: Vec<Substitution>,
+    pub msg: String,
+    pub show_code_when_inline: bool,
+    /// Whether or not the suggestion is approximate
+    ///
+    /// Sometimes we may show suggestions with placeholders,
+    /// which are useful for users but not useful for
+    /// tools like rustfix
+    pub applicability: Applicability,
+}
+
+#[derive(Clone, Debug, PartialEq, Hash)]
+/// See the docs on `CodeSuggestion::substitutions`
+pub struct Substitution {
+    pub parts: Vec<SubstitutionPart>,
+}
+
+#[derive(Clone, Debug, PartialEq, Hash)]
+pub struct SubstitutionPart {
+    pub span: Span,
+    pub snippet: String,
+}
+
+pub type SourceMapperDyn = dyn SourceMapper + sync::Send + sync::Sync;
+
+pub trait SourceMapper {
+    fn lookup_char_pos(&self, pos: BytePos) -> Loc;
+    fn span_to_lines(&self, sp: Span) -> FileLinesResult;
+    fn span_to_string(&self, sp: Span) -> String;
+    fn span_to_filename(&self, sp: Span) -> FileName;
+    fn merge_spans(&self, sp_lhs: Span, sp_rhs: Span) -> Option<Span>;
+    fn call_span_if_macro(&self, sp: Span) -> Span;
+    fn doctest_offset_line(&self, file: &FileName, line: usize) -> usize;
+}
+
+impl CodeSuggestion {
+    /// Returns the assembled code suggestions and whether they should be shown
+    /// with an underline.
+    pub fn splice_lines(&self, cm: &SourceMapperDyn) -> Vec<(String, Vec<SubstitutionPart>)> {
+        use syntax_pos::{CharPos, Loc, Pos};
+
+        fn push_trailing(
+            buf: &mut String,
+            line_opt: Option<&Cow<str>>,
+            lo: &Loc,
+            hi_opt: Option<&Loc>,
+        ) {
+            let (lo, hi_opt) = (lo.col.to_usize(), hi_opt.map(|hi| hi.col.to_usize()));
+            if let Some(line) = line_opt {
+                if let Some(lo) = line.char_indices().map(|(i, _)| i).nth(lo) {
+                    let hi_opt = hi_opt.and_then(|hi| line.char_indices().map(|(i, _)| i).nth(hi));
+                    buf.push_str(match hi_opt {
+                        Some(hi) => &line[lo..hi],
+                        None => &line[lo..],
+                    });
+                }
+                if let None = hi_opt {
+                    buf.push('\n');
+                }
+            }
+        }
+
+        assert!(!self.substitutions.is_empty());
+
+        self.substitutions
+            .iter()
+            .cloned()
+            .map(|mut substitution| {
+                // Assumption: all spans are in the same file, and all spans
+                // are disjoint. Sort in ascending order.
+                substitution.parts.sort_by_key(|part| part.span.lo());
+
+                // Find the bounding span.
+                let lo = substitution
+                    .parts
+                    .iter()
+                    .map(|part| part.span.lo())
+                    .min()
+                    .unwrap();
+                let hi = substitution
+                    .parts
+                    .iter()
+                    .map(|part| part.span.hi())
+                    .min()
+                    .unwrap();
+                let bounding_span = Span::new(lo, hi, NO_EXPANSION);
+                let lines = cm.span_to_lines(bounding_span).unwrap();
+                assert!(!lines.lines.is_empty());
+
+                // To build up the result, we do this for each span:
+                // - push the line segment trailing the previous span (at the beginning a
+                //   "phantom" span pointing at the start of the line)
+                // - push lines between the previous and current span (if any)
+                // - if the previous and current span are not on the same line push the line
+                //   segment leading up to the current span
+                // - splice in the span substitution
+                //
+                // Finally push the trailing line segment of the last span
+                let fm = &lines.file;
+                let mut prev_hi = cm.lookup_char_pos(bounding_span.lo());
+                prev_hi.col = CharPos::from_usize(0);
+
+                let mut prev_line = fm.get_line(lines.lines[0].line_index);
+                let mut buf = String::new();
+
+                for part in &substitution.parts {
+                    let cur_lo = cm.lookup_char_pos(part.span.lo());
+                    if prev_hi.line == cur_lo.line {
+                        push_trailing(&mut buf, prev_line.as_ref(), &prev_hi, Some(&cur_lo));
+                    } else {
+                        push_trailing(&mut buf, prev_line.as_ref(), &prev_hi, None);
+                        // push lines between the previous and current span (if any)
+                        for idx in prev_hi.line..(cur_lo.line - 1) {
+                            if let Some(line) = fm.get_line(idx) {
+                                buf.push_str(line.as_ref());
+                                buf.push('\n');
+                            }
+                        }
+                        if let Some(cur_line) = fm.get_line(cur_lo.line - 1) {
+                            buf.push_str(&cur_line[..cur_lo.col.to_usize()]);
+                        }
+                    }
+                    buf.push_str(&part.snippet);
+                    prev_hi = cm.lookup_char_pos(part.span.hi());
+                    prev_line = fm.get_line(prev_hi.line - 1);
+                }
+                // if the replacement already ends with a newline, don't print the next line
+                if !buf.ends_with('\n') {
+                    push_trailing(&mut buf, prev_line.as_ref(), &prev_hi, None);
+                }
+                // remove trailing newlines
+                while buf.ends_with('\n') {
+                    buf.pop();
+                }
+                (buf, substitution.parts)
+            })
+            .collect()
+    }
+}
+
+/// Used as a return value to signify a fatal error occurred. (It is also
+/// used as the argument to panic at the moment, but that will eventually
+/// not be true.)
+#[derive(Copy, Clone, Debug)]
+#[must_use]
+pub struct FatalError;
+
+pub struct FatalErrorMarker;
+
+impl FatalError {
+    pub fn raise(self) -> ! {
+        panic::resume_unwind(Box::new(FatalErrorMarker))
+    }
+}
+
+impl fmt::Display for FatalError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "parser fatal error")
+    }
+}
+
+impl error::Error for FatalError {
+    fn description(&self) -> &str {
+        "The parser has encountered a fatal error"
+    }
+}
+
+/// Signifies that the compiler died with an explicit call to `.bug`
+/// or `.span_bug` rather than a failed assertion, etc.
+#[derive(Copy, Clone, Debug)]
+pub struct ExplicitBug;
+
+impl fmt::Display for ExplicitBug {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "parser internal bug")
+    }
+}
+
+impl error::Error for ExplicitBug {
+    fn description(&self) -> &str {
+        "The parser has encountered an internal bug"
+    }
+}
+
+/// A handler deals with errors; certain errors
+/// (fatal, bug, unimpl) may cause immediate exit,
+/// others log errors for later reporting.
+pub struct Handler {
+    pub flags: HandlerFlags,
+
+    err_count: AtomicUsize,
+    emitter: Lock<Box<dyn Emitter + sync::Send>>,
+    continue_after_error: AtomicBool,
+    delayed_span_bugs: Lock<Vec<Diagnostic>>,
+
+    // This set contains the `DiagnosticId` of all emitted diagnostics to avoid
+    // emitting the same diagnostic with extended help (`--teach`) twice, which
+    // would be uneccessary repetition.
+    taught_diagnostics: Lock<FxHashSet<DiagnosticId>>,
+
+    /// Used to suggest rustc --explain <error code>
+    emitted_diagnostic_codes: Lock<FxHashSet<DiagnosticId>>,
+
+    // This set contains a hash of every diagnostic that has been emitted by
+    // this handler. These hashes is used to avoid emitting the same error
+    // twice.
+    emitted_diagnostics: Lock<FxHashSet<u128>>,
+}
+
+fn default_track_diagnostic(_: &Diagnostic) {}
+
+thread_local!(pub static TRACK_DIAGNOSTICS: Cell<fn(&Diagnostic)> =
+                Cell::new(default_track_diagnostic));
+
+#[derive(Default)]
+pub struct HandlerFlags {
+    /// If false, warning-level lints are suppressed.
+    /// (rustc: see `--allow warnings` and `--cap-lints`)
+    pub can_emit_warnings: bool,
+    /// If true, error-level diagnostics are upgraded to bug-level.
+    /// (rustc: see `-Z treat-err-as-bug`)
+    pub treat_err_as_bug: bool,
+    /// If true, immediately emit diagnostics that would otherwise be buffered.
+    /// (rustc: see `-Z dont-buffer-diagnostics` and `-Z treat-err-as-bug`)
+    pub dont_buffer_diagnostics: bool,
+    /// If true, immediately print bugs registered with `delay_span_bug`.
+    /// (rustc: see `-Z report-delayed-bugs`)
+    pub report_delayed_bugs: bool,
+    /// show macro backtraces even for non-local macros.
+    /// (rustc: see `-Z external-macro-backtrace`)
+    pub external_macro_backtrace: bool,
+}
+
+impl Drop for Handler {
+    fn drop(&mut self) {
+        if self.err_count() == 0 {
+            let mut bugs = self.delayed_span_bugs.borrow_mut();
+            let has_bugs = !bugs.is_empty();
+            for bug in bugs.drain(..) {
+                DiagnosticBuilder::new_diagnostic(self, bug).emit();
+            }
+            if has_bugs {
+                panic!("no errors encountered even though `delay_span_bug` issued");
+            }
+        }
+    }
+}
+
+impl Handler {
+    pub fn with_tty_emitter(
+        color_config: ColorConfig,
+        can_emit_warnings: bool,
+        treat_err_as_bug: bool,
+        cm: Option<Lrc<SourceMapperDyn>>,
+    ) -> Handler {
+        Handler::with_tty_emitter_and_flags(
+            color_config,
+            cm,
+            HandlerFlags {
+                can_emit_warnings,
+                treat_err_as_bug,
+                ..Default::default()
+            },
+        )
+    }
+
+    pub fn with_tty_emitter_and_flags(
+        color_config: ColorConfig,
+        cm: Option<Lrc<SourceMapperDyn>>,
+        flags: HandlerFlags,
+    ) -> Handler {
+        let emitter = Box::new(EmitterWriter::stderr(color_config, cm, false, false));
+        Handler::with_emitter_and_flags(emitter, flags)
+    }
+
+    pub fn with_emitter(
+        can_emit_warnings: bool,
+        treat_err_as_bug: bool,
+        e: Box<dyn Emitter + sync::Send>,
+    ) -> Handler {
+        Handler::with_emitter_and_flags(
+            e,
+            HandlerFlags {
+                can_emit_warnings,
+                treat_err_as_bug,
+                ..Default::default()
+            },
+        )
+    }
+
+    pub fn with_emitter_and_flags(
+        e: Box<dyn Emitter + sync::Send>,
+        flags: HandlerFlags,
+    ) -> Handler {
+        Handler {
+            flags,
+            err_count: AtomicUsize::new(0),
+            emitter: Lock::new(e),
+            continue_after_error: AtomicBool::new(true),
+            delayed_span_bugs: Lock::new(Vec::new()),
+            taught_diagnostics: Default::default(),
+            emitted_diagnostic_codes: Default::default(),
+            emitted_diagnostics: Default::default(),
+        }
+    }
+
+    pub fn set_continue_after_error(&self, continue_after_error: bool) {
+        self.continue_after_error
+            .store(continue_after_error, SeqCst);
+    }
+
+    /// Resets the diagnostic error count as well as the cached emitted
+    /// diagnostics.
+    ///
+    /// NOTE: DO NOT call this function from rustc. It is only meant to be
+    /// called from external tools that want to reuse a `Parser` cleaning
+    /// the previously emitted diagnostics as well as the overall count of
+    /// emitted error diagnostics.
+    pub fn reset_err_count(&self) {
+        // actually frees the underlying memory (which `clear` would not do)
+        *self.emitted_diagnostics.borrow_mut() = Default::default();
+        self.err_count.store(0, SeqCst);
+    }
+
+    pub fn struct_dummy<'a>(&'a self) -> DiagnosticBuilder<'a> {
+        DiagnosticBuilder::new(self, Level::Cancelled, "")
+    }
+
+    pub fn struct_span_warn<'a, S: Into<MultiSpan>>(
+        &'a self,
+        sp: S,
+        msg: &str,
+    ) -> DiagnosticBuilder<'a> {
+        let mut result = DiagnosticBuilder::new(self, Level::Warning, msg);
+        result.set_span(sp);
+        if !self.flags.can_emit_warnings {
+            result.cancel();
+        }
+        result
+    }
+    pub fn struct_span_warn_with_code<'a, S: Into<MultiSpan>>(
+        &'a self,
+        sp: S,
+        msg: &str,
+        code: DiagnosticId,
+    ) -> DiagnosticBuilder<'a> {
+        let mut result = DiagnosticBuilder::new(self, Level::Warning, msg);
+        result.set_span(sp);
+        result.code(code);
+        if !self.flags.can_emit_warnings {
+            result.cancel();
+        }
+        result
+    }
+    pub fn struct_warn<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> {
+        let mut result = DiagnosticBuilder::new(self, Level::Warning, msg);
+        if !self.flags.can_emit_warnings {
+            result.cancel();
+        }
+        result
+    }
+    pub fn struct_span_err<'a, S: Into<MultiSpan>>(
+        &'a self,
+        sp: S,
+        msg: &str,
+    ) -> DiagnosticBuilder<'a> {
+        let mut result = DiagnosticBuilder::new(self, Level::Error, msg);
+        result.set_span(sp);
+        result
+    }
+    pub fn struct_span_err_with_code<'a, S: Into<MultiSpan>>(
+        &'a self,
+        sp: S,
+        msg: &str,
+        code: DiagnosticId,
+    ) -> DiagnosticBuilder<'a> {
+        let mut result = DiagnosticBuilder::new(self, Level::Error, msg);
+        result.set_span(sp);
+        result.code(code);
+        result
+    }
+    // FIXME: This method should be removed (every error should have an associated
+    // error code).
+    pub fn struct_err<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> {
+        DiagnosticBuilder::new(self, Level::Error, msg)
+    }
+    pub fn struct_err_with_code<'a>(
+        &'a self,
+        msg: &str,
+        code: DiagnosticId,
+    ) -> DiagnosticBuilder<'a> {
+        let mut result = DiagnosticBuilder::new(self, Level::Error, msg);
+        result.code(code);
+        result
+    }
+    pub fn struct_span_fatal<'a, S: Into<MultiSpan>>(
+        &'a self,
+        sp: S,
+        msg: &str,
+    ) -> DiagnosticBuilder<'a> {
+        let mut result = DiagnosticBuilder::new(self, Level::Fatal, msg);
+        result.set_span(sp);
+        result
+    }
+    pub fn struct_span_fatal_with_code<'a, S: Into<MultiSpan>>(
+        &'a self,
+        sp: S,
+        msg: &str,
+        code: DiagnosticId,
+    ) -> DiagnosticBuilder<'a> {
+        let mut result = DiagnosticBuilder::new(self, Level::Fatal, msg);
+        result.set_span(sp);
+        result.code(code);
+        result
+    }
+    pub fn struct_fatal<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> {
+        DiagnosticBuilder::new(self, Level::Fatal, msg)
+    }
+
+    pub fn cancel(&self, err: &mut DiagnosticBuilder) {
+        err.cancel();
+    }
+
+    fn panic_if_treat_err_as_bug(&self) {
+        if self.flags.treat_err_as_bug {
+            panic!("encountered error with `-Z treat_err_as_bug");
+        }
+    }
+
+    pub fn span_fatal<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> FatalError {
+        self.emit(&sp.into(), msg, Fatal);
+        FatalError
+    }
+    pub fn span_fatal_with_code<S: Into<MultiSpan>>(
+        &self,
+        sp: S,
+        msg: &str,
+        code: DiagnosticId,
+    ) -> FatalError {
+        self.emit_with_code(&sp.into(), msg, code, Fatal);
+        FatalError
+    }
+    pub fn span_err<S: Into<MultiSpan>>(&self, sp: S, msg: &str) {
+        self.emit(&sp.into(), msg, Error);
+    }
+    pub fn mut_span_err<'a, S: Into<MultiSpan>>(
+        &'a self,
+        sp: S,
+        msg: &str,
+    ) -> DiagnosticBuilder<'a> {
+        let mut result = DiagnosticBuilder::new(self, Level::Error, msg);
+        result.set_span(sp);
+        result
+    }
+    pub fn span_err_with_code<S: Into<MultiSpan>>(&self, sp: S, msg: &str, code: DiagnosticId) {
+        self.emit_with_code(&sp.into(), msg, code, Error);
+    }
+    pub fn span_warn<S: Into<MultiSpan>>(&self, sp: S, msg: &str) {
+        self.emit(&sp.into(), msg, Warning);
+    }
+    pub fn span_warn_with_code<S: Into<MultiSpan>>(&self, sp: S, msg: &str, code: DiagnosticId) {
+        self.emit_with_code(&sp.into(), msg, code, Warning);
+    }
+    pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> ! {
+        self.emit(&sp.into(), msg, Bug);
+        panic!(ExplicitBug);
+    }
+    pub fn delay_span_bug<S: Into<MultiSpan>>(&self, sp: S, msg: &str) {
+        if self.flags.treat_err_as_bug {
+            // FIXME: don't abort here if report_delayed_bugs is off
+            self.span_bug(sp, msg);
+        }
+        let mut diagnostic = Diagnostic::new(Level::Bug, msg);
+        diagnostic.set_span(sp.into());
+        self.delay_as_bug(diagnostic);
+    }
+    fn delay_as_bug(&self, diagnostic: Diagnostic) {
+        if self.flags.report_delayed_bugs {
+            DiagnosticBuilder::new_diagnostic(self, diagnostic.clone()).emit();
+        }
+        self.delayed_span_bugs.borrow_mut().push(diagnostic);
+    }
+    pub fn span_bug_no_panic<S: Into<MultiSpan>>(&self, sp: S, msg: &str) {
+        self.emit(&sp.into(), msg, Bug);
+    }
+    pub fn span_note_without_error<S: Into<MultiSpan>>(&self, sp: S, msg: &str) {
+        self.emit(&sp.into(), msg, Note);
+    }
+    pub fn span_note_diag<'a>(&'a self, sp: Span, msg: &str) -> DiagnosticBuilder<'a> {
+        let mut db = DiagnosticBuilder::new(self, Note, msg);
+        db.set_span(sp);
+        db
+    }
+    pub fn span_unimpl<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> ! {
+        self.span_bug(sp, &format!("unimplemented {}", msg));
+    }
+    pub fn failure(&self, msg: &str) {
+        DiagnosticBuilder::new(self, FailureNote, msg).emit()
+    }
+    pub fn fatal(&self, msg: &str) -> FatalError {
+        if self.flags.treat_err_as_bug {
+            self.bug(msg);
+        }
+        DiagnosticBuilder::new(self, Fatal, msg).emit();
+        FatalError
+    }
+    pub fn err(&self, msg: &str) {
+        if self.flags.treat_err_as_bug {
+            self.bug(msg);
+        }
+        let mut db = DiagnosticBuilder::new(self, Error, msg);
+        db.emit();
+    }
+    pub fn warn(&self, msg: &str) {
+        let mut db = DiagnosticBuilder::new(self, Warning, msg);
+        db.emit();
+    }
+    pub fn note_without_error(&self, msg: &str) {
+        let mut db = DiagnosticBuilder::new(self, Note, msg);
+        db.emit();
+    }
+    pub fn bug(&self, msg: &str) -> ! {
+        let mut db = DiagnosticBuilder::new(self, Bug, msg);
+        db.emit();
+        panic!(ExplicitBug);
+    }
+    pub fn unimpl(&self, msg: &str) -> ! {
+        self.bug(&format!("unimplemented {}", msg));
+    }
+
+    fn bump_err_count(&self) {
+        self.panic_if_treat_err_as_bug();
+        self.err_count.fetch_add(1, SeqCst);
+    }
+
+    pub fn err_count(&self) -> usize {
+        self.err_count.load(SeqCst)
+    }
+
+    pub fn has_errors(&self) -> bool {
+        self.err_count() > 0
+    }
+
+    pub fn print_error_count(&self) {
+        let s = match self.err_count() {
+            0 => return,
+            1 => "aborting due to previous error".to_string(),
+            _ => format!("aborting due to {} previous errors", self.err_count()),
+        };
+
+        let _ = self.fatal(&s);
+
+        let can_show_explain = self.emitter.borrow().should_show_explain();
+        let are_there_diagnostics = !self.emitted_diagnostic_codes.borrow().is_empty();
+        if can_show_explain && are_there_diagnostics {
+            let mut error_codes = self
+                .emitted_diagnostic_codes
+                .borrow()
+                .iter()
+                .filter_map(|x| match *x {
+                    DiagnosticId::Error(ref s) => Some(s.clone()),
+                    _ => None,
+                })
+                .collect::<Vec<_>>();
+            if !error_codes.is_empty() {
+                error_codes.sort();
+                if error_codes.len() > 1 {
+                    let limit = if error_codes.len() > 9 {
+                        9
+                    } else {
+                        error_codes.len()
+                    };
+                    self.failure(&format!(
+                        "Some errors occurred: {}{}",
+                        error_codes[..limit].join(", "),
+                        if error_codes.len() > 9 { "..." } else { "." }
+                    ));
+                    self.failure(&format!(
+                        "For more information about an error, try `rustc --explain {}`.",
+                        &error_codes[0]
+                    ));
+                } else {
+                    self.failure(&format!(
+                        "For more information about this error, try `rustc --explain {}`.",
+                        &error_codes[0]
+                    ));
+                }
+            }
+        }
+    }
+
+    pub fn abort_if_errors(&self) {
+        if self.err_count() == 0 {
+            return;
+        }
+        FatalError.raise();
+    }
+    pub fn emit(&self, msp: &MultiSpan, msg: &str, lvl: Level) {
+        if lvl == Warning && !self.flags.can_emit_warnings {
+            return;
+        }
+        let mut db = DiagnosticBuilder::new(self, lvl, msg);
+        db.set_span(msp.clone());
+        db.emit();
+        if !self.continue_after_error.load(SeqCst) {
+            self.abort_if_errors();
+        }
+    }
+    pub fn emit_with_code(&self, msp: &MultiSpan, msg: &str, code: DiagnosticId, lvl: Level) {
+        if lvl == Warning && !self.flags.can_emit_warnings {
+            return;
+        }
+        let mut db = DiagnosticBuilder::new_with_code(self, lvl, Some(code), msg);
+        db.set_span(msp.clone());
+        db.emit();
+        if !self.continue_after_error.load(SeqCst) {
+            self.abort_if_errors();
+        }
+    }
+
+    /// `true` if we haven't taught a diagnostic with this code already.
+    /// The caller must then teach the user about such a diagnostic.
+    ///
+    /// Used to suppress emitting the same error multiple times with extended
+    /// explanation when calling `-Zteach`.
+    pub fn must_teach(&self, code: &DiagnosticId) -> bool {
+        self.taught_diagnostics.borrow_mut().insert(code.clone())
+    }
+
+    pub fn force_print_db(&self, mut db: DiagnosticBuilder) {
+        self.emitter.borrow_mut().emit(&db);
+        db.cancel();
+    }
+
+    fn emit_db(&self, db: &DiagnosticBuilder) {
+        let diagnostic = &**db;
+
+        TRACK_DIAGNOSTICS.with(|track_diagnostics| {
+            track_diagnostics.get()(diagnostic);
+        });
+
+        if let Some(ref code) = diagnostic.code {
+            self.emitted_diagnostic_codes
+                .borrow_mut()
+                .insert(code.clone());
+        }
+
+        let diagnostic_hash = {
+            use std::hash::Hash;
+            let mut hasher = StableHasher::new();
+            diagnostic.hash(&mut hasher);
+            hasher.finish()
+        };
+
+        // Only emit the diagnostic if we haven't already emitted an equivalent
+        // one:
+        if self
+            .emitted_diagnostics
+            .borrow_mut()
+            .insert(diagnostic_hash)
+        {
+            self.emitter.borrow_mut().emit(db);
+            if db.is_error() {
+                self.bump_err_count();
+            }
+        }
+    }
+}
+
+#[derive(Copy, PartialEq, Clone, Hash, Debug)]
+pub enum Level {
+    Bug,
+    Fatal,
+    // An error which while not immediately fatal, should stop the compiler
+    // progressing beyond the current phase.
+    PhaseFatal,
+    Error,
+    Warning,
+    Note,
+    Help,
+    Cancelled,
+    FailureNote,
+}
+
+impl fmt::Display for Level {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.to_str().fmt(f)
+    }
+}
+
+impl Level {
+    fn color(self) -> ColorSpec {
+        let mut spec = ColorSpec::new();
+        match self {
+            Bug | Fatal | PhaseFatal | Error => {
+                spec.set_fg(Some(Color::Red)).set_intense(true);
+            }
+            Warning => {
+                spec.set_fg(Some(Color::Yellow)).set_intense(cfg!(windows));
+            }
+            Note => {
+                spec.set_fg(Some(Color::Green)).set_intense(true);
+            }
+            Help => {
+                spec.set_fg(Some(Color::Cyan)).set_intense(true);
+            }
+            FailureNote => {}
+            Cancelled => unreachable!(),
+        }
+        spec
+    }
+
+    pub fn to_str(self) -> &'static str {
+        match self {
+            Bug => "error: internal compiler error",
+            Fatal | PhaseFatal | Error => "error",
+            Warning => "warning",
+            Note => "note",
+            Help => "help",
+            FailureNote => "",
+            Cancelled => panic!("Shouldn't call on cancelled error"),
+        }
+    }
+
+    pub fn is_failure_note(&self) -> bool {
+        match *self {
+            FailureNote => true,
+            _ => false,
+        }
+    }
+}
diff --git a/common/src/errors/registry.rs b/common/src/errors/registry.rs
new file mode 100644
index 000000000000..aa86de21a09c
--- /dev/null
+++ b/common/src/errors/registry.rs
@@ -0,0 +1,18 @@
+use fxhash::FxHashMap;
+
+#[derive(Clone)]
+pub struct Registry {
+    descriptions: FxHashMap<&'static str, &'static str>,
+}
+
+impl Registry {
+    pub fn new(descriptions: &[(&'static str, &'static str)]) -> Registry {
+        Registry {
+            descriptions: descriptions.iter().cloned().collect(),
+        }
+    }
+
+    pub fn find_description(&self, code: &str) -> Option<&'static str> {
+        self.descriptions.get(code).cloned()
+    }
+}
diff --git a/common/src/errors/snippet.rs b/common/src/errors/snippet.rs
new file mode 100644
index 000000000000..95c030a792a0
--- /dev/null
+++ b/common/src/errors/snippet.rs
@@ -0,0 +1,186 @@
+// Code for annotating snippets.
+
+use super::Level;
+
+#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub struct Line {
+    pub line_index: usize,
+    pub annotations: Vec<Annotation>,
+}
+
+#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub struct MultilineAnnotation {
+    pub depth: usize,
+    pub line_start: usize,
+    pub line_end: usize,
+    pub start_col: usize,
+    pub end_col: usize,
+    pub is_primary: bool,
+    pub label: Option<String>,
+}
+
+impl MultilineAnnotation {
+    pub fn increase_depth(&mut self) {
+        self.depth += 1;
+    }
+
+    pub fn as_start(&self) -> Annotation {
+        Annotation {
+            start_col: self.start_col,
+            end_col: self.start_col + 1,
+            is_primary: self.is_primary,
+            label: None,
+            annotation_type: AnnotationType::MultilineStart(self.depth),
+        }
+    }
+
+    pub fn as_end(&self) -> Annotation {
+        Annotation {
+            start_col: self.end_col.saturating_sub(1),
+            end_col: self.end_col,
+            is_primary: self.is_primary,
+            label: self.label.clone(),
+            annotation_type: AnnotationType::MultilineEnd(self.depth),
+        }
+    }
+
+    pub fn as_line(&self) -> Annotation {
+        Annotation {
+            start_col: 0,
+            end_col: 0,
+            is_primary: self.is_primary,
+            label: None,
+            annotation_type: AnnotationType::MultilineLine(self.depth),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub enum AnnotationType {
+    /// Annotation under a single line of code
+    Singleline,
+
+    /// Annotation enclosing the first and last character of a multiline span
+    Multiline(MultilineAnnotation),
+
+    // The Multiline type above is replaced with the following three in order
+    // to reuse the current label drawing code.
+    //
+    // Each of these corresponds to one part of the following diagram:
+    //
+    //     x |   foo(1 + bar(x,
+    //       |  _________^              < MultilineStart
+    //     x | |             y),        < MultilineLine
+    //       | |______________^ label   < MultilineEnd
+    //     x |       z);
+    /// Annotation marking the first character of a fully shown multiline span
+    MultilineStart(usize),
+    /// Annotation marking the last character of a fully shown multiline span
+    MultilineEnd(usize),
+    /// Line at the left enclosing the lines of a fully shown multiline span
+    // Just a placeholder for the drawing algorithm, to know that it shouldn't skip the first 4
+    // and last 2 lines of code. The actual line is drawn in `emit_message_default` and not in
+    // `draw_multiline_line`.
+    MultilineLine(usize),
+}
+
+#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub struct Annotation {
+    /// Start column, 0-based indexing -- counting *characters*, not
+    /// utf-8 bytes. Note that it is important that this field goes
+    /// first, so that when we sort, we sort orderings by start
+    /// column.
+    pub start_col: usize,
+
+    /// End column within the line (exclusive)
+    pub end_col: usize,
+
+    /// Is this annotation derived from primary span
+    pub is_primary: bool,
+
+    /// Optional label to display adjacent to the annotation.
+    pub label: Option<String>,
+
+    /// Is this a single line, multiline or multiline span minimized down to a
+    /// smaller span.
+    pub annotation_type: AnnotationType,
+}
+
+impl Annotation {
+    /// Whether this annotation is a vertical line placeholder.
+    pub fn is_line(&self) -> bool {
+        if let AnnotationType::MultilineLine(_) = self.annotation_type {
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn is_multiline(&self) -> bool {
+        match self.annotation_type {
+            AnnotationType::Multiline(_)
+            | AnnotationType::MultilineStart(_)
+            | AnnotationType::MultilineLine(_)
+            | AnnotationType::MultilineEnd(_) => true,
+            _ => false,
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        // Account for usize underflows
+        if self.end_col > self.start_col {
+            self.end_col - self.start_col
+        } else {
+            self.start_col - self.end_col
+        }
+    }
+
+    pub fn has_label(&self) -> bool {
+        if let Some(ref label) = self.label {
+            // Consider labels with no text as effectively not being there
+            // to avoid weird output with unnecessary vertical lines, like:
+            //
+            //     X | fn foo(x: u32) {
+            //       | -------^------
+            //       | |      |
+            //       | |
+            //       |
+            //
+            // Note that this would be the complete output users would see.
+            label.len() > 0
+        } else {
+            false
+        }
+    }
+
+    pub fn takes_space(&self) -> bool {
+        // Multiline annotations always have to keep vertical space.
+        match self.annotation_type {
+            AnnotationType::MultilineStart(_) | AnnotationType::MultilineEnd(_) => true,
+            _ => false,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct StyledString {
+    pub text: String,
+    pub style: Style,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Hash)]
+pub enum Style {
+    MainHeaderMsg,
+    HeaderMsg,
+    LineAndColumn,
+    LineNumber,
+    Quotation,
+    UnderlinePrimary,
+    UnderlineSecondary,
+    LabelPrimary,
+    LabelSecondary,
+    OldSchoolNoteText,
+    NoStyle,
+    Level(Level),
+    Highlight,
+}
diff --git a/common/src/errors/styled_buffer.rs b/common/src/errors/styled_buffer.rs
new file mode 100644
index 000000000000..0cfd248cb2d1
--- /dev/null
+++ b/common/src/errors/styled_buffer.rs
@@ -0,0 +1,160 @@
+// Code for creating styled buffers
+
+use super::snippet::{Style, StyledString};
+
+#[derive(Debug)]
+pub struct StyledBuffer {
+    text: Vec<Vec<char>>,
+    styles: Vec<Vec<Style>>,
+}
+
+impl StyledBuffer {
+    pub fn new() -> StyledBuffer {
+        StyledBuffer {
+            text: vec![],
+            styles: vec![],
+        }
+    }
+
+    fn replace_tabs(&mut self) {
+        for (line_pos, line) in self.text.iter_mut().enumerate() {
+            let mut tab_pos = vec![];
+            for (pos, c) in line.iter().enumerate() {
+                if *c == '\t' {
+                    tab_pos.push(pos);
+                }
+            }
+            // start with the tabs at the end of the line to replace them with 4 space chars
+            for pos in tab_pos.iter().rev() {
+                assert_eq!(line.remove(*pos), '\t');
+                // fix the position of the style to match up after replacing the tabs
+                let s = self.styles[line_pos].remove(*pos);
+                for _ in 0..4 {
+                    line.insert(*pos, ' ');
+                    self.styles[line_pos].insert(*pos, s);
+                }
+            }
+        }
+    }
+
+    pub fn render(&mut self) -> Vec<Vec<StyledString>> {
+        let mut output: Vec<Vec<StyledString>> = vec![];
+        let mut styled_vec: Vec<StyledString> = vec![];
+
+        // before we render, replace tabs with spaces
+        self.replace_tabs();
+
+        for (row, row_style) in self.text.iter().zip(&self.styles) {
+            let mut current_style = Style::NoStyle;
+            let mut current_text = String::new();
+
+            for (&c, &s) in row.iter().zip(row_style) {
+                if s != current_style {
+                    if !current_text.is_empty() {
+                        styled_vec.push(StyledString {
+                            text: current_text,
+                            style: current_style,
+                        });
+                    }
+                    current_style = s;
+                    current_text = String::new();
+                }
+                current_text.push(c);
+            }
+            if !current_text.is_empty() {
+                styled_vec.push(StyledString {
+                    text: current_text,
+                    style: current_style,
+                });
+            }
+
+            // We're done with the row, push and keep going
+            output.push(styled_vec);
+
+            styled_vec = vec![];
+        }
+
+        output
+    }
+
+    fn ensure_lines(&mut self, line: usize) {
+        while line >= self.text.len() {
+            self.text.push(vec![]);
+            self.styles.push(vec![]);
+        }
+    }
+
+    pub fn putc(&mut self, line: usize, col: usize, chr: char, style: Style) {
+        self.ensure_lines(line);
+        if col < self.text[line].len() {
+            self.text[line][col] = chr;
+            self.styles[line][col] = style;
+        } else {
+            let mut i = self.text[line].len();
+            while i < col {
+                self.text[line].push(' ');
+                self.styles[line].push(Style::NoStyle);
+                i += 1;
+            }
+            self.text[line].push(chr);
+            self.styles[line].push(style);
+        }
+    }
+
+    pub fn puts(&mut self, line: usize, col: usize, string: &str, style: Style) {
+        let mut n = col;
+        for c in string.chars() {
+            self.putc(line, n, c, style);
+            n += 1;
+        }
+    }
+
+    pub fn prepend(&mut self, line: usize, string: &str, style: Style) {
+        self.ensure_lines(line);
+        let string_len = string.len();
+
+        // Push the old content over to make room for new content
+        for _ in 0..string_len {
+            self.styles[line].insert(0, Style::NoStyle);
+            self.text[line].insert(0, ' ');
+        }
+
+        self.puts(line, 0, string, style);
+    }
+
+    pub fn append(&mut self, line: usize, string: &str, style: Style) {
+        if line >= self.text.len() {
+            self.puts(line, 0, string, style);
+        } else {
+            let col = self.text[line].len();
+            self.puts(line, col, string, style);
+        }
+    }
+
+    pub fn num_lines(&self) -> usize {
+        self.text.len()
+    }
+
+    pub fn set_style_range(
+        &mut self,
+        line: usize,
+        col_start: usize,
+        col_end: usize,
+        style: Style,
+        overwrite: bool,
+    ) {
+        for col in col_start..col_end {
+            self.set_style(line, col, style, overwrite);
+        }
+    }
+
+    pub fn set_style(&mut self, line: usize, col: usize, style: Style, overwrite: bool) {
+        if let Some(ref mut line) = self.styles.get_mut(line) {
+            if let Some(s) = line.get_mut(col) {
+                if *s == Style::NoStyle || *s == Style::Quotation || overwrite {
+                    *s = style;
+                }
+            }
+        }
+    }
+}
diff --git a/common/src/fold/and_then.rs b/common/src/fold/and_then.rs
index 402f07e54bb5..2be1ef58fa38 100644
--- a/common/src/fold/and_then.rs
+++ b/common/src/fold/and_then.rs
@@ -1,5 +1,5 @@
 use super::{Fold, FoldWith, Visit, VisitWith};
-use syntax::util::move_map::MoveMap;
+use crate::util::move_map::MoveMap;
 
 #[macro_export]
 macro_rules! chain {
diff --git a/common/src/fold/mod.rs b/common/src/fold/mod.rs
index fdc4f14c3998..32a80821c450 100644
--- a/common/src/fold/mod.rs
+++ b/common/src/fold/mod.rs
@@ -168,16 +168,6 @@ where
     }
 }
 
-impl<F> FoldWith<F> for ! {
-    fn fold_children(self, _: &mut F) -> Self {
-        self
-    }
-}
-
-impl<F> VisitWith<F> for ! {
-    fn visit_children(&self, _: &mut F) {}
-}
-
 impl<T, F> FoldWith<F> for Box<T>
 where
     F: Fold<T>,
diff --git a/common/src/lib.rs b/common/src/lib.rs
index 1059296025b2..1f3196399fcf 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -1,28 +1,32 @@
-#![feature(box_syntax)]
-#![feature(range_contains)]
-#![feature(try_trait)]
-#![feature(never_type)]
-#![feature(core_intrinsics)]
-#![feature(specialization)]
+#![cfg_attr(feature = "fold", feature(specialization))]
+
 extern crate ast_node;
+extern crate atty;
 extern crate either;
-extern crate rustc_data_structures;
-extern crate rustc_errors;
+extern crate fxhash;
+extern crate owning_ref;
+extern crate parking_lot;
+extern crate rayon;
+extern crate rayon_core;
 extern crate string_cache;
-extern crate syntax;
-extern crate syntax_pos;
+extern crate termcolor;
+extern crate unicode_width;
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate scoped_tls;
+#[macro_use]
+extern crate cfg_if;
 
+#[cfg(feature = "fold")]
+pub use self::fold::{Fold, FoldWith, Visit, VisitWith};
 pub use self::{
     errors::{SourceMapper, SourceMapperDyn},
-    fold::{Fold, FoldWith, Visit, VisitWith},
     pos::*,
+    source_map::{FileLines, FileLoader, FileName, FilePathMapping, SourceMap, SpanSnippetError},
 };
 pub use ast_node::{ast_node, Fold, FromVariant, Spanned};
-pub use rustc_data_structures::sync;
 use std::fmt::Debug;
-pub use syntax::source_map::{
-    FileLines, FileLoader, FileName, FilePathMapping, SourceMap, SpanSnippetError,
-};
 
 /// A marker trait for ast nodes.
 pub trait AstNode: Debug + PartialEq + Clone + Spanned {}
@@ -30,7 +34,12 @@ pub trait AstNode: Debug + PartialEq + Clone + Spanned {}
 impl<N: Debug + PartialEq + Clone + Spanned> AstNode for N {}
 
 pub mod errors;
+#[cfg(feature = "fold")]
 pub mod fold;
 pub mod macros;
 mod pos;
+mod rustc_data_structures;
+mod source_map;
+pub mod sync;
+mod syntax_pos;
 pub mod util;
diff --git a/common/src/pos.rs b/common/src/pos.rs
index f1dfd81d28f9..75083821c66a 100644
--- a/common/src/pos.rs
+++ b/common/src/pos.rs
@@ -1,7 +1,8 @@
+#[cfg(feature = "fold")]
 use fold::{FoldWith, VisitWith};
 pub use syntax_pos::{
-    hygiene, BytePos, ExpnFormat, ExpnInfo, FileName, Globals, Mark, MultiSpan, SourceFile, Span,
-    SpanData, SyntaxContext, DUMMY_SP, GLOBALS, NO_EXPANSION,
+    hygiene, BytePos, ExpnInfo, FileName, Globals, Mark, MultiSpan, SourceFile, Span, SpanData,
+    SyntaxContext, DUMMY_SP, GLOBALS, NO_EXPANSION,
 };
 
 ///
@@ -70,6 +71,7 @@ where
     }
 }
 
+#[cfg(feature = "fold")]
 impl<F> FoldWith<F> for Span {
     /// No op as span does not have any child.
     fn fold_children(self, _: &mut F) -> Span {
@@ -77,6 +79,7 @@ impl<F> FoldWith<F> for Span {
     }
 }
 
+#[cfg(feature = "fold")]
 impl<F> VisitWith<F> for Span {
     /// No op as span does not have any child.
     fn visit_children(&self, _: &mut F) {}
diff --git a/common/src/rustc_data_structures/mod.rs b/common/src/rustc_data_structures/mod.rs
new file mode 100644
index 000000000000..7976d3b3d90f
--- /dev/null
+++ b/common/src/rustc_data_structures/mod.rs
@@ -0,0 +1,4 @@
+pub use crate::sync;
+pub extern crate fxhash as fx;
+pub mod sip128;
+pub mod stable_hasher;
diff --git a/common/src/rustc_data_structures/sip128.rs b/common/src/rustc_data_structures/sip128.rs
new file mode 100644
index 000000000000..207d7b990bdb
--- /dev/null
+++ b/common/src/rustc_data_structures/sip128.rs
@@ -0,0 +1,723 @@
+//! This is a copy of `core::hash::sip` adapted to providing 128 bit hashes.
+
+use std::{cmp, hash::Hasher, mem, ptr, slice};
+
+#[derive(Debug, Clone)]
+pub struct SipHasher128 {
+    k0: u64,
+    k1: u64,
+    length: usize, // how many bytes we've processed
+    state: State,  // hash State
+    tail: u64,     // unprocessed bytes le
+    ntail: usize,  // how many bytes in tail are valid
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+struct State {
+    // v0, v2 and v1, v3 show up in pairs in the algorithm,
+    // and simd implementations of SipHash will use vectors
+    // of v02 and v13. By placing them in this order in the struct,
+    // the compiler can pick up on just a few simd optimizations by itself.
+    v0: u64,
+    v2: u64,
+    v1: u64,
+    v3: u64,
+}
+
+macro_rules! compress {
+    ($state:expr) => {{
+        compress!($state.v0, $state.v1, $state.v2, $state.v3)
+    }};
+    ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => {{
+        $v0 = $v0.wrapping_add($v1);
+        $v1 = $v1.rotate_left(13);
+        $v1 ^= $v0;
+        $v0 = $v0.rotate_left(32);
+        $v2 = $v2.wrapping_add($v3);
+        $v3 = $v3.rotate_left(16);
+        $v3 ^= $v2;
+        $v0 = $v0.wrapping_add($v3);
+        $v3 = $v3.rotate_left(21);
+        $v3 ^= $v0;
+        $v2 = $v2.wrapping_add($v1);
+        $v1 = $v1.rotate_left(17);
+        $v1 ^= $v2;
+        $v2 = $v2.rotate_left(32);
+    }};
+}
+
+/// Load an integer of the desired type from a byte stream, in LE order. Uses
+/// `copy_nonoverlapping` to let the compiler generate the most efficient way
+/// to load it from a possibly unaligned address.
+///
+/// Unsafe because: unchecked indexing at i..i+size_of(int_ty)
+macro_rules! load_int_le {
+    ($buf:expr, $i:expr, $int_ty:ident) => {{
+        debug_assert!($i + mem::size_of::<$int_ty>() <= $buf.len());
+        let mut data = 0 as $int_ty;
+        ptr::copy_nonoverlapping(
+            $buf.get_unchecked($i),
+            &mut data as *mut _ as *mut u8,
+            mem::size_of::<$int_ty>(),
+        );
+        data.to_le()
+    }};
+}
+
+/// Load an u64 using up to 7 bytes of a byte slice.
+///
+/// Unsafe because: unchecked indexing at start..start+len
+#[inline]
+unsafe fn u8to64_le(buf: &[u8], start: usize, len: usize) -> u64 {
+    debug_assert!(len < 8);
+    let mut i = 0; // current byte index (from LSB) in the output u64
+    let mut out = 0;
+    if i + 3 < len {
+        out = load_int_le!(buf, start + i, u32) as u64;
+        i += 4;
+    }
+    if i + 1 < len {
+        out |= (load_int_le!(buf, start + i, u16) as u64) << (i * 8);
+        i += 2
+    }
+    if i < len {
+        out |= (*buf.get_unchecked(start + i) as u64) << (i * 8);
+        i += 1;
+    }
+    debug_assert_eq!(i, len);
+    out
+}
+
+impl SipHasher128 {
+    #[inline]
+    pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher128 {
+        let mut state = SipHasher128 {
+            k0: key0,
+            k1: key1,
+            length: 0,
+            state: State {
+                v0: 0,
+                v1: 0,
+                v2: 0,
+                v3: 0,
+            },
+            tail: 0,
+            ntail: 0,
+        };
+        state.reset();
+        state
+    }
+
+    #[inline]
+    fn reset(&mut self) {
+        self.length = 0;
+        self.state.v0 = self.k0 ^ 0x736f6d6570736575;
+        self.state.v1 = self.k1 ^ 0x646f72616e646f6d;
+        self.state.v2 = self.k0 ^ 0x6c7967656e657261;
+        self.state.v3 = self.k1 ^ 0x7465646279746573;
+        self.ntail = 0;
+
+        // This is only done in the 128 bit version:
+        self.state.v1 ^= 0xee;
+    }
+
+    // Specialized write function that is only valid for buffers with len <= 8.
+    // It's used to force inlining of write_u8 and write_usize, those would normally
+    // be inlined except for composite types (that includes slices and str
+    // hashing because of delimiter). Without this extra push the compiler is
+    // very reluctant to inline delimiter writes, degrading performance
+    // substantially for the most common use cases.
+    #[inline]
+    fn short_write(&mut self, msg: &[u8]) {
+        debug_assert!(msg.len() <= 8);
+        let length = msg.len();
+        self.length += length;
+
+        let needed = 8 - self.ntail;
+        let fill = cmp::min(length, needed);
+        if fill == 8 {
+            self.tail = unsafe { load_int_le!(msg, 0, u64) };
+        } else {
+            self.tail |= unsafe { u8to64_le(msg, 0, fill) } << (8 * self.ntail);
+            if length < needed {
+                self.ntail += length;
+                return;
+            }
+        }
+        self.state.v3 ^= self.tail;
+        Sip24Rounds::c_rounds(&mut self.state);
+        self.state.v0 ^= self.tail;
+
+        // Buffered tail is now flushed, process new input.
+        self.ntail = length - needed;
+        self.tail = unsafe { u8to64_le(msg, needed, self.ntail) };
+    }
+
+    #[inline(always)]
+    fn short_write_gen<T>(&mut self, x: T) {
+        let bytes =
+            unsafe { slice::from_raw_parts(&x as *const T as *const u8, mem::size_of::<T>()) };
+        self.short_write(bytes);
+    }
+
+    #[inline]
+    pub fn finish128(mut self) -> (u64, u64) {
+        let b: u64 = ((self.length as u64 & 0xff) << 56) | self.tail;
+
+        self.state.v3 ^= b;
+        Sip24Rounds::c_rounds(&mut self.state);
+        self.state.v0 ^= b;
+
+        self.state.v2 ^= 0xee;
+        Sip24Rounds::d_rounds(&mut self.state);
+        let _0 = self.state.v0 ^ self.state.v1 ^ self.state.v2 ^ self.state.v3;
+
+        self.state.v1 ^= 0xdd;
+        Sip24Rounds::d_rounds(&mut self.state);
+        let _1 = self.state.v0 ^ self.state.v1 ^ self.state.v2 ^ self.state.v3;
+        (_0, _1)
+    }
+}
+
+impl Hasher for SipHasher128 {
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.short_write_gen(i);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.short_write_gen(i);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.short_write_gen(i);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.short_write_gen(i);
+    }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.short_write_gen(i);
+    }
+
+    #[inline]
+    fn write_i8(&mut self, i: i8) {
+        self.short_write_gen(i);
+    }
+
+    #[inline]
+    fn write_i16(&mut self, i: i16) {
+        self.short_write_gen(i);
+    }
+
+    #[inline]
+    fn write_i32(&mut self, i: i32) {
+        self.short_write_gen(i);
+    }
+
+    #[inline]
+    fn write_i64(&mut self, i: i64) {
+        self.short_write_gen(i);
+    }
+
+    #[inline]
+    fn write_isize(&mut self, i: isize) {
+        self.short_write_gen(i);
+    }
+
+    #[inline]
+    fn write(&mut self, msg: &[u8]) {
+        let length = msg.len();
+        self.length += length;
+
+        let mut needed = 0;
+
+        if self.ntail != 0 {
+            needed = 8 - self.ntail;
+            self.tail |= unsafe { u8to64_le(msg, 0, cmp::min(length, needed)) } << 8 * self.ntail;
+            if length < needed {
+                self.ntail += length;
+                return;
+            } else {
+                self.state.v3 ^= self.tail;
+                Sip24Rounds::c_rounds(&mut self.state);
+                self.state.v0 ^= self.tail;
+                self.ntail = 0;
+            }
+        }
+
+        // Buffered tail is now flushed, process new input.
+        let len = length - needed;
+        let left = len & 0x7;
+
+        let mut i = needed;
+        while i < len - left {
+            let mi = unsafe { load_int_le!(msg, i, u64) };
+
+            self.state.v3 ^= mi;
+            Sip24Rounds::c_rounds(&mut self.state);
+            self.state.v0 ^= mi;
+
+            i += 8;
+        }
+
+        self.tail = unsafe { u8to64_le(msg, i, left) };
+        self.ntail = left;
+    }
+
+    fn finish(&self) -> u64 {
+        panic!("SipHasher128 cannot provide valid 64 bit hashes")
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+struct Sip24Rounds;
+
+impl Sip24Rounds {
+    #[inline]
+    fn c_rounds(state: &mut State) {
+        compress!(state);
+        compress!(state);
+    }
+
+    #[inline]
+    fn d_rounds(state: &mut State) {
+        compress!(state);
+        compress!(state);
+        compress!(state);
+        compress!(state);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::SipHasher128;
+    use std::{
+        hash::{Hash, Hasher},
+        mem, slice,
+    };
+
+    // Hash just the bytes of the slice, without length prefix
+    struct Bytes<'a>(&'a [u8]);
+
+    impl<'a> Hash for Bytes<'a> {
+        #[allow(unused_must_use)]
+        fn hash<H: Hasher>(&self, state: &mut H) {
+            for byte in self.0 {
+                state.write_u8(*byte);
+            }
+        }
+    }
+
+    fn hash_with<T: Hash>(mut st: SipHasher128, x: &T) -> (u64, u64) {
+        x.hash(&mut st);
+        st.finish128()
+    }
+
+    fn hash<T: Hash>(x: &T) -> (u64, u64) {
+        hash_with(SipHasher128::new_with_keys(0, 0), x)
+    }
+
+    const TEST_VECTOR: [[u8; 16]; 64] = [
+        [
+            0xa3, 0x81, 0x7f, 0x04, 0xba, 0x25, 0xa8, 0xe6, 0x6d, 0xf6, 0x72, 0x14, 0xc7, 0x55,
+            0x02, 0x93,
+        ],
+        [
+            0xda, 0x87, 0xc1, 0xd8, 0x6b, 0x99, 0xaf, 0x44, 0x34, 0x76, 0x59, 0x11, 0x9b, 0x22,
+            0xfc, 0x45,
+        ],
+        [
+            0x81, 0x77, 0x22, 0x8d, 0xa4, 0xa4, 0x5d, 0xc7, 0xfc, 0xa3, 0x8b, 0xde, 0xf6, 0x0a,
+            0xff, 0xe4,
+        ],
+        [
+            0x9c, 0x70, 0xb6, 0x0c, 0x52, 0x67, 0xa9, 0x4e, 0x5f, 0x33, 0xb6, 0xb0, 0x29, 0x85,
+            0xed, 0x51,
+        ],
+        [
+            0xf8, 0x81, 0x64, 0xc1, 0x2d, 0x9c, 0x8f, 0xaf, 0x7d, 0x0f, 0x6e, 0x7c, 0x7b, 0xcd,
+            0x55, 0x79,
+        ],
+        [
+            0x13, 0x68, 0x87, 0x59, 0x80, 0x77, 0x6f, 0x88, 0x54, 0x52, 0x7a, 0x07, 0x69, 0x0e,
+            0x96, 0x27,
+        ],
+        [
+            0x14, 0xee, 0xca, 0x33, 0x8b, 0x20, 0x86, 0x13, 0x48, 0x5e, 0xa0, 0x30, 0x8f, 0xd7,
+            0xa1, 0x5e,
+        ],
+        [
+            0xa1, 0xf1, 0xeb, 0xbe, 0xd8, 0xdb, 0xc1, 0x53, 0xc0, 0xb8, 0x4a, 0xa6, 0x1f, 0xf0,
+            0x82, 0x39,
+        ],
+        [
+            0x3b, 0x62, 0xa9, 0xba, 0x62, 0x58, 0xf5, 0x61, 0x0f, 0x83, 0xe2, 0x64, 0xf3, 0x14,
+            0x97, 0xb4,
+        ],
+        [
+            0x26, 0x44, 0x99, 0x06, 0x0a, 0xd9, 0xba, 0xab, 0xc4, 0x7f, 0x8b, 0x02, 0xbb, 0x6d,
+            0x71, 0xed,
+        ],
+        [
+            0x00, 0x11, 0x0d, 0xc3, 0x78, 0x14, 0x69, 0x56, 0xc9, 0x54, 0x47, 0xd3, 0xf3, 0xd0,
+            0xfb, 0xba,
+        ],
+        [
+            0x01, 0x51, 0xc5, 0x68, 0x38, 0x6b, 0x66, 0x77, 0xa2, 0xb4, 0xdc, 0x6f, 0x81, 0xe5,
+            0xdc, 0x18,
+        ],
+        [
+            0xd6, 0x26, 0xb2, 0x66, 0x90, 0x5e, 0xf3, 0x58, 0x82, 0x63, 0x4d, 0xf6, 0x85, 0x32,
+            0xc1, 0x25,
+        ],
+        [
+            0x98, 0x69, 0xe2, 0x47, 0xe9, 0xc0, 0x8b, 0x10, 0xd0, 0x29, 0x93, 0x4f, 0xc4, 0xb9,
+            0x52, 0xf7,
+        ],
+        [
+            0x31, 0xfc, 0xef, 0xac, 0x66, 0xd7, 0xde, 0x9c, 0x7e, 0xc7, 0x48, 0x5f, 0xe4, 0x49,
+            0x49, 0x02,
+        ],
+        [
+            0x54, 0x93, 0xe9, 0x99, 0x33, 0xb0, 0xa8, 0x11, 0x7e, 0x08, 0xec, 0x0f, 0x97, 0xcf,
+            0xc3, 0xd9,
+        ],
+        [
+            0x6e, 0xe2, 0xa4, 0xca, 0x67, 0xb0, 0x54, 0xbb, 0xfd, 0x33, 0x15, 0xbf, 0x85, 0x23,
+            0x05, 0x77,
+        ],
+        [
+            0x47, 0x3d, 0x06, 0xe8, 0x73, 0x8d, 0xb8, 0x98, 0x54, 0xc0, 0x66, 0xc4, 0x7a, 0xe4,
+            0x77, 0x40,
+        ],
+        [
+            0xa4, 0x26, 0xe5, 0xe4, 0x23, 0xbf, 0x48, 0x85, 0x29, 0x4d, 0xa4, 0x81, 0xfe, 0xae,
+            0xf7, 0x23,
+        ],
+        [
+            0x78, 0x01, 0x77, 0x31, 0xcf, 0x65, 0xfa, 0xb0, 0x74, 0xd5, 0x20, 0x89, 0x52, 0x51,
+            0x2e, 0xb1,
+        ],
+        [
+            0x9e, 0x25, 0xfc, 0x83, 0x3f, 0x22, 0x90, 0x73, 0x3e, 0x93, 0x44, 0xa5, 0xe8, 0x38,
+            0x39, 0xeb,
+        ],
+        [
+            0x56, 0x8e, 0x49, 0x5a, 0xbe, 0x52, 0x5a, 0x21, 0x8a, 0x22, 0x14, 0xcd, 0x3e, 0x07,
+            0x1d, 0x12,
+        ],
+        [
+            0x4a, 0x29, 0xb5, 0x45, 0x52, 0xd1, 0x6b, 0x9a, 0x46, 0x9c, 0x10, 0x52, 0x8e, 0xff,
+            0x0a, 0xae,
+        ],
+        [
+            0xc9, 0xd1, 0x84, 0xdd, 0xd5, 0xa9, 0xf5, 0xe0, 0xcf, 0x8c, 0xe2, 0x9a, 0x9a, 0xbf,
+            0x69, 0x1c,
+        ],
+        [
+            0x2d, 0xb4, 0x79, 0xae, 0x78, 0xbd, 0x50, 0xd8, 0x88, 0x2a, 0x8a, 0x17, 0x8a, 0x61,
+            0x32, 0xad,
+        ],
+        [
+            0x8e, 0xce, 0x5f, 0x04, 0x2d, 0x5e, 0x44, 0x7b, 0x50, 0x51, 0xb9, 0xea, 0xcb, 0x8d,
+            0x8f, 0x6f,
+        ],
+        [
+            0x9c, 0x0b, 0x53, 0xb4, 0xb3, 0xc3, 0x07, 0xe8, 0x7e, 0xae, 0xe0, 0x86, 0x78, 0x14,
+            0x1f, 0x66,
+        ],
+        [
+            0xab, 0xf2, 0x48, 0xaf, 0x69, 0xa6, 0xea, 0xe4, 0xbf, 0xd3, 0xeb, 0x2f, 0x12, 0x9e,
+            0xeb, 0x94,
+        ],
+        [
+            0x06, 0x64, 0xda, 0x16, 0x68, 0x57, 0x4b, 0x88, 0xb9, 0x35, 0xf3, 0x02, 0x73, 0x58,
+            0xae, 0xf4,
+        ],
+        [
+            0xaa, 0x4b, 0x9d, 0xc4, 0xbf, 0x33, 0x7d, 0xe9, 0x0c, 0xd4, 0xfd, 0x3c, 0x46, 0x7c,
+            0x6a, 0xb7,
+        ],
+        [
+            0xea, 0x5c, 0x7f, 0x47, 0x1f, 0xaf, 0x6b, 0xde, 0x2b, 0x1a, 0xd7, 0xd4, 0x68, 0x6d,
+            0x22, 0x87,
+        ],
+        [
+            0x29, 0x39, 0xb0, 0x18, 0x32, 0x23, 0xfa, 0xfc, 0x17, 0x23, 0xde, 0x4f, 0x52, 0xc4,
+            0x3d, 0x35,
+        ],
+        [
+            0x7c, 0x39, 0x56, 0xca, 0x5e, 0xea, 0xfc, 0x3e, 0x36, 0x3e, 0x9d, 0x55, 0x65, 0x46,
+            0xeb, 0x68,
+        ],
+        [
+            0x77, 0xc6, 0x07, 0x71, 0x46, 0xf0, 0x1c, 0x32, 0xb6, 0xb6, 0x9d, 0x5f, 0x4e, 0xa9,
+            0xff, 0xcf,
+        ],
+        [
+            0x37, 0xa6, 0x98, 0x6c, 0xb8, 0x84, 0x7e, 0xdf, 0x09, 0x25, 0xf0, 0xf1, 0x30, 0x9b,
+            0x54, 0xde,
+        ],
+        [
+            0xa7, 0x05, 0xf0, 0xe6, 0x9d, 0xa9, 0xa8, 0xf9, 0x07, 0x24, 0x1a, 0x2e, 0x92, 0x3c,
+            0x8c, 0xc8,
+        ],
+        [
+            0x3d, 0xc4, 0x7d, 0x1f, 0x29, 0xc4, 0x48, 0x46, 0x1e, 0x9e, 0x76, 0xed, 0x90, 0x4f,
+            0x67, 0x11,
+        ],
+        [
+            0x0d, 0x62, 0xbf, 0x01, 0xe6, 0xfc, 0x0e, 0x1a, 0x0d, 0x3c, 0x47, 0x51, 0xc5, 0xd3,
+            0x69, 0x2b,
+        ],
+        [
+            0x8c, 0x03, 0x46, 0x8b, 0xca, 0x7c, 0x66, 0x9e, 0xe4, 0xfd, 0x5e, 0x08, 0x4b, 0xbe,
+            0xe7, 0xb5,
+        ],
+        [
+            0x52, 0x8a, 0x5b, 0xb9, 0x3b, 0xaf, 0x2c, 0x9c, 0x44, 0x73, 0xcc, 0xe5, 0xd0, 0xd2,
+            0x2b, 0xd9,
+        ],
+        [
+            0xdf, 0x6a, 0x30, 0x1e, 0x95, 0xc9, 0x5d, 0xad, 0x97, 0xae, 0x0c, 0xc8, 0xc6, 0x91,
+            0x3b, 0xd8,
+        ],
+        [
+            0x80, 0x11, 0x89, 0x90, 0x2c, 0x85, 0x7f, 0x39, 0xe7, 0x35, 0x91, 0x28, 0x5e, 0x70,
+            0xb6, 0xdb,
+        ],
+        [
+            0xe6, 0x17, 0x34, 0x6a, 0xc9, 0xc2, 0x31, 0xbb, 0x36, 0x50, 0xae, 0x34, 0xcc, 0xca,
+            0x0c, 0x5b,
+        ],
+        [
+            0x27, 0xd9, 0x34, 0x37, 0xef, 0xb7, 0x21, 0xaa, 0x40, 0x18, 0x21, 0xdc, 0xec, 0x5a,
+            0xdf, 0x89,
+        ],
+        [
+            0x89, 0x23, 0x7d, 0x9d, 0xed, 0x9c, 0x5e, 0x78, 0xd8, 0xb1, 0xc9, 0xb1, 0x66, 0xcc,
+            0x73, 0x42,
+        ],
+        [
+            0x4a, 0x6d, 0x80, 0x91, 0xbf, 0x5e, 0x7d, 0x65, 0x11, 0x89, 0xfa, 0x94, 0xa2, 0x50,
+            0xb1, 0x4c,
+        ],
+        [
+            0x0e, 0x33, 0xf9, 0x60, 0x55, 0xe7, 0xae, 0x89, 0x3f, 0xfc, 0x0e, 0x3d, 0xcf, 0x49,
+            0x29, 0x02,
+        ],
+        [
+            0xe6, 0x1c, 0x43, 0x2b, 0x72, 0x0b, 0x19, 0xd1, 0x8e, 0xc8, 0xd8, 0x4b, 0xdc, 0x63,
+            0x15, 0x1b,
+        ],
+        [
+            0xf7, 0xe5, 0xae, 0xf5, 0x49, 0xf7, 0x82, 0xcf, 0x37, 0x90, 0x55, 0xa6, 0x08, 0x26,
+            0x9b, 0x16,
+        ],
+        [
+            0x43, 0x8d, 0x03, 0x0f, 0xd0, 0xb7, 0xa5, 0x4f, 0xa8, 0x37, 0xf2, 0xad, 0x20, 0x1a,
+            0x64, 0x03,
+        ],
+        [
+            0xa5, 0x90, 0xd3, 0xee, 0x4f, 0xbf, 0x04, 0xe3, 0x24, 0x7e, 0x0d, 0x27, 0xf2, 0x86,
+            0x42, 0x3f,
+        ],
+        [
+            0x5f, 0xe2, 0xc1, 0xa1, 0x72, 0xfe, 0x93, 0xc4, 0xb1, 0x5c, 0xd3, 0x7c, 0xae, 0xf9,
+            0xf5, 0x38,
+        ],
+        [
+            0x2c, 0x97, 0x32, 0x5c, 0xbd, 0x06, 0xb3, 0x6e, 0xb2, 0x13, 0x3d, 0xd0, 0x8b, 0x3a,
+            0x01, 0x7c,
+        ],
+        [
+            0x92, 0xc8, 0x14, 0x22, 0x7a, 0x6b, 0xca, 0x94, 0x9f, 0xf0, 0x65, 0x9f, 0x00, 0x2a,
+            0xd3, 0x9e,
+        ],
+        [
+            0xdc, 0xe8, 0x50, 0x11, 0x0b, 0xd8, 0x32, 0x8c, 0xfb, 0xd5, 0x08, 0x41, 0xd6, 0x91,
+            0x1d, 0x87,
+        ],
+        [
+            0x67, 0xf1, 0x49, 0x84, 0xc7, 0xda, 0x79, 0x12, 0x48, 0xe3, 0x2b, 0xb5, 0x92, 0x25,
+            0x83, 0xda,
+        ],
+        [
+            0x19, 0x38, 0xf2, 0xcf, 0x72, 0xd5, 0x4e, 0xe9, 0x7e, 0x94, 0x16, 0x6f, 0xa9, 0x1d,
+            0x2a, 0x36,
+        ],
+        [
+            0x74, 0x48, 0x1e, 0x96, 0x46, 0xed, 0x49, 0xfe, 0x0f, 0x62, 0x24, 0x30, 0x16, 0x04,
+            0x69, 0x8e,
+        ],
+        [
+            0x57, 0xfc, 0xa5, 0xde, 0x98, 0xa9, 0xd6, 0xd8, 0x00, 0x64, 0x38, 0xd0, 0x58, 0x3d,
+            0x8a, 0x1d,
+        ],
+        [
+            0x9f, 0xec, 0xde, 0x1c, 0xef, 0xdc, 0x1c, 0xbe, 0xd4, 0x76, 0x36, 0x74, 0xd9, 0x57,
+            0x53, 0x59,
+        ],
+        [
+            0xe3, 0x04, 0x0c, 0x00, 0xeb, 0x28, 0xf1, 0x53, 0x66, 0xca, 0x73, 0xcb, 0xd8, 0x72,
+            0xe7, 0x40,
+        ],
+        [
+            0x76, 0x97, 0x00, 0x9a, 0x6a, 0x83, 0x1d, 0xfe, 0xcc, 0xa9, 0x1c, 0x59, 0x93, 0x67,
+            0x0f, 0x7a,
+        ],
+        [
+            0x58, 0x53, 0x54, 0x23, 0x21, 0xf5, 0x67, 0xa0, 0x05, 0xd5, 0x47, 0xa4, 0xf0, 0x47,
+            0x59, 0xbd,
+        ],
+        [
+            0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a, 0x50, 0x3e, 0x06, 0x9a, 0x97, 0x3f,
+            0xbd, 0x7c,
+        ],
+    ];
+
+    // Test vector from reference implementation
+    #[test]
+    fn test_siphash_2_4_test_vector() {
+        let k0 = 0x_07_06_05_04_03_02_01_00;
+        let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
+
+        let mut input: Vec<u8> = Vec::new();
+
+        for i in 0..64 {
+            let out = hash_with(SipHasher128::new_with_keys(k0, k1), &Bytes(&input[..]));
+            let expected = (
+                ((TEST_VECTOR[i][0] as u64) << 0)
+                    | ((TEST_VECTOR[i][1] as u64) << 8)
+                    | ((TEST_VECTOR[i][2] as u64) << 16)
+                    | ((TEST_VECTOR[i][3] as u64) << 24)
+                    | ((TEST_VECTOR[i][4] as u64) << 32)
+                    | ((TEST_VECTOR[i][5] as u64) << 40)
+                    | ((TEST_VECTOR[i][6] as u64) << 48)
+                    | ((TEST_VECTOR[i][7] as u64) << 56),
+                ((TEST_VECTOR[i][8] as u64) << 0)
+                    | ((TEST_VECTOR[i][9] as u64) << 8)
+                    | ((TEST_VECTOR[i][10] as u64) << 16)
+                    | ((TEST_VECTOR[i][11] as u64) << 24)
+                    | ((TEST_VECTOR[i][12] as u64) << 32)
+                    | ((TEST_VECTOR[i][13] as u64) << 40)
+                    | ((TEST_VECTOR[i][14] as u64) << 48)
+                    | ((TEST_VECTOR[i][15] as u64) << 56),
+            );
+
+            assert_eq!(out, expected);
+            input.push(i as u8);
+        }
+    }
+
+    #[test]
+    #[cfg(target_arch = "arm")]
+    fn test_hash_usize() {
+        let val = 0xdeadbeef_deadbeef_u64;
+        assert!(hash(&(val as u64)) != hash(&(val as usize)));
+        assert_eq!(hash(&(val as u32)), hash(&(val as usize)));
+    }
+    #[test]
+    #[cfg(target_arch = "x86_64")]
+    fn test_hash_usize() {
+        let val = 0xdeadbeef_deadbeef_u64;
+        assert_eq!(hash(&(val as u64)), hash(&(val as usize)));
+        assert!(hash(&(val as u32)) != hash(&(val as usize)));
+    }
+    #[test]
+    #[cfg(target_arch = "x86")]
+    fn test_hash_usize() {
+        let val = 0xdeadbeef_deadbeef_u64;
+        assert!(hash(&(val as u64)) != hash(&(val as usize)));
+        assert_eq!(hash(&(val as u32)), hash(&(val as usize)));
+    }
+
+    #[test]
+    fn test_hash_idempotent() {
+        let val64 = 0xdeadbeef_deadbeef_u64;
+        assert_eq!(hash(&val64), hash(&val64));
+        let val32 = 0xdeadbeef_u32;
+        assert_eq!(hash(&val32), hash(&val32));
+    }
+
+    #[test]
+    fn test_hash_no_bytes_dropped_64() {
+        let val = 0xdeadbeef_deadbeef_u64;
+
+        assert!(hash(&val) != hash(&zero_byte(val, 0)));
+        assert!(hash(&val) != hash(&zero_byte(val, 1)));
+        assert!(hash(&val) != hash(&zero_byte(val, 2)));
+        assert!(hash(&val) != hash(&zero_byte(val, 3)));
+        assert!(hash(&val) != hash(&zero_byte(val, 4)));
+        assert!(hash(&val) != hash(&zero_byte(val, 5)));
+        assert!(hash(&val) != hash(&zero_byte(val, 6)));
+        assert!(hash(&val) != hash(&zero_byte(val, 7)));
+
+        fn zero_byte(val: u64, byte: usize) -> u64 {
+            assert!(byte < 8);
+            val & !(0xff << (byte * 8))
+        }
+    }
+
+    #[test]
+    fn test_hash_no_bytes_dropped_32() {
+        let val = 0xdeadbeef_u32;
+
+        assert!(hash(&val) != hash(&zero_byte(val, 0)));
+        assert!(hash(&val) != hash(&zero_byte(val, 1)));
+        assert!(hash(&val) != hash(&zero_byte(val, 2)));
+        assert!(hash(&val) != hash(&zero_byte(val, 3)));
+
+        fn zero_byte(val: u32, byte: usize) -> u32 {
+            assert!(byte < 4);
+            val & !(0xff << (byte * 8))
+        }
+    }
+
+    #[test]
+    fn test_hash_no_concat_alias() {
+        let s = ("aa", "bb");
+        let t = ("aabb", "");
+        let u = ("a", "abb");
+
+        assert!(s != t && t != u);
+        assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u));
+
+        let u = [1, 0, 0, 0];
+        let v = (&u[..1], &u[1..3], &u[3..]);
+        let w = (&u[..], &u[4..4], &u[4..4]);
+
+        assert!(v != w);
+        assert!(hash(&v) != hash(&w));
+    }
+
+    #[test]
+    fn test_write_short_works() {
+        let test_usize = 0xd0c0b0a0usize;
+        let mut h1 = SipHasher128::new_with_keys(0, 0);
+        h1.write_usize(test_usize);
+        h1.write(b"bytes");
+        h1.write(b"string");
+        h1.write_u8(0xFFu8);
+        h1.write_u8(0x01u8);
+        let mut h2 = SipHasher128::new_with_keys(0, 0);
+        h2.write(unsafe {
+            slice::from_raw_parts(
+                &test_usize as *const _ as *const u8,
+                mem::size_of::<usize>(),
+            )
+        });
+        h2.write(b"bytes");
+        h2.write(b"string");
+        h2.write(&[0xFFu8, 0x01u8]);
+        assert_eq!(h1.finish128(), h2.finish128());
+    }
+
+}
diff --git a/common/src/rustc_data_structures/stable_hasher.rs b/common/src/rustc_data_structures/stable_hasher.rs
new file mode 100644
index 000000000000..f70fa3024ce0
--- /dev/null
+++ b/common/src/rustc_data_structures/stable_hasher.rs
@@ -0,0 +1,480 @@
+use super::sip128::SipHasher128;
+use std::{
+    hash::{BuildHasher, Hash, Hasher},
+    marker::PhantomData,
+    mem,
+};
+
+/// When hashing something that ends up affecting properties like symbol names,
+/// we want these symbol names to be calculated independently of other factors
+/// like what architecture you're compiling *from*.
+///
+/// To that end we always convert integers to little-endian format before
+/// hashing and the architecture dependent `isize` and `usize` types are
+/// extended to 64 bits if needed.
+pub struct StableHasher<W> {
+    state: SipHasher128,
+    bytes_hashed: u64,
+    width: PhantomData<W>,
+}
+
+impl<W: StableHasherResult> ::std::fmt::Debug for StableHasher<W> {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "{:?}", self.state)
+    }
+}
+
+pub trait StableHasherResult: Sized {
+    fn finish(hasher: StableHasher<Self>) -> Self;
+}
+
+impl<W: StableHasherResult> StableHasher<W> {
+    pub fn new() -> Self {
+        StableHasher {
+            state: SipHasher128::new_with_keys(0, 0),
+            bytes_hashed: 0,
+            width: PhantomData,
+        }
+    }
+
+    pub fn finish(self) -> W {
+        W::finish(self)
+    }
+}
+
+impl StableHasherResult for u128 {
+    fn finish(hasher: StableHasher<Self>) -> Self {
+        let (_0, _1) = hasher.finalize();
+        (_0 as u128) | ((_1 as u128) << 64)
+    }
+}
+
+impl StableHasherResult for u64 {
+    fn finish(hasher: StableHasher<Self>) -> Self {
+        hasher.finalize().0
+    }
+}
+
+impl<W> StableHasher<W> {
+    #[inline]
+    pub fn finalize(self) -> (u64, u64) {
+        self.state.finish128()
+    }
+}
+
+impl<W> Hasher for StableHasher<W> {
+    fn finish(&self) -> u64 {
+        panic!("use StableHasher::finalize instead");
+    }
+
+    #[inline]
+    fn write(&mut self, bytes: &[u8]) {
+        self.state.write(bytes);
+        self.bytes_hashed += bytes.len() as u64;
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.state.write_u8(i);
+        self.bytes_hashed += 1;
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.state.write_u16(i.to_le());
+        self.bytes_hashed += 2;
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.state.write_u32(i.to_le());
+        self.bytes_hashed += 4;
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.state.write_u64(i.to_le());
+        self.bytes_hashed += 8;
+    }
+
+    #[inline]
+    fn write_u128(&mut self, i: u128) {
+        self.state.write_u128(i.to_le());
+        self.bytes_hashed += 16;
+    }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        // Always treat usize as u64 so we get the same results on 32 and 64 bit
+        // platforms. This is important for symbol hashes when cross compiling,
+        // for example.
+        self.state.write_u64((i as u64).to_le());
+        self.bytes_hashed += 8;
+    }
+
+    #[inline]
+    fn write_i8(&mut self, i: i8) {
+        self.state.write_i8(i);
+        self.bytes_hashed += 1;
+    }
+
+    #[inline]
+    fn write_i16(&mut self, i: i16) {
+        self.state.write_i16(i.to_le());
+        self.bytes_hashed += 2;
+    }
+
+    #[inline]
+    fn write_i32(&mut self, i: i32) {
+        self.state.write_i32(i.to_le());
+        self.bytes_hashed += 4;
+    }
+
+    #[inline]
+    fn write_i64(&mut self, i: i64) {
+        self.state.write_i64(i.to_le());
+        self.bytes_hashed += 8;
+    }
+
+    #[inline]
+    fn write_i128(&mut self, i: i128) {
+        self.state.write_i128(i.to_le());
+        self.bytes_hashed += 16;
+    }
+
+    #[inline]
+    fn write_isize(&mut self, i: isize) {
+        // Always treat isize as i64 so we get the same results on 32 and 64 bit
+        // platforms. This is important for symbol hashes when cross compiling,
+        // for example.
+        self.state.write_i64((i as i64).to_le());
+        self.bytes_hashed += 8;
+    }
+}
+
+/// Something that implements `HashStable<CTX>` can be hashed in a way that is
+/// stable across multiple compilation sessions.
+pub trait HashStable<CTX> {
+    fn hash_stable<W: StableHasherResult>(&self, hcx: &mut CTX, hasher: &mut StableHasher<W>);
+}
+
+/// Implement this for types that can be turned into stable keys like, for
+/// example, for DefId that can be converted to a DefPathHash. This is used for
+/// bringing maps into a predictable order before hashing them.
+pub trait ToStableHashKey<HCX> {
+    type KeyType: Ord + Clone + Sized + HashStable<HCX>;
+    fn to_stable_hash_key(&self, hcx: &HCX) -> Self::KeyType;
+}
+
+// Implement HashStable by just calling `Hash::hash()`. This works fine for
+// self-contained values that don't depend on the hashing context `CTX`.
+#[macro_export]
+macro_rules! impl_stable_hash_via_hash {
+    ($t:ty) => {
+        impl<CTX> $crate::rustc_data_structures::stable_hasher::HashStable<CTX> for $t {
+            #[inline]
+            fn hash_stable<W: $crate::rustc_data_structures::stable_hasher::StableHasherResult>(
+                &self,
+                _: &mut CTX,
+                hasher: &mut $crate::rustc_data_structures::stable_hasher::StableHasher<W>,
+            ) {
+                ::std::hash::Hash::hash(self, hasher);
+            }
+        }
+    };
+}
+
+impl_stable_hash_via_hash!(i8);
+impl_stable_hash_via_hash!(i16);
+impl_stable_hash_via_hash!(i32);
+impl_stable_hash_via_hash!(i64);
+impl_stable_hash_via_hash!(isize);
+
+impl_stable_hash_via_hash!(u8);
+impl_stable_hash_via_hash!(u16);
+impl_stable_hash_via_hash!(u32);
+impl_stable_hash_via_hash!(u64);
+impl_stable_hash_via_hash!(usize);
+
+impl_stable_hash_via_hash!(u128);
+impl_stable_hash_via_hash!(i128);
+
+impl_stable_hash_via_hash!(char);
+impl_stable_hash_via_hash!(());
+
+impl<CTX> HashStable<CTX> for ::std::num::NonZeroU32 {
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        self.get().hash_stable(ctx, hasher)
+    }
+}
+
+impl<CTX> HashStable<CTX> for f32 {
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        let val: u32 = unsafe { ::std::mem::transmute(*self) };
+        val.hash_stable(ctx, hasher);
+    }
+}
+
+impl<CTX> HashStable<CTX> for f64 {
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        let val: u64 = unsafe { ::std::mem::transmute(*self) };
+        val.hash_stable(ctx, hasher);
+    }
+}
+
+impl<CTX> HashStable<CTX> for ::std::cmp::Ordering {
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        (*self as i8).hash_stable(ctx, hasher);
+    }
+}
+
+impl<T1: HashStable<CTX>, CTX> HashStable<CTX> for (T1,) {
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        let (ref _0,) = *self;
+        _0.hash_stable(ctx, hasher);
+    }
+}
+
+impl<T1: HashStable<CTX>, T2: HashStable<CTX>, CTX> HashStable<CTX> for (T1, T2) {
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        let (ref _0, ref _1) = *self;
+        _0.hash_stable(ctx, hasher);
+        _1.hash_stable(ctx, hasher);
+    }
+}
+
+impl<T1, T2, T3, CTX> HashStable<CTX> for (T1, T2, T3)
+where
+    T1: HashStable<CTX>,
+    T2: HashStable<CTX>,
+    T3: HashStable<CTX>,
+{
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        let (ref _0, ref _1, ref _2) = *self;
+        _0.hash_stable(ctx, hasher);
+        _1.hash_stable(ctx, hasher);
+        _2.hash_stable(ctx, hasher);
+    }
+}
+
+impl<T1, T2, T3, T4, CTX> HashStable<CTX> for (T1, T2, T3, T4)
+where
+    T1: HashStable<CTX>,
+    T2: HashStable<CTX>,
+    T3: HashStable<CTX>,
+    T4: HashStable<CTX>,
+{
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        let (ref _0, ref _1, ref _2, ref _3) = *self;
+        _0.hash_stable(ctx, hasher);
+        _1.hash_stable(ctx, hasher);
+        _2.hash_stable(ctx, hasher);
+        _3.hash_stable(ctx, hasher);
+    }
+}
+
+impl<T: HashStable<CTX>, CTX> HashStable<CTX> for [T] {
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        self.len().hash_stable(ctx, hasher);
+        for item in self {
+            item.hash_stable(ctx, hasher);
+        }
+    }
+}
+
+impl<T: HashStable<CTX>, CTX> HashStable<CTX> for Vec<T> {
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        (&self[..]).hash_stable(ctx, hasher);
+    }
+}
+
+impl<T: ?Sized + HashStable<CTX>, CTX> HashStable<CTX> for Box<T> {
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        (**self).hash_stable(ctx, hasher);
+    }
+}
+
+impl<T: ?Sized + HashStable<CTX>, CTX> HashStable<CTX> for ::std::rc::Rc<T> {
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        (**self).hash_stable(ctx, hasher);
+    }
+}
+
+impl<T: ?Sized + HashStable<CTX>, CTX> HashStable<CTX> for ::std::sync::Arc<T> {
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        (**self).hash_stable(ctx, hasher);
+    }
+}
+
+impl<CTX> HashStable<CTX> for str {
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, _: &mut CTX, hasher: &mut StableHasher<W>) {
+        self.len().hash(hasher);
+        self.as_bytes().hash(hasher);
+    }
+}
+
+impl<CTX> HashStable<CTX> for String {
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, hcx: &mut CTX, hasher: &mut StableHasher<W>) {
+        (&self[..]).hash_stable(hcx, hasher);
+    }
+}
+
+impl<HCX> ToStableHashKey<HCX> for String {
+    type KeyType = String;
+    #[inline]
+    fn to_stable_hash_key(&self, _: &HCX) -> Self::KeyType {
+        self.clone()
+    }
+}
+
+impl<CTX> HashStable<CTX> for bool {
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        (if *self { 1u8 } else { 0u8 }).hash_stable(ctx, hasher);
+    }
+}
+
+impl<T, CTX> HashStable<CTX> for Option<T>
+where
+    T: HashStable<CTX>,
+{
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        if let Some(ref value) = *self {
+            1u8.hash_stable(ctx, hasher);
+            value.hash_stable(ctx, hasher);
+        } else {
+            0u8.hash_stable(ctx, hasher);
+        }
+    }
+}
+
+impl<T1, T2, CTX> HashStable<CTX> for Result<T1, T2>
+where
+    T1: HashStable<CTX>,
+    T2: HashStable<CTX>,
+{
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        mem::discriminant(self).hash_stable(ctx, hasher);
+        match *self {
+            Ok(ref x) => x.hash_stable(ctx, hasher),
+            Err(ref x) => x.hash_stable(ctx, hasher),
+        }
+    }
+}
+
+impl<'a, T, CTX> HashStable<CTX> for &'a T
+where
+    T: HashStable<CTX> + ?Sized,
+{
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut StableHasher<W>) {
+        (**self).hash_stable(ctx, hasher);
+    }
+}
+
+impl<T, CTX> HashStable<CTX> for ::std::mem::Discriminant<T> {
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, _: &mut CTX, hasher: &mut StableHasher<W>) {
+        ::std::hash::Hash::hash(self, hasher);
+    }
+}
+
+// impl<I: ::indexed_vec::Idx, T, CTX> HashStable<CTX> for
+// ::indexed_vec::IndexVec<I, T> where
+//     T: HashStable<CTX>,
+// {
+//     fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut
+// StableHasher<W>) {         self.len().hash_stable(ctx, hasher);
+//         for v in &self.raw {
+//             v.hash_stable(ctx, hasher);
+//         }
+//     }
+// }
+
+// impl<I: ::indexed_vec::Idx, CTX> HashStable<CTX> for ::bit_set::BitSet<I> {
+//     fn hash_stable<W: StableHasherResult>(&self, ctx: &mut CTX, hasher: &mut
+// StableHasher<W>) {         self.words().hash_stable(ctx, hasher);
+//     }
+// }
+
+impl_stable_hash_via_hash!(::std::path::Path);
+impl_stable_hash_via_hash!(::std::path::PathBuf);
+
+impl<K, V, R, HCX> HashStable<HCX> for ::std::collections::HashMap<K, V, R>
+where
+    K: ToStableHashKey<HCX> + Eq + Hash,
+    V: HashStable<HCX>,
+    R: BuildHasher,
+{
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self, hcx: &mut HCX, hasher: &mut StableHasher<W>) {
+        hash_stable_hashmap(hcx, hasher, self, ToStableHashKey::to_stable_hash_key);
+    }
+}
+
+impl<K, R, HCX> HashStable<HCX> for ::std::collections::HashSet<K, R>
+where
+    K: ToStableHashKey<HCX> + Eq + Hash,
+    R: BuildHasher,
+{
+    fn hash_stable<W: StableHasherResult>(&self, hcx: &mut HCX, hasher: &mut StableHasher<W>) {
+        let mut keys: Vec<_> = self.iter().map(|k| k.to_stable_hash_key(hcx)).collect();
+        keys.sort_unstable();
+        keys.hash_stable(hcx, hasher);
+    }
+}
+
+impl<K, V, HCX> HashStable<HCX> for ::std::collections::BTreeMap<K, V>
+where
+    K: ToStableHashKey<HCX>,
+    V: HashStable<HCX>,
+{
+    fn hash_stable<W: StableHasherResult>(&self, hcx: &mut HCX, hasher: &mut StableHasher<W>) {
+        let mut entries: Vec<_> = self
+            .iter()
+            .map(|(k, v)| (k.to_stable_hash_key(hcx), v))
+            .collect();
+        entries.sort_unstable_by(|&(ref sk1, _), &(ref sk2, _)| sk1.cmp(sk2));
+        entries.hash_stable(hcx, hasher);
+    }
+}
+
+impl<K, HCX> HashStable<HCX> for ::std::collections::BTreeSet<K>
+where
+    K: ToStableHashKey<HCX>,
+{
+    fn hash_stable<W: StableHasherResult>(&self, hcx: &mut HCX, hasher: &mut StableHasher<W>) {
+        let mut keys: Vec<_> = self.iter().map(|k| k.to_stable_hash_key(hcx)).collect();
+        keys.sort_unstable();
+        keys.hash_stable(hcx, hasher);
+    }
+}
+
+pub fn hash_stable_hashmap<HCX, K, V, R, SK, F, W>(
+    hcx: &mut HCX,
+    hasher: &mut StableHasher<W>,
+    map: &::std::collections::HashMap<K, V, R>,
+    to_stable_hash_key: F,
+) where
+    K: Eq + Hash,
+    V: HashStable<HCX>,
+    R: BuildHasher,
+    SK: HashStable<HCX> + Ord + Clone,
+    F: Fn(&K, &HCX) -> SK,
+    W: StableHasherResult,
+{
+    let mut entries: Vec<_> = map
+        .iter()
+        .map(|(k, v)| (to_stable_hash_key(k, hcx), v))
+        .collect();
+    entries.sort_unstable_by(|&(ref sk1, _), &(ref sk2, _)| sk1.cmp(sk2));
+    entries.hash_stable(hcx, hasher);
+}
diff --git a/common/src/source_map.rs b/common/src/source_map.rs
new file mode 100644
index 000000000000..a7ce7538cbdb
--- /dev/null
+++ b/common/src/source_map.rs
@@ -0,0 +1,1229 @@
+//! The SourceMap tracks all the source code used within a single crate, mapping
+//! from integer byte positions to the original source code location. Each bit
+//! of source parsed during crate parsing (typically files, in-memory strings,
+//! or various bits of macro expansion) cover a continuous range of bytes in the
+//! SourceMap and are represented by SourceFiles. Byte positions are stored in
+//! `spans` and used pervasively in the compiler. They are absolute positions
+//! within the SourceMap, which upon request can be converted to line and column
+//! information, source code snippets, etc.
+
+use errors::SourceMapper;
+use fxhash::FxHashMap;
+use rustc_data_structures::stable_hasher::StableHasher;
+use std::{
+    cmp, env, fs,
+    hash::Hash,
+    io,
+    path::{Path, PathBuf},
+};
+use sync::{Lock, LockGuard, Lrc, MappedLockGuard};
+pub use syntax_pos::{hygiene::ExpnInfo, *};
+
+// _____________________________________________________________________________
+// SourceFile, MultiByteChar, FileName, FileLines
+//
+
+/// An abstraction over the fs operations used by the Parser.
+pub trait FileLoader {
+    /// Query the existence of a file.
+    fn file_exists(&self, path: &Path) -> bool;
+
+    /// Return an absolute path to a file, if possible.
+    fn abs_path(&self, path: &Path) -> Option<PathBuf>;
+
+    /// Read the contents of an UTF-8 file into memory.
+    fn read_file(&self, path: &Path) -> io::Result<String>;
+}
+
+/// A FileLoader that uses std::fs to load real files.
+pub struct RealFileLoader;
+
+impl FileLoader for RealFileLoader {
+    fn file_exists(&self, path: &Path) -> bool {
+        fs::metadata(path).is_ok()
+    }
+
+    fn abs_path(&self, path: &Path) -> Option<PathBuf> {
+        if path.is_absolute() {
+            Some(path.to_path_buf())
+        } else {
+            env::current_dir().ok().map(|cwd| cwd.join(path))
+        }
+    }
+
+    fn read_file(&self, path: &Path) -> io::Result<String> {
+        fs::read_to_string(path)
+    }
+}
+
+// This is a SourceFile identifier that is used to correlate SourceFiles between
+// subsequent compilation sessions (which is something we need to do during
+// incremental compilation).
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub struct StableSourceFileId(u128);
+
+impl StableSourceFileId {
+    pub fn new(source_file: &SourceFile) -> StableSourceFileId {
+        StableSourceFileId::new_from_pieces(
+            &source_file.name,
+            source_file.name_was_remapped,
+            source_file.unmapped_path.as_ref(),
+        )
+    }
+
+    pub fn new_from_pieces(
+        name: &FileName,
+        name_was_remapped: bool,
+        unmapped_path: Option<&FileName>,
+    ) -> StableSourceFileId {
+        let mut hasher = StableHasher::new();
+
+        name.hash(&mut hasher);
+        name_was_remapped.hash(&mut hasher);
+        unmapped_path.hash(&mut hasher);
+
+        StableSourceFileId(hasher.finish())
+    }
+}
+
+// _____________________________________________________________________________
+// SourceMap
+//
+
+#[derive(Default)]
+pub(super) struct SourceMapFiles {
+    pub(super) source_files: Vec<Lrc<SourceFile>>,
+    stable_id_to_source_file: FxHashMap<StableSourceFileId, Lrc<SourceFile>>,
+}
+
+pub struct SourceMap {
+    pub(super) files: Lock<SourceMapFiles>,
+    file_loader: Box<dyn FileLoader + Sync + Send>,
+    // This is used to apply the file path remapping as specified via
+    // --remap-path-prefix to all SourceFiles allocated within this SourceMap.
+    path_mapping: FilePathMapping,
+}
+
+impl SourceMap {
+    pub fn new(path_mapping: FilePathMapping) -> SourceMap {
+        SourceMap {
+            files: Default::default(),
+            file_loader: Box::new(RealFileLoader),
+            path_mapping,
+        }
+    }
+
+    pub fn with_file_loader(
+        file_loader: Box<dyn FileLoader + Sync + Send>,
+        path_mapping: FilePathMapping,
+    ) -> SourceMap {
+        SourceMap {
+            files: Default::default(),
+            file_loader,
+            path_mapping,
+        }
+    }
+
+    pub fn path_mapping(&self) -> &FilePathMapping {
+        &self.path_mapping
+    }
+
+    pub fn file_exists(&self, path: &Path) -> bool {
+        self.file_loader.file_exists(path)
+    }
+
+    pub fn load_file(&self, path: &Path) -> io::Result<Lrc<SourceFile>> {
+        let src = self.file_loader.read_file(path)?;
+        let filename = path.to_owned().into();
+        Ok(self.new_source_file(filename, src))
+    }
+
+    pub fn files(&self) -> MappedLockGuard<Vec<Lrc<SourceFile>>> {
+        LockGuard::map(self.files.borrow(), |files| &mut files.source_files)
+    }
+
+    pub fn source_file_by_stable_id(
+        &self,
+        stable_id: StableSourceFileId,
+    ) -> Option<Lrc<SourceFile>> {
+        self.files
+            .borrow()
+            .stable_id_to_source_file
+            .get(&stable_id)
+            .map(|sf| sf.clone())
+    }
+
+    fn next_start_pos(&self) -> usize {
+        match self.files.borrow().source_files.last() {
+            None => 0,
+            // Add one so there is some space between files. This lets us distinguish
+            // positions in the source_map, even in the presence of zero-length files.
+            Some(last) => last.end_pos.to_usize() + 1,
+        }
+    }
+
+    /// Creates a new source_file.
+    /// If a file already exists in the source_map with the same id, that file
+    /// is returned unmodified
+    pub fn new_source_file(&self, filename: FileName, src: String) -> Lrc<SourceFile> {
+        let start_pos = self.next_start_pos();
+
+        // The path is used to determine the directory for loading submodules and
+        // include files, so it must be before remapping.
+        // Note that filename may not be a valid path, eg it may be `<anon>` etc,
+        // but this is okay because the directory determined by `path.pop()` will
+        // be empty, so the working directory will be used.
+        let unmapped_path = filename.clone();
+
+        let (filename, was_remapped) = match filename {
+            FileName::Real(filename) => {
+                let (filename, was_remapped) = self.path_mapping.map_prefix(filename);
+                (FileName::Real(filename), was_remapped)
+            }
+            other => (other, false),
+        };
+
+        let file_id =
+            StableSourceFileId::new_from_pieces(&filename, was_remapped, Some(&unmapped_path));
+
+        return match self.source_file_by_stable_id(file_id) {
+            Some(lrc_sf) => lrc_sf,
+            None => {
+                let source_file = Lrc::new(SourceFile::new(
+                    filename,
+                    was_remapped,
+                    unmapped_path,
+                    src,
+                    Pos::from_usize(start_pos),
+                ));
+
+                let mut files = self.files.borrow_mut();
+
+                files.source_files.push(source_file.clone());
+                files
+                    .stable_id_to_source_file
+                    .insert(file_id, source_file.clone());
+
+                source_file
+            }
+        };
+    }
+
+    pub fn mk_substr_filename(&self, sp: Span) -> String {
+        let pos = self.lookup_char_pos(sp.lo());
+        format!(
+            "<{}:{}:{}>",
+            pos.file.name,
+            pos.line,
+            pos.col.to_usize() + 1
+        )
+    }
+
+    // If there is a doctest_offset, apply it to the line
+    pub fn doctest_offset_line(&self, file: &FileName, orig: usize) -> usize {
+        return match file {
+            FileName::DocTest(_, offset) => {
+                return if *offset >= 0 {
+                    orig + *offset as usize
+                } else {
+                    orig - (-(*offset)) as usize
+                };
+            }
+            _ => orig,
+        };
+    }
+
+    /// Lookup source information about a BytePos
+    pub fn lookup_char_pos(&self, pos: BytePos) -> Loc {
+        let chpos = self.bytepos_to_file_charpos(pos);
+        match self.lookup_line(pos) {
+            Ok(SourceFileAndLine { sf: f, line: a }) => {
+                let line = a + 1; // Line numbers start at 1
+                let linebpos = f.lines[a];
+                let linechpos = self.bytepos_to_file_charpos(linebpos);
+                let col = chpos - linechpos;
+
+                let col_display = {
+                    let start_width_idx = f
+                        .non_narrow_chars
+                        .binary_search_by_key(&linebpos, |x| x.pos())
+                        .unwrap_or_else(|x| x);
+                    let end_width_idx = f
+                        .non_narrow_chars
+                        .binary_search_by_key(&pos, |x| x.pos())
+                        .unwrap_or_else(|x| x);
+                    let special_chars = end_width_idx - start_width_idx;
+                    let non_narrow: usize = f.non_narrow_chars[start_width_idx..end_width_idx]
+                        .into_iter()
+                        .map(|x| x.width())
+                        .sum();
+                    col.0 - special_chars + non_narrow
+                };
+                debug!(
+                    "byte pos {:?} is on the line at byte pos {:?}",
+                    pos, linebpos
+                );
+                debug!(
+                    "char pos {:?} is on the line at char pos {:?}",
+                    chpos, linechpos
+                );
+                debug!("byte is on line: {}", line);
+                assert!(chpos >= linechpos);
+                Loc {
+                    file: f,
+                    line,
+                    col,
+                    col_display,
+                }
+            }
+            Err(f) => {
+                let col_display = {
+                    let end_width_idx = f
+                        .non_narrow_chars
+                        .binary_search_by_key(&pos, |x| x.pos())
+                        .unwrap_or_else(|x| x);
+                    let non_narrow: usize = f.non_narrow_chars[0..end_width_idx]
+                        .into_iter()
+                        .map(|x| x.width())
+                        .sum();
+                    chpos.0 - end_width_idx + non_narrow
+                };
+                Loc {
+                    file: f,
+                    line: 0,
+                    col: chpos,
+                    col_display,
+                }
+            }
+        }
+    }
+
+    // If the relevant source_file is empty, we don't return a line number.
+    pub fn lookup_line(&self, pos: BytePos) -> Result<SourceFileAndLine, Lrc<SourceFile>> {
+        let idx = self.lookup_source_file_idx(pos);
+
+        let f = (*self.files.borrow().source_files)[idx].clone();
+
+        match f.lookup_line(pos) {
+            Some(line) => Ok(SourceFileAndLine { sf: f, line }),
+            None => Err(f),
+        }
+    }
+
+    pub fn lookup_char_pos_adj(&self, pos: BytePos) -> LocWithOpt {
+        let loc = self.lookup_char_pos(pos);
+        LocWithOpt {
+            filename: loc.file.name.clone(),
+            line: loc.line,
+            col: loc.col,
+            file: Some(loc.file),
+        }
+    }
+
+    /// Returns `Some(span)`, a union of the lhs and rhs span.  The lhs must
+    /// precede the rhs. If there are gaps between lhs and rhs, the
+    /// resulting union will cross these gaps. For this to work, the spans
+    /// have to be:
+    ///
+    ///    * the ctxt of both spans much match
+    ///    * the lhs span needs to end on the same line the rhs span begins
+    ///    * the lhs span must start at or before the rhs span
+    pub fn merge_spans(&self, sp_lhs: Span, sp_rhs: Span) -> Option<Span> {
+        // make sure we're at the same expansion id
+        if sp_lhs.ctxt() != sp_rhs.ctxt() {
+            return None;
+        }
+
+        let lhs_end = match self.lookup_line(sp_lhs.hi()) {
+            Ok(x) => x,
+            Err(_) => return None,
+        };
+        let rhs_begin = match self.lookup_line(sp_rhs.lo()) {
+            Ok(x) => x,
+            Err(_) => return None,
+        };
+
+        // if we must cross lines to merge, don't merge
+        if lhs_end.line != rhs_begin.line {
+            return None;
+        }
+
+        // ensure these follow the expected order and we don't overlap
+        if (sp_lhs.lo() <= sp_rhs.lo()) && (sp_lhs.hi() <= sp_rhs.lo()) {
+            Some(sp_lhs.to(sp_rhs))
+        } else {
+            None
+        }
+    }
+
+    pub fn span_to_string(&self, sp: Span) -> String {
+        if self.files.borrow().source_files.is_empty() && sp.is_dummy() {
+            return "no-location".to_string();
+        }
+
+        let lo = self.lookup_char_pos_adj(sp.lo());
+        let hi = self.lookup_char_pos_adj(sp.hi());
+        format!(
+            "{}:{}:{}: {}:{}",
+            lo.filename,
+            lo.line,
+            lo.col.to_usize() + 1,
+            hi.line,
+            hi.col.to_usize() + 1
+        )
+    }
+
+    pub fn span_to_filename(&self, sp: Span) -> FileName {
+        self.lookup_char_pos(sp.lo()).file.name.clone()
+    }
+
+    pub fn span_to_unmapped_path(&self, sp: Span) -> FileName {
+        self.lookup_char_pos(sp.lo())
+            .file
+            .unmapped_path
+            .clone()
+            .expect("SourceMap::span_to_unmapped_path called for imported SourceFile?")
+    }
+
+    pub fn is_multiline(&self, sp: Span) -> bool {
+        let lo = self.lookup_char_pos(sp.lo());
+        let hi = self.lookup_char_pos(sp.hi());
+        lo.line != hi.line
+    }
+
+    pub fn span_to_lines(&self, sp: Span) -> FileLinesResult {
+        debug!("span_to_lines(sp={:?})", sp);
+
+        if sp.lo() > sp.hi() {
+            return Err(SpanLinesError::IllFormedSpan(sp));
+        }
+
+        let lo = self.lookup_char_pos(sp.lo());
+        debug!("span_to_lines: lo={:?}", lo);
+        let hi = self.lookup_char_pos(sp.hi());
+        debug!("span_to_lines: hi={:?}", hi);
+
+        if lo.file.start_pos != hi.file.start_pos {
+            return Err(SpanLinesError::DistinctSources(DistinctSources {
+                begin: (lo.file.name.clone(), lo.file.start_pos),
+                end: (hi.file.name.clone(), hi.file.start_pos),
+            }));
+        }
+        assert!(hi.line >= lo.line);
+
+        let mut lines = Vec::with_capacity(hi.line - lo.line + 1);
+
+        // The span starts partway through the first line,
+        // but after that it starts from offset 0.
+        let mut start_col = lo.col;
+
+        // For every line but the last, it extends from `start_col`
+        // and to the end of the line. Be careful because the line
+        // numbers in Loc are 1-based, so we subtract 1 to get 0-based
+        // lines.
+        for line_index in lo.line - 1..hi.line - 1 {
+            let line_len = lo
+                .file
+                .get_line(line_index)
+                .map(|s| s.chars().count())
+                .unwrap_or(0);
+            lines.push(LineInfo {
+                line_index,
+                start_col,
+                end_col: CharPos::from_usize(line_len),
+            });
+            start_col = CharPos::from_usize(0);
+        }
+
+        // For the last line, it extends from `start_col` to `hi.col`:
+        lines.push(LineInfo {
+            line_index: hi.line - 1,
+            start_col,
+            end_col: hi.col,
+        });
+
+        Ok(FileLines {
+            file: lo.file,
+            lines,
+        })
+    }
+
+    /// Extract the source surrounding the given `Span` using the
+    /// `extract_source` function. The extract function takes three
+    /// arguments: a string slice containing the source, an index in
+    /// the slice for the beginning of the span and an index in the slice for
+    /// the end of the span.
+    fn span_to_source<F>(&self, sp: Span, extract_source: F) -> Result<String, SpanSnippetError>
+    where
+        F: Fn(&str, usize, usize) -> String,
+    {
+        if sp.lo() > sp.hi() {
+            return Err(SpanSnippetError::IllFormedSpan(sp));
+        }
+
+        let local_begin = self.lookup_byte_offset(sp.lo());
+        let local_end = self.lookup_byte_offset(sp.hi());
+
+        if local_begin.sf.start_pos != local_end.sf.start_pos {
+            return Err(SpanSnippetError::DistinctSources(DistinctSources {
+                begin: (local_begin.sf.name.clone(), local_begin.sf.start_pos),
+                end: (local_end.sf.name.clone(), local_end.sf.start_pos),
+            }));
+        } else {
+            // self.ensure_source_file_source_present(local_begin.sf.clone());
+
+            let start_index = local_begin.pos.to_usize();
+            let end_index = local_end.pos.to_usize();
+            let source_len = (local_begin.sf.end_pos - local_begin.sf.start_pos).to_usize();
+
+            if start_index > end_index || end_index > source_len {
+                return Err(SpanSnippetError::MalformedForSourcemap(
+                    MalformedSourceMapPositions {
+                        name: local_begin.sf.name.clone(),
+                        source_len,
+                        begin_pos: local_begin.pos,
+                        end_pos: local_end.pos,
+                    },
+                ));
+            }
+
+            return Ok(extract_source(&local_begin.sf.src, start_index, end_index));
+        }
+    }
+
+    /// Return the source snippet as `String` corresponding to the given `Span`
+    pub fn span_to_snippet(&self, sp: Span) -> Result<String, SpanSnippetError> {
+        self.span_to_source(sp, |src, start_index, end_index| {
+            src[start_index..end_index].to_string()
+        })
+    }
+
+    pub fn span_to_margin(&self, sp: Span) -> Option<usize> {
+        match self.span_to_prev_source(sp) {
+            Err(_) => None,
+            Ok(source) => source
+                .split('\n')
+                .last()
+                .map(|last_line| last_line.len() - last_line.trim_start().len()),
+        }
+    }
+
+    /// Return the source snippet as `String` before the given `Span`
+    pub fn span_to_prev_source(&self, sp: Span) -> Result<String, SpanSnippetError> {
+        self.span_to_source(sp, |src, start_index, _| src[..start_index].to_string())
+    }
+
+    /// Extend the given `Span` to just after the previous occurrence of `c`.
+    /// Return the same span if no character could be found or if an error
+    /// occurred while retrieving the code snippet.
+    pub fn span_extend_to_prev_char(&self, sp: Span, c: char) -> Span {
+        if let Ok(prev_source) = self.span_to_prev_source(sp) {
+            let prev_source = prev_source.rsplit(c).nth(0).unwrap_or("").trim_start();
+            if !prev_source.is_empty() && !prev_source.contains('\n') {
+                return sp.with_lo(BytePos(sp.lo().0 - prev_source.len() as u32));
+            }
+        }
+
+        sp
+    }
+
+    /// Extend the given `Span` to just after the previous occurrence of `pat`
+    /// when surrounded by whitespace. Return the same span if no character
+    /// could be found or if an error occurred while retrieving the code
+    /// snippet.
+    pub fn span_extend_to_prev_str(&self, sp: Span, pat: &str, accept_newlines: bool) -> Span {
+        // assure that the pattern is delimited, to avoid the following
+        //     fn my_fn()
+        //           ^^^^ returned span without the check
+        //     ---------- correct span
+        for ws in &[" ", "\t", "\n"] {
+            let pat = pat.to_owned() + ws;
+            if let Ok(prev_source) = self.span_to_prev_source(sp) {
+                let prev_source = prev_source.rsplit(&pat).nth(0).unwrap_or("").trim_start();
+                if !prev_source.is_empty() && (!prev_source.contains('\n') || accept_newlines) {
+                    return sp.with_lo(BytePos(sp.lo().0 - prev_source.len() as u32));
+                }
+            }
+        }
+
+        sp
+    }
+
+    /// Given a `Span`, try to get a shorter span ending before the first
+    /// occurrence of `c` `char`
+    pub fn span_until_char(&self, sp: Span, c: char) -> Span {
+        match self.span_to_snippet(sp) {
+            Ok(snippet) => {
+                let snippet = snippet.split(c).nth(0).unwrap_or("").trim_end();
+                if !snippet.is_empty() && !snippet.contains('\n') {
+                    sp.with_hi(BytePos(sp.lo().0 + snippet.len() as u32))
+                } else {
+                    sp
+                }
+            }
+            _ => sp,
+        }
+    }
+
+    /// Given a `Span`, try to get a shorter span ending just after the first
+    /// occurrence of `char` `c`.
+    pub fn span_through_char(&self, sp: Span, c: char) -> Span {
+        if let Ok(snippet) = self.span_to_snippet(sp) {
+            if let Some(offset) = snippet.find(c) {
+                return sp.with_hi(BytePos(sp.lo().0 + (offset + c.len_utf8()) as u32));
+            }
+        }
+        sp
+    }
+
+    /// Given a `Span`, get a new `Span` covering the first token and all its
+    /// trailing whitespace or the original `Span`.
+    ///
+    /// If `sp` points to `"let mut x"`, then a span pointing at `"let "` will
+    /// be returned.
+    pub fn span_until_non_whitespace(&self, sp: Span) -> Span {
+        let mut whitespace_found = false;
+
+        self.span_take_while(sp, |c| {
+            if !whitespace_found && c.is_whitespace() {
+                whitespace_found = true;
+            }
+
+            if whitespace_found && !c.is_whitespace() {
+                false
+            } else {
+                true
+            }
+        })
+    }
+
+    /// Given a `Span`, get a new `Span` covering the first token without its
+    /// trailing whitespace or the original `Span` in case of error.
+    ///
+    /// If `sp` points to `"let mut x"`, then a span pointing at `"let"` will be
+    /// returned.
+    pub fn span_until_whitespace(&self, sp: Span) -> Span {
+        self.span_take_while(sp, |c| !c.is_whitespace())
+    }
+
+    /// Given a `Span`, get a shorter one until `predicate` yields false.
+    pub fn span_take_while<P>(&self, sp: Span, predicate: P) -> Span
+    where
+        P: for<'r> FnMut(&'r char) -> bool,
+    {
+        if let Ok(snippet) = self.span_to_snippet(sp) {
+            let offset = snippet
+                .chars()
+                .take_while(predicate)
+                .map(|c| c.len_utf8())
+                .sum::<usize>();
+
+            sp.with_hi(BytePos(sp.lo().0 + (offset as u32)))
+        } else {
+            sp
+        }
+    }
+
+    pub fn def_span(&self, sp: Span) -> Span {
+        self.span_until_char(sp, '{')
+    }
+
+    /// Returns a new span representing just the start-point of this span
+    pub fn start_point(&self, sp: Span) -> Span {
+        let pos = sp.lo().0;
+        let width = self.find_width_of_character_at_span(sp, false);
+        let corrected_start_position = pos.checked_add(width).unwrap_or(pos);
+        let end_point = BytePos(cmp::max(corrected_start_position, sp.lo().0));
+        sp.with_hi(end_point)
+    }
+
+    /// Returns a new span representing just the end-point of this span
+    pub fn end_point(&self, sp: Span) -> Span {
+        let pos = sp.hi().0;
+
+        let width = self.find_width_of_character_at_span(sp, false);
+        let corrected_end_position = pos.checked_sub(width).unwrap_or(pos);
+
+        let end_point = BytePos(cmp::max(corrected_end_position, sp.lo().0));
+        sp.with_lo(end_point)
+    }
+
+    /// Returns a new span representing the next character after the end-point
+    /// of this span
+    pub fn next_point(&self, sp: Span) -> Span {
+        let start_of_next_point = sp.hi().0;
+
+        let width = self.find_width_of_character_at_span(sp, true);
+        // If the width is 1, then the next span should point to the same `lo` and `hi`.
+        // However, in the case of a multibyte character, where the width != 1,
+        // the next span should span multiple bytes to include the whole
+        // character.
+        let end_of_next_point = start_of_next_point
+            .checked_add(width - 1)
+            .unwrap_or(start_of_next_point);
+
+        let end_of_next_point = BytePos(cmp::max(sp.lo().0 + 1, end_of_next_point));
+        Span::new(BytePos(start_of_next_point), end_of_next_point, sp.ctxt())
+    }
+
+    /// Finds the width of a character, either before or after the provided
+    /// span.
+    fn find_width_of_character_at_span(&self, sp: Span, forwards: bool) -> u32 {
+        // Disregard malformed spans and assume a one-byte wide character.
+        if sp.lo() >= sp.hi() {
+            debug!("find_width_of_character_at_span: early return malformed span");
+            return 1;
+        }
+
+        let local_begin = self.lookup_byte_offset(sp.lo());
+        let local_end = self.lookup_byte_offset(sp.hi());
+        debug!(
+            "find_width_of_character_at_span: local_begin=`{:?}`, local_end=`{:?}`",
+            local_begin, local_end
+        );
+
+        let start_index = local_begin.pos.to_usize();
+        let end_index = local_end.pos.to_usize();
+        debug!(
+            "find_width_of_character_at_span: start_index=`{:?}`, end_index=`{:?}`",
+            start_index, end_index
+        );
+
+        // Disregard indexes that are at the start or end of their spans, they can't fit
+        // bigger characters.
+        if (!forwards && end_index == usize::min_value())
+            || (forwards && start_index == usize::max_value())
+        {
+            debug!("find_width_of_character_at_span: start or end of span, cannot be multibyte");
+            return 1;
+        }
+
+        let source_len = (local_begin.sf.end_pos - local_begin.sf.start_pos).to_usize();
+        debug!(
+            "find_width_of_character_at_span: source_len=`{:?}`",
+            source_len
+        );
+        // Ensure indexes are also not malformed.
+        if start_index > end_index || end_index > source_len {
+            debug!("find_width_of_character_at_span: source indexes are malformed");
+            return 1;
+        }
+
+        let src = &local_begin.sf.src;
+
+        // We need to extend the snippet to the end of the src rather than to end_index
+        // so when searching forwards for boundaries we've got somewhere to
+        // search.
+        let snippet = {
+            let len = local_begin.sf.src.len();
+            (&src[start_index..len])
+        };
+        debug!("find_width_of_character_at_span: snippet=`{:?}`", snippet);
+
+        let mut target = if forwards {
+            end_index + 1
+        } else {
+            end_index - 1
+        };
+        debug!(
+            "find_width_of_character_at_span: initial target=`{:?}`",
+            target
+        );
+
+        while !snippet.is_char_boundary(target - start_index) && target < source_len {
+            target = if forwards {
+                target + 1
+            } else {
+                match target.checked_sub(1) {
+                    Some(target) => target,
+                    None => {
+                        break;
+                    }
+                }
+            };
+            debug!("find_width_of_character_at_span: target=`{:?}`", target);
+        }
+        debug!(
+            "find_width_of_character_at_span: final target=`{:?}`",
+            target
+        );
+
+        if forwards {
+            (target - end_index) as u32
+        } else {
+            (end_index - target) as u32
+        }
+    }
+
+    pub fn get_source_file(&self, filename: &FileName) -> Option<Lrc<SourceFile>> {
+        for sf in self.files.borrow().source_files.iter() {
+            if *filename == sf.name {
+                return Some(sf.clone());
+            }
+        }
+        None
+    }
+
+    /// For a global BytePos compute the local offset within the containing
+    /// SourceFile
+    pub fn lookup_byte_offset(&self, bpos: BytePos) -> SourceFileAndBytePos {
+        let idx = self.lookup_source_file_idx(bpos);
+        let sf = (*self.files.borrow().source_files)[idx].clone();
+        let offset = bpos - sf.start_pos;
+        SourceFileAndBytePos { sf, pos: offset }
+    }
+
+    /// Converts an absolute BytePos to a CharPos relative to the source_file.
+    pub fn bytepos_to_file_charpos(&self, bpos: BytePos) -> CharPos {
+        let idx = self.lookup_source_file_idx(bpos);
+        let map = &(*self.files.borrow().source_files)[idx];
+
+        // The number of extra bytes due to multibyte chars in the SourceFile
+        let mut total_extra_bytes = 0;
+
+        for mbc in map.multibyte_chars.iter() {
+            debug!("{}-byte char at {:?}", mbc.bytes, mbc.pos);
+            if mbc.pos < bpos {
+                // every character is at least one byte, so we only
+                // count the actual extra bytes.
+                total_extra_bytes += mbc.bytes as u32 - 1;
+                // We should never see a byte position in the middle of a
+                // character
+                assert!(bpos.to_u32() >= mbc.pos.to_u32() + mbc.bytes as u32);
+            } else {
+                break;
+            }
+        }
+
+        assert!(map.start_pos.to_u32() + total_extra_bytes <= bpos.to_u32());
+        CharPos(bpos.to_usize() - map.start_pos.to_usize() - total_extra_bytes as usize)
+    }
+
+    // Return the index of the source_file (in self.files) which contains pos.
+    pub fn lookup_source_file_idx(&self, pos: BytePos) -> usize {
+        let files = self.files.borrow();
+        let files = &files.source_files;
+        let count = files.len();
+
+        // Binary search for the source_file.
+        let mut a = 0;
+        let mut b = count;
+        while b - a > 1 {
+            let m = (a + b) / 2;
+            if files[m].start_pos > pos {
+                b = m;
+            } else {
+                a = m;
+            }
+        }
+
+        assert!(
+            a < count,
+            "position {} does not resolve to a source location",
+            pos.to_usize()
+        );
+
+        return a;
+    }
+
+    pub fn count_lines(&self) -> usize {
+        self.files().iter().fold(0, |a, f| a + f.count_lines())
+    }
+
+    pub fn generate_fn_name_span(&self, span: Span) -> Option<Span> {
+        let prev_span = self.span_extend_to_prev_str(span, "fn", true);
+        self.span_to_snippet(prev_span)
+            .map(|snippet| {
+                let len = snippet
+                    .find(|c: char| !c.is_alphanumeric() && c != '_')
+                    .expect("no label after fn");
+                prev_span.with_hi(BytePos(prev_span.lo().0 + len as u32))
+            })
+            .ok()
+    }
+
+    /// Take the span of a type parameter in a function signature and try to
+    /// generate a span for the function name (with generics) and a new
+    /// snippet for this span with the pointed type parameter as a new local
+    /// type parameter.
+    ///
+    /// For instance:
+    /// ```rust,ignore (pseudo-Rust)
+    /// // Given span
+    /// fn my_function(param: T)
+    /// //                    ^ Original span
+    ///
+    /// // Result
+    /// fn my_function(param: T)
+    /// // ^^^^^^^^^^^ Generated span with snippet `my_function<T>`
+    /// ```
+    ///
+    /// Attention: The method used is very fragile since it essentially
+    /// duplicates the work of the parser. If you need to use this function
+    /// or something similar, please consider updating the source_map
+    /// functions and this function to something more robust.
+    pub fn generate_local_type_param_snippet(&self, span: Span) -> Option<(Span, String)> {
+        // Try to extend the span to the previous "fn" keyword to retrieve the function
+        // signature
+        let sugg_span = self.span_extend_to_prev_str(span, "fn", false);
+        if sugg_span != span {
+            if let Ok(snippet) = self.span_to_snippet(sugg_span) {
+                // Consume the function name
+                let mut offset = snippet
+                    .find(|c: char| !c.is_alphanumeric() && c != '_')
+                    .expect("no label after fn");
+
+                // Consume the generics part of the function signature
+                let mut bracket_counter = 0;
+                let mut last_char = None;
+                for c in snippet[offset..].chars() {
+                    match c {
+                        '<' => bracket_counter += 1,
+                        '>' => bracket_counter -= 1,
+                        '(' => {
+                            if bracket_counter == 0 {
+                                break;
+                            }
+                        }
+                        _ => {}
+                    }
+                    offset += c.len_utf8();
+                    last_char = Some(c);
+                }
+
+                // Adjust the suggestion span to encompass the function name with its generics
+                let sugg_span = sugg_span.with_hi(BytePos(sugg_span.lo().0 + offset as u32));
+
+                // Prepare the new suggested snippet to append the type parameter that triggered
+                // the error in the generics of the function signature
+                let mut new_snippet = if last_char == Some('>') {
+                    format!("{}, ", &snippet[..(offset - '>'.len_utf8())])
+                } else {
+                    format!("{}<", &snippet[..offset])
+                };
+                new_snippet.push_str(
+                    &self
+                        .span_to_snippet(span)
+                        .unwrap_or_else(|_| "T".to_string()),
+                );
+                new_snippet.push('>');
+
+                return Some((sugg_span, new_snippet));
+            }
+        }
+
+        None
+    }
+}
+
+impl SourceMapper for SourceMap {
+    fn lookup_char_pos(&self, pos: BytePos) -> Loc {
+        self.lookup_char_pos(pos)
+    }
+    fn span_to_lines(&self, sp: Span) -> FileLinesResult {
+        self.span_to_lines(sp)
+    }
+    fn span_to_string(&self, sp: Span) -> String {
+        self.span_to_string(sp)
+    }
+    fn span_to_filename(&self, sp: Span) -> FileName {
+        self.span_to_filename(sp)
+    }
+    fn merge_spans(&self, sp_lhs: Span, sp_rhs: Span) -> Option<Span> {
+        self.merge_spans(sp_lhs, sp_rhs)
+    }
+    fn call_span_if_macro(&self, sp: Span) -> Span {
+        // if self.span_to_filename(sp.clone()).is_macros() {
+        //     let v = sp.macro_backtrace();
+        //     if let Some(use_site) = v.last() {
+        //         return use_site.call_site;
+        //     }
+        // }
+        sp
+    }
+
+    fn doctest_offset_line(&self, file: &FileName, line: usize) -> usize {
+        self.doctest_offset_line(file, line)
+    }
+}
+
+#[derive(Clone)]
+pub struct FilePathMapping {
+    mapping: Vec<(PathBuf, PathBuf)>,
+}
+
+impl FilePathMapping {
+    pub fn empty() -> FilePathMapping {
+        FilePathMapping { mapping: vec![] }
+    }
+
+    pub fn new(mapping: Vec<(PathBuf, PathBuf)>) -> FilePathMapping {
+        FilePathMapping { mapping }
+    }
+
+    /// Applies any path prefix substitution as defined by the mapping.
+    /// The return value is the remapped path and a boolean indicating whether
+    /// the path was affected by the mapping.
+    pub fn map_prefix(&self, path: PathBuf) -> (PathBuf, bool) {
+        // NOTE: We are iterating over the mapping entries from last to first
+        //       because entries specified later on the command line should
+        //       take precedence.
+        for &(ref from, ref to) in self.mapping.iter().rev() {
+            if let Ok(rest) = path.strip_prefix(from) {
+                return (to.join(rest), true);
+            }
+        }
+
+        (path, false)
+    }
+}
+
+// _____________________________________________________________________________
+// Tests
+//
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rustc_data_structures::sync::Lrc;
+
+    fn init_source_map() -> SourceMap {
+        let sm = SourceMap::new(FilePathMapping::empty());
+        sm.new_source_file(
+            PathBuf::from("blork.rs").into(),
+            "first line.\nsecond line".to_string(),
+        );
+        sm.new_source_file(PathBuf::from("empty.rs").into(), String::new());
+        sm.new_source_file(
+            PathBuf::from("blork2.rs").into(),
+            "first line.\nsecond line".to_string(),
+        );
+        sm
+    }
+
+    #[test]
+    fn t3() {
+        // Test lookup_byte_offset
+        let sm = init_source_map();
+
+        let srcfbp1 = sm.lookup_byte_offset(BytePos(23));
+        assert_eq!(srcfbp1.sf.name, PathBuf::from("blork.rs").into());
+        assert_eq!(srcfbp1.pos, BytePos(23));
+
+        let srcfbp1 = sm.lookup_byte_offset(BytePos(24));
+        assert_eq!(srcfbp1.sf.name, PathBuf::from("empty.rs").into());
+        assert_eq!(srcfbp1.pos, BytePos(0));
+
+        let srcfbp2 = sm.lookup_byte_offset(BytePos(25));
+        assert_eq!(srcfbp2.sf.name, PathBuf::from("blork2.rs").into());
+        assert_eq!(srcfbp2.pos, BytePos(0));
+    }
+
+    #[test]
+    fn t4() {
+        // Test bytepos_to_file_charpos
+        let sm = init_source_map();
+
+        let cp1 = sm.bytepos_to_file_charpos(BytePos(22));
+        assert_eq!(cp1, CharPos(22));
+
+        let cp2 = sm.bytepos_to_file_charpos(BytePos(25));
+        assert_eq!(cp2, CharPos(0));
+    }
+
+    #[test]
+    fn t5() {
+        // Test zero-length source_files.
+        let sm = init_source_map();
+
+        let loc1 = sm.lookup_char_pos(BytePos(22));
+        assert_eq!(loc1.file.name, PathBuf::from("blork.rs").into());
+        assert_eq!(loc1.line, 2);
+        assert_eq!(loc1.col, CharPos(10));
+
+        let loc2 = sm.lookup_char_pos(BytePos(25));
+        assert_eq!(loc2.file.name, PathBuf::from("blork2.rs").into());
+        assert_eq!(loc2.line, 1);
+        assert_eq!(loc2.col, CharPos(0));
+    }
+
+    fn init_source_map_mbc() -> SourceMap {
+        let sm = SourceMap::new(FilePathMapping::empty());
+        // € is a three byte utf8 char.
+        sm.new_source_file(
+            PathBuf::from("blork.rs").into(),
+            "fir€st €€€€ line.\nsecond line".to_string(),
+        );
+        sm.new_source_file(
+            PathBuf::from("blork2.rs").into(),
+            "first line€€.\n€ second line".to_string(),
+        );
+        sm
+    }
+
+    #[test]
+    fn t6() {
+        // Test bytepos_to_file_charpos in the presence of multi-byte chars
+        let sm = init_source_map_mbc();
+
+        let cp1 = sm.bytepos_to_file_charpos(BytePos(3));
+        assert_eq!(cp1, CharPos(3));
+
+        let cp2 = sm.bytepos_to_file_charpos(BytePos(6));
+        assert_eq!(cp2, CharPos(4));
+
+        let cp3 = sm.bytepos_to_file_charpos(BytePos(56));
+        assert_eq!(cp3, CharPos(12));
+
+        let cp4 = sm.bytepos_to_file_charpos(BytePos(61));
+        assert_eq!(cp4, CharPos(15));
+    }
+
+    #[test]
+    fn t7() {
+        // Test span_to_lines for a span ending at the end of source_file
+        let sm = init_source_map();
+        let span = Span::new(BytePos(12), BytePos(23), NO_EXPANSION);
+        let file_lines = sm.span_to_lines(span).unwrap();
+
+        assert_eq!(file_lines.file.name, PathBuf::from("blork.rs").into());
+        assert_eq!(file_lines.lines.len(), 1);
+        assert_eq!(file_lines.lines[0].line_index, 1);
+    }
+
+    /// Given a string like " ~~~~~~~~~~~~ ", produces a span
+    /// converting that range. The idea is that the string has the same
+    /// length as the input, and we uncover the byte positions.  Note
+    /// that this can span lines and so on.
+    fn span_from_selection(input: &str, selection: &str) -> Span {
+        assert_eq!(input.len(), selection.len());
+        let left_index = selection.find('~').unwrap() as u32;
+        let right_index = selection.rfind('~').map(|x| x as u32).unwrap_or(left_index);
+        Span::new(BytePos(left_index), BytePos(right_index + 1), NO_EXPANSION)
+    }
+
+    /// Test span_to_snippet and span_to_lines for a span converting 3
+    /// lines in the middle of a file.
+    #[test]
+    fn span_to_snippet_and_lines_spanning_multiple_lines() {
+        let sm = SourceMap::new(FilePathMapping::empty());
+        let inputtext = "aaaaa\nbbbbBB\nCCC\nDDDDDddddd\neee\n";
+        let selection = "     \n    ~~\n~~~\n~~~~~     \n   \n";
+        sm.new_source_file(
+            Path::new("blork.rs").to_owned().into(),
+            inputtext.to_string(),
+        );
+        let span = span_from_selection(inputtext, selection);
+
+        // check that we are extracting the text we thought we were extracting
+        assert_eq!(&sm.span_to_snippet(span).unwrap(), "BB\nCCC\nDDDDD");
+
+        // check that span_to_lines gives us the complete result with the lines/cols we
+        // expected
+        let lines = sm.span_to_lines(span).unwrap();
+        let expected = vec![
+            LineInfo {
+                line_index: 1,
+                start_col: CharPos(4),
+                end_col: CharPos(6),
+            },
+            LineInfo {
+                line_index: 2,
+                start_col: CharPos(0),
+                end_col: CharPos(3),
+            },
+            LineInfo {
+                line_index: 3,
+                start_col: CharPos(0),
+                end_col: CharPos(5),
+            },
+        ];
+        assert_eq!(lines.lines, expected);
+    }
+
+    #[test]
+    fn t8() {
+        // Test span_to_snippet for a span ending at the end of source_file
+        let sm = init_source_map();
+        let span = Span::new(BytePos(12), BytePos(23), NO_EXPANSION);
+        let snippet = sm.span_to_snippet(span);
+
+        assert_eq!(snippet, Ok("second line".to_string()));
+    }
+
+    #[test]
+    fn t9() {
+        // Test span_to_str for a span ending at the end of source_file
+        let sm = init_source_map();
+        let span = Span::new(BytePos(12), BytePos(23), NO_EXPANSION);
+        let sstr = sm.span_to_string(span);
+
+        assert_eq!(sstr, "blork.rs:2:1: 2:12");
+    }
+
+    /// Test failing to merge two spans on different lines
+    #[test]
+    fn span_merging_fail() {
+        let sm = SourceMap::new(FilePathMapping::empty());
+        let inputtext = "bbbb BB\ncc CCC\n";
+        let selection1 = "     ~~\n      \n";
+        let selection2 = "       \n   ~~~\n";
+        sm.new_source_file(
+            Path::new("blork.rs").to_owned().into(),
+            inputtext.to_owned(),
+        );
+        let span1 = span_from_selection(inputtext, selection1);
+        let span2 = span_from_selection(inputtext, selection2);
+
+        assert!(sm.merge_spans(span1, span2).is_none());
+    }
+
+    /// Returns the span corresponding to the `n`th occurrence of
+    /// `substring` in `source_text`.
+    trait SourceMapExtension {
+        fn span_substr(
+            &self,
+            file: &Lrc<SourceFile>,
+            source_text: &str,
+            substring: &str,
+            n: usize,
+        ) -> Span;
+    }
+
+    impl SourceMapExtension for SourceMap {
+        fn span_substr(
+            &self,
+            file: &Lrc<SourceFile>,
+            source_text: &str,
+            substring: &str,
+            n: usize,
+        ) -> Span {
+            println!(
+                "span_substr(file={:?}/{:?}, substring={:?}, n={})",
+                file.name, file.start_pos, substring, n
+            );
+            let mut i = 0;
+            let mut hi = 0;
+            loop {
+                let offset = source_text[hi..].find(substring).unwrap_or_else(|| {
+                    panic!(
+                        "source_text `{}` does not have {} occurrences of `{}`, only {}",
+                        source_text, n, substring, i
+                    );
+                });
+                let lo = hi + offset;
+                hi = lo + substring.len();
+                if i == n {
+                    let span = Span::new(
+                        BytePos(lo as u32 + file.start_pos.0),
+                        BytePos(hi as u32 + file.start_pos.0),
+                        NO_EXPANSION,
+                    );
+                    assert_eq!(&self.span_to_snippet(span).unwrap()[..], substring);
+                    return span;
+                }
+                i += 1;
+            }
+        }
+    }
+}
diff --git a/common/src/sync.rs b/common/src/sync.rs
new file mode 100644
index 000000000000..dee6634f0685
--- /dev/null
+++ b/common/src/sync.rs
@@ -0,0 +1,476 @@
+//! This module defines types which are thread safe if cfg!(parallel_queries) is
+//! true.
+//!
+//! `Lrc` is an alias of either Rc or Arc.
+//!
+//! `Lock` is a mutex.
+//! It internally uses `parking_lot::Mutex` if cfg!(parallel_queries) is true,
+//! `RefCell` otherwise.
+//!
+//! `RwLock` is a read-write lock.
+//! It internally uses `parking_lot::RwLock` if cfg!(parallel_queries) is true,
+//! `RefCell` otherwise.
+//!
+//! `MTLock` is a mutex which disappears if cfg!(parallel_queries) is false.
+//!
+//! `MTRef` is a immutable reference if cfg!(parallel_queries), and an mutable
+//! reference otherwise.
+//!
+//! `rustc_erase_owner!` erases a OwningRef owner into Erased or Erased + Send +
+//! Sync depending on the value of cfg!(parallel_queries).
+
+use owning_ref::{Erased, OwningRef};
+use std::{
+    collections::HashMap,
+    hash::{BuildHasher, Hash},
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+};
+
+pub fn serial_join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
+where
+    A: FnOnce() -> RA,
+    B: FnOnce() -> RB,
+{
+    (oper_a(), oper_b())
+}
+
+pub struct SerialScope;
+
+impl SerialScope {
+    pub fn spawn<F>(&self, f: F)
+    where
+        F: FnOnce(&SerialScope),
+    {
+        f(self)
+    }
+}
+
+pub fn serial_scope<F, R>(f: F) -> R
+where
+    F: FnOnce(&SerialScope) -> R,
+{
+    f(&SerialScope)
+}
+
+pub use std::sync::atomic::Ordering::{self, SeqCst};
+
+pub use std::marker::{Send, Sync};
+
+pub use parking_lot::{
+    MappedRwLockReadGuard as MappedReadGuard, MappedRwLockWriteGuard as MappedWriteGuard,
+    RwLockReadGuard as ReadGuard, RwLockWriteGuard as WriteGuard,
+};
+
+pub use parking_lot::{MappedMutexGuard as MappedLockGuard, MutexGuard as LockGuard};
+
+pub use std::sync::atomic::{AtomicBool, AtomicUsize};
+
+pub use std::sync::{Arc as Lrc, Weak};
+
+pub type MTRef<'a, T> = &'a T;
+
+#[derive(Debug, Default)]
+pub struct MTLock<T>(Lock<T>);
+
+impl<T> MTLock<T> {
+    #[inline(always)]
+    pub fn new(inner: T) -> Self {
+        MTLock(Lock::new(inner))
+    }
+
+    #[inline(always)]
+    pub fn into_inner(self) -> T {
+        self.0.into_inner()
+    }
+
+    #[inline(always)]
+    pub fn get_mut(&mut self) -> &mut T {
+        self.0.get_mut()
+    }
+
+    #[inline(always)]
+    pub fn lock(&self) -> LockGuard<T> {
+        self.0.lock()
+    }
+
+    #[inline(always)]
+    pub fn lock_mut(&self) -> LockGuard<T> {
+        self.lock()
+    }
+}
+
+use parking_lot::{Mutex as InnerLock, RwLock as InnerRwLock};
+
+pub use rayon::{join, scope};
+use std::{self, thread};
+
+use rayon::iter::IntoParallelIterator;
+pub use rayon::iter::ParallelIterator;
+
+pub fn par_iter<T: IntoParallelIterator>(t: T) -> T::Iter {
+    t.into_par_iter()
+}
+
+pub type MetadataRef = OwningRef<Box<dyn Erased + Send + Sync>, [u8]>;
+
+/// This makes locks panic if they are already held.
+/// It is only useful when you are running in a single thread
+const ERROR_CHECKING: bool = false;
+
+#[macro_export]
+macro_rules! rustc_erase_owner {
+    ($v:expr) => {{
+        let v = $v;
+        ::data_structures::sync::assert_send_val(&v);
+        v.erase_send_sync_owner()
+    }};
+}
+
+pub fn assert_sync<T: ?Sized + Sync>() {}
+pub fn assert_send<T: ?Sized + Send>() {}
+pub fn assert_send_val<T: ?Sized + Send>(_t: &T) {}
+pub fn assert_send_sync_val<T: ?Sized + Sync + Send>(_t: &T) {}
+
+pub trait HashMapExt<K, V> {
+    /// Same as HashMap::insert, but it may panic if there's already an
+    /// entry for `key` with a value not equal to `value`
+    fn insert_same(&mut self, key: K, value: V);
+}
+
+impl<K: Eq + Hash, V: Eq, S: BuildHasher> HashMapExt<K, V> for HashMap<K, V, S> {
+    fn insert_same(&mut self, key: K, value: V) {
+        self.entry(key)
+            .and_modify(|old| assert!(*old == value))
+            .or_insert(value);
+    }
+}
+
+/// A type whose inner value can be written once and then will stay read-only
+// This contains a PhantomData<T> since this type conceptually owns a T outside
+// the Mutex once initialized. This ensures that Once<T> is Sync only if T is.
+// If we did not have PhantomData<T> we could send a &Once<Cell<bool>> to
+// multiple threads and call `get` on it to get access to &Cell<bool> on those
+// threads.
+pub struct Once<T>(Lock<Option<T>>, PhantomData<T>);
+
+impl<T> Once<T> {
+    /// Creates an Once value which is uninitialized
+    #[inline(always)]
+    pub fn new() -> Self {
+        Once(Lock::new(None), PhantomData)
+    }
+
+    /// Consumes the value and returns Some(T) if it was initialized
+    #[inline(always)]
+    pub fn into_inner(self) -> Option<T> {
+        self.0.into_inner()
+    }
+
+    /// Tries to initialize the inner value to `value`.
+    /// Returns `None` if the inner value was uninitialized and `value` was
+    /// consumed setting it otherwise if the inner value was already set it
+    /// returns `value` back to the caller
+    #[inline]
+    pub fn try_set(&self, value: T) -> Option<T> {
+        let mut lock = self.0.lock();
+        if lock.is_some() {
+            return Some(value);
+        }
+        *lock = Some(value);
+        None
+    }
+
+    /// Tries to initialize the inner value to `value`.
+    /// Returns `None` if the inner value was uninitialized and `value` was
+    /// consumed setting it otherwise if the inner value was already set it
+    /// asserts that `value` is equal to the inner value and then returns
+    /// `value` back to the caller
+    #[inline]
+    pub fn try_set_same(&self, value: T) -> Option<T>
+    where
+        T: Eq,
+    {
+        let mut lock = self.0.lock();
+        if let Some(ref inner) = *lock {
+            assert!(*inner == value);
+            return Some(value);
+        }
+        *lock = Some(value);
+        None
+    }
+
+    /// Tries to initialize the inner value to `value` and panics if it was
+    /// already initialized
+    #[inline]
+    pub fn set(&self, value: T) {
+        assert!(self.try_set(value).is_none());
+    }
+
+    /// Tries to initialize the inner value by calling the closure while
+    /// ensuring that no-one else can access the value in the mean time by
+    /// holding a lock for the duration of the closure. If the value was
+    /// already initialized the closure is not called and `false` is returned,
+    /// otherwise if the value from the closure initializes the inner value,
+    /// `true` is returned
+    #[inline]
+    pub fn init_locking<F: FnOnce() -> T>(&self, f: F) -> bool {
+        let mut lock = self.0.lock();
+        if lock.is_some() {
+            return false;
+        }
+        *lock = Some(f());
+        true
+    }
+
+    /// Tries to initialize the inner value by calling the closure without
+    /// ensuring that no-one else can access it. This mean when this is
+    /// called from multiple threads, multiple closures may concurrently be
+    /// computing a value which the inner value should take. Only one of
+    /// these closures are used to actually initialize the value.
+    /// If some other closure already set the value,
+    /// we return the value our closure computed wrapped in a `Option`.
+    /// If our closure set the value, `None` is returned.
+    /// If the value is already initialized, the closure is not called and
+    /// `None` is returned.
+    #[inline]
+    pub fn init_nonlocking<F: FnOnce() -> T>(&self, f: F) -> Option<T> {
+        if self.0.lock().is_some() {
+            None
+        } else {
+            self.try_set(f())
+        }
+    }
+
+    /// Tries to initialize the inner value by calling the closure without
+    /// ensuring that no-one else can access it. This mean when this is
+    /// called from multiple threads, multiple closures may concurrently be
+    /// computing a value which the inner value should take. Only one of
+    /// these closures are used to actually initialize the value.
+    /// If some other closure already set the value, we assert that it our
+    /// closure computed a value equal to the value already set and then
+    /// we return the value our closure computed wrapped in a `Option`.
+    /// If our closure set the value, `None` is returned.
+    /// If the value is already initialized, the closure is not called and
+    /// `None` is returned.
+    #[inline]
+    pub fn init_nonlocking_same<F: FnOnce() -> T>(&self, f: F) -> Option<T>
+    where
+        T: Eq,
+    {
+        if self.0.lock().is_some() {
+            None
+        } else {
+            self.try_set_same(f())
+        }
+    }
+
+    /// Tries to get a reference to the inner value, returns `None` if it is not
+    /// yet initialized
+    #[inline(always)]
+    pub fn try_get(&self) -> Option<&T> {
+        let lock = &*self.0.lock();
+        if let Some(ref inner) = *lock {
+            // This is safe since we won't mutate the inner value
+            unsafe { Some(&*(inner as *const T)) }
+        } else {
+            None
+        }
+    }
+
+    /// Gets reference to the inner value, panics if it is not yet initialized
+    #[inline(always)]
+    pub fn get(&self) -> &T {
+        self.try_get().expect("value was not set")
+    }
+
+    /// Gets reference to the inner value, panics if it is not yet initialized
+    #[inline(always)]
+    pub fn borrow(&self) -> &T {
+        self.get()
+    }
+}
+
+#[derive(Debug)]
+pub struct Lock<T>(InnerLock<T>);
+
+impl<T> Lock<T> {
+    #[inline(always)]
+    pub fn new(inner: T) -> Self {
+        Lock(InnerLock::new(inner))
+    }
+
+    #[inline(always)]
+    pub fn into_inner(self) -> T {
+        self.0.into_inner()
+    }
+
+    #[inline(always)]
+    pub fn get_mut(&mut self) -> &mut T {
+        self.0.get_mut()
+    }
+
+    #[inline(always)]
+    pub fn try_lock(&self) -> Option<LockGuard<T>> {
+        self.0.try_lock()
+    }
+
+    #[inline(always)]
+    pub fn lock(&self) -> LockGuard<T> {
+        if ERROR_CHECKING {
+            self.0.try_lock().expect("lock was already held")
+        } else {
+            self.0.lock()
+        }
+    }
+
+    #[inline(always)]
+    pub fn with_lock<F: FnOnce(&mut T) -> R, R>(&self, f: F) -> R {
+        f(&mut *self.lock())
+    }
+
+    #[inline(always)]
+    pub fn borrow(&self) -> LockGuard<T> {
+        self.lock()
+    }
+
+    #[inline(always)]
+    pub fn borrow_mut(&self) -> LockGuard<T> {
+        self.lock()
+    }
+}
+
+impl<T: Default> Default for Lock<T> {
+    #[inline]
+    fn default() -> Self {
+        Lock::new(T::default())
+    }
+}
+
+// FIXME: Probably a bad idea
+impl<T: Clone> Clone for Lock<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Lock::new(self.borrow().clone())
+    }
+}
+
+#[derive(Debug)]
+pub struct RwLock<T>(InnerRwLock<T>);
+
+impl<T> RwLock<T> {
+    #[inline(always)]
+    pub fn new(inner: T) -> Self {
+        RwLock(InnerRwLock::new(inner))
+    }
+
+    #[inline(always)]
+    pub fn into_inner(self) -> T {
+        self.0.into_inner()
+    }
+
+    #[inline(always)]
+    pub fn get_mut(&mut self) -> &mut T {
+        self.0.get_mut()
+    }
+
+    #[inline(always)]
+    pub fn read(&self) -> ReadGuard<T> {
+        if ERROR_CHECKING {
+            self.0.try_read().expect("lock was already held")
+        } else {
+            self.0.read()
+        }
+    }
+
+    #[inline(always)]
+    pub fn with_read_lock<F: FnOnce(&T) -> R, R>(&self, f: F) -> R {
+        f(&*self.read())
+    }
+
+    #[inline(always)]
+    pub fn try_write(&self) -> Result<WriteGuard<T>, ()> {
+        self.0.try_write().ok_or(())
+    }
+
+    #[inline(always)]
+    pub fn write(&self) -> WriteGuard<T> {
+        if ERROR_CHECKING {
+            self.0.try_write().expect("lock was already held")
+        } else {
+            self.0.write()
+        }
+    }
+
+    #[inline(always)]
+    pub fn with_write_lock<F: FnOnce(&mut T) -> R, R>(&self, f: F) -> R {
+        f(&mut *self.write())
+    }
+
+    #[inline(always)]
+    pub fn borrow(&self) -> ReadGuard<T> {
+        self.read()
+    }
+
+    #[inline(always)]
+    pub fn borrow_mut(&self) -> WriteGuard<T> {
+        self.write()
+    }
+}
+
+// FIXME: Probably a bad idea
+impl<T: Clone> Clone for RwLock<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        RwLock::new(self.borrow().clone())
+    }
+}
+
+/// A type which only allows its inner value to be used in one thread.
+/// It will panic if it is used on multiple threads.
+#[derive(Copy, Clone, Hash, Debug, Eq, PartialEq)]
+pub struct OneThread<T> {
+    thread: thread::ThreadId,
+    inner: T,
+}
+
+unsafe impl<T> std::marker::Sync for OneThread<T> {}
+
+unsafe impl<T> std::marker::Send for OneThread<T> {}
+
+impl<T> OneThread<T> {
+    #[inline(always)]
+    fn check(&self) {
+        assert_eq!(thread::current().id(), self.thread);
+    }
+
+    #[inline(always)]
+    pub fn new(inner: T) -> Self {
+        OneThread {
+            thread: thread::current().id(),
+            inner,
+        }
+    }
+
+    #[inline(always)]
+    pub fn into_inner(value: Self) -> T {
+        value.check();
+        value.inner
+    }
+}
+
+impl<T> Deref for OneThread<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.check();
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for OneThread<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        self.check();
+        &mut self.inner
+    }
+}
diff --git a/common/src/syntax_pos/analyze_source_file.rs b/common/src/syntax_pos/analyze_source_file.rs
new file mode 100644
index 000000000000..f2752db45ee2
--- /dev/null
+++ b/common/src/syntax_pos/analyze_source_file.rs
@@ -0,0 +1,418 @@
+use super::*;
+use unicode_width::UnicodeWidthChar;
+
+/// Find all newlines, multi-byte characters, and non-narrow characters in a
+/// SourceFile.
+///
+/// This function will use an SSE2 enhanced implementation if hardware support
+/// is detected at runtime.
+pub fn analyze_source_file(
+    src: &str,
+    source_file_start_pos: BytePos,
+) -> (Vec<BytePos>, Vec<MultiByteChar>, Vec<NonNarrowChar>) {
+    let mut lines = vec![source_file_start_pos];
+    let mut multi_byte_chars = vec![];
+    let mut non_narrow_chars = vec![];
+
+    // Calls the right implementation, depending on hardware support available.
+    analyze_source_file_dispatch(
+        src,
+        source_file_start_pos,
+        &mut lines,
+        &mut multi_byte_chars,
+        &mut non_narrow_chars,
+    );
+
+    // The code above optimistically registers a new line *after* each \n
+    // it encounters. If that point is already outside the source_file, remove
+    // it again.
+    if let Some(&last_line_start) = lines.last() {
+        let source_file_end = source_file_start_pos + BytePos::from_usize(src.len());
+        assert!(source_file_end >= last_line_start);
+        if last_line_start == source_file_end {
+            lines.pop();
+        }
+    }
+
+    (lines, multi_byte_chars, non_narrow_chars)
+}
+
+cfg_if! {
+    if #[cfg(all(any(target_arch = "x86", target_arch = "x86_64")))] {
+        fn analyze_source_file_dispatch(src: &str,
+                                    source_file_start_pos: BytePos,
+                                    lines: &mut Vec<BytePos>,
+                                    multi_byte_chars: &mut Vec<MultiByteChar>,
+                                    non_narrow_chars: &mut Vec<NonNarrowChar>) {
+            if is_x86_feature_detected!("sse2") {
+                unsafe {
+                    analyze_source_file_sse2(src,
+                                         source_file_start_pos,
+                                         lines,
+                                         multi_byte_chars,
+                                         non_narrow_chars);
+                }
+            } else {
+                analyze_source_file_generic(src,
+                                        src.len(),
+                                        source_file_start_pos,
+                                        lines,
+                                        multi_byte_chars,
+                                        non_narrow_chars);
+
+            }
+        }
+
+        /// Check 16 byte chunks of text at a time. If the chunk contains
+        /// something other than printable ASCII characters and newlines, the
+        /// function falls back to the generic implementation. Otherwise it uses
+        /// SSE2 intrinsics to quickly find all newlines.
+        #[target_feature(enable = "sse2")]
+        unsafe fn analyze_source_file_sse2(src: &str,
+                                       output_offset: BytePos,
+                                       lines: &mut Vec<BytePos>,
+                                       multi_byte_chars: &mut Vec<MultiByteChar>,
+                                       non_narrow_chars: &mut Vec<NonNarrowChar>) {
+            #[cfg(target_arch = "x86")]
+            use std::arch::x86::*;
+            #[cfg(target_arch = "x86_64")]
+            use std::arch::x86_64::*;
+
+            const CHUNK_SIZE: usize = 16;
+
+            let src_bytes = src.as_bytes();
+
+            let chunk_count = src.len() / CHUNK_SIZE;
+
+            // This variable keeps track of where we should start decoding a
+            // chunk. If a multi-byte character spans across chunk boundaries,
+            // we need to skip that part in the next chunk because we already
+            // handled it.
+            let mut intra_chunk_offset = 0;
+
+            for chunk_index in 0 .. chunk_count {
+                let ptr = src_bytes.as_ptr() as *const __m128i;
+                // We don't know if the pointer is aligned to 16 bytes, so we
+                // use `loadu`, which supports unaligned loading.
+                let chunk = _mm_loadu_si128(ptr.offset(chunk_index as isize));
+
+                // For character in the chunk, see if its byte value is < 0, which
+                // indicates that it's part of a UTF-8 char.
+                let multibyte_test = _mm_cmplt_epi8(chunk, _mm_set1_epi8(0));
+                // Create a bit mask from the comparison results.
+                let multibyte_mask = _mm_movemask_epi8(multibyte_test);
+
+                // If the bit mask is all zero, we only have ASCII chars here:
+                if multibyte_mask == 0 {
+                    assert!(intra_chunk_offset == 0);
+
+                    // Check if there are any control characters in the chunk. All
+                    // control characters that we can encounter at this point have a
+                    // byte value less than 32 or ...
+                    let control_char_test0 = _mm_cmplt_epi8(chunk, _mm_set1_epi8(32));
+                    let control_char_mask0 = _mm_movemask_epi8(control_char_test0);
+
+                    // ... it's the ASCII 'DEL' character with a value of 127.
+                    let control_char_test1 = _mm_cmpeq_epi8(chunk, _mm_set1_epi8(127));
+                    let control_char_mask1 = _mm_movemask_epi8(control_char_test1);
+
+                    let control_char_mask = control_char_mask0 | control_char_mask1;
+
+                    if control_char_mask != 0 {
+                        // Check for newlines in the chunk
+                        let newlines_test = _mm_cmpeq_epi8(chunk, _mm_set1_epi8(b'\n' as i8));
+                        let newlines_mask = _mm_movemask_epi8(newlines_test);
+
+                        if control_char_mask == newlines_mask {
+                            // All control characters are newlines, record them
+                            let mut newlines_mask = 0xFFFF0000 | newlines_mask as u32;
+                            let output_offset = output_offset +
+                                BytePos::from_usize(chunk_index * CHUNK_SIZE + 1);
+
+                            loop {
+                                let index = newlines_mask.trailing_zeros();
+
+                                if index >= CHUNK_SIZE as u32 {
+                                    // We have arrived at the end of the chunk.
+                                    break
+                                }
+
+                                lines.push(BytePos(index) + output_offset);
+
+                                // Clear the bit, so we can find the next one.
+                                newlines_mask &= (!1) << index;
+                            }
+
+                            // We are done for this chunk. All control characters were
+                            // newlines and we took care of those.
+                            continue
+                        } else {
+                            // Some of the control characters are not newlines,
+                            // fall through to the slow path below.
+                        }
+                    } else {
+                        // No control characters, nothing to record for this chunk
+                        continue
+                    }
+                }
+
+                // The slow path.
+                // There are control chars in here, fallback to generic decoding.
+                let scan_start = chunk_index * CHUNK_SIZE + intra_chunk_offset;
+                intra_chunk_offset = analyze_source_file_generic(
+                    &src[scan_start .. ],
+                    CHUNK_SIZE - intra_chunk_offset,
+                    BytePos::from_usize(scan_start) + output_offset,
+                    lines,
+                    multi_byte_chars,
+                    non_narrow_chars
+                );
+            }
+
+            // There might still be a tail left to analyze
+            let tail_start = chunk_count * CHUNK_SIZE + intra_chunk_offset;
+            if tail_start < src.len() {
+                analyze_source_file_generic(&src[tail_start as usize ..],
+                                        src.len() - tail_start,
+                                        output_offset + BytePos::from_usize(tail_start),
+                                        lines,
+                                        multi_byte_chars,
+                                        non_narrow_chars);
+            }
+        }
+    } else {
+
+        // The target (or compiler version) does not support SSE2 ...
+        fn analyze_source_file_dispatch(src: &str,
+                                    source_file_start_pos: BytePos,
+                                    lines: &mut Vec<BytePos>,
+                                    multi_byte_chars: &mut Vec<MultiByteChar>,
+                                    non_narrow_chars: &mut Vec<NonNarrowChar>) {
+            analyze_source_file_generic(src,
+                                    src.len(),
+                                    source_file_start_pos,
+                                    lines,
+                                    multi_byte_chars,
+                                    non_narrow_chars);
+        }
+    }
+}
+
+// `scan_len` determines the number of bytes in `src` to scan. Note that the
+// function can read past `scan_len` if a multi-byte character start within the
+// range but extends past it. The overflow is returned by the function.
+fn analyze_source_file_generic(
+    src: &str,
+    scan_len: usize,
+    output_offset: BytePos,
+    lines: &mut Vec<BytePos>,
+    multi_byte_chars: &mut Vec<MultiByteChar>,
+    non_narrow_chars: &mut Vec<NonNarrowChar>,
+) -> usize {
+    assert!(src.len() >= scan_len);
+    let mut i = 0;
+    let src_bytes = src.as_bytes();
+
+    while i < scan_len {
+        let byte = unsafe {
+            // We verified that i < scan_len <= src.len()
+            *src_bytes.get_unchecked(i as usize)
+        };
+
+        // How much to advance in order to get to the next UTF-8 char in the
+        // string.
+        let mut char_len = 1;
+
+        if byte < 32 {
+            // This is an ASCII control character, it could be one of the cases
+            // that are interesting to us.
+
+            let pos = BytePos::from_usize(i) + output_offset;
+
+            match byte {
+                b'\n' => {
+                    lines.push(pos + BytePos(1));
+                }
+                b'\t' => {
+                    non_narrow_chars.push(NonNarrowChar::Tab(pos));
+                }
+                _ => {
+                    non_narrow_chars.push(NonNarrowChar::ZeroWidth(pos));
+                }
+            }
+        } else if byte >= 127 {
+            // The slow path:
+            // This is either ASCII control character "DEL" or the beginning of
+            // a multibyte char. Just decode to `char`.
+            let c = (&src[i..]).chars().next().unwrap();
+            char_len = c.len_utf8();
+
+            let pos = BytePos::from_usize(i) + output_offset;
+
+            if char_len > 1 {
+                assert!(char_len >= 2 && char_len <= 4);
+                let mbc = MultiByteChar {
+                    pos,
+                    bytes: char_len as u8,
+                };
+                multi_byte_chars.push(mbc);
+            }
+
+            // Assume control characters are zero width.
+            // FIXME: How can we decide between `width` and `width_cjk`?
+            let char_width = UnicodeWidthChar::width(c).unwrap_or(0);
+
+            if char_width != 1 {
+                non_narrow_chars.push(NonNarrowChar::new(pos, char_width));
+            }
+        }
+
+        i += char_len;
+    }
+
+    i - scan_len
+}
+
+macro_rules! test {
+    (case: $test_name:ident,
+     text: $text:expr,
+     source_file_start_pos: $source_file_start_pos:expr,
+     lines: $lines:expr,
+     multi_byte_chars: $multi_byte_chars:expr,
+     non_narrow_chars: $non_narrow_chars:expr,) => {
+        #[test]
+        fn $test_name() {
+            let (lines, multi_byte_chars, non_narrow_chars) =
+                analyze_source_file($text, BytePos($source_file_start_pos));
+
+            let expected_lines: Vec<BytePos> = $lines.into_iter().map(|pos| BytePos(pos)).collect();
+
+            assert_eq!(lines, expected_lines);
+
+            let expected_mbcs: Vec<MultiByteChar> = $multi_byte_chars
+                .into_iter()
+                .map(|(pos, bytes)| MultiByteChar {
+                    pos: BytePos(pos),
+                    bytes,
+                })
+                .collect();
+
+            assert_eq!(multi_byte_chars, expected_mbcs);
+
+            let expected_nncs: Vec<NonNarrowChar> = $non_narrow_chars
+                .into_iter()
+                .map(|(pos, width)| NonNarrowChar::new(BytePos(pos), width))
+                .collect();
+
+            assert_eq!(non_narrow_chars, expected_nncs);
+        }
+    };
+}
+
+test!(
+    case: empty_text,
+    text: "",
+    source_file_start_pos: 0,
+    lines: vec![],
+    multi_byte_chars: vec![],
+    non_narrow_chars: vec![],
+);
+
+test!(
+    case: newlines_short,
+    text: "a\nc",
+    source_file_start_pos: 0,
+    lines: vec![0, 2],
+    multi_byte_chars: vec![],
+    non_narrow_chars: vec![],
+);
+
+test!(
+    case: newlines_long,
+    text: "012345678\nabcdef012345678\na",
+    source_file_start_pos: 0,
+    lines: vec![0, 10, 26],
+    multi_byte_chars: vec![],
+    non_narrow_chars: vec![],
+);
+
+test!(
+    case: newline_and_multi_byte_char_in_same_chunk,
+    text: "01234β789\nbcdef0123456789abcdef",
+    source_file_start_pos: 0,
+    lines: vec![0, 11],
+    multi_byte_chars: vec![(5, 2)],
+    non_narrow_chars: vec![],
+);
+
+test!(
+    case: newline_and_control_char_in_same_chunk,
+    text: "01234\u{07}6789\nbcdef0123456789abcdef",
+    source_file_start_pos: 0,
+    lines: vec![0, 11],
+    multi_byte_chars: vec![],
+    non_narrow_chars: vec![(5, 0)],
+);
+
+test!(
+    case: multi_byte_char_short,
+    text: "aβc",
+    source_file_start_pos: 0,
+    lines: vec![0],
+    multi_byte_chars: vec![(1, 2)],
+    non_narrow_chars: vec![],
+);
+
+test!(
+    case: multi_byte_char_long,
+    text: "0123456789abcΔf012345β",
+    source_file_start_pos: 0,
+    lines: vec![0],
+    multi_byte_chars: vec![(13, 2), (22, 2)],
+    non_narrow_chars: vec![],
+);
+
+test!(
+    case: multi_byte_char_across_chunk_boundary,
+    text: "0123456789abcdeΔ123456789abcdef01234",
+    source_file_start_pos: 0,
+    lines: vec![0],
+    multi_byte_chars: vec![(15, 2)],
+    non_narrow_chars: vec![],
+);
+
+test!(
+    case: multi_byte_char_across_chunk_boundary_tail,
+    text: "0123456789abcdeΔ....",
+    source_file_start_pos: 0,
+    lines: vec![0],
+    multi_byte_chars: vec![(15, 2)],
+    non_narrow_chars: vec![],
+);
+
+test!(
+    case: non_narrow_short,
+    text: "0\t2",
+    source_file_start_pos: 0,
+    lines: vec![0],
+    multi_byte_chars: vec![],
+    non_narrow_chars: vec![(1, 4)],
+);
+
+test!(
+    case: non_narrow_long,
+    text: "01\t3456789abcdef01234567\u{07}9",
+    source_file_start_pos: 0,
+    lines: vec![0],
+    multi_byte_chars: vec![],
+    non_narrow_chars: vec![(2, 4), (24, 0)],
+);
+
+test!(
+    case: output_offset_all,
+    text: "01\t345\n789abcΔf01234567\u{07}9\nbcΔf",
+    source_file_start_pos: 1000,
+    lines: vec![0 + 1000, 7 + 1000, 27 + 1000],
+    multi_byte_chars: vec![(13 + 1000, 2), (29 + 1000, 2)],
+    non_narrow_chars: vec![(2 + 1000, 4), (24 + 1000, 0)],
+);
diff --git a/common/src/syntax_pos/hygiene.rs b/common/src/syntax_pos/hygiene.rs
new file mode 100644
index 000000000000..54580a35ffd8
--- /dev/null
+++ b/common/src/syntax_pos/hygiene.rs
@@ -0,0 +1,524 @@
+//! Machinery for hygienic macros, inspired by the `MTWT[1]` paper.
+//!
+//! `[1]` Matthew Flatt, Ryan Culpepper, David Darais, and Robert Bruce Findler.
+//! 2012. *Macros that work together: Compile-time bindings, partial expansion,
+//! and definition contexts*. J. Funct. Program. 22, 2 (March 2012), 181-216.
+//! DOI=10.1017/S0956796812000093 <https://doi.org/10.1017/S0956796812000093>
+
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use std::fmt;
+use Span;
+use GLOBALS;
+
+/// A SyntaxContext represents a chain of macro expansions (represented by
+/// marks).
+#[derive(Clone, Copy, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+pub struct SyntaxContext(u32);
+
+#[derive(Copy, Clone, Debug)]
+struct SyntaxContextData {
+    outer_mark: Mark,
+    transparency: Transparency,
+    prev_ctxt: SyntaxContext,
+    // This context, but with all transparent and semi-transparent marks filtered away.
+    opaque: SyntaxContext,
+    // This context, but with all transparent marks filtered away.
+    opaque_and_semitransparent: SyntaxContext,
+}
+
+/// A mark is a unique id associated with a macro expansion.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub struct Mark(u32);
+
+#[derive(Clone, Debug)]
+struct MarkData {
+    parent: Mark,
+    default_transparency: Transparency,
+    expn_info: Option<ExpnInfo>,
+}
+
+/// A property of a macro expansion that determines how identifiers
+/// produced by that expansion are resolved.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Hash, Debug)]
+pub enum Transparency {
+    /// Identifier produced by a transparent expansion is always resolved at
+    /// call-site. Call-site spans in procedural macros, hygiene opt-out in
+    /// `macro` should use this.
+    Transparent,
+    /// Identifier produced by a semi-transparent expansion may be resolved
+    /// either at call-site or at definition-site.
+    /// If it's a local variable, label or `$crate` then it's resolved at
+    /// def-site. Otherwise it's resolved at call-site.
+    /// `macro_rules` macros behave like this, built-in macros currently behave
+    /// like this too, but that's an implementation detail.
+    SemiTransparent,
+    /// Identifier produced by an opaque expansion is always resolved at
+    /// definition-site. Def-site spans in procedural macros, identifiers
+    /// from `macro` by default use this.
+    Opaque,
+}
+
+impl Mark {
+    pub fn fresh(parent: Mark) -> Self {
+        HygieneData::with(|data| {
+            data.marks.push(MarkData {
+                parent,
+                // By default expansions behave like `macro_rules`.
+                default_transparency: Transparency::SemiTransparent,
+                expn_info: None,
+            });
+            Mark(data.marks.len() as u32 - 1)
+        })
+    }
+
+    /// The mark of the theoretical expansion that generates freshly parsed,
+    /// unexpanded AST.
+    #[inline]
+    pub fn root() -> Self {
+        Mark(0)
+    }
+
+    #[inline]
+    pub fn as_u32(self) -> u32 {
+        self.0
+    }
+
+    #[inline]
+    pub fn from_u32(raw: u32) -> Mark {
+        Mark(raw)
+    }
+
+    #[inline]
+    pub fn parent(self) -> Mark {
+        HygieneData::with(|data| data.marks[self.0 as usize].parent)
+    }
+
+    #[inline]
+    pub fn expn_info(self) -> Option<ExpnInfo> {
+        HygieneData::with(|data| data.marks[self.0 as usize].expn_info.clone())
+    }
+
+    #[inline]
+    pub fn set_expn_info(self, info: ExpnInfo) {
+        HygieneData::with(|data| data.marks[self.0 as usize].expn_info = Some(info))
+    }
+
+    #[inline]
+    pub fn set_default_transparency(self, transparency: Transparency) {
+        assert_ne!(self, Mark::root());
+        HygieneData::with(|data| data.marks[self.0 as usize].default_transparency = transparency)
+    }
+
+    pub fn is_descendant_of(mut self, ancestor: Mark) -> bool {
+        HygieneData::with(|data| {
+            while self != ancestor {
+                if self == Mark::root() {
+                    return false;
+                }
+                self = data.marks[self.0 as usize].parent;
+            }
+            true
+        })
+    }
+
+    /// Computes a mark such that both input marks are descendants of (or equal
+    /// to) the returned mark. That is, the following holds:
+    ///
+    /// ```rust,ignore
+    /// let la = least_ancestor(a, b);
+    /// assert!(a.is_descendant_of(la))
+    /// assert!(b.is_descendant_of(la))
+    /// ```
+    pub fn least_ancestor(mut a: Mark, mut b: Mark) -> Mark {
+        HygieneData::with(|data| {
+            // Compute the path from a to the root
+            let mut a_path = FxHashSet::<Mark>::default();
+            while a != Mark::root() {
+                a_path.insert(a);
+                a = data.marks[a.0 as usize].parent;
+            }
+
+            // While the path from b to the root hasn't intersected, move up the tree
+            while !a_path.contains(&b) {
+                b = data.marks[b.0 as usize].parent;
+            }
+
+            b
+        })
+    }
+}
+
+#[derive(Debug)]
+pub(in crate::syntax_pos) struct HygieneData {
+    marks: Vec<MarkData>,
+    syntax_contexts: Vec<SyntaxContextData>,
+    markings: FxHashMap<(SyntaxContext, Mark, Transparency), SyntaxContext>,
+}
+
+impl HygieneData {
+    pub(in crate::syntax_pos) fn new() -> Self {
+        HygieneData {
+            marks: vec![MarkData {
+                parent: Mark::root(),
+                // If the root is opaque, then loops searching for an opaque mark
+                // will automatically stop after reaching it.
+                default_transparency: Transparency::Opaque,
+                expn_info: None,
+            }],
+            syntax_contexts: vec![SyntaxContextData {
+                outer_mark: Mark::root(),
+                transparency: Transparency::Opaque,
+                prev_ctxt: SyntaxContext(0),
+                opaque: SyntaxContext(0),
+                opaque_and_semitransparent: SyntaxContext(0),
+            }],
+            markings: FxHashMap::default(),
+        }
+    }
+
+    fn with<T, F: FnOnce(&mut HygieneData) -> T>(f: F) -> T {
+        GLOBALS.with(|globals| f(&mut *globals.hygiene_data.borrow_mut()))
+    }
+}
+
+impl SyntaxContext {
+    pub const fn empty() -> Self {
+        SyntaxContext(0)
+    }
+
+    pub(in crate::syntax_pos) fn as_u32(self) -> u32 {
+        self.0
+    }
+
+    pub(in crate::syntax_pos) fn from_u32(raw: u32) -> SyntaxContext {
+        SyntaxContext(raw)
+    }
+
+    // Allocate a new SyntaxContext with the given ExpnInfo. This is used when
+    // deserializing Spans from the incr. comp. cache.
+    // FIXME(mw): This method does not restore MarkData::parent or
+    // SyntaxContextData::prev_ctxt or SyntaxContextData::opaque. These things
+    // don't seem to be used after HIR lowering, so everything should be fine
+    // as long as incremental compilation does not kick in before that.
+    pub fn allocate_directly(expansion_info: ExpnInfo) -> Self {
+        HygieneData::with(|data| {
+            data.marks.push(MarkData {
+                parent: Mark::root(),
+                default_transparency: Transparency::SemiTransparent,
+                expn_info: Some(expansion_info),
+            });
+
+            let mark = Mark(data.marks.len() as u32 - 1);
+
+            data.syntax_contexts.push(SyntaxContextData {
+                outer_mark: mark,
+                transparency: Transparency::SemiTransparent,
+                prev_ctxt: SyntaxContext::empty(),
+                opaque: SyntaxContext::empty(),
+                opaque_and_semitransparent: SyntaxContext::empty(),
+            });
+            SyntaxContext(data.syntax_contexts.len() as u32 - 1)
+        })
+    }
+
+    /// Extend a syntax context with a given mark and default transparency for
+    /// that mark.
+    pub fn apply_mark(self, mark: Mark) -> SyntaxContext {
+        assert_ne!(mark, Mark::root());
+        self.apply_mark_with_transparency(
+            mark,
+            HygieneData::with(|data| data.marks[mark.0 as usize].default_transparency),
+        )
+    }
+
+    /// Extend a syntax context with a given mark and transparency
+    pub fn apply_mark_with_transparency(
+        self,
+        mark: Mark,
+        transparency: Transparency,
+    ) -> SyntaxContext {
+        assert_ne!(mark, Mark::root());
+        if transparency == Transparency::Opaque {
+            return self.apply_mark_internal(mark, transparency);
+        }
+
+        let call_site_ctxt = mark
+            .expn_info()
+            .map_or(SyntaxContext::empty(), |info| info.call_site.ctxt());
+        let call_site_ctxt = if transparency == Transparency::SemiTransparent {
+            call_site_ctxt.modern()
+        } else {
+            call_site_ctxt.modern_and_legacy()
+        };
+
+        if call_site_ctxt == SyntaxContext::empty() {
+            return self.apply_mark_internal(mark, transparency);
+        }
+
+        // Otherwise, `mark` is a macros 1.0 definition and the call site is in a
+        // macros 2.0 expansion, i.e., a macros 1.0 invocation is in a macros 2.0
+        // definition.
+        //
+        // In this case, the tokens from the macros 1.0 definition inherit the hygiene
+        // at their invocation. That is, we pretend that the macros 1.0 definition
+        // was defined at its invocation (i.e., inside the macros 2.0 definition)
+        // so that the macros 2.0 definition remains hygienic.
+        //
+        // See the example at `test/run-pass/hygiene/legacy_interaction.rs`.
+        let mut ctxt = call_site_ctxt;
+        for (mark, transparency) in self.marks() {
+            ctxt = ctxt.apply_mark_internal(mark, transparency);
+        }
+        ctxt.apply_mark_internal(mark, transparency)
+    }
+
+    fn apply_mark_internal(self, mark: Mark, transparency: Transparency) -> SyntaxContext {
+        HygieneData::with(|data| {
+            let syntax_contexts = &mut data.syntax_contexts;
+            let mut opaque = syntax_contexts[self.0 as usize].opaque;
+            let mut opaque_and_semitransparent =
+                syntax_contexts[self.0 as usize].opaque_and_semitransparent;
+
+            if transparency >= Transparency::Opaque {
+                let prev_ctxt = opaque;
+                opaque = *data
+                    .markings
+                    .entry((prev_ctxt, mark, transparency))
+                    .or_insert_with(|| {
+                        let new_opaque = SyntaxContext(syntax_contexts.len() as u32);
+                        syntax_contexts.push(SyntaxContextData {
+                            outer_mark: mark,
+                            transparency,
+                            prev_ctxt,
+                            opaque: new_opaque,
+                            opaque_and_semitransparent: new_opaque,
+                        });
+                        new_opaque
+                    });
+            }
+
+            if transparency >= Transparency::SemiTransparent {
+                let prev_ctxt = opaque_and_semitransparent;
+                opaque_and_semitransparent = *data
+                    .markings
+                    .entry((prev_ctxt, mark, transparency))
+                    .or_insert_with(|| {
+                        let new_opaque_and_semitransparent =
+                            SyntaxContext(syntax_contexts.len() as u32);
+                        syntax_contexts.push(SyntaxContextData {
+                            outer_mark: mark,
+                            transparency,
+                            prev_ctxt,
+                            opaque,
+                            opaque_and_semitransparent: new_opaque_and_semitransparent,
+                        });
+                        new_opaque_and_semitransparent
+                    });
+            }
+
+            let prev_ctxt = self;
+            *data
+                .markings
+                .entry((prev_ctxt, mark, transparency))
+                .or_insert_with(|| {
+                    let new_opaque_and_semitransparent_and_transparent =
+                        SyntaxContext(syntax_contexts.len() as u32);
+                    syntax_contexts.push(SyntaxContextData {
+                        outer_mark: mark,
+                        transparency,
+                        prev_ctxt,
+                        opaque,
+                        opaque_and_semitransparent,
+                    });
+                    new_opaque_and_semitransparent_and_transparent
+                })
+        })
+    }
+
+    /// Pulls a single mark off of the syntax context. This effectively moves
+    /// the context up one macro definition level. That is, if we have a
+    /// nested macro definition as follows:
+    ///
+    /// ```rust,ignore
+    /// macro_rules! f {
+    ///    macro_rules! g {
+    ///        ...
+    ///    }
+    /// }
+    /// ```
+    ///
+    /// and we have a SyntaxContext that is referring to something declared by
+    /// an invocation of g (call it g1), calling remove_mark will result in
+    /// the SyntaxContext for the invocation of f that created g1.
+    /// Returns the mark that was removed.
+    pub fn remove_mark(&mut self) -> Mark {
+        HygieneData::with(|data| {
+            let outer_mark = data.syntax_contexts[self.0 as usize].outer_mark;
+            *self = data.syntax_contexts[self.0 as usize].prev_ctxt;
+            outer_mark
+        })
+    }
+
+    pub fn marks(mut self) -> Vec<(Mark, Transparency)> {
+        HygieneData::with(|data| {
+            let mut marks = Vec::new();
+            while self != SyntaxContext::empty() {
+                let ctxt_data = &data.syntax_contexts[self.0 as usize];
+                marks.push((ctxt_data.outer_mark, ctxt_data.transparency));
+                self = ctxt_data.prev_ctxt;
+            }
+            marks.reverse();
+            marks
+        })
+    }
+
+    /// Adjust this context for resolution in a scope created by the given
+    /// expansion. For example, consider the following three resolutions of
+    /// `f`:
+    ///
+    /// ```rust,ignore
+    /// mod foo {
+    ///     pub fn f() {}
+    /// } // `f`'s `SyntaxContext` is empty.
+    /// m!(f);
+    /// macro m($f:ident) {
+    ///     mod bar {
+    ///         pub fn f() {} // `f`'s `SyntaxContext` has a single `Mark` from `m`.
+    ///         pub fn $f() {} // `$f`'s `SyntaxContext` is empty.
+    ///     }
+    ///     foo::f(); // `f`'s `SyntaxContext` has a single `Mark` from `m`
+    ///               //^ Since `mod foo` is outside this expansion, `adjust` removes the mark from `f`,
+    ///               //| and it resolves to `::foo::f`.
+    ///     bar::f(); // `f`'s `SyntaxContext` has a single `Mark` from `m`
+    ///               //^ Since `mod bar` not outside this expansion, `adjust` does not change `f`,
+    ///               //| and it resolves to `::bar::f`.
+    ///     bar::$f(); // `f`'s `SyntaxContext` is empty.
+    ///                //^ Since `mod bar` is not outside this expansion, `adjust` does not change `$f`,
+    ///                //| and it resolves to `::bar::$f`.
+    /// }
+    /// ```
+    /// This returns the expansion whose definition scope we use to privacy
+    /// check the resolution, or `None` if we privacy check as usual (i.e.,
+    /// not w.r.t. a macro definition scope).
+    pub fn adjust(&mut self, expansion: Mark) -> Option<Mark> {
+        let mut scope = None;
+        while !expansion.is_descendant_of(self.outer()) {
+            scope = Some(self.remove_mark());
+        }
+        scope
+    }
+
+    /// Adjust this context for resolution in a scope created by the given
+    /// expansion via a glob import with the given `SyntaxContext`.
+    /// For example:
+    ///
+    /// ```rust,ignore
+    /// m!(f);
+    /// macro m($i:ident) {
+    ///     mod foo {
+    ///         pub fn f() {} // `f`'s `SyntaxContext` has a single `Mark` from `m`.
+    ///         pub fn $i() {} // `$i`'s `SyntaxContext` is empty.
+    ///     }
+    ///     n(f);
+    ///     macro n($j:ident) {
+    ///         use foo::*;
+    ///         f(); // `f`'s `SyntaxContext` has a mark from `m` and a mark from `n`
+    ///              //^ `glob_adjust` removes the mark from `n`, so this resolves to `foo::f`.
+    ///         $i(); // `$i`'s `SyntaxContext` has a mark from `n`
+    ///               //^ `glob_adjust` removes the mark from `n`, so this resolves to `foo::$i`.
+    ///         $j(); // `$j`'s `SyntaxContext` has a mark from `m`
+    ///               //^ This cannot be glob-adjusted, so this is a resolution error.
+    ///     }
+    /// }
+    /// ```
+    /// This returns `None` if the context cannot be glob-adjusted.
+    /// Otherwise, it returns the scope to use when privacy checking (see
+    /// `adjust` for details).
+    pub fn glob_adjust(
+        &mut self,
+        expansion: Mark,
+        mut glob_ctxt: SyntaxContext,
+    ) -> Option<Option<Mark>> {
+        let mut scope = None;
+        while !expansion.is_descendant_of(glob_ctxt.outer()) {
+            scope = Some(glob_ctxt.remove_mark());
+            if self.remove_mark() != scope.unwrap() {
+                return None;
+            }
+        }
+        if self.adjust(expansion).is_some() {
+            return None;
+        }
+        Some(scope)
+    }
+
+    /// Undo `glob_adjust` if possible:
+    ///
+    /// ```rust,ignore
+    /// if let Some(privacy_checking_scope) = self.reverse_glob_adjust(expansion, glob_ctxt) {
+    ///     assert!(self.glob_adjust(expansion, glob_ctxt) == Some(privacy_checking_scope));
+    /// }
+    /// ```
+    pub fn reverse_glob_adjust(
+        &mut self,
+        expansion: Mark,
+        mut glob_ctxt: SyntaxContext,
+    ) -> Option<Option<Mark>> {
+        if self.adjust(expansion).is_some() {
+            return None;
+        }
+
+        let mut marks = Vec::new();
+        while !expansion.is_descendant_of(glob_ctxt.outer()) {
+            marks.push(glob_ctxt.remove_mark());
+        }
+
+        let scope = marks.last().cloned();
+        while let Some(mark) = marks.pop() {
+            *self = self.apply_mark(mark);
+        }
+        Some(scope)
+    }
+
+    #[inline]
+    pub fn modern(self) -> SyntaxContext {
+        HygieneData::with(|data| data.syntax_contexts[self.0 as usize].opaque)
+    }
+
+    #[inline]
+    pub fn modern_and_legacy(self) -> SyntaxContext {
+        HygieneData::with(|data| data.syntax_contexts[self.0 as usize].opaque_and_semitransparent)
+    }
+
+    #[inline]
+    pub fn outer(self) -> Mark {
+        HygieneData::with(|data| data.syntax_contexts[self.0 as usize].outer_mark)
+    }
+}
+
+impl fmt::Debug for SyntaxContext {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "#{}", self.0)
+    }
+}
+
+/// Extra information for tracking spans of macro and syntax sugar expansion
+#[derive(Clone, Hash, Debug)]
+pub struct ExpnInfo {
+    /// The location of the actual macro invocation or syntax sugar , e.g.
+    /// `let x = foo!();` or `if let Some(y) = x {}`
+    ///
+    /// This may recursively refer to other macro invocations, e.g., if
+    /// `foo!()` invoked `bar!()` internally, and there was an
+    /// expression inside `bar!`; the call_site of the expression in
+    /// the expansion would point to the `bar!` invocation; that
+    /// call_site span would have its own ExpnInfo, with the call_site
+    /// pointing to the `foo!` invocation.
+    pub call_site: Span,
+    /// The span of the macro definition itself. The macro may not
+    /// have a sensible definition span (e.g., something defined
+    /// completely inside libsyntax) in which case this is None.
+    /// This span serves only informational purpose and is not used for
+    /// resolution.
+    pub def_site: Option<Span>,
+}
diff --git a/common/src/syntax_pos/mod.rs b/common/src/syntax_pos/mod.rs
new file mode 100644
index 000000000000..4a166510d523
--- /dev/null
+++ b/common/src/syntax_pos/mod.rs
@@ -0,0 +1,1026 @@
+pub use self::{
+    hygiene::{ExpnInfo, Mark, SyntaxContext},
+    span_encoding::{Span, DUMMY_SP},
+};
+use rustc_data_structures::{
+    stable_hasher::StableHasher,
+    sync::{Lock, Lrc},
+};
+use std::{
+    borrow::Cow,
+    cell::Cell,
+    cmp::{self, Ordering},
+    fmt,
+    hash::{Hash, Hasher},
+    ops::{Add, Sub},
+    path::PathBuf,
+};
+
+mod analyze_source_file;
+pub mod hygiene;
+mod span_encoding;
+
+pub struct Globals {
+    span_interner: Lock<span_encoding::SpanInterner>,
+    hygiene_data: Lock<hygiene::HygieneData>,
+}
+
+impl Globals {
+    pub fn new() -> Globals {
+        Globals {
+            span_interner: Lock::new(span_encoding::SpanInterner::default()),
+            hygiene_data: Lock::new(hygiene::HygieneData::new()),
+        }
+    }
+}
+
+scoped_thread_local!(pub static GLOBALS: Globals);
+
+/// Differentiates between real files and common virtual files.
+#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash)]
+pub enum FileName {
+    Real(PathBuf),
+    /// A macro.  This includes the full name of the macro, so that there are no
+    /// clashes.
+    Macros(String),
+    /// Call to `quote!`.
+    QuoteExpansion(u64),
+    /// Command line.
+    Anon(u64),
+    /// Hack in `src/libsyntax/parse.rs`.
+    // FIXME(jseyfried)
+    MacroExpansion(u64),
+    ProcMacroSourceCode(u64),
+    /// Strings provided as `--cfg [cfgspec]` stored in a `crate_cfg`.
+    CfgSpec(u64),
+    /// Strings provided as crate attributes in the CLI.
+    CliCrateAttr(u64),
+    /// Custom sources for explicit parser calls from plugins and drivers.
+    Custom(String),
+    DocTest(PathBuf, isize),
+}
+
+impl std::fmt::Display for FileName {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+        use self::FileName::*;
+        match *self {
+            Real(ref path) => write!(fmt, "{}", path.display()),
+            Macros(ref name) => write!(fmt, "<{} macros>", name),
+            QuoteExpansion(_) => write!(fmt, "<quote expansion>"),
+            MacroExpansion(_) => write!(fmt, "<macro expansion>"),
+            Anon(_) => write!(fmt, "<anon>"),
+            ProcMacroSourceCode(_) => write!(fmt, "<proc-macro source code>"),
+            CfgSpec(_) => write!(fmt, "<cfgspec>"),
+            CliCrateAttr(_) => write!(fmt, "<crate attribute>"),
+            Custom(ref s) => write!(fmt, "<{}>", s),
+            DocTest(ref path, _) => write!(fmt, "{}", path.display()),
+        }
+    }
+}
+
+impl From<PathBuf> for FileName {
+    fn from(p: PathBuf) -> Self {
+        assert!(!p.to_string_lossy().ends_with('>'));
+        FileName::Real(p)
+    }
+}
+
+impl FileName {
+    pub fn is_real(&self) -> bool {
+        use self::FileName::*;
+        match *self {
+            Real(_) => true,
+            Macros(_)
+            | Anon(_)
+            | MacroExpansion(_)
+            | ProcMacroSourceCode(_)
+            | CfgSpec(_)
+            | CliCrateAttr(_)
+            | Custom(_)
+            | QuoteExpansion(_)
+            | DocTest(_, _) => false,
+        }
+    }
+
+    pub fn is_macros(&self) -> bool {
+        use self::FileName::*;
+        match *self {
+            Real(_)
+            | Anon(_)
+            | MacroExpansion(_)
+            | ProcMacroSourceCode(_)
+            | CfgSpec(_)
+            | CliCrateAttr(_)
+            | Custom(_)
+            | QuoteExpansion(_)
+            | DocTest(_, _) => false,
+            Macros(_) => true,
+        }
+    }
+
+    pub fn quote_expansion_source_code(src: &str) -> FileName {
+        let mut hasher = StableHasher::new();
+        src.hash(&mut hasher);
+        FileName::QuoteExpansion(hasher.finish())
+    }
+
+    pub fn macro_expansion_source_code(src: &str) -> FileName {
+        let mut hasher = StableHasher::new();
+        src.hash(&mut hasher);
+        FileName::MacroExpansion(hasher.finish())
+    }
+
+    pub fn anon_source_code(src: &str) -> FileName {
+        let mut hasher = StableHasher::new();
+        src.hash(&mut hasher);
+        FileName::Anon(hasher.finish())
+    }
+
+    pub fn proc_macro_source_code(src: &str) -> FileName {
+        let mut hasher = StableHasher::new();
+        src.hash(&mut hasher);
+        FileName::ProcMacroSourceCode(hasher.finish())
+    }
+
+    pub fn cfg_spec_source_code(src: &str) -> FileName {
+        let mut hasher = StableHasher::new();
+        src.hash(&mut hasher);
+        FileName::QuoteExpansion(hasher.finish())
+    }
+
+    pub fn cli_crate_attr_source_code(src: &str) -> FileName {
+        let mut hasher = StableHasher::new();
+        src.hash(&mut hasher);
+        FileName::CliCrateAttr(hasher.finish())
+    }
+
+    pub fn doc_test_source_code(path: PathBuf, line: isize) -> FileName {
+        FileName::DocTest(path, line)
+    }
+}
+
+/// Spans represent a region of code, used for error reporting. Positions in
+/// spans are *absolute* positions from the beginning of the source_map, not
+/// positions relative to `SourceFile`s. Methods on the `SourceMap` can be used
+/// to relate spans back to the original source.
+/// You must be careful if the span crosses more than one file - you will not be
+/// able to use many of the functions on spans in source_map and you cannot
+/// assume that the length of the `span = hi - lo`; there may be space in the
+/// `BytePos` range between files.
+///
+/// `SpanData` is public because `Span` uses a thread-local interner and can't
+/// be sent to other threads, but some pieces of performance infra run in a
+/// separate thread. Using `Span` is generally preferred.
+#[derive(Clone, Copy, Hash, PartialEq, Eq, Ord, PartialOrd)]
+pub struct SpanData {
+    pub lo: BytePos,
+    pub hi: BytePos,
+    /// Information about where the macro came from, if this piece of
+    /// code was created by a macro expansion.
+    pub ctxt: SyntaxContext,
+}
+
+impl SpanData {
+    #[inline]
+    pub fn with_lo(&self, lo: BytePos) -> Span {
+        Span::new(lo, self.hi, self.ctxt)
+    }
+    #[inline]
+    pub fn with_hi(&self, hi: BytePos) -> Span {
+        Span::new(self.lo, hi, self.ctxt)
+    }
+    #[inline]
+    pub fn with_ctxt(&self, ctxt: SyntaxContext) -> Span {
+        Span::new(self.lo, self.hi, ctxt)
+    }
+}
+
+impl PartialOrd for Span {
+    fn partial_cmp(&self, rhs: &Self) -> Option<Ordering> {
+        PartialOrd::partial_cmp(&self.data(), &rhs.data())
+    }
+}
+impl Ord for Span {
+    fn cmp(&self, rhs: &Self) -> Ordering {
+        Ord::cmp(&self.data(), &rhs.data())
+    }
+}
+
+/// A collection of spans. Spans have two orthogonal attributes:
+///
+/// - They can be *primary spans*. In this case they are the locus of the error,
+///   and would be rendered with `^^^`.
+/// - They can have a *label*. In this case, the label is written next to the
+///   mark in the snippet when we render.
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct MultiSpan {
+    primary_spans: Vec<Span>,
+    span_labels: Vec<(Span, String)>,
+}
+
+impl Span {
+    #[inline]
+    pub fn lo(self) -> BytePos {
+        self.data().lo
+    }
+    #[inline]
+    pub fn with_lo(self, lo: BytePos) -> Span {
+        self.data().with_lo(lo)
+    }
+    #[inline]
+    pub fn hi(self) -> BytePos {
+        self.data().hi
+    }
+    #[inline]
+    pub fn with_hi(self, hi: BytePos) -> Span {
+        self.data().with_hi(hi)
+    }
+    #[inline]
+    pub fn ctxt(self) -> SyntaxContext {
+        self.data().ctxt
+    }
+    #[inline]
+    pub fn with_ctxt(self, ctxt: SyntaxContext) -> Span {
+        self.data().with_ctxt(ctxt)
+    }
+
+    /// Returns `true` if this is a dummy span with any hygienic context.
+    #[inline]
+    pub fn is_dummy(self) -> bool {
+        let span = self.data();
+        span.lo.0 == 0 && span.hi.0 == 0
+    }
+
+    /// Returns a new span representing an empty span at the beginning of this
+    /// span
+    #[inline]
+    pub fn shrink_to_lo(self) -> Span {
+        let span = self.data();
+        span.with_hi(span.lo)
+    }
+    /// Returns a new span representing an empty span at the end of this span.
+    #[inline]
+    pub fn shrink_to_hi(self) -> Span {
+        let span = self.data();
+        span.with_lo(span.hi)
+    }
+
+    /// Returns `self` if `self` is not the dummy span, and `other` otherwise.
+    pub fn substitute_dummy(self, other: Span) -> Span {
+        if self.is_dummy() {
+            other
+        } else {
+            self
+        }
+    }
+
+    /// Return `true` if `self` fully encloses `other`.
+    pub fn contains(self, other: Span) -> bool {
+        let span = self.data();
+        let other = other.data();
+        span.lo <= other.lo && other.hi <= span.hi
+    }
+
+    /// Return `true` if `self` touches `other`.
+    pub fn overlaps(self, other: Span) -> bool {
+        let span = self.data();
+        let other = other.data();
+        span.lo < other.hi && other.lo < span.hi
+    }
+
+    /// Return true if the spans are equal with regards to the source text.
+    ///
+    /// Use this instead of `==` when either span could be generated code,
+    /// and you only care that they point to the same bytes of source text.
+    pub fn source_equal(&self, other: &Span) -> bool {
+        let span = self.data();
+        let other = other.data();
+        span.lo == other.lo && span.hi == other.hi
+    }
+
+    /// Returns `Some(span)`, where the start is trimmed by the end of `other`.
+    pub fn trim_start(self, other: Span) -> Option<Span> {
+        let span = self.data();
+        let other = other.data();
+        if span.hi > other.hi {
+            Some(span.with_lo(cmp::max(span.lo, other.hi)))
+        } else {
+            None
+        }
+    }
+
+    /// The `Span` for the tokens in the previous macro expansion from which
+    /// `self` was generated, if any.
+    pub fn parent(self) -> Option<Span> {
+        self.ctxt().outer().expn_info().map(|i| i.call_site)
+    }
+
+    /// Return a `Span` that would enclose both `self` and `end`.
+    pub fn to(self, end: Span) -> Span {
+        let span_data = self.data();
+        let end_data = end.data();
+        // FIXME(jseyfried): `self.ctxt` should always equal `end.ctxt` here (cf. issue
+        // #23480). Return the macro span on its own to avoid weird diagnostic
+        // output. It is preferable to have an incomplete span than a completely
+        // nonsensical one.
+        if span_data.ctxt != end_data.ctxt {
+            if span_data.ctxt == SyntaxContext::empty() {
+                return end;
+            } else if end_data.ctxt == SyntaxContext::empty() {
+                return self;
+            }
+            // Both spans fall within a macro.
+            // FIXME(estebank): check if it is the *same* macro.
+        }
+        Span::new(
+            cmp::min(span_data.lo, end_data.lo),
+            cmp::max(span_data.hi, end_data.hi),
+            if span_data.ctxt == SyntaxContext::empty() {
+                end_data.ctxt
+            } else {
+                span_data.ctxt
+            },
+        )
+    }
+
+    /// Return a `Span` between the end of `self` to the beginning of `end`.
+    pub fn between(self, end: Span) -> Span {
+        let span = self.data();
+        let end = end.data();
+        Span::new(
+            span.hi,
+            end.lo,
+            if end.ctxt == SyntaxContext::empty() {
+                end.ctxt
+            } else {
+                span.ctxt
+            },
+        )
+    }
+
+    /// Return a `Span` between the beginning of `self` to the beginning of
+    /// `end`.
+    pub fn until(self, end: Span) -> Span {
+        let span = self.data();
+        let end = end.data();
+        Span::new(
+            span.lo,
+            end.lo,
+            if end.ctxt == SyntaxContext::empty() {
+                end.ctxt
+            } else {
+                span.ctxt
+            },
+        )
+    }
+
+    pub fn from_inner_byte_pos(self, start: usize, end: usize) -> Span {
+        let span = self.data();
+        Span::new(
+            span.lo + BytePos::from_usize(start),
+            span.lo + BytePos::from_usize(end),
+            span.ctxt,
+        )
+    }
+
+    #[inline]
+    pub fn apply_mark(self, mark: Mark) -> Span {
+        let span = self.data();
+        span.with_ctxt(span.ctxt.apply_mark(mark))
+    }
+
+    #[inline]
+    pub fn remove_mark(&mut self) -> Mark {
+        let mut span = self.data();
+        let mark = span.ctxt.remove_mark();
+        *self = Span::new(span.lo, span.hi, span.ctxt);
+        mark
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct SpanLabel {
+    /// The span we are going to include in the final snippet.
+    pub span: Span,
+
+    /// Is this a primary span? This is the "locus" of the message,
+    /// and is indicated with a `^^^^` underline, versus `----`.
+    pub is_primary: bool,
+
+    /// What label should we attach to this span (if any)?
+    pub label: Option<String>,
+}
+
+impl Default for Span {
+    fn default() -> Self {
+        DUMMY_SP
+    }
+}
+
+pub fn default_span_debug(span: Span, f: &mut fmt::Formatter) -> fmt::Result {
+    f.debug_struct("Span")
+        .field("lo", &span.lo())
+        .field("hi", &span.hi())
+        .field("ctxt", &span.ctxt())
+        .finish()
+}
+
+impl fmt::Debug for Span {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        SPAN_DEBUG.with(|span_debug| span_debug.get()(*self, f))
+    }
+}
+
+impl fmt::Debug for SpanData {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        SPAN_DEBUG.with(|span_debug| span_debug.get()(Span::new(self.lo, self.hi, self.ctxt), f))
+    }
+}
+
+impl MultiSpan {
+    #[inline]
+    pub fn new() -> MultiSpan {
+        MultiSpan {
+            primary_spans: vec![],
+            span_labels: vec![],
+        }
+    }
+
+    pub fn from_span(primary_span: Span) -> MultiSpan {
+        MultiSpan {
+            primary_spans: vec![primary_span],
+            span_labels: vec![],
+        }
+    }
+
+    pub fn from_spans(vec: Vec<Span>) -> MultiSpan {
+        MultiSpan {
+            primary_spans: vec,
+            span_labels: vec![],
+        }
+    }
+
+    pub fn push_span_label(&mut self, span: Span, label: String) {
+        self.span_labels.push((span, label));
+    }
+
+    /// Selects the first primary span (if any).
+    pub fn primary_span(&self) -> Option<Span> {
+        self.primary_spans.first().cloned()
+    }
+
+    /// Returns all primary spans.
+    pub fn primary_spans(&self) -> &[Span] {
+        &self.primary_spans
+    }
+
+    /// Returns `true` if this contains only a dummy primary span with any
+    /// hygienic context.
+    pub fn is_dummy(&self) -> bool {
+        let mut is_dummy = true;
+        for span in &self.primary_spans {
+            if !span.is_dummy() {
+                is_dummy = false;
+            }
+        }
+        is_dummy
+    }
+
+    /// Replaces all occurrences of one Span with another. Used to move `Span`s
+    /// in areas that don't display well (like std macros). Returns true if
+    /// replacements occurred.
+    pub fn replace(&mut self, before: Span, after: Span) -> bool {
+        let mut replacements_occurred = false;
+        for primary_span in &mut self.primary_spans {
+            if *primary_span == before {
+                *primary_span = after;
+                replacements_occurred = true;
+            }
+        }
+        for span_label in &mut self.span_labels {
+            if span_label.0 == before {
+                span_label.0 = after;
+                replacements_occurred = true;
+            }
+        }
+        replacements_occurred
+    }
+
+    /// Returns the strings to highlight. We always ensure that there
+    /// is an entry for each of the primary spans -- for each primary
+    /// span `P`, if there is at least one label with span `P`, we return
+    /// those labels (marked as primary). But otherwise we return
+    /// `SpanLabel` instances with empty labels.
+    pub fn span_labels(&self) -> Vec<SpanLabel> {
+        let is_primary = |span| self.primary_spans.contains(&span);
+
+        let mut span_labels = self
+            .span_labels
+            .iter()
+            .map(|&(span, ref label)| SpanLabel {
+                span,
+                is_primary: is_primary(span),
+                label: Some(label.clone()),
+            })
+            .collect::<Vec<_>>();
+
+        for &span in &self.primary_spans {
+            if !span_labels.iter().any(|sl| sl.span == span) {
+                span_labels.push(SpanLabel {
+                    span,
+                    is_primary: true,
+                    label: None,
+                });
+            }
+        }
+
+        span_labels
+    }
+}
+
+impl From<Span> for MultiSpan {
+    fn from(span: Span) -> MultiSpan {
+        MultiSpan::from_span(span)
+    }
+}
+
+impl From<Vec<Span>> for MultiSpan {
+    fn from(spans: Vec<Span>) -> MultiSpan {
+        MultiSpan::from_spans(spans)
+    }
+}
+
+pub const NO_EXPANSION: SyntaxContext = SyntaxContext::empty();
+
+/// Identifies an offset of a multi-byte character in a `SourceFile`.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub struct MultiByteChar {
+    /// The absolute offset of the character in the `SourceMap`.
+    pub pos: BytePos,
+    /// The number of bytes, `>= 2`.
+    pub bytes: u8,
+}
+
+/// Identifies an offset of a non-narrow character in a `SourceFile`.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum NonNarrowChar {
+    /// Represents a zero-width character.
+    ZeroWidth(BytePos),
+    /// Represents a wide (full-width) character.
+    Wide(BytePos),
+    /// Represents a tab character, represented visually with a width of 4
+    /// characters.
+    Tab(BytePos),
+}
+
+impl NonNarrowChar {
+    fn new(pos: BytePos, width: usize) -> Self {
+        match width {
+            0 => NonNarrowChar::ZeroWidth(pos),
+            2 => NonNarrowChar::Wide(pos),
+            4 => NonNarrowChar::Tab(pos),
+            _ => panic!("width {} given for non-narrow character", width),
+        }
+    }
+
+    /// Returns the absolute offset of the character in the `SourceMap`.
+    pub fn pos(&self) -> BytePos {
+        match *self {
+            NonNarrowChar::ZeroWidth(p) | NonNarrowChar::Wide(p) | NonNarrowChar::Tab(p) => p,
+        }
+    }
+
+    /// Returns the width of the character, 0 (zero-width) or 2 (wide).
+    pub fn width(&self) -> usize {
+        match *self {
+            NonNarrowChar::ZeroWidth(_) => 0,
+            NonNarrowChar::Wide(_) => 2,
+            NonNarrowChar::Tab(_) => 4,
+        }
+    }
+}
+
+impl Add<BytePos> for NonNarrowChar {
+    type Output = Self;
+
+    fn add(self, rhs: BytePos) -> Self {
+        match self {
+            NonNarrowChar::ZeroWidth(pos) => NonNarrowChar::ZeroWidth(pos + rhs),
+            NonNarrowChar::Wide(pos) => NonNarrowChar::Wide(pos + rhs),
+            NonNarrowChar::Tab(pos) => NonNarrowChar::Tab(pos + rhs),
+        }
+    }
+}
+
+impl Sub<BytePos> for NonNarrowChar {
+    type Output = Self;
+
+    fn sub(self, rhs: BytePos) -> Self {
+        match self {
+            NonNarrowChar::ZeroWidth(pos) => NonNarrowChar::ZeroWidth(pos - rhs),
+            NonNarrowChar::Wide(pos) => NonNarrowChar::Wide(pos - rhs),
+            NonNarrowChar::Tab(pos) => NonNarrowChar::Tab(pos - rhs),
+        }
+    }
+}
+
+/// A single source in the `SourceMap`.
+#[derive(Clone)]
+pub struct SourceFile {
+    /// The name of the file that the source came from, source that doesn't
+    /// originate from files has names between angle brackets by convention
+    /// (e.g., `<anon>`).
+    pub name: FileName,
+    /// True if the `name` field above has been modified by
+    /// `--remap-path-prefix`.
+    pub name_was_remapped: bool,
+    /// The unmapped path of the file that the source came from.
+    /// Set to `None` if the `SourceFile` was imported from an external crate.
+    pub unmapped_path: Option<FileName>,
+    /// Indicates which crate this `SourceFile` was imported from.
+    pub crate_of_origin: u32,
+    /// The complete source code.
+    pub src: Lrc<String>,
+    /// The source code's hash.
+    pub src_hash: u128,
+
+    /// The start position of this source in the `SourceMap`.
+    pub start_pos: BytePos,
+    /// The end position of this source in the `SourceMap`.
+    pub end_pos: BytePos,
+    /// Locations of lines beginnings in the source code.
+    pub lines: Vec<BytePos>,
+    /// Locations of multi-byte characters in the source code.
+    pub multibyte_chars: Vec<MultiByteChar>,
+    /// Width of characters that are not narrow in the source code.
+    pub non_narrow_chars: Vec<NonNarrowChar>,
+    /// A hash of the filename, used for speeding up hashing in incremental
+    /// compilation.
+    pub name_hash: u128,
+}
+
+impl fmt::Debug for SourceFile {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "SourceFile({})", self.name)
+    }
+}
+
+impl SourceFile {
+    pub fn new(
+        name: FileName,
+        name_was_remapped: bool,
+        unmapped_path: FileName,
+        mut src: String,
+        start_pos: BytePos,
+    ) -> SourceFile {
+        remove_bom(&mut src);
+
+        let src_hash = {
+            let mut hasher: StableHasher<u128> = StableHasher::new();
+            hasher.write(src.as_bytes());
+            hasher.finish()
+        };
+        let name_hash = {
+            let mut hasher: StableHasher<u128> = StableHasher::new();
+            name.hash(&mut hasher);
+            hasher.finish()
+        };
+        let end_pos = start_pos.to_usize() + src.len();
+
+        let (lines, multibyte_chars, non_narrow_chars) =
+            analyze_source_file::analyze_source_file(&src[..], start_pos);
+
+        SourceFile {
+            name,
+            name_was_remapped,
+            unmapped_path: Some(unmapped_path),
+            crate_of_origin: 0,
+            src: Lrc::new(src),
+            src_hash,
+            start_pos,
+            end_pos: Pos::from_usize(end_pos),
+            lines,
+            multibyte_chars,
+            non_narrow_chars,
+            name_hash,
+        }
+    }
+
+    /// Return the `BytePos` of the beginning of the current line.
+    pub fn line_begin_pos(&self, pos: BytePos) -> BytePos {
+        let line_index = self.lookup_line(pos).unwrap();
+        self.lines[line_index]
+    }
+
+    /// Get a line from the list of pre-computed line-beginnings.
+    /// The line number here is 0-based.
+    pub fn get_line(&self, line_number: usize) -> Option<Cow<str>> {
+        fn get_until_newline(src: &str, begin: usize) -> &str {
+            // We can't use `lines.get(line_number+1)` because we might
+            // be parsing when we call this function and thus the current
+            // line is the last one we have line info for.
+            let slice = &src[begin..];
+            match slice.find('\n') {
+                Some(e) => &slice[..e],
+                None => slice,
+            }
+        }
+
+        let begin = {
+            let line = if let Some(line) = self.lines.get(line_number) {
+                line
+            } else {
+                return None;
+            };
+            let begin: BytePos = *line - self.start_pos;
+            begin.to_usize()
+        };
+
+        Some(Cow::from(get_until_newline(&self.src, begin)))
+    }
+
+    pub fn is_real_file(&self) -> bool {
+        self.name.is_real()
+    }
+
+    pub fn byte_length(&self) -> u32 {
+        self.end_pos.0 - self.start_pos.0
+    }
+    pub fn count_lines(&self) -> usize {
+        self.lines.len()
+    }
+
+    /// Find the line containing the given position. The return value is the
+    /// index into the `lines` array of this `SourceFile`, not the 1-based line
+    /// number. If the source_file is empty or the position is located before
+    /// the first line, `None` is returned.
+    pub fn lookup_line(&self, pos: BytePos) -> Option<usize> {
+        if self.lines.len() == 0 {
+            return None;
+        }
+
+        let line_index = lookup_line(&self.lines[..], pos);
+        assert!(line_index < self.lines.len() as isize);
+        if line_index >= 0 {
+            Some(line_index as usize)
+        } else {
+            None
+        }
+    }
+
+    pub fn line_bounds(&self, line_index: usize) -> (BytePos, BytePos) {
+        if self.start_pos == self.end_pos {
+            return (self.start_pos, self.end_pos);
+        }
+
+        assert!(line_index < self.lines.len());
+        if line_index == (self.lines.len() - 1) {
+            (self.lines[line_index], self.end_pos)
+        } else {
+            (self.lines[line_index], self.lines[line_index + 1])
+        }
+    }
+
+    #[inline]
+    pub fn contains(&self, byte_pos: BytePos) -> bool {
+        byte_pos >= self.start_pos && byte_pos <= self.end_pos
+    }
+}
+
+/// Remove utf-8 BOM if any.
+fn remove_bom(src: &mut String) {
+    if src.starts_with("\u{feff}") {
+        src.drain(..3);
+    }
+}
+
+// _____________________________________________________________________________
+// Pos, BytePos, CharPos
+//
+
+pub trait Pos {
+    fn from_usize(n: usize) -> Self;
+    fn to_usize(&self) -> usize;
+    fn from_u32(n: u32) -> Self;
+    fn to_u32(&self) -> u32;
+}
+
+/// A byte offset. Keep this small (currently 32-bits), as AST contains
+/// a lot of them.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
+pub struct BytePos(pub u32);
+
+/// A character offset. Because of multibyte UTF-8 characters, a byte offset
+/// is not equivalent to a character offset. The `SourceMap` will convert
+/// `BytePos` values to `CharPos` values as necessary.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
+pub struct CharPos(pub usize);
+
+// FIXME: lots of boilerplate in these impls, but so far my attempts to fix
+// have been unsuccessful.
+
+impl Pos for BytePos {
+    #[inline(always)]
+    fn from_usize(n: usize) -> BytePos {
+        BytePos(n as u32)
+    }
+
+    #[inline(always)]
+    fn to_usize(&self) -> usize {
+        self.0 as usize
+    }
+
+    #[inline(always)]
+    fn from_u32(n: u32) -> BytePos {
+        BytePos(n)
+    }
+
+    #[inline(always)]
+    fn to_u32(&self) -> u32 {
+        self.0
+    }
+}
+
+impl Add for BytePos {
+    type Output = BytePos;
+
+    #[inline(always)]
+    fn add(self, rhs: BytePos) -> BytePos {
+        BytePos((self.to_usize() + rhs.to_usize()) as u32)
+    }
+}
+
+impl Sub for BytePos {
+    type Output = BytePos;
+
+    #[inline(always)]
+    fn sub(self, rhs: BytePos) -> BytePos {
+        BytePos((self.to_usize() - rhs.to_usize()) as u32)
+    }
+}
+
+impl Pos for CharPos {
+    #[inline(always)]
+    fn from_usize(n: usize) -> CharPos {
+        CharPos(n)
+    }
+
+    #[inline(always)]
+    fn to_usize(&self) -> usize {
+        self.0
+    }
+
+    #[inline(always)]
+    fn from_u32(n: u32) -> CharPos {
+        CharPos(n as usize)
+    }
+
+    #[inline(always)]
+    fn to_u32(&self) -> u32 {
+        self.0 as u32
+    }
+}
+
+impl Add for CharPos {
+    type Output = CharPos;
+
+    #[inline(always)]
+    fn add(self, rhs: CharPos) -> CharPos {
+        CharPos(self.to_usize() + rhs.to_usize())
+    }
+}
+
+impl Sub for CharPos {
+    type Output = CharPos;
+
+    #[inline(always)]
+    fn sub(self, rhs: CharPos) -> CharPos {
+        CharPos(self.to_usize() - rhs.to_usize())
+    }
+}
+
+// _____________________________________________________________________________
+// Loc, LocWithOpt, SourceFileAndLine, SourceFileAndBytePos
+//
+
+/// A source code location used for error reporting.
+#[derive(Debug, Clone)]
+pub struct Loc {
+    /// Information about the original source.
+    pub file: Lrc<SourceFile>,
+    /// The (1-based) line number.
+    pub line: usize,
+    /// The (0-based) column offset.
+    pub col: CharPos,
+    /// The (0-based) column offset when displayed.
+    pub col_display: usize,
+}
+
+/// A source code location used as the result of `lookup_char_pos_adj`.
+// Actually, *none* of the clients use the filename *or* file field;
+// perhaps they should just be removed.
+#[derive(Debug)]
+pub struct LocWithOpt {
+    pub filename: FileName,
+    pub line: usize,
+    pub col: CharPos,
+    pub file: Option<Lrc<SourceFile>>,
+}
+
+// Used to be structural records.
+#[derive(Debug)]
+pub struct SourceFileAndLine {
+    pub sf: Lrc<SourceFile>,
+    pub line: usize,
+}
+#[derive(Debug)]
+pub struct SourceFileAndBytePos {
+    pub sf: Lrc<SourceFile>,
+    pub pos: BytePos,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct LineInfo {
+    /// Index of line, starting from 0.
+    pub line_index: usize,
+
+    /// Column in line where span begins, starting from 0.
+    pub start_col: CharPos,
+
+    /// Column in line where span ends, starting from 0, exclusive.
+    pub end_col: CharPos,
+}
+
+pub struct FileLines {
+    pub file: Lrc<SourceFile>,
+    pub lines: Vec<LineInfo>,
+}
+
+thread_local!(pub static SPAN_DEBUG: Cell<fn(Span, &mut fmt::Formatter) -> fmt::Result> =
+                Cell::new(default_span_debug));
+
+// _____________________________________________________________________________
+// SpanLinesError, SpanSnippetError, DistinctSources,
+// MalformedSourceMapPositions
+//
+
+pub type FileLinesResult = Result<FileLines, SpanLinesError>;
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum SpanLinesError {
+    IllFormedSpan(Span),
+    DistinctSources(DistinctSources),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum SpanSnippetError {
+    IllFormedSpan(Span),
+    DistinctSources(DistinctSources),
+    MalformedForSourcemap(MalformedSourceMapPositions),
+    SourceNotAvailable { filename: FileName },
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct DistinctSources {
+    pub begin: (FileName, BytePos),
+    pub end: (FileName, BytePos),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct MalformedSourceMapPositions {
+    pub name: FileName,
+    pub source_len: usize,
+    pub begin_pos: BytePos,
+    pub end_pos: BytePos,
+}
+
+// Given a slice of line start positions and a position, returns the index of
+// the line the position is on. Returns -1 if the position is located before
+// the first line.
+fn lookup_line(lines: &[BytePos], pos: BytePos) -> isize {
+    match lines.binary_search(&pos) {
+        Ok(line) => line as isize,
+        Err(line) => line as isize - 1,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{lookup_line, BytePos};
+
+    #[test]
+    fn test_lookup_line() {
+        let lines = &[BytePos(3), BytePos(17), BytePos(28)];
+
+        assert_eq!(lookup_line(lines, BytePos(0)), -1);
+        assert_eq!(lookup_line(lines, BytePos(3)), 0);
+        assert_eq!(lookup_line(lines, BytePos(4)), 0);
+
+        assert_eq!(lookup_line(lines, BytePos(16)), 0);
+        assert_eq!(lookup_line(lines, BytePos(17)), 1);
+        assert_eq!(lookup_line(lines, BytePos(18)), 1);
+
+        assert_eq!(lookup_line(lines, BytePos(28)), 2);
+        assert_eq!(lookup_line(lines, BytePos(29)), 2);
+    }
+}
diff --git a/common/src/syntax_pos/span_encoding.rs b/common/src/syntax_pos/span_encoding.rs
new file mode 100644
index 000000000000..7c0ffb2e4985
--- /dev/null
+++ b/common/src/syntax_pos/span_encoding.rs
@@ -0,0 +1,171 @@
+// Spans are encoded using 1-bit tag and 2 different encoding formats (one for
+// each tag value). One format is used for keeping span data inline,
+// another contains index into an out-of-line span interner.
+// The encoding format for inline spans were obtained by optimizing over crates
+// in rustc/libstd. See https://internals.rust-lang.org/t/rfc-compiler-refactoring-spans/1357/28
+
+use hygiene::SyntaxContext;
+use BytePos;
+use SpanData;
+use GLOBALS;
+
+use rustc_data_structures::fx::FxHashMap;
+use std::hash::{Hash, Hasher};
+
+/// A compressed span.
+/// Contains either fields of `SpanData` inline if they are small, or index into
+/// span interner. The primary goal of `Span` is to be as small as possible and
+/// fit into other structures (that's why it uses `packed` as well). Decoding
+/// speed is the second priority. See `SpanData` for the info on span fields in
+/// decoded representation.
+#[repr(packed)]
+pub struct Span(u32);
+
+impl Copy for Span {}
+impl Clone for Span {
+    #[inline]
+    fn clone(&self) -> Span {
+        *self
+    }
+}
+impl PartialEq for Span {
+    #[inline]
+    fn eq(&self, other: &Span) -> bool {
+        let a = self.0;
+        let b = other.0;
+        a == b
+    }
+}
+impl Eq for Span {}
+impl Hash for Span {
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        let a = self.0;
+        a.hash(state)
+    }
+}
+
+/// Dummy span, both position and length are zero, syntax context is zero as
+/// well. This span is kept inline and encoded with format 0.
+pub const DUMMY_SP: Span = Span(0);
+
+impl Span {
+    #[inline]
+    pub fn new(lo: BytePos, hi: BytePos, ctxt: SyntaxContext) -> Self {
+        encode(&match lo <= hi {
+            true => SpanData { lo, hi, ctxt },
+            false => SpanData {
+                lo: hi,
+                hi: lo,
+                ctxt,
+            },
+        })
+    }
+
+    #[inline]
+    pub fn data(self) -> SpanData {
+        decode(self)
+    }
+}
+
+// Tags
+const TAG_INLINE: u32 = 0;
+const TAG_INTERNED: u32 = 1;
+const TAG_MASK: u32 = 1;
+
+// Fields indexes
+const BASE_INDEX: usize = 0;
+const LEN_INDEX: usize = 1;
+const CTXT_INDEX: usize = 2;
+
+// Tag = 0, inline format.
+// -------------------------------------------------------------
+// | base 31:8  | len 7:1  | ctxt (currently 0 bits) | tag 0:0 |
+// -------------------------------------------------------------
+// Since there are zero bits for ctxt, only SpanData with a 0 SyntaxContext
+// can be inline.
+const INLINE_SIZES: [u32; 3] = [24, 7, 0];
+const INLINE_OFFSETS: [u32; 3] = [8, 1, 1];
+
+// Tag = 1, interned format.
+// ------------------------
+// | index 31:1 | tag 0:0 |
+// ------------------------
+const INTERNED_INDEX_SIZE: u32 = 31;
+const INTERNED_INDEX_OFFSET: u32 = 1;
+
+#[inline]
+fn encode(sd: &SpanData) -> Span {
+    let (base, len, ctxt) = (sd.lo.0, sd.hi.0 - sd.lo.0, sd.ctxt.as_u32());
+
+    let val = if (base >> INLINE_SIZES[BASE_INDEX]) == 0
+        && (len >> INLINE_SIZES[LEN_INDEX]) == 0
+        && (ctxt >> INLINE_SIZES[CTXT_INDEX]) == 0
+    {
+        (base << INLINE_OFFSETS[BASE_INDEX])
+            | (len << INLINE_OFFSETS[LEN_INDEX])
+            | (ctxt << INLINE_OFFSETS[CTXT_INDEX])
+            | TAG_INLINE
+    } else {
+        let index = with_span_interner(|interner| interner.intern(sd));
+        (index << INTERNED_INDEX_OFFSET) | TAG_INTERNED
+    };
+    Span(val)
+}
+
+#[inline]
+fn decode(span: Span) -> SpanData {
+    let val = span.0;
+
+    // Extract a field at position `pos` having size `size`.
+    let extract = |pos: u32, size: u32| {
+        let mask = ((!0u32) as u64 >> (32 - size)) as u32; // Can't shift u32 by 32
+        (val >> pos) & mask
+    };
+
+    let (base, len, ctxt) = if val & TAG_MASK == TAG_INLINE {
+        (
+            extract(INLINE_OFFSETS[BASE_INDEX], INLINE_SIZES[BASE_INDEX]),
+            extract(INLINE_OFFSETS[LEN_INDEX], INLINE_SIZES[LEN_INDEX]),
+            extract(INLINE_OFFSETS[CTXT_INDEX], INLINE_SIZES[CTXT_INDEX]),
+        )
+    } else {
+        let index = extract(INTERNED_INDEX_OFFSET, INTERNED_INDEX_SIZE);
+        return with_span_interner(|interner| *interner.get(index));
+    };
+    SpanData {
+        lo: BytePos(base),
+        hi: BytePos(base + len),
+        ctxt: SyntaxContext::from_u32(ctxt),
+    }
+}
+
+#[derive(Default)]
+pub struct SpanInterner {
+    spans: FxHashMap<SpanData, u32>,
+    span_data: Vec<SpanData>,
+}
+
+impl SpanInterner {
+    fn intern(&mut self, span_data: &SpanData) -> u32 {
+        if let Some(index) = self.spans.get(span_data) {
+            return *index;
+        }
+
+        let index = self.spans.len() as u32;
+        self.span_data.push(*span_data);
+        self.spans.insert(*span_data, index);
+        index
+    }
+
+    #[inline]
+    fn get(&self, index: u32) -> &SpanData {
+        &self.span_data[index as usize]
+    }
+}
+
+// If an interner exists, return it. Otherwise, prepare a fresh one.
+#[inline]
+fn with_span_interner<T, F: FnOnce(&mut SpanInterner) -> T>(f: F) -> T {
+    GLOBALS.with(|globals| f(&mut *globals.span_interner.lock()))
+}
diff --git a/common/tests/fold_and_then.rs b/common/tests/fold_and_then.rs
index 420c6b1443e8..a07f977569ef 100644
--- a/common/tests/fold_and_then.rs
+++ b/common/tests/fold_and_then.rs
@@ -2,6 +2,7 @@
 #![feature(box_syntax)]
 #![feature(specialization)]
 #![feature(test)]
+#![cfg(feature = "fold")]
 
 #[macro_use]
 extern crate swc_common;
diff --git a/ecmascript/ast/Cargo.toml b/ecmascript/ast/Cargo.toml
index 52fd1afdfd2d..e6238a96ad49 100644
--- a/ecmascript/ast/Cargo.toml
+++ b/ecmascript/ast/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "swc_ecma_ast"
-version = "0.5.0"
+version = "0.6.0"
 authors = ["강동윤 <kdy1@outlook.kr>"]
 license = "Apache-2.0/MIT"
 repository = "https://github.com/swc-project/swc.git"
@@ -8,8 +8,13 @@ documentation = "https://swc-project.github.io/rustdoc/swc_ecma_ast/"
 description = "Ecmascript ast."
 edition = "2018"
 
+[features]
+default = []
+# Requires nightly.
+fold = ["swc_common/fold"]
+
 [dependencies]
 swc_atoms = { version = "0.1", path ="../../atoms" }
-swc_common = { version = "0.1", path ="../../common" }
+swc_common = { version = "0.2", path ="../../common" }
 enum_kind = { version = "0.1", path ="../../macros/enum_kind" }
 string_enum = { version = "0.1", path ="../../macros/string_enum" }
\ No newline at end of file
diff --git a/ecmascript/ast/src/class.rs b/ecmascript/ast/src/class.rs
index 9d28e5130042..99026a3bc118 100644
--- a/ecmascript/ast/src/class.rs
+++ b/ecmascript/ast/src/class.rs
@@ -9,7 +9,9 @@ use crate::{
         TsTypeParamInstantiation,
     },
 };
-use swc_common::{ast_node, Fold, Span};
+#[cfg(feature = "fold")]
+use swc_common::Fold;
+use swc_common::{ast_node, Span};
 
 #[ast_node]
 pub struct Class {
@@ -48,7 +50,7 @@ pub type PrivateProp = ClassProperty<PrivateName>;
 pub struct ClassProperty<K> {
     pub span: Span,
 
-    #[fold(bound)]
+    #[cfg_attr(feature = "fold", fold(bound))]
     pub key: K,
     pub value: Option<Box<Expr>>,
 
@@ -83,12 +85,12 @@ pub struct Constructor {
 #[ast_node]
 pub struct ClassMethod<K> {
     pub span: Span,
-    #[fold(bound)]
+    #[cfg_attr(feature = "fold", fold(bound))]
     pub key: K,
 
     pub function: Function,
 
-    #[fold(ignore)]
+    #[cfg_attr(feature = "fold", fold(ignore))]
     pub kind: MethodKind,
 
     pub is_static: bool,
@@ -107,7 +109,8 @@ pub struct Decorator {
     pub expr: Box<Expr>,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Fold)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub enum MethodKind {
     Method,
     Getter,
diff --git a/ecmascript/ast/src/decl.rs b/ecmascript/ast/src/decl.rs
index 294e10483c74..40911be942ee 100644
--- a/ecmascript/ast/src/decl.rs
+++ b/ecmascript/ast/src/decl.rs
@@ -6,7 +6,9 @@ use crate::{
     pat::Pat,
     typescript::{TsEnumDecl, TsInterfaceDecl, TsModuleDecl, TsTypeAliasDecl},
 };
-use swc_common::{ast_node, Fold, Span};
+#[cfg(feature = "fold")]
+use swc_common::Fold;
+use swc_common::{ast_node, Span};
 
 #[ast_node]
 pub enum Decl {
@@ -43,7 +45,8 @@ pub struct VarDecl {
     pub decls: Vec<VarDeclarator>,
 }
 
-#[derive(Fold, StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[derive(StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub enum VarDeclKind {
     /// `var`
     Var,
diff --git a/ecmascript/ast/src/expr.rs b/ecmascript/ast/src/expr.rs
index cbd7a163b3e1..8b41640eaf85 100644
--- a/ecmascript/ast/src/expr.rs
+++ b/ecmascript/ast/src/expr.rs
@@ -13,7 +13,9 @@ use crate::{
         TsTypeParamInstantiation,
     },
 };
-use swc_common::{ast_node, Fold, Span, Spanned};
+#[cfg(feature = "fold")]
+use swc_common::Fold;
+use swc_common::{ast_node, Span, Spanned};
 
 #[ast_node]
 pub enum Expr {
@@ -283,7 +285,8 @@ pub enum ExprOrSuper {
     Expr(Box<Expr>),
 }
 
-#[derive(Fold, Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub struct ExprOrSpread {
     pub spread: Option<Span>,
     pub expr: Box<Expr>,
diff --git a/ecmascript/ast/src/ident.rs b/ecmascript/ast/src/ident.rs
index 48c78336de0d..d0a9dba507aa 100644
--- a/ecmascript/ast/src/ident.rs
+++ b/ecmascript/ast/src/ident.rs
@@ -4,10 +4,11 @@ use swc_atoms::JsWord;
 use swc_common::{ast_node, Fold, Span, Spanned};
 
 /// Ident with span.
-#[derive(Spanned, Fold, Clone, PartialEq)]
+#[derive(Spanned, Clone, PartialEq)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub struct Ident {
     pub span: Span,
-    #[fold(ignore)]
+    #[cfg_attr(feature = "fold", fold(ignore))]
     pub sym: JsWord,
     pub type_ann: Option<TsTypeAnn>,
     /// TypeScript only. Used in case of an optional parameter.
diff --git a/ecmascript/ast/src/lib.rs b/ecmascript/ast/src/lib.rs
index b102881e6ed9..a811194a3396 100644
--- a/ecmascript/ast/src/lib.rs
+++ b/ecmascript/ast/src/lib.rs
@@ -1,5 +1,3 @@
-#![feature(specialization)]
-#![feature(never_type)]
 #![deny(unreachable_patterns)]
 #![deny(missing_copy_implementations)]
 #![deny(missing_debug_implementations)]
diff --git a/ecmascript/ast/src/operators.rs b/ecmascript/ast/src/operators.rs
index 30830a1bb85a..f7281bfed4c6 100644
--- a/ecmascript/ast/src/operators.rs
+++ b/ecmascript/ast/src/operators.rs
@@ -1,8 +1,10 @@
 use enum_kind::Kind;
 use string_enum::StringEnum;
+#[cfg(feature = "fold")]
 use swc_common::Fold;
 
-#[derive(Kind, Fold, StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[derive(Kind, StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 #[kind(function(precedence = "u8"))]
 pub enum BinaryOp {
     /// `==`
@@ -85,7 +87,8 @@ pub enum BinaryOp {
     Exp,
 }
 
-#[derive(Fold, StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[derive(StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub enum AssignOp {
     /// `=`
     Assign,
@@ -116,7 +119,8 @@ pub enum AssignOp {
     ExpAssign,
 }
 
-#[derive(Fold, StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[derive(StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub enum UpdateOp {
     /// `++`
     PlusPlus,
@@ -124,7 +128,8 @@ pub enum UpdateOp {
     MinusMinus,
 }
 
-#[derive(Fold, StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[derive(StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub enum UnaryOp {
     /// `-`
     Minus,
diff --git a/ecmascript/ast/src/typescript.rs b/ecmascript/ast/src/typescript.rs
index df3c0def1fd2..c58001bdc411 100644
--- a/ecmascript/ast/src/typescript.rs
+++ b/ecmascript/ast/src/typescript.rs
@@ -8,7 +8,9 @@ use crate::{
     module::ModuleItem,
     pat::{AssignPat, ObjectPat, RestPat},
 };
-use swc_common::{ast_node, Fold, Span};
+#[cfg(feature = "fold")]
+use swc_common::Fold;
+use swc_common::{ast_node, Span};
 
 #[ast_node]
 pub struct TsTypeAnn {
@@ -209,7 +211,8 @@ pub struct TsKeywordType {
     pub kind: TsKeywordTypeKind,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Fold)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub enum TsKeywordTypeKind {
     TsAnyKeyword,
     TsUnknownKeyword,
@@ -358,7 +361,8 @@ pub struct TsTypeOperator {
     pub type_ann: Box<TsType>,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Fold)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub enum TsTypeOperatorOp {
     KeyOf,
     Unique,
@@ -371,7 +375,8 @@ pub struct TsIndexedAccessType {
     pub index_type: Box<TsType>,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Fold)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub enum TruePlusMinus {
     True,
     Plus,
@@ -558,7 +563,8 @@ pub struct TsNonNullExpr {
     pub expr: Box<Expr>,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Fold)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 pub enum Accessibility {
     Public,
     Protected,
diff --git a/ecmascript/codegen/Cargo.toml b/ecmascript/codegen/Cargo.toml
index 1b5cce781115..82d34c71661e 100644
--- a/ecmascript/codegen/Cargo.toml
+++ b/ecmascript/codegen/Cargo.toml
@@ -10,11 +10,11 @@ description = "Ecmascript code generator for the swc project."
 [dependencies]
 bitflags = "1"
 swc_atoms = { version = "0.1", path ="../../atoms" }
-swc_common = { version = "0.1", path ="../../common" }
-swc_ecma_ast = { version = "0.5", path ="../ast" }
+swc_common = { version = "0.2", path ="../../common" }
+swc_ecma_ast = { version = "0.6", path ="../ast" }
 swc_ecma_codegen_macros = { version = "0.1", path ="./macros" }
 sourcemap = "2.2"
 
 [dev-dependencies]
-testing = { version = "0.1", path ="../../testing" }
-swc_ecma_parser = { version = "0.7", path ="../parser" }
\ No newline at end of file
+testing = { version = "0.2", path ="../../testing" }
+swc_ecma_parser = { version = "0.8", path ="../parser" }
\ No newline at end of file
diff --git a/ecmascript/codegen/benches/bench.rs b/ecmascript/codegen/benches/bench.rs
index 29845e54f26e..b08321164a02 100644
--- a/ecmascript/codegen/benches/bench.rs
+++ b/ecmascript/codegen/benches/bench.rs
@@ -96,7 +96,7 @@ fn emit_colors(b: &mut Bencher) {
         let mut parser = Parser::new(session, Syntax::default(), SourceFileInput::from(&*fm));
         let module = parser
             .parse_module()
-            .map_err(|e| {
+            .map_err(|mut e| {
                 e.emit();
                 ()
             })
diff --git a/ecmascript/codegen/src/tests.rs b/ecmascript/codegen/src/tests.rs
index cb99bc867701..bb0d07290977 100644
--- a/ecmascript/codegen/src/tests.rs
+++ b/ecmascript/codegen/src/tests.rs
@@ -83,7 +83,7 @@ fn test_from_to(from: &str, to: &str) {
                 Syntax::default(),
                 (&*src).into(),
             ))
-            .map_err(|e| {
+            .map_err(|mut e| {
                 e.emit();
                 ()
             });
diff --git a/ecmascript/codegen/src/typescript.rs b/ecmascript/codegen/src/typescript.rs
index 8338c313dc4f..dd2490e2a73e 100644
--- a/ecmascript/codegen/src/typescript.rs
+++ b/ecmascript/codegen/src/typescript.rs
@@ -1,6 +1,4 @@
 use super::{Emitter, Result};
-use crate::list::ListFormat;
-use swc_common::Spanned;
 use swc_ecma_ast::*;
 use swc_ecma_codegen_macros::emitter;
 
diff --git a/ecmascript/codegen/tests/test262.rs b/ecmascript/codegen/tests/test262.rs
index 53c592f492b7..fa82d455e5fb 100644
--- a/ecmascript/codegen/tests/test262.rs
+++ b/ecmascript/codegen/tests/test262.rs
@@ -153,7 +153,7 @@ fn error_tests(tests: &mut Vec<TestDescAndFn>) -> Result<(), io::Error> {
                     (&*src).into(),
                 );
 
-                let s: Lrc<String> = src.src.as_ref().map(|s| s.clone()).unwrap();
+                let s: Lrc<String> = src.src.clone();
                 let mut src_map_builder = SourceMapBuilder::new(Some(&s));
                 {
                     let mut emitter = Emitter {
@@ -172,14 +172,14 @@ fn error_tests(tests: &mut Vec<TestDescAndFn>) -> Result<(), io::Error> {
                     // Parse source
                     if module {
                         emitter
-                            .emit_module(&parser.parse_module().map_err(|e| {
+                            .emit_module(&parser.parse_module().map_err(|mut e| {
                                 e.emit();
                                 ()
                             })?)
                             .unwrap();
                     } else {
                         emitter
-                            .emit_script(&parser.parse_script().map_err(|e| {
+                            .emit_script(&parser.parse_script().map_err(|mut e| {
                                 e.emit();
                                 ()
                             })?)
diff --git a/ecmascript/lints/src/with.rs b/ecmascript/lints/src/with.rs
index 4252ecbb269f..8f9e13d80ee1 100644
--- a/ecmascript/lints/src/with.rs
+++ b/ecmascript/lints/src/with.rs
@@ -7,6 +7,9 @@ pub struct With<'a> {
 
 impl<'a> Visit<WithStmt> for With<'a> {
     fn visit(&mut self, stmt: &WithStmt) {
-        self.handler.warn("with statement").span(stmt.span).emit();
+        self.handler
+            .struct_warn("with statement")
+            .set_span(stmt.span)
+            .emit();
     }
 }
diff --git a/ecmascript/lints/tests/golden.rs b/ecmascript/lints/tests/golden.rs
index b1b0220b0d5d..220241a0a58b 100644
--- a/ecmascript/lints/tests/golden.rs
+++ b/ecmascript/lints/tests/golden.rs
@@ -94,7 +94,7 @@ fn add_golden_tests(tests: &mut Vec<TestDescAndFn>) -> Result<(), io::Error> {
                     let session = parser::Session { handler: &handler };
                     parser::Parser::new(session, Syntax::default(), SourceFileInput::from(&*fm))
                         .parse_module()
-                        .map_err(|e| {
+                        .map_err(|mut e| {
                             e.emit();
                             ()
                         })?
diff --git a/ecmascript/parser/Cargo.toml b/ecmascript/parser/Cargo.toml
index b2b3600c4f95..4847b85f77e6 100644
--- a/ecmascript/parser/Cargo.toml
+++ b/ecmascript/parser/Cargo.toml
@@ -1,16 +1,23 @@
 [package]
 name = "swc_ecma_parser"
-version = "0.7.0"
+version = "0.8.0"
 authors = ["강동윤 <kdy1@outlook.kr>"]
 license = "Apache-2.0/MIT"
 repository = "https://github.com/swc-project/swc.git"
 documentation = "https://swc-project.github.io/rustdoc/swc_ecma_parser/"
 description = "Feature-complete es2019 parser."
 
+[features]
+default = []
+# Requires nightly.
+fold = ["swc_common/fold", "swc_ecma_ast/fold"]
+# Verify that expression is valid. Requires nightly.
+verify = ["fold"]
+
 [dependencies]
 swc_atoms = { version = "0.1", path ="../../atoms" }
-swc_common = { version = "0.1", path ="../../common" }
-swc_ecma_ast = { version = "0.5", path ="../ast" }
+swc_common = { version = "0.2", path ="../../common" }
+swc_ecma_ast = { version = "0.6", path ="../ast" }
 swc_ecma_parser_macros = { version = "0.1", path ="./macros" }
 enum_kind = { version = "0.1", path ="../../macros/enum_kind" }
 unicode-xid = "0.1"
@@ -22,6 +29,6 @@ lazy_static = "1"
 regex = "1"
 
 [dev-dependencies]
-testing = { version = "0.1", path ="../../testing" }
+testing = { version = "0.2", path ="../../testing" }
 env_logger = "0.6.0"
 walkdir = "2"
diff --git a/ecmascript/parser/src/error.rs b/ecmascript/parser/src/error.rs
index 7a63a5b8cb47..98cffcee0a8d 100644
--- a/ecmascript/parser/src/error.rs
+++ b/ecmascript/parser/src/error.rs
@@ -18,7 +18,9 @@ pub(crate) struct Eof<'a> {
 
 impl<'a> From<Eof<'a>> for DiagnosticBuilder<'a> {
     fn from(Eof { handler, last }: Eof<'a>) -> Self {
-        handler.error("Unexpected eof").span(last)
+        let mut db = handler.struct_err("Unexpected eof");
+        db.set_span(last);
+        db
     }
 }
 
@@ -285,19 +287,22 @@ impl<'a> From<ErrorToDiag<'a>> for DiagnosticBuilder<'a> {
                 .into(),
         };
 
-        let d = e.handler.error(&msg).span(e.span);
+        let mut db = e.handler.struct_err(&msg);
+        db.set_span(e.span);
 
-        let d = match e.error {
-            ExpectedSemiForExprStmt { expr } => d.span_note(
-                expr,
-                "This is the expression part of an expression statement",
-            ),
+        match e.error {
+            ExpectedSemiForExprStmt { expr } => {
+                db.span_note(
+                    expr,
+                    "This is the expression part of an expression statement",
+                );
+            }
             MultipleDefault { previous } => {
-                d.span_note(previous, "previous default case is declared at here")
+                db.span_note(previous, "previous default case is declared at here");
             }
-            _ => d,
-        };
+            _ => {}
+        }
 
-        d
+        db
     }
 }
diff --git a/ecmascript/parser/src/lexer/input.rs b/ecmascript/parser/src/lexer/input.rs
index a5f0508eb25d..b9b7656ac3c0 100644
--- a/ecmascript/parser/src/lexer/input.rs
+++ b/ecmascript/parser/src/lexer/input.rs
@@ -12,10 +12,7 @@ pub struct SourceFileInput<'a> {
 
 impl<'a> From<&'a SourceFile> for SourceFileInput<'a> {
     fn from(fm: &'a SourceFile) -> Self {
-        let src = match fm.src {
-            Some(ref s) => s,
-            None => unreachable!("Cannot lex SourceFile without source: {}", fm.name),
-        };
+        let src = &fm.src;
 
         SourceFileInput {
             start_pos: fm.start_pos,
diff --git a/ecmascript/parser/src/lexer/mod.rs b/ecmascript/parser/src/lexer/mod.rs
index 58458403063a..022e5b9b0a3b 100644
--- a/ecmascript/parser/src/lexer/mod.rs
+++ b/ecmascript/parser/src/lexer/mod.rs
@@ -213,7 +213,7 @@ impl<'a, I: Input> Lexer<'a, I> {
                     // Handle -->
                     if self.state.had_line_break && c == '-' && self.eat('>') {
                         if self.ctx.module {
-                            self.error(start, SyntaxError::LegacyCommentInModule)?
+                            return self.error(start, SyntaxError::LegacyCommentInModule)?;
                         }
                         self.skip_line_comment(0);
                         self.skip_space()?;
diff --git a/ecmascript/parser/src/lexer/state.rs b/ecmascript/parser/src/lexer/state.rs
index f94a86e05c42..6c64483329d9 100644
--- a/ecmascript/parser/src/lexer/state.rs
+++ b/ecmascript/parser/src/lexer/state.rs
@@ -83,7 +83,7 @@ impl<'a> From<&'a Token> for TokenType {
 }
 
 impl<'a, I: Input> Lexer<'a, I> {
-    pub const fn token_context(&self) -> &TokenContexts {
+    pub fn token_context(&self) -> &TokenContexts {
         &self.state.context
     }
     pub fn token_context_mut(&mut self) -> &mut TokenContexts {
diff --git a/ecmascript/parser/src/lexer/util.rs b/ecmascript/parser/src/lexer/util.rs
index 4f6f7d08eeb0..97d89dcd6c34 100644
--- a/ecmascript/parser/src/lexer/util.rs
+++ b/ecmascript/parser/src/lexer/util.rs
@@ -85,13 +85,13 @@ impl<'a, I: Input> Lexer<'a, I> {
 
     /// Shorthand for `let span = self.span(start); self.error_span(span)`
     #[cold]
-    pub(super) fn error(&mut self, start: BytePos, kind: SyntaxError) -> LexResult<!> {
+    pub(super) fn error<T>(&mut self, start: BytePos, kind: SyntaxError) -> LexResult<T> {
         let span = self.span(start);
         self.error_span(span, kind)
     }
 
     #[cold]
-    pub(super) fn error_span(&mut self, span: Span, kind: SyntaxError) -> LexResult<!> {
+    pub(super) fn error_span<T>(&mut self, span: Span, kind: SyntaxError) -> LexResult<T> {
         let err = ErrorToDiag {
             handler: self.session.handler,
             span,
diff --git a/ecmascript/parser/src/lib.rs b/ecmascript/parser/src/lib.rs
index 90f331920e0a..c6e88d58e27d 100644
--- a/ecmascript/parser/src/lib.rs
+++ b/ecmascript/parser/src/lib.rs
@@ -55,7 +55,7 @@
 //!
 //!         let _module = parser
 //!             .parse_module()
-//!             .map_err(|e| {
+//!             .map_err(|mut e| {
 //!                 e.emit();
 //!                 ()
 //!             })
@@ -67,13 +67,8 @@
 //!
 //! [tc39/test262]:https://github.com/tc39/test262
 
-#![feature(box_syntax)]
-#![feature(box_patterns)]
-#![feature(const_fn)]
-#![feature(specialization)]
-#![feature(never_type)]
-#![feature(try_from)]
-#![feature(try_trait)]
+#![cfg_attr(any(test, feature = "fold"), feature(specialization))]
+#![cfg_attr(test, feature(box_syntax))]
 #![cfg_attr(test, feature(test))]
 #![deny(unreachable_patterns)]
 #![deny(unsafe_code)]
diff --git a/ecmascript/parser/src/parser/class_and_fn.rs b/ecmascript/parser/src/parser/class_and_fn.rs
index a5d17b6610d5..26d44643ab48 100644
--- a/ecmascript/parser/src/parser/class_and_fn.rs
+++ b/ecmascript/parser/src/parser/class_and_fn.rs
@@ -159,12 +159,12 @@ impl<'a, I: Input> Parser<'a, I> {
             while eat!('.') {
                 let ident = self.parse_ident(true, true)?;
 
-                expr = box Expr::Member(MemberExpr {
+                expr = Box::new(Expr::Member(MemberExpr {
                     span: span!(start),
                     obj: ExprOrSuper::Expr(expr),
                     computed: false,
-                    prop: box Expr::Ident(ident),
-                })
+                    prop: Box::new(Expr::Ident(ident)),
+                }))
             }
 
             expr
@@ -190,12 +190,12 @@ impl<'a, I: Input> Parser<'a, I> {
         }
 
         let args = self.parse_args()?;
-        Ok(box Expr::Call(CallExpr {
+        Ok(Box::new(Expr::Call(CallExpr {
             span: span!(expr.span().lo()),
             callee: ExprOrSuper::Expr(expr),
             args,
             type_args: None,
-        }))
+        })))
     }
 
     fn parse_class_body(&mut self) -> PResult<'a, Vec<ClassMember>> {
@@ -556,9 +556,9 @@ impl<'a, I: Input> Parser<'a, I> {
                 Either::Right(key) => ClassProperty {
                     span: span!(start),
                     key: match key {
-                        PropName::Ident(i) => box Expr::Ident(i),
-                        PropName::Str(s) => box Expr::Lit(Lit::Str(s)),
-                        PropName::Num(n) => box Expr::Lit(Lit::Num(n)),
+                        PropName::Ident(i) => Box::new(Expr::Ident(i)),
+                        PropName::Str(s) => Box::new(Expr::Lit(Lit::Str(s))),
+                        PropName::Num(n) => Box::new(Expr::Lit(Lit::Num(n))),
                         PropName::Computed(e) => e,
                     },
                     value,
@@ -819,10 +819,10 @@ impl OutputType for Box<Expr> {
     }
 
     fn finish_fn(ident: Option<Ident>, function: Function) -> Self {
-        box Expr::Fn(FnExpr { ident, function })
+        Box::new(Expr::Fn(FnExpr { ident, function }))
     }
     fn finish_class(ident: Option<Ident>, class: Class) -> Self {
-        box Expr::Class(ClassExpr { ident, class })
+        Box::new(Expr::Class(ClassExpr { ident, class }))
     }
 }
 
@@ -927,7 +927,7 @@ mod tests {
 
     fn lhs(s: &'static str) -> Box<Expr> {
         test_parser(s, Syntax::default(), |p| {
-            p.parse_lhs_expr().map_err(|e| {
+            p.parse_lhs_expr().map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -936,7 +936,7 @@ mod tests {
 
     fn expr(s: &'static str) -> Box<Expr> {
         test_parser(s, Syntax::default(), |p| {
-            p.parse_expr().map_err(|e| {
+            p.parse_expr().map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -947,9 +947,9 @@ mod tests {
     fn class_expr() {
         assert_eq_ignore_span!(
             expr("(class extends a {})"),
-            box Expr::Paren(ParenExpr {
+            Box::new(Expr::Paren(ParenExpr {
                 span,
-                expr: box Expr::Class(ClassExpr {
+                expr: Box::new(Expr::Class(ClassExpr {
                     ident: None,
                     class: Class {
                         decorators: vec![],
@@ -961,8 +961,8 @@ mod tests {
                         super_type_params: None,
                         type_params: None,
                     },
-                }),
-            })
+                })),
+            }))
         );
     }
 }
diff --git a/ecmascript/parser/src/parser/expr/mod.rs b/ecmascript/parser/src/parser/expr/mod.rs
index 6ca6fb046668..dba6e9aaadbd 100644
--- a/ecmascript/parser/src/parser/expr/mod.rs
+++ b/ecmascript/parser/src/parser/expr/mod.rs
@@ -20,10 +20,10 @@ impl<'a, I: Input> Parser<'a, I> {
                 exprs.push(self.parse_assignment_expr()?);
             }
             let end = exprs.last().unwrap().span().hi();
-            return Ok(box Expr::Seq(SeqExpr {
+            return Ok(Box::new(Expr::Seq(SeqExpr {
                 span: span!(start),
                 exprs,
-            }));
+            })));
         }
 
         Ok(expr)
@@ -130,13 +130,13 @@ impl<'a, I: Input> Parser<'a, I> {
 
                 bump!();
                 let right = self.parse_assignment_expr()?;
-                Ok(box Expr::Assign(AssignExpr {
+                Ok(Box::new(Expr::Assign(AssignExpr {
                     span: span!(start),
                     op,
                     // TODO:
                     left,
                     right,
-                }))
+                })))
             }
             _ => Ok(cond),
         }
@@ -154,12 +154,12 @@ impl<'a, I: Input> Parser<'a, I> {
             expect!(':');
             let alt = self.parse_assignment_expr()?;
 
-            Ok(box Expr::Cond(CondExpr {
+            Ok(Box::new(Expr::Cond(CondExpr {
                 test,
                 cons,
                 alt,
                 span: span!(start),
-            }))
+            })))
         } else {
             return Ok(test);
         }
@@ -177,7 +177,7 @@ impl<'a, I: Input> Parser<'a, I> {
             .unwrap_or(false);
 
         if eat!("this") {
-            return Ok(box Expr::This(ThisExpr { span: span!(start) }));
+            return Ok(Box::new(Expr::This(ThisExpr { span: span!(start) })));
         }
 
         if is!("async") {
@@ -193,7 +193,7 @@ impl<'a, I: Input> Parser<'a, I> {
                     assert_and_bump!("async");
                     p.try_parse_ts_generic_async_arrow_fn(start)
                 }) {
-                    return Ok(box Expr::Arrow(res));
+                    return Ok(Box::new(Expr::Arrow(res)));
                 }
             }
 
@@ -231,7 +231,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 _ => false,
             }
         } {
-            return Ok(box Expr::Lit(self.parse_lit()?));
+            return Ok(Box::new(Expr::Lit(self.parse_lit()?)));
         }
 
         // Regexp
@@ -243,11 +243,11 @@ impl<'a, I: Input> Parser<'a, I> {
         } {
             match bump!() {
                 Token::Regex(exp, flags) => {
-                    return Ok(box Expr::Lit(Lit::Regex(Regex {
+                    return Ok(Box::new(Expr::Lit(Lit::Regex(Regex {
                         span: span!(start),
                         exp,
                         flags,
-                    })));
+                    }))));
                 }
                 _ => unreachable!(),
             }
@@ -255,7 +255,7 @@ impl<'a, I: Input> Parser<'a, I> {
 
         if is!('`') {
             // parse template literal
-            return Ok(box Expr::Tpl(self.parse_tpl()?));
+            return Ok(Box::new(Expr::Tpl(self.parse_tpl()?)));
         }
 
         if is!('(') {
@@ -271,7 +271,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 let params = vec![arg];
                 expect!("=>");
                 let body = self.parse_fn_body(true, false)?;
-                return Ok(box Expr::Arrow(ArrowExpr {
+                return Ok(Box::new(Expr::Arrow(ArrowExpr {
                     span: span!(start),
                     body,
                     params,
@@ -279,12 +279,12 @@ impl<'a, I: Input> Parser<'a, I> {
                     is_generator: false,
                     return_type: None,
                     type_params: None,
-                }));
+                })));
             } else if can_be_arrow && !self.input.had_line_break_before_cur() && eat!("=>") {
                 let params = vec![id.into()];
                 let body = self.parse_fn_body(false, false)?;
 
-                return Ok(box Expr::Arrow(ArrowExpr {
+                return Ok(Box::new(Expr::Arrow(ArrowExpr {
                     span: span!(start),
                     body,
                     params,
@@ -294,9 +294,9 @@ impl<'a, I: Input> Parser<'a, I> {
                     return_type: None,
                     // TODO
                     type_params: None,
-                }));
+                })));
             } else {
-                return Ok(box Expr::Ident(id));
+                return Ok(Box::new(Expr::Ident(id)));
             }
         }
 
@@ -328,7 +328,7 @@ impl<'a, I: Input> Parser<'a, I> {
         expect!(']');
 
         let span = span!(start);
-        Ok(box Expr::Array(ArrayLit { span, elems }))
+        Ok(Box::new(Expr::Array(ArrayLit { span, elems })))
     }
 
     fn parse_member_expr(&mut self) -> PResult<'a, (Box<Expr>)> {
@@ -343,10 +343,10 @@ impl<'a, I: Input> Parser<'a, I> {
             if eat!('.') {
                 let start_of_target = cur_pos!();
                 if eat!("target") {
-                    return Ok(box Expr::MetaProp(MetaPropExpr {
+                    return Ok(Box::new(Expr::MetaProp(MetaPropExpr {
                         meta: Ident::new(js_word!("new"), span_of_new),
                         prop: Ident::new(js_word!("target"), span!(start_of_target)),
-                    }));
+                    })));
                 }
 
                 unexpected!()
@@ -372,12 +372,12 @@ impl<'a, I: Input> Parser<'a, I> {
                 // Parsed with 'MemberExpression' production.
                 let args = self.parse_args().map(Some)?;
 
-                let new_expr = ExprOrSuper::Expr(box Expr::New(NewExpr {
+                let new_expr = ExprOrSuper::Expr(Box::new(Expr::New(NewExpr {
                     span: span!(start),
                     callee,
                     args,
                     type_args,
-                }));
+                })));
 
                 // We should parse subscripts for MemberExpression.
                 // Because it's left recursive.
@@ -386,12 +386,12 @@ impl<'a, I: Input> Parser<'a, I> {
 
             // Parsed with 'NewExpression' production.
 
-            return Ok(box Expr::New(NewExpr {
+            return Ok(Box::new(Expr::New(NewExpr {
                 span: span!(start),
                 callee,
                 args: None,
                 type_args,
-            }));
+            })));
         }
 
         if eat!("super") {
@@ -493,7 +493,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 .collect();
 
             let body: BlockStmtOrExpr = self.parse_fn_body(async_span.is_some(), false)?;
-            return Ok(box Expr::Arrow(ArrowExpr {
+            return Ok(Box::new(Expr::Arrow(ArrowExpr {
                 span: span!(start),
                 is_async: async_span.is_some(),
                 is_generator: false,
@@ -501,7 +501,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 body,
                 return_type,
                 type_params: None,
-            }));
+            })));
         }
 
         let expr_or_spreads = paren_items
@@ -515,12 +515,15 @@ impl<'a, I: Input> Parser<'a, I> {
             .collect::<Result<Vec<_>, _>>()?;
         if let Some(async_span) = async_span {
             // It's a call expression
-            return Ok(box Expr::Call(CallExpr {
+            return Ok(Box::new(Expr::Call(CallExpr {
                 span: span!(async_span.lo()),
-                callee: ExprOrSuper::Expr(box Expr::Ident(Ident::new("async".into(), async_span))),
+                callee: ExprOrSuper::Expr(Box::new(Expr::Ident(Ident::new(
+                    "async".into(),
+                    async_span,
+                )))),
                 args: expr_or_spreads,
                 type_args: None,
-            }));
+            })));
         }
 
         // It was not head of arrow function.
@@ -543,10 +546,10 @@ impl<'a, I: Input> Parser<'a, I> {
                 } => syntax_error!(expr.span(), SyntaxError::SpreadInParenExpr),
                 ExprOrSpread { expr, .. } => expr,
             };
-            return Ok(box Expr::Paren(ParenExpr {
+            return Ok(Box::new(Expr::Paren(ParenExpr {
                 span: span!(start),
                 expr,
-            }));
+            })));
         } else {
             debug_assert!(expr_or_spreads.len() >= 2);
 
@@ -563,18 +566,18 @@ impl<'a, I: Input> Parser<'a, I> {
             debug_assert!(exprs.len() >= 2);
 
             // span of sequence expression should not include '(', ')'
-            let seq_expr = box Expr::Seq(SeqExpr {
+            let seq_expr = Box::new(Expr::Seq(SeqExpr {
                 span: Span::new(
                     exprs.first().unwrap().span().lo(),
                     exprs.last().unwrap().span().hi(),
                     Default::default(),
                 ),
                 exprs,
-            });
-            return Ok(box Expr::Paren(ParenExpr {
+            }));
+            return Ok(Box::new(Expr::Paren(ParenExpr {
                 span: span!(start),
                 expr: seq_expr,
-            }));
+            })));
         }
     }
 
@@ -707,10 +710,10 @@ impl<'a, I: Input> Parser<'a, I> {
                     ExprOrSuper::Expr(expr) => expr,
                 };
                 return Ok((
-                    box Expr::TsNonNull(TsNonNullExpr {
+                    Box::new(Expr::TsNonNull(TsNonNullExpr {
                         span: span!(start),
                         expr,
-                    }),
+                    })),
                     true,
                 ));
             }
@@ -740,7 +743,7 @@ impl<'a, I: Input> Parser<'a, I> {
                         // But it might be a call with a type argument `async<T>();`
                         let async_arrow_fn = p.try_parse_ts_generic_async_arrow_fn(start)?;
                         if let Some(async_arrow_fn) = async_arrow_fn {
-                            return Ok(Some((box Expr::Arrow(async_arrow_fn), true)));
+                            return Ok(Some((Box::new(Expr::Arrow(async_arrow_fn)), true)));
                         }
                     }
 
@@ -752,12 +755,12 @@ impl<'a, I: Input> Parser<'a, I> {
                         let args = p.parse_args()?;
 
                         return Ok(Some((
-                            box Expr::Call(CallExpr {
+                            Box::new(Expr::Call(CallExpr {
                                 span: span!(start),
                                 callee: obj,
                                 type_args: Some(type_args),
                                 args,
-                            }),
+                            })),
                             true,
                         )));
                     } else if is!('`') {
@@ -769,7 +772,7 @@ impl<'a, I: Input> Parser<'a, I> {
                                 },
                                 Some(type_args),
                             )
-                            .map(|expr| (box Expr::TaggedTpl(expr), true))
+                            .map(|expr| (Box::new(Expr::TaggedTpl(expr)), true))
                             .map(Some);
                     } else {
                         unexpected!()
@@ -784,15 +787,15 @@ impl<'a, I: Input> Parser<'a, I> {
         // member expression
         // $obj.name
         if eat!('.') {
-            let prop: Box<Expr> = box self.parse_ident_name().map(Expr::from)?;
+            let prop: Box<Expr> = Box::new(self.parse_ident_name().map(Expr::from)?);
             return Ok((
-                box Expr::Member(MemberExpr {
+                Box::new(Expr::Member(MemberExpr {
                     span: span!(start),
                     obj,
 
                     prop,
                     computed: false,
-                }),
+                })),
                 true,
             ));
         }
@@ -802,12 +805,12 @@ impl<'a, I: Input> Parser<'a, I> {
             let prop = self.include_in_expr(true).parse_expr()?;
             expect!(']');
             return Ok((
-                box Expr::Member(MemberExpr {
+                Box::new(Expr::Member(MemberExpr {
                     span: span!(start),
                     obj,
                     prop,
                     computed: true,
-                }),
+                })),
                 true,
             ));
         }
@@ -815,12 +818,12 @@ impl<'a, I: Input> Parser<'a, I> {
         if !no_call && is!('(') {
             let args = self.parse_args()?;
             return Ok((
-                box Expr::Call(CallExpr {
+                Box::new(Expr::Call(CallExpr {
                     span: span!(start),
                     callee: obj,
                     args,
                     type_args: None,
-                }),
+                })),
                 true,
             ));
         }
@@ -830,7 +833,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 // MemberExpression[?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged]
                 if is!('`') {
                     let tpl = self.parse_tagged_tpl(expr, None)?;
-                    return Ok((box Expr::TaggedTpl(tpl), true));
+                    return Ok((Box::new(Expr::TaggedTpl(tpl)), true));
                 }
 
                 Ok((expr, false))
@@ -851,8 +854,8 @@ impl<'a, I: Input> Parser<'a, I> {
         if self.input.syntax().jsx() {
             fn into_expr(e: Either<JSXFragment, JSXElement>) -> Box<Expr> {
                 match e {
-                    Either::Left(l) => box l.into(),
-                    Either::Right(r) => box r.into(),
+                    Either::Left(l) => Box::new(l.into()),
+                    Either::Right(r) => Box::new(r.into()),
                 }
             }
             match *cur!(true)? {
@@ -915,7 +918,7 @@ impl<'a, I: Input> Parser<'a, I> {
                     Some(&tok!('(')),
                     "parse_new_expr() should eat paren if it exists"
                 );
-                return Ok(box Expr::New(NewExpr { type_args, ..ne }));
+                return Ok(Box::new(Expr::New(NewExpr { type_args, ..ne })));
             }
             _ => {}
         }
@@ -927,13 +930,13 @@ impl<'a, I: Input> Parser<'a, I> {
             // which is left-recursive.
             let args = self.parse_args()?;
 
-            let call_expr = box Expr::Call(CallExpr {
+            let call_expr = Box::new(Expr::Call(CallExpr {
                 span: span!(start),
 
                 callee: ExprOrSuper::Expr(callee),
                 args,
                 type_args,
-            });
+            }));
 
             return self.parse_subscripts(ExprOrSuper::Expr(call_expr), false);
         }
@@ -997,11 +1000,8 @@ impl<'a, I: Input> Parser<'a, I> {
             };
             let optional = if self.input.syntax().typescript() {
                 if eat!('?') {
-                    match arg {
-                        ExprOrSpread {
-                            expr: box Expr::Ident(..),
-                            ..
-                        } => {}
+                    match *arg.expr {
+                        Expr::Ident(..) => {}
                         _ => syntax_error!(arg.span(), SyntaxError::TsBindingPatCannotBeOptional),
                     }
                     true
@@ -1029,7 +1029,7 @@ impl<'a, I: Input> Parser<'a, I> {
                     rest_span = Some(span);
                     pat = Pat::Rest(RestPat {
                         dot3_token: span,
-                        arg: box pat,
+                        arg: Box::new(pat),
                         type_ann: None,
                     });
                 }
@@ -1061,7 +1061,7 @@ impl<'a, I: Input> Parser<'a, I> {
                     let right = self.parse_expr()?;
                     pat = Pat::Assign(AssignPat {
                         span: span!(start),
-                        left: box pat,
+                        left: Box::new(pat),
                         right,
                         type_ann: None,
                     });
@@ -1102,20 +1102,20 @@ impl<'a, I: Input> Parser<'a, I> {
         }
 
         if is!(';') || (!is!('*') && !cur!(false).map(Token::starts_expr).unwrap_or(true)) {
-            Ok(box Expr::Yield(YieldExpr {
+            Ok(Box::new(Expr::Yield(YieldExpr {
                 span: span!(start),
                 arg: None,
                 delegate: false,
-            }))
+            })))
         } else {
             let has_star = eat!('*');
             let arg = self.parse_assignment_expr()?;
 
-            Ok(box Expr::Yield(YieldExpr {
+            Ok(Box::new(Expr::Yield(YieldExpr {
                 span: span!(start),
                 arg: Some(arg),
                 delegate: has_star,
-            }))
+            })))
         }
     }
 
diff --git a/ecmascript/parser/src/parser/expr/ops.rs b/ecmascript/parser/src/parser/expr/ops.rs
index 53c3bd3b7498..cafb1c3647aa 100644
--- a/ecmascript/parser/src/parser/expr/ops.rs
+++ b/ecmascript/parser/src/parser/expr/ops.rs
@@ -32,11 +32,11 @@ impl<'a, I: Input> Parser<'a, I> {
                 let span = span!(left.span().lo());
                 let expr = left;
                 let type_ann = self.next_then_parse_ts_type()?;
-                let node = box Expr::TsAs(TsAsExpr {
+                let node = Box::new(Expr::TsAs(TsAsExpr {
                     span,
                     expr,
                     type_ann,
-                });
+                }));
                 return self.parse_bin_op_recursively(node, min_prec);
             }
         }
@@ -104,12 +104,12 @@ impl<'a, I: Input> Parser<'a, I> {
             )?
         };
 
-        let node = box Expr::Bin(BinExpr {
+        let node = Box::new(Expr::Bin(BinExpr {
             span: span!(left.span().lo()),
             op,
             left,
             right,
-        });
+        }));
 
         let expr = self.parse_bin_op_recursively(node, min_prec)?;
         Ok(expr)
@@ -138,12 +138,12 @@ impl<'a, I: Input> Parser<'a, I> {
                 // This is early ReferenceError
                 syntax_error!(arg.span(), SyntaxError::NotSimpleAssign)
             }
-            return Ok(box Expr::Update(UpdateExpr {
+            return Ok(Box::new(Expr::Update(UpdateExpr {
                 span: span!(start),
                 prefix: true,
                 op,
                 arg,
-            }));
+            })));
         }
 
         // Parse unary expression
@@ -159,11 +159,11 @@ impl<'a, I: Input> Parser<'a, I> {
                 _ => unreachable!(),
             };
             let arg = self.parse_unary_expr()?;
-            return Ok(box Expr::Unary(UnaryExpr {
+            return Ok(Box::new(Expr::Unary(UnaryExpr {
                 span: span!(start),
                 op,
                 arg,
-            }));
+            })));
         }
 
         if self.ctx().in_async && is!("await") {
@@ -192,12 +192,12 @@ impl<'a, I: Input> Parser<'a, I> {
                 op!("--")
             };
 
-            return Ok(box Expr::Update(UpdateExpr {
+            return Ok(Box::new(Expr::Update(UpdateExpr {
                 span: span!(start),
                 prefix: false,
                 op,
                 arg: expr,
-            }));
+            })));
         }
         Ok(expr)
     }
@@ -213,10 +213,10 @@ impl<'a, I: Input> Parser<'a, I> {
         }
 
         let arg = self.parse_unary_expr()?;
-        Ok(box Expr::Await(AwaitExpr {
+        Ok(Box::new(Expr::Await(AwaitExpr {
             span: span!(start),
             arg,
-        }))
+        })))
     }
 }
 
@@ -227,7 +227,7 @@ mod tests {
 
     fn bin(s: &'static str) -> Box<Expr> {
         test_parser(s, Syntax::default(), |p| {
-            p.parse_bin_expr().map_err(|e| {
+            p.parse_bin_expr().map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -238,12 +238,12 @@ mod tests {
     fn simple() {
         assert_eq_ignore_span!(
             bin("5 + 4 * 7"),
-            box Expr::Bin(BinExpr {
+            Box::new(Expr::Bin(BinExpr {
                 span,
                 op: op!(bin, "+"),
                 left: bin("5"),
                 right: bin("4 * 7"),
-            })
+            }))
         );
     }
 
@@ -251,12 +251,12 @@ mod tests {
     fn same_prec() {
         assert_eq_ignore_span!(
             bin("5 + 4 + 7"),
-            box Expr::Bin(BinExpr {
+            Box::new(Expr::Bin(BinExpr {
                 span,
                 op: op!(bin, "+"),
                 left: bin("5 + 4"),
                 right: bin("7"),
-            })
+            }))
         );
     }
 
diff --git a/ecmascript/parser/src/parser/expr/tests.rs b/ecmascript/parser/src/parser/expr/tests.rs
index 8d3b48bc275c..033d9bc381ef 100644
--- a/ecmascript/parser/src/parser/expr/tests.rs
+++ b/ecmascript/parser/src/parser/expr/tests.rs
@@ -3,7 +3,7 @@ use swc_common::DUMMY_SP as span;
 
 fn lhs(s: &'static str) -> Box<Expr> {
     test_parser(s, Syntax::default(), |p| {
-        p.parse_lhs_expr().map_err(|e| {
+        p.parse_lhs_expr().map_err(|mut e| {
             e.emit();
             ()
         })
@@ -12,7 +12,7 @@ fn lhs(s: &'static str) -> Box<Expr> {
 
 fn new_expr(s: &'static str) -> Box<Expr> {
     test_parser(s, Syntax::default(), |p| {
-        p.parse_new_expr().map_err(|e| {
+        p.parse_new_expr().map_err(|mut e| {
             e.emit();
             ()
         })
@@ -21,7 +21,7 @@ fn new_expr(s: &'static str) -> Box<Expr> {
 
 fn member_expr(s: &'static str) -> Box<Expr> {
     test_parser(s, Syntax::default(), |p| {
-        p.parse_member_expr().map_err(|e| {
+        p.parse_member_expr().map_err(|mut e| {
             e.emit();
             ()
         })
@@ -35,7 +35,7 @@ fn expr(s: &'static str) -> Box<Expr> {
                 Stmt::Expr(expr) => expr,
                 _ => unreachable!(),
             })
-            .map_err(|e| {
+            .map_err(|mut e| {
                 e.emit();
                 ()
             })
diff --git a/ecmascript/parser/src/parser/expr/verifier.rs b/ecmascript/parser/src/parser/expr/verifier.rs
index e9897d52560b..e048a4027a17 100644
--- a/ecmascript/parser/src/parser/expr/verifier.rs
+++ b/ecmascript/parser/src/parser/expr/verifier.rs
@@ -1,7 +1,9 @@
 use super::*;
+#[cfg(feature = "verify")]
 use swc_common::{Span, Spanned, Visit, VisitWith};
 
 impl<'a, I: Input> Parser<'a, I> {
+    #[cfg(feature = "verify")]
     pub(in crate::parser) fn verify_expr(&self, expr: Box<Expr>) -> PResult<'a, Box<Expr>> {
         let mut v = Verifier { errors: vec![] };
 
@@ -15,12 +17,20 @@ impl<'a, I: Input> Parser<'a, I> {
         let (span, error) = v.errors.into_iter().next().unwrap();
         syntax_error!(self, span, error)
     }
+
+    #[cfg(not(feature = "verify"))]
+    pub(in crate::parser) fn verify_expr(&self, expr: Box<Expr>) -> PResult<'a, Box<Expr>> {
+        // TODO(kdy1): Somehow verify it
+        Ok(expr)
+    }
 }
 
+#[cfg(feature = "verify")]
 pub(super) struct Verifier {
     pub errors: Vec<(Span, SyntaxError)>,
 }
 
+#[cfg(feature = "verify")]
 impl Visit<Expr> for Verifier {
     fn visit(&mut self, e: &Expr) {
         match *e {
@@ -30,6 +40,7 @@ impl Visit<Expr> for Verifier {
     }
 }
 
+#[cfg(feature = "verify")]
 impl Visit<Prop> for Verifier {
     fn visit(&mut self, p: &Prop) {
         match *p {
diff --git a/ecmascript/parser/src/parser/input.rs b/ecmascript/parser/src/parser/input.rs
index 1df3390c673c..bb7aede2511d 100644
--- a/ecmascript/parser/src/parser/input.rs
+++ b/ecmascript/parser/src/parser/input.rs
@@ -156,11 +156,11 @@ impl<'a, I: Input> ParserInput<'a, I> {
     }
 
     /// Returns span of the previous token.
-    pub const fn prev_span(&self) -> Span {
+    pub fn prev_span(&self) -> Span {
         self.prev_span
     }
 
-    pub const fn get_ctx(&self) -> Context {
+    pub fn get_ctx(&self) -> Context {
         self.iter.ctx
     }
 
@@ -168,7 +168,7 @@ impl<'a, I: Input> ParserInput<'a, I> {
         self.iter.ctx = ctx;
     }
 
-    pub const fn syntax(&self) -> Syntax {
+    pub fn syntax(&self) -> Syntax {
         self.iter.syntax
     }
 
@@ -176,7 +176,7 @@ impl<'a, I: Input> ParserInput<'a, I> {
         self.iter.set_expr_allowed(allow)
     }
 
-    pub(crate) const fn token_context(&self) -> &lexer::TokenContexts {
+    pub(crate) fn token_context(&self) -> &lexer::TokenContexts {
         self.iter.token_context()
     }
     pub fn token_context_mut(&mut self) -> &mut lexer::TokenContexts {
diff --git a/ecmascript/parser/src/parser/jsx/mod.rs b/ecmascript/parser/src/parser/jsx/mod.rs
index f9adde780f65..f0e297a8621c 100644
--- a/ecmascript/parser/src/parser/jsx/mod.rs
+++ b/ecmascript/parser/src/parser/jsx/mod.rs
@@ -55,7 +55,7 @@ impl<'a, I: Input> Parser<'a, I> {
             let new_node = JSXElementName::JSXMemberExpr(JSXMemberExpr {
                 obj: match node {
                     JSXElementName::Ident(i) => JSXObject::Ident(i),
-                    JSXElementName::JSXMemberExpr(i) => JSXObject::JSXMemberExpr(box i),
+                    JSXElementName::JSXMemberExpr(i) => JSXObject::JSXMemberExpr(Box::new(i)),
                     _ => unimplemented!("JSXNamespacedName -> JSXObject"),
                 },
                 prop,
@@ -280,7 +280,7 @@ impl<'a, I: Input> Parser<'a, I> {
 
                             children.push(p.parse_jsx_element_at(start).map(|e| match e {
                                 Either::Left(e) => JSXElementChild::from(e),
-                                Either::Right(e) => JSXElementChild::from(box e),
+                                Either::Right(e) => JSXElementChild::from(Box::new(e)),
                             })?);
                         }
                         Token::JSXText { .. } => {
@@ -419,9 +419,12 @@ fn get_qualified_jsx_name(name: &JSXElementName) -> JsWord {
     fn get_qualified_obj_name(obj: &JSXObject) -> JsWord {
         match *obj {
             JSXObject::Ident(ref i) => i.sym.clone(),
-            JSXObject::JSXMemberExpr(box JSXMemberExpr { ref obj, ref prop }) => {
-                format!("{}.{}", get_qualified_obj_name(obj), prop.sym).into()
-            }
+            JSXObject::JSXMemberExpr(ref member) => format!(
+                "{}.{}",
+                get_qualified_obj_name(&member.obj),
+                member.prop.sym
+            )
+            .into(),
         }
     }
     match *name {
diff --git a/ecmascript/parser/src/parser/jsx/tests.rs b/ecmascript/parser/src/parser/jsx/tests.rs
index 16733e3d96ec..d68edad38d50 100644
--- a/ecmascript/parser/src/parser/jsx/tests.rs
+++ b/ecmascript/parser/src/parser/jsx/tests.rs
@@ -10,7 +10,7 @@ fn jsx(src: &'static str) -> Box<Expr> {
             ..Default::default()
         }),
         |p| {
-            p.parse_expr().map_err(|e| {
+            p.parse_expr().map_err(|mut e| {
                 e.emit();
                 ()
             })
diff --git a/ecmascript/parser/src/parser/macros.rs b/ecmascript/parser/src/parser/macros.rs
index 85c1b118ba18..95ade58781c0 100644
--- a/ecmascript/parser/src/parser/macros.rs
+++ b/ecmascript/parser/src/parser/macros.rs
@@ -182,8 +182,7 @@ macro_rules! cur {
                             span: e.span,
                             error: e.error,
                         });
-                    let err: Result<!, _> = Err(err);
-                    err?
+                    return Err(err.into());
                 }
                 _ => unreachable!(),
             }
@@ -197,8 +196,7 @@ macro_rules! cur {
                         last,
                         handler: &$p.session.handler,
                     });
-                    let err: Result<!, _> = Err(err);
-                    err?
+                    return Err(err.into());
                 }
                 Err($crate::error::Eof {
                     last,
@@ -303,7 +301,6 @@ macro_rules! syntax_error {
             span: $span,
             error: $err,
         });
-        let err: Result<!, _> = Err(err);
-        err?
+        return Err(err.into());
     }};
 }
diff --git a/ecmascript/parser/src/parser/mod.rs b/ecmascript/parser/src/parser/mod.rs
index 5622cfc14b9b..0f849b6d6afa 100644
--- a/ecmascript/parser/src/parser/mod.rs
+++ b/ecmascript/parser/src/parser/mod.rs
@@ -81,7 +81,7 @@ impl<'a, I: Input> Parser<'a, I> {
         })
     }
 
-    const fn ctx(&self) -> Context {
+    fn ctx(&self) -> Context {
         self.input.get_ctx()
     }
 }
diff --git a/ecmascript/parser/src/parser/object.rs b/ecmascript/parser/src/parser/object.rs
index b06fce3a53a4..269804062ccf 100644
--- a/ecmascript/parser/src/parser/object.rs
+++ b/ecmascript/parser/src/parser/object.rs
@@ -85,7 +85,7 @@ impl<'a, I: Input> ParseObject<'a, (Box<Expr>)> for Parser<'a, I> {
     type Prop = PropOrSpread;
 
     fn make_object(span: Span, props: Vec<Self::Prop>) -> Box<Expr> {
-        box Expr::Object(ObjectLit { span, props })
+        Box::new(Expr::Object(ObjectLit { span, props }))
     }
 
     /// spec: 'PropertyDefinition'
@@ -116,10 +116,10 @@ impl<'a, I: Input> ParseObject<'a, (Box<Expr>)> for Parser<'a, I> {
                     true,
                 )
                 .map(|function| {
-                    PropOrSpread::Prop(box Prop::Method(MethodProp {
+                    PropOrSpread::Prop(Box::new(Prop::Method(MethodProp {
                         key: name,
                         function,
-                    }))
+                    })))
                 });
         }
 
@@ -131,10 +131,10 @@ impl<'a, I: Input> ParseObject<'a, (Box<Expr>)> for Parser<'a, I> {
         // { a: expr, }
         if eat!(':') {
             let value = self.include_in_expr(true).parse_assignment_expr()?;
-            return Ok(PropOrSpread::Prop(box Prop::KeyValue(KeyValueProp {
+            return Ok(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
                 key,
                 value,
-            })));
+            }))));
         }
 
         // Handle `a(){}` (and async(){} / get(){} / set(){})
@@ -148,7 +148,7 @@ impl<'a, I: Input> ParseObject<'a, (Box<Expr>)> for Parser<'a, I> {
                     false,
                     false,
                 )
-                .map(|function| box Prop::Method(MethodProp { key, function }))
+                .map(|function| Box::new(Prop::Method(MethodProp { key, function })))
                 .map(PropOrSpread::Prop);
         }
 
@@ -167,12 +167,12 @@ impl<'a, I: Input> ParseObject<'a, (Box<Expr>)> for Parser<'a, I> {
 
             if eat!('=') {
                 let value = self.include_in_expr(true).parse_assignment_expr()?;
-                return Ok(PropOrSpread::Prop(box Prop::Assign(AssignProp {
+                return Ok(PropOrSpread::Prop(Box::new(Prop::Assign(AssignProp {
                     key: ident,
                     value,
-                })));
+                }))));
             }
-            return Ok(PropOrSpread::Prop(box Prop::from(ident)));
+            return Ok(PropOrSpread::Prop(Box::new(Prop::from(ident))));
         }
 
         // get a(){}
@@ -194,11 +194,11 @@ impl<'a, I: Input> ParseObject<'a, (Box<Expr>)> for Parser<'a, I> {
                             false,
                         )
                         .map(|Function { body, .. }| {
-                            PropOrSpread::Prop(box Prop::Getter(GetterProp {
+                            PropOrSpread::Prop(Box::new(Prop::Getter(GetterProp {
                                 span: span!(start),
                                 key,
                                 body,
-                            }))
+                            })))
                         }),
                     js_word!("set") => self
                         .parse_fn_args_body(
@@ -211,12 +211,12 @@ impl<'a, I: Input> ParseObject<'a, (Box<Expr>)> for Parser<'a, I> {
                         )
                         .map(|Function { params, body, .. }| {
                             debug_assert_eq!(params.len(), 1);
-                            PropOrSpread::Prop(box Prop::Setter(SetterProp {
+                            PropOrSpread::Prop(Box::new(Prop::Setter(SetterProp {
                                 span: span!(start),
                                 key,
                                 body,
                                 param: params.into_iter().next().unwrap(),
-                            }))
+                            })))
                         }),
                     js_word!("async") => self
                         .parse_fn_args_body(
@@ -228,7 +228,7 @@ impl<'a, I: Input> ParseObject<'a, (Box<Expr>)> for Parser<'a, I> {
                             false,
                         )
                         .map(|function| {
-                            PropOrSpread::Prop(box Prop::Method(MethodProp { key, function }))
+                            PropOrSpread::Prop(Box::new(Prop::Method(MethodProp { key, function })))
                         }),
                     _ => unreachable!(),
                 };
@@ -258,7 +258,7 @@ impl<'a, I: Input> ParseObject<'a, Pat> for Parser<'a, I> {
             // spread elemnent
             let dot3_token = span!(start);
 
-            let arg = box self.parse_binding_pat_or_ident()?;
+            let arg = Box::new(self.parse_binding_pat_or_ident()?);
 
             return Ok(ObjectPatProp::Rest(RestPat {
                 dot3_token,
@@ -269,7 +269,7 @@ impl<'a, I: Input> ParseObject<'a, Pat> for Parser<'a, I> {
 
         let key = self.parse_prop_name()?;
         if eat!(':') {
-            let value = box self.parse_binding_element()?;
+            let value = Box::new(self.parse_binding_element()?);
 
             return Ok(ObjectPatProp::KeyValue(KeyValuePatProp { key, value }));
         }
diff --git a/ecmascript/parser/src/parser/pat.rs b/ecmascript/parser/src/parser/pat.rs
index b7eb88fc67ad..4a78e5284fcb 100644
--- a/ecmascript/parser/src/parser/pat.rs
+++ b/ecmascript/parser/src/parser/pat.rs
@@ -59,7 +59,7 @@ impl<'a, I: Input> Parser<'a, I> {
             let right = self.include_in_expr(true).parse_assignment_expr()?;
             return Ok(Pat::Assign(AssignPat {
                 span: span!(start),
-                left: box left,
+                left: Box::new(left),
                 right,
                 type_ann: None,
             }));
@@ -95,7 +95,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 let pat = self.parse_binding_pat_or_ident()?;
                 let pat = Pat::Rest(RestPat {
                     dot3_token,
-                    arg: box pat,
+                    arg: Box::new(pat),
                     type_ann: None,
                 });
                 elems.push(Some(pat));
@@ -162,7 +162,7 @@ impl<'a, I: Input> Parser<'a, I> {
             let right = self.parse_expr()?;
             Ok(Pat::Assign(AssignPat {
                 span: span!(start),
-                left: box pat,
+                left: Box::new(pat),
                 type_ann: None,
                 right,
             }))
@@ -201,7 +201,7 @@ impl<'a, I: Input> Parser<'a, I> {
 
                 let pat = Pat::Rest(RestPat {
                     dot3_token,
-                    arg: box pat,
+                    arg: Box::new(pat),
                     type_ann,
                 });
                 params.push(PatOrTsParamProp::Pat(pat));
@@ -272,7 +272,7 @@ impl<'a, I: Input> Parser<'a, I> {
 
                 let pat = Pat::Rest(RestPat {
                     dot3_token,
-                    arg: box pat,
+                    arg: Box::new(pat),
                     type_ann,
                 });
                 params.push(pat);
@@ -402,7 +402,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 return Ok(Pat::Assign(AssignPat {
                     span,
                     left: match left {
-                        PatOrExpr::Expr(left) => box self.reparse_expr_as_pat(pat_ty, left)?,
+                        PatOrExpr::Expr(left) => Box::new(self.reparse_expr_as_pat(pat_ty, left)?),
                         PatOrExpr::Pat(left) => left,
                     },
                     right,
@@ -418,38 +418,43 @@ impl<'a, I: Input> Parser<'a, I> {
                         .map(|prop| {
                             let span = prop.span();
                             match prop {
-                                PropOrSpread::Prop(box Prop::Shorthand(id)) => {
-                                    Ok(ObjectPatProp::Assign(AssignPatProp {
-                                        span: id.span(),
-                                        key: id.into(),
-                                        value: None,
-                                    }))
-                                }
-                                PropOrSpread::Prop(box Prop::KeyValue(kv_prop)) => {
-                                    Ok(ObjectPatProp::KeyValue(KeyValuePatProp {
-                                        key: kv_prop.key,
-                                        value: box self
-                                            .reparse_expr_as_pat(pat_ty.element(), kv_prop.value)?,
-                                    }))
-                                }
-                                PropOrSpread::Prop(box Prop::Assign(assign_prop)) => {
-                                    Ok(ObjectPatProp::Assign(AssignPatProp {
-                                        span,
-                                        key: assign_prop.key,
-                                        value: Some(assign_prop.value),
-                                    }))
-                                }
+                                PropOrSpread::Prop(prop) => match *prop {
+                                    Prop::Shorthand(id) => {
+                                        Ok(ObjectPatProp::Assign(AssignPatProp {
+                                            span: id.span(),
+                                            key: id.into(),
+                                            value: None,
+                                        }))
+                                    }
+                                    Prop::KeyValue(kv_prop) => {
+                                        Ok(ObjectPatProp::KeyValue(KeyValuePatProp {
+                                            key: kv_prop.key,
+                                            value: Box::new(self.reparse_expr_as_pat(
+                                                pat_ty.element(),
+                                                kv_prop.value,
+                                            )?),
+                                        }))
+                                    }
+                                    Prop::Assign(assign_prop) => {
+                                        Ok(ObjectPatProp::Assign(AssignPatProp {
+                                            span,
+                                            key: assign_prop.key,
+                                            value: Some(assign_prop.value),
+                                        }))
+                                    }
+                                    _ => syntax_error!(prop.span(), SyntaxError::InvalidPat),
+                                },
+
                                 PropOrSpread::Spread(SpreadElement { dot3_token, expr }) => {
                                     Ok(ObjectPatProp::Rest(RestPat {
                                         dot3_token,
                                         // FIXME: is BindingPat correct?
-                                        arg: box self
-                                            .reparse_expr_as_pat(PatType::BindingPat, expr)?,
+                                        arg: Box::new(
+                                            self.reparse_expr_as_pat(PatType::BindingPat, expr)?,
+                                        ),
                                         type_ann: None,
                                     }))
                                 }
-
-                                _ => syntax_error!(prop.span(), SyntaxError::InvalidPat),
                             }
                         })
                         .collect::<(PResult<'a, _>)>()?,
@@ -510,7 +515,7 @@ impl<'a, I: Input> Parser<'a, I> {
                                 .map(|pat| {
                                     Pat::Rest(RestPat {
                                         dot3_token,
-                                        arg: box pat,
+                                        arg: Box::new(pat),
                                         type_ann: None,
                                     })
                                 })
@@ -592,7 +597,7 @@ impl<'a, I: Input> Parser<'a, I> {
             }) => self.reparse_expr_as_pat(pat_ty, expr).map(|pat| {
                 Pat::Rest(RestPat {
                     dot3_token,
-                    arg: box pat,
+                    arg: Box::new(pat),
                     type_ann: None,
                 })
             })?,
@@ -614,7 +619,7 @@ mod tests {
 
     fn array_pat(s: &'static str) -> Pat {
         test_parser(s, Syntax::default(), |p| {
-            p.parse_array_binding_pat().map_err(|e| {
+            p.parse_array_binding_pat().map_err(|mut e| {
                 e.emit();
                 ()
             })
diff --git a/ecmascript/parser/src/parser/stmt/mod.rs b/ecmascript/parser/src/parser/stmt/mod.rs
index 1b9181a39a07..e823c76dadfa 100644
--- a/ecmascript/parser/src/parser/stmt/mod.rs
+++ b/ecmascript/parser/src/parser/stmt/mod.rs
@@ -215,14 +215,14 @@ impl<'a, I: Input> Parser<'a, I> {
         // Identifier node, we switch to interpreting it as a label.
         let expr = self.include_in_expr(true).parse_expr()?;
 
-        let expr = match expr {
-            box Expr::Ident(ident) => {
+        let expr = match *expr {
+            Expr::Ident(ident) => {
                 if eat!(':') {
                     return self.parse_labelled_stmt(ident);
                 }
-                box Expr::Ident(ident)
+                Box::new(Expr::Ident(ident))
             }
-            expr => {
+            _ => {
                 let expr = self.verify_expr(expr)?;
 
                 expr
@@ -260,11 +260,11 @@ impl<'a, I: Input> Parser<'a, I> {
             if !self.ctx().strict && is!("function") {
                 // TODO: report error?
             }
-            box self.parse_stmt(false)?
+            self.parse_stmt(false).map(Box::new)?
         };
 
         let alt = if eat!("else") {
-            Some(box self.parse_stmt(false)?)
+            Some(self.parse_stmt(false).map(Box::new)?)
         } else {
             None
         };
@@ -530,7 +530,7 @@ impl<'a, I: Input> Parser<'a, I> {
 
         assert_and_bump!("do");
 
-        let body = box self.parse_stmt(false)?;
+        let body = self.parse_stmt(false).map(Box::new)?;
         expect!("while");
         let test = self.include_in_expr(true).parse_expr()?;
 
@@ -551,7 +551,7 @@ impl<'a, I: Input> Parser<'a, I> {
         let test = self.include_in_expr(true).parse_expr()?;
         expect!(')');
 
-        let body = box self.parse_stmt(false)?;
+        let body = self.parse_stmt(false).map(Box::new)?;
 
         let span = span!(start);
         Ok(Stmt::While(WhileStmt { span, test, body }))
@@ -570,7 +570,7 @@ impl<'a, I: Input> Parser<'a, I> {
         let obj = self.include_in_expr(true).parse_expr()?;
         expect!(')');
 
-        let body = box self.parse_stmt(false)?;
+        let body = self.parse_stmt(false).map(Box::new)?;
 
         let span = span!(start);
         Ok(Stmt::With(WithStmt { span, obj, body }))
@@ -595,7 +595,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 syntax_error!(SyntaxError::DuplicateLabel(label.sym.clone()));
             }
         }
-        let body = box if is!("function") {
+        let body = Box::new(if is!("function") {
             let f = self.parse_fn_decl(vec![])?;
             match f {
                 Decl::Fn(FnDecl {
@@ -613,7 +613,7 @@ impl<'a, I: Input> Parser<'a, I> {
             f.into()
         } else {
             self.parse_stmt(false)?
-        };
+        });
 
         Ok(Stmt::Labeled(LabeledStmt {
             span: span!(start),
@@ -634,7 +634,7 @@ impl<'a, I: Input> Parser<'a, I> {
         expect!('(');
         let head = self.parse_for_head()?;
         expect!(')');
-        let body = box self.parse_stmt(false)?;
+        let body = self.parse_stmt(false).map(Box::new)?;
 
         let span = span!(start);
         Ok(match head {
@@ -763,11 +763,14 @@ pub(super) trait IsDirective {
     fn as_ref(&self) -> Option<&Stmt>;
     fn is_use_strict(&self) -> bool {
         match self.as_ref() {
-            Some(&Stmt::Expr(box Expr::Lit(Lit::Str(Str {
-                ref value,
-                has_escape: false,
-                ..
-            })))) => value == "use strict",
+            Some(&Stmt::Expr(ref expr)) => match **expr {
+                Expr::Lit(Lit::Str(Str {
+                    ref value,
+                    has_escape: false,
+                    ..
+                })) => value == "use strict",
+                _ => false,
+            },
             _ => false,
         }
     }
@@ -802,7 +805,7 @@ mod tests {
 
     fn stmt(s: &'static str) -> Stmt {
         test_parser(s, Syntax::default(), |p| {
-            p.parse_stmt(true).map_err(|e| {
+            p.parse_stmt(true).map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -810,7 +813,7 @@ mod tests {
     }
     fn expr(s: &'static str) -> Box<Expr> {
         test_parser(s, Syntax::default(), |p| {
-            p.parse_expr().map_err(|e| {
+            p.parse_expr().map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -936,7 +939,7 @@ mod tests {
                     decorators: true,
                     ..Default::default()
                 }),
-                |p| p.parse_stmt_list_item(true).map_err(|e| {
+                |p| p.parse_stmt_list_item(true).map_err(|mut e| {
                     e.emit();
                     ()
                 }),
diff --git a/ecmascript/parser/src/parser/typescript.rs b/ecmascript/parser/src/parser/typescript.rs
index f39eb0ba58e3..ad344bb4b0d4 100644
--- a/ecmascript/parser/src/parser/typescript.rs
+++ b/ecmascript/parser/src/parser/typescript.rs
@@ -160,7 +160,7 @@ impl<'a, I: Input> Parser<'a, I> {
         while eat!('.') {
             let left = entity;
             let right = self.parse_ident(allow_reserved_words, allow_reserved_words)?;
-            entity = TsEntityName::TsQualifiedName(box TsQualifiedName { left, right });
+            entity = TsEntityName::TsQualifiedName(Box::new(TsQualifiedName { left, right }));
         }
 
         Ok(entity)
@@ -311,11 +311,11 @@ impl<'a, I: Input> Parser<'a, I> {
                 false, pos,
             )?;
 
-            let node = box TsType::TsTypePredicate(TsTypePredicate {
+            let node = Box::new(TsType::TsTypePredicate(TsTypePredicate {
                 span: span!(start),
                 param_name: type_pred_var,
                 type_ann,
-            });
+            }));
 
             Ok(TsTypeAnn {
                 span: span!(start),
@@ -352,7 +352,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 *self = cloned;
                 Ok(res)
             }
-            Err(err) => {
+            Err(mut err) => {
                 let _ = err.cancel();
                 Ok(false)
             }
@@ -376,7 +376,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 Some(res)
             }
             Ok(None) => None,
-            Err(err) => {
+            Err(mut err) => {
                 let _ = err.cancel();
                 None
             }
@@ -527,7 +527,7 @@ impl<'a, I: Input> Parser<'a, I> {
                     TsModuleName::Ident(i) => i,
                     _ => unreachable!(),
                 },
-                body: box inner.body.unwrap(),
+                body: Box::new(inner.body.unwrap()),
                 declare: inner.declare,
                 global: inner.global,
             };
@@ -611,13 +611,13 @@ impl<'a, I: Input> Parser<'a, I> {
 
         let false_type = self.parse_ts_type()?;
 
-        Ok(box TsType::TsConditionalType(TsConditionalType {
+        Ok(Box::new(TsType::TsConditionalType(TsConditionalType {
             span: span!(start),
             check_type,
             extends_type,
             true_type,
             false_type,
-        }))
+        })))
     }
 
     /// `tsParseNonConditionalType`
@@ -1004,7 +1004,7 @@ impl<'a, I: Input> Parser<'a, I> {
                         Either::Left(_) => unreachable!(
                             "private name inside parse_ts_property_or_method_signature"
                         ),
-                        Either::Right(e) => box Expr::Ident(e),
+                        Either::Right(e) => Box::new(Expr::Ident(e)),
                     }),
                 };
 
@@ -1264,20 +1264,20 @@ impl<'a, I: Input> Parser<'a, I> {
 
         if eat!("...") {
             let type_ann = self.parse_ts_type()?;
-            return Ok(box TsType::TsRestType(TsRestType {
+            return Ok(Box::new(TsType::TsRestType(TsRestType {
                 span: span!(start),
                 type_ann,
-            }));
+            })));
         }
 
         let ty = self.parse_ts_type()?;
         // parses `TsType?`
         if eat!('?') {
             let type_ann = ty;
-            return Ok(box TsType::TsOptionalType(TsOptionalType {
+            return Ok(Box::new(TsType::TsOptionalType(TsOptionalType {
                 span: span!(start),
                 type_ann,
-            }));
+            })));
         }
 
         Ok(ty)
@@ -1446,10 +1446,10 @@ impl<'a, I: Input> Parser<'a, I> {
                 match kind {
                     Some(kind) if !peeked_is_dot => {
                         bump!();
-                        return Ok(box TsType::TsKeywordType(TsKeywordType {
+                        return Ok(Box::new(TsType::TsKeywordType(TsKeywordType {
                             span: span!(start),
                             kind,
-                        }));
+                        })));
                     }
                     _ => {
                         return self.parse_ts_type_ref().map(TsType::from).map(Box::new);
@@ -1480,10 +1480,10 @@ impl<'a, I: Input> Parser<'a, I> {
                     _ => unreachable!(),
                 };
 
-                return Ok(box TsType::TsLitType(TsLitType {
+                return Ok(Box::new(TsType::TsLitType(TsLitType {
                     span: span!(start),
                     lit,
-                }));
+                })));
             }
 
             tok!("this") => {
@@ -1494,7 +1494,7 @@ impl<'a, I: Input> Parser<'a, I> {
                         .map(TsType::from)
                         .map(Box::new);
                 } else {
-                    return Ok(box TsType::TsThisType(this_keyword));
+                    return Ok(Box::new(TsType::TsThisType(this_keyword)));
                 }
             }
             tok!("typeof") => {
@@ -1533,18 +1533,18 @@ impl<'a, I: Input> Parser<'a, I> {
 
         while !self.input.had_line_break_before_cur() && eat!('[') {
             if eat!(']') {
-                ty = box TsType::TsArrayType(TsArrayType {
+                ty = Box::new(TsType::TsArrayType(TsArrayType {
                     span: span!(ty.span().lo()),
                     elem_type: ty,
-                });
+                }));
             } else {
                 let index_type = self.parse_ts_type()?;
                 expect!(']');
-                ty = box TsType::TsIndexedAccessType(TsIndexedAccessType {
+                ty = Box::new(TsType::TsIndexedAccessType(TsIndexedAccessType {
                     span: span!(ty.span().lo()),
                     obj_type: ty,
                     index_type,
-                })
+                }))
             }
         }
 
@@ -1979,7 +1979,7 @@ impl<'a, I: Input> Parser<'a, I> {
                 types.push(parse_constituent_type(self)?);
             }
 
-            return Ok(box TsType::TsUnionOrIntersectionType(match kind {
+            return Ok(Box::new(TsType::TsUnionOrIntersectionType(match kind {
                 UnionOrIntersection::Union => TsUnionOrIntersectionType::TsUnionType(TsUnionType {
                     span: span!(start),
                     types,
@@ -1990,7 +1990,7 @@ impl<'a, I: Input> Parser<'a, I> {
                         types,
                     })
                 }
-            }));
+            })));
         }
 
         Ok(ty)
diff --git a/ecmascript/parser/src/parser/util.rs b/ecmascript/parser/src/parser/util.rs
index c6205899851e..95cda6c74c66 100644
--- a/ecmascript/parser/src/parser/util.rs
+++ b/ecmascript/parser/src/parser/util.rs
@@ -124,7 +124,7 @@ impl<'a, I: Input> Parser<'a, I> {
         Span::new(start, end, Default::default())
     }
 
-    pub(super) const fn syntax(&self) -> Syntax {
+    pub(super) fn syntax(&self) -> Syntax {
         self.input.syntax()
     }
 }
diff --git a/ecmascript/parser/src/token/mod.rs b/ecmascript/parser/src/token/mod.rs
index 72987565aa6e..fcb7dbb9bced 100644
--- a/ecmascript/parser/src/token/mod.rs
+++ b/ecmascript/parser/src/token/mod.rs
@@ -8,9 +8,12 @@ use ast::{BinaryOp, Str};
 use enum_kind::Kind;
 use std::fmt::{self, Debug, Display, Formatter};
 use swc_atoms::JsWord;
-use swc_common::{Fold, Span};
+#[cfg(feature = "fold")]
+use swc_common::Fold;
+use swc_common::Span;
 
-#[derive(Kind, Debug, Clone, PartialEq, Fold)]
+#[derive(Kind, Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 #[kind(functions(starts_expr = "bool", before_expr = "bool"))]
 pub(crate) enum Token {
     /// Identifier, "null", "true", "false".
@@ -128,10 +131,11 @@ pub(crate) enum Token {
     JSXTagStart,
     JSXTagEnd,
 
-    Error(#[fold(ignore)] Error),
+    Error(#[cfg_attr(feature = "fold", fold(ignore))] Error),
 }
 
-#[derive(Kind, Debug, Clone, Copy, Eq, PartialEq, Hash, Fold)]
+#[derive(Kind, Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 #[kind(functions(starts_expr = "bool"))]
 pub enum BinOpToken {
     /// `==`
@@ -206,7 +210,8 @@ pub(crate) struct TokenAndSpan {
     pub span: Span,
 }
 
-#[derive(Kind, Clone, PartialEq, Eq, Hash, Fold)]
+#[derive(Kind, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 #[kind(functions(starts_expr = "bool", before_expr = "bool"))]
 pub enum Word {
     #[kind(delegate)]
@@ -353,7 +358,8 @@ impl Debug for Word {
 }
 
 /// Keywords
-#[derive(Kind, Clone, Copy, PartialEq, Eq, Hash, Fold)]
+#[derive(Kind, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "fold", derive(Fold))]
 #[kind(function(before_expr = "bool", starts_expr = "bool"))]
 pub enum Keyword {
     /// Spec says this might be identifier.
diff --git a/ecmascript/parser/tests/jsx.rs b/ecmascript/parser/tests/jsx.rs
index 3c55de8748b9..9adeb238ff95 100644
--- a/ecmascript/parser/tests/jsx.rs
+++ b/ecmascript/parser/tests/jsx.rs
@@ -175,7 +175,7 @@ where
             }),
             (&*fm).into(),
         ))
-        .map_err(|e| {
+        .map_err(|mut e| {
             e.emit();
             ()
         });
diff --git a/ecmascript/parser/tests/test262.rs b/ecmascript/parser/tests/test262.rs
index 8194c089c5f0..272899963fda 100644
--- a/ecmascript/parser/tests/test262.rs
+++ b/ecmascript/parser/tests/test262.rs
@@ -283,7 +283,7 @@ where
             Syntax::default(),
             (&*fm).into(),
         ))
-        .map_err(|e| {
+        .map_err(|mut e| {
             e.emit();
             ()
         });
diff --git a/ecmascript/parser/tests/typescript.rs b/ecmascript/parser/tests/typescript.rs
index 9050a39741de..8e975584b8da 100644
--- a/ecmascript/parser/tests/typescript.rs
+++ b/ecmascript/parser/tests/typescript.rs
@@ -138,7 +138,7 @@ where
             }),
             (&*fm).into(),
         ))
-        .map_err(|e| {
+        .map_err(|mut e| {
             e.emit();
             ()
         });
diff --git a/ecmascript/transforms/Cargo.toml b/ecmascript/transforms/Cargo.toml
index fec9029f24b3..705274f106fc 100644
--- a/ecmascript/transforms/Cargo.toml
+++ b/ecmascript/transforms/Cargo.toml
@@ -12,7 +12,7 @@ publish = false
 swc_atoms = { path ="../../atoms" }
 swc_common = { path ="../../common" }
 swc_ecma_ast = { path ="../ast" }
-swc_ecma_parser = { path ="../parser" }
+swc_ecma_parser = { path ="../parser", features = ["verify"] }
 either = "1.5"
 fnv = "1"
 lazy_static = "1"
diff --git a/ecmascript/transforms/benches/base.rs b/ecmascript/transforms/benches/base.rs
index 9aef83aae95d..4eeaebd56cb4 100644
--- a/ecmascript/transforms/benches/base.rs
+++ b/ecmascript/transforms/benches/base.rs
@@ -98,7 +98,7 @@ fn module_clone(b: &mut Bencher) {
         );
         let module = parser
             .parse_module()
-            .map_err(|e| {
+            .map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -124,7 +124,7 @@ fn fold_empty(b: &mut Bencher) {
         );
         let module = parser
             .parse_module()
-            .map_err(|e| {
+            .map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -161,7 +161,7 @@ fn fold_noop_impl_all(b: &mut Bencher) {
         );
         let module = parser
             .parse_module()
-            .map_err(|e| {
+            .map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -198,7 +198,7 @@ fn fold_noop_impl_vec(b: &mut Bencher) {
         );
         let module = parser
             .parse_module()
-            .map_err(|e| {
+            .map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -280,7 +280,7 @@ fn visit_empty(b: &mut Bencher) {
         );
         let module = parser
             .parse_module()
-            .map_err(|e| {
+            .map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -332,7 +332,7 @@ fn visit_contains_this(b: &mut Bencher) {
         );
         let module = parser
             .parse_module()
-            .map_err(|e| {
+            .map_err(|mut e| {
                 e.emit();
                 ()
             })
diff --git a/ecmascript/transforms/benches/bench.rs b/ecmascript/transforms/benches/bench.rs
index e01df149dff5..b08501462e95 100644
--- a/ecmascript/transforms/benches/bench.rs
+++ b/ecmascript/transforms/benches/bench.rs
@@ -104,7 +104,7 @@ macro_rules! tr {
             );
             let module = parser
                 .parse_module()
-                .map_err(|e| {
+                .map_err(|mut e| {
                     e.emit();
                     ()
                 })
diff --git a/ecmascript/transforms/src/helpers/mod.rs b/ecmascript/transforms/src/helpers/mod.rs
index 72c9af19f803..dbb9f1ffa47a 100644
--- a/ecmascript/transforms/src/helpers/mod.rs
+++ b/ecmascript/transforms/src/helpers/mod.rs
@@ -6,7 +6,7 @@ use std::sync::{
 use swc_common::{
     errors::{ColorConfig, Handler},
     sync::Lrc,
-    FileName, FilePathMapping, Fold, SourceMap,
+    FileName, FilePathMapping, Fold, FoldWith, SourceMap, Span, DUMMY_SP,
 };
 use swc_ecma_parser::{Parser, Session, SourceFileInput, Syntax};
 
@@ -75,7 +75,8 @@ impl InjectHelpers {
                         let stmts =
                             Parser::new(*SESSION, Syntax::default(), SourceFileInput::from(&*fm))
                                 .parse_script()
-                                .map_err(|e| {
+                                .map(|stmts| stmts.fold_with(&mut DropSpan))
+                                .map_err(|mut e| {
                                     e.emit();
                                     ()
                                 })
@@ -138,3 +139,10 @@ impl Fold<Module> for InjectHelpers {
         Module { body, ..module }
     }
 }
+
+struct DropSpan;
+impl Fold<Span> for DropSpan {
+    fn fold(&mut self, _: Span) -> Span {
+        DUMMY_SP
+    }
+}
diff --git a/ecmascript/transforms/src/hygiene.rs b/ecmascript/transforms/src/hygiene.rs
index ba48b080ac6c..3d2593c9ab6e 100644
--- a/ecmascript/transforms/src/hygiene.rs
+++ b/ecmascript/transforms/src/hygiene.rs
@@ -122,14 +122,14 @@ mod tests {
                 body: stmts.into_iter().map(ModuleItem::Stmt).collect(),
             };
 
-            let module = hygiene().fold(module);
+            let module = module.fold_with(&mut hygiene());
 
             let actual = tester.print(&module);
 
             let expected = {
                 let expected =
                     tester.with_parser("expected.js", Syntax::default(), expected, |p| {
-                        p.parse_module().map_err(|e| {
+                        p.parse_module().map_err(|mut e| {
                             e.emit();
                             ()
                         })
diff --git a/ecmascript/transforms/src/react/jsx/mod.rs b/ecmascript/transforms/src/react/jsx/mod.rs
index 35c8b819b180..c08710caee8a 100644
--- a/ecmascript/transforms/src/react/jsx/mod.rs
+++ b/ecmascript/transforms/src/react/jsx/mod.rs
@@ -70,7 +70,7 @@ pub fn jsx(cm: Lrc<SourceMap>, options: Options, helpers: Arc<Helpers>) -> impl
 
         Parser::new(session, Syntax::default(), SourceFileInput::from(&*fm))
             .parse_expr()
-            .map_err(|e| {
+            .map_err(|mut e| {
                 e.emit();
                 ()
             })
diff --git a/ecmascript/transforms/src/simplify/tests.rs b/ecmascript/transforms/src/simplify/tests.rs
index ae1ec0e37b7b..c07fc853ea84 100644
--- a/ecmascript/transforms/src/simplify/tests.rs
+++ b/ecmascript/transforms/src/simplify/tests.rs
@@ -3,7 +3,12 @@ use super::Simplifier;
 
 macro_rules! test_stmt {
     ($l:expr, $r:expr) => {
-        test_transform!(::swc_ecma_parser::Syntax::default(), Simplifier, $l, $r)
+        test_transform!(
+            ::swc_ecma_parser::Syntax::default(),
+            Simplifier { enable: true },
+            $l,
+            $r
+        )
     };
     ($l:expr, $r:expr,) => {
         test_expr!($l, $r);
diff --git a/ecmascript/transforms/src/tests.rs b/ecmascript/transforms/src/tests.rs
index c28db2610dcf..1787a4ac0ec4 100644
--- a/ecmascript/transforms/src/tests.rs
+++ b/ecmascript/transforms/src/tests.rs
@@ -54,7 +54,7 @@ impl<'a> Tester<'a> {
 
     pub fn parse_stmt(&mut self, file_name: &str, src: &str) -> Result<Stmt, ()> {
         let mut stmts = self.with_parser(file_name, Syntax::default(), src, |p| {
-            p.parse_script().map_err(|e| {
+            p.parse_script().map_err(|mut e| {
                 e.emit();
                 ()
             })
@@ -82,7 +82,7 @@ impl<'a> Tester<'a> {
 
             let module = {
                 let mut p = Parser::new(sess, syntax, SourceFileInput::from(&*fm));
-                p.parse_module().map_err(|e| {
+                p.parse_module().map_err(|mut e| {
                     e.emit();
                     ()
                 })?
diff --git a/macros/ast_node/Cargo.toml b/macros/ast_node/Cargo.toml
index 5c96a1bc5b57..0154b4d9aa56 100644
--- a/macros/ast_node/Cargo.toml
+++ b/macros/ast_node/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ast_node"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["강동윤 <kdy1@outlook.kr>"]
 license = "Apache-2.0/MIT"
 repository = "https://github.com/swc-project/swc.git"
@@ -10,6 +10,11 @@ description = "Macros for ast nodes."
 [lib]
 proc-macro = true
 
+[features]
+default = []
+# Requires nightly.
+fold = []
+
 [dependencies]
 swc_macros_common = { version = "0.1", path = "../common" }
 pmutil = "0.2"
@@ -23,4 +28,4 @@ features = ["derive", "fold", "parsing", "printing"]
 
 
 [dev-dependencies]
-swc_common = { version = "0.1", path = "../../common" }
\ No newline at end of file
+swc_common = { version = "0.2", path = "../../common" }
\ No newline at end of file
diff --git a/macros/ast_node/src/lib.rs b/macros/ast_node/src/lib.rs
index 189bfffa53a1..08d86dcbc57e 100644
--- a/macros/ast_node/src/lib.rs
+++ b/macros/ast_node/src/lib.rs
@@ -1,6 +1,5 @@
 #![feature(box_syntax)]
 
-#[macro_use]
 extern crate darling;
 #[macro_use]
 extern crate pmutil;
@@ -99,12 +98,13 @@ pub fn ast_node(
     let mut item = Quote::new(Span::call_site());
     item = match input.data {
         Data::Enum(..) => item.quote_with(smart_quote!(Vars { input }, {
-            #[derive(::swc_common::FromVariant, ::swc_common::Spanned,
-            ::swc_common::Fold, Clone, Debug, PartialEq)]
+            #[derive(::swc_common::FromVariant, ::swc_common::Spanned, Clone, Debug, PartialEq)]
+            #[cfg_attr(feature = "fold", derive(::swc_common::Fold))]
             input
         })),
         _ => item.quote_with(smart_quote!(Vars { input }, {
-            #[derive(::swc_common::Spanned, ::swc_common::Fold, Clone, Debug, PartialEq)]
+            #[derive(::swc_common::Spanned, Clone, Debug, PartialEq)]
+            #[cfg_attr(feature = "fold", derive(::swc_common::Fold))]
             input
         })),
     };
diff --git a/macros/ast_node/tests/fold_ignore.rs b/macros/ast_node/tests/fold_ignore.rs
index 3217dfdd0548..c1909cf2c549 100644
--- a/macros/ast_node/tests/fold_ignore.rs
+++ b/macros/ast_node/tests/fold_ignore.rs
@@ -1,7 +1,7 @@
 #![feature(specialization)]
 
 extern crate swc_common;
-use swc_common::{Fold, FoldWith, Visit, VisitWith};
+use swc_common::{Fold, FoldWith, VisitWith};
 struct MyFold;
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
diff --git a/testing/Cargo.toml b/testing/Cargo.toml
index 35bfc24fe5c1..989b28d05cbf 100644
--- a/testing/Cargo.toml
+++ b/testing/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "testing"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["강동윤 <kdy1@outlook.kr>"]
 license = "Apache-2.0/MIT"
 repository = "https://github.com/swc-project/swc.git"
@@ -8,7 +8,7 @@ documentation = "https://swc-project.github.io/rustdoc/testing/"
 description = "Testing utilities for the swc project."
 
 [dependencies]
-swc_common = { version = "0.1", path ="../common" }
+swc_common = { version = "0.2", path ="../common", features = ["fold"] }
 lazy_static = "1"
 regex = "0.2.5"
 relative-path = "0.4.0"
\ No newline at end of file
diff --git a/testing/src/errors.rs b/testing/src/errors.rs
index 6f7a51da7277..2be084bc6f76 100644
--- a/testing/src/errors.rs
+++ b/testing/src/errors.rs
@@ -17,7 +17,7 @@ pub(crate) fn new_handler(
 
     let e = EmitterWriter::new(box buf.clone(), Some(cm.clone()), false, true);
 
-    let handler = Handler::with_emitter(
+    let handler = Handler::with_emitter_and_flags(
         box e,
         HandlerFlags {
             treat_err_as_bug,