Unexpected compiler panic

[th0114nd]

The version of rust I was using was

rustc 0.13.0-nightly (8bca470c5 2014-12-08 00:12:30 +0000)
binary: rustc
commit-hash: 8bca470c5acf13aa20022a2c462a89f72de721fc
commit-date: 2014-12-08 00:12:30 +0000
host: x86_64-apple-darwin
release: 0.13.0-nightly

The file I was compiling was

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use std::ascii::AsciiExt;

use dom::attr::Attr;
use dom::attr::AttrHelpers;
use dom::bindings::codegen::Bindings::AttrBinding::AttrMethods;
use dom::bindings::codegen::Bindings::HTMLScriptElementBinding;
use dom::bindings::codegen::Bindings::HTMLScriptElementBinding::HTMLScriptElementMethods;
use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
use dom::bindings::codegen::InheritTypes::{HTMLScriptElementDerived, HTMLScriptElementCast};
use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, NodeCast};
use dom::bindings::js::{JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{HTMLScriptElementTypeId, Element, AttributeHandlers};
use dom::element::{ElementCreator, ParserCreated};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId, window_from_node, CloneChildrenFlag};
use dom::virtualmethods::VirtualMethods;
use dom::window::WindowHelpers;

use encoding::all::UTF_8;
use encoding::types::{Encoding, DecodeReplace};
use servo_net::resource_task::load_whole_resource;
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS, StaticStringVec};
use std::cell::Cell;
use string_cache::Atom;
use url::UrlParser;

#[dom_struct]
pub struct HTMLScriptElement {
    htmlelement: HTMLElement,

    /// https://html.spec.whatwg.org/multipage/scripting.html#already-started
    already_started: Cell<bool>,

    /// https://html.spec.whatwg.org/multipage/scripting.html#parser-inserted
    parser_inserted: Cell<bool>,

    /// https://html.spec.whatwg.org/multipage/scripting.html#non-blocking
    ///
    /// (currently unused)
    non_blocking: Cell<bool>,

    /// https://html.spec.whatwg.org/multipage/scripting.html#ready-to-be-parser-executed
    ///
    /// (currently unused)
    ready_to_be_parser_executed: Cell<bool>,
}

impl HTMLScriptElementDerived for EventTarget {
    fn is_htmlscriptelement(&self) -> bool {
        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLScriptElementTypeId))
    }
}

impl HTMLScriptElement {
    fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>,
                     creator: ElementCreator) -> HTMLScriptElement {
        HTMLScriptElement {
            htmlelement: HTMLElement::new_inherited(HTMLScriptElementTypeId, localName, prefix, document),
            already_started: Cell::new(false),
            parser_inserted: Cell::new(creator == ParserCreated),
            non_blocking: Cell::new(creator != ParserCreated),
            ready_to_be_parser_executed: Cell::new(false),
        }
    }

    #[allow(unrooted_must_root)]
    pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>,
               creator: ElementCreator) -> Temporary<HTMLScriptElement> {
        let element = HTMLScriptElement::new_inherited(localName, prefix, document, creator);
        Node::reflect_node(box element, document, HTMLScriptElementBinding::Wrap)
    }
}

pub trait HTMLScriptElementHelpers {
    /// Prepare a script (<http://www.whatwg.org/html/#prepare-a-script>)
    fn prepare(self);

    /// Prepare a script, steps 6 and 7.
    fn is_javascript(self) -> bool;

    /// Set the "already started" flag (<https://whatwg.org/html/#already-started>)
    fn mark_already_started(self);
}

/// Supported script types as defined by
/// <http://whatwg.org/html/#support-the-scripting-language>.
static SCRIPT_JS_MIMES: StaticStringVec = &[
    "application/ecmascript",
    "application/javascript",
    "application/x-ecmascript",
    "application/x-javascript",
    "text/ecmascript",
    "text/javascript",
    "text/javascript1.0",
    "text/javascript1.1",
    "text/javascript1.2",
    "text/javascript1.3",
    "text/javascript1.4",
    "text/javascript1.5",
    "text/jscript",
    "text/livescript",
    "text/x-ecmascript",
    "text/x-javascript",
];

impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
    fn prepare(self) {
        // https://html.spec.whatwg.org/multipage/scripting.html#prepare-a-script
        // Step 1.
        if self.already_started.get() {
            return;
        }
        // Step 2.
        let was_parser_inserted = self.parser_inserted.get();
        self.parser_inserted.set(false);

        // Step 3.
        let element: JSRef<Element> = ElementCast::from_ref(self);
        if was_parser_inserted && element.has_attribute(&atom!("async")) {
            self.non_blocking.set(true);
        }
        // Step 4.
        let text = self.Text();
        if text.len() == 0 && !element.has_attribute(&atom!("src")) {
            return;
        }
        // Step 5.
        let node: JSRef<Node> = NodeCast::from_ref(self);
        if !node.is_in_doc() {
            return;
        }
        // Step 6, 7.
        if !self.is_javascript() {
            return;
        }
        // Step 8.
        if was_parser_inserted {
            self.parser_inserted.set(true);
            self.non_blocking.set(false);
        }
        // Step 9.
        self.already_started.set(true);

        // Step 10.
        // TODO: If the element is flagged as "parser-inserted", but the element's node document is
        // not the Document of the parser that created the element, then abort these steps.
        if self.parser_inserted.get() && document.from_root(node) != self. 

        // Step 11.
        // TODO: If scripting is disabled for the script element, then the user agent must abort
        // these steps at this point. The script is not executed.

        // Step 12.
        // TODO: If the script element has an `event` attribute and a `for` attribute, then run
        // these substeps...
        if (element.has_attribute(&atom!("event")) && element.has_attribute(&atom!("for"))) {
            event_attr = element.get_string_attribute(&atom!("event")).trim().to_ascii_lower();
            if event_attr != "window" {
                return
            }
            for_attr = element.get_string_attribute(&atom!("for")).trim().to_ascii_lower();
            if for_attr != "onload" && for_attr != "onload()" {
                return
            }

        }

        // Step 13.
        // TODO: If the script element has a `charset` attribute, then let the script block's
        // character encoding for this script element be the result of getting an encoding from the
        // value of the `charset` attribute.

        // Step 14 and 15.
        // TODO: Add support for the `defer` and `async` attributes.  (For now, we fetch all
        // scripts synchronously and execute them immediately.)
        let window = window_from_node(self).root();
        let page = window.page();
        let base_url = page.get_url();

        let (source, url) = match element.get_attribute(ns!(""), &atom!("src")).root() {
            Some(src) => {
                if src.deref().Value().is_empty() {
                    // TODO: queue a task to fire a simple event named `error` at the element
                    return;
                }
                match UrlParser::new().base_url(&base_url).parse(src.deref().Value().as_slice()) {
                    Ok(url) => {
                        // TODO: Do a potentially CORS-enabled fetch with the mode being the current
                        // state of the element's `crossorigin` content attribute, the origin being
                        // the origin of the script element's node document, and the default origin
                        // behaviour set to taint.
                        match load_whole_resource(&page.resource_task, url) {
                            Ok((metadata, bytes)) => {
                                // TODO: use the charset from step 13.
                                let source = UTF_8.decode(bytes.as_slice(), DecodeReplace).unwrap();
                                (source, metadata.final_url)
                            }
                            Err(_) => {
                                error!("error loading script {}", src.deref().Value());
                                return;
                            }
                        }
                    }
                    Err(_) => {
                        // TODO: queue a task to fire a simple event named `error` at the element
                        error!("error parsing URL for script {}", src.deref().Value());
                        return;
                    }
                }
            }
            None => (text, base_url)
        };

        window.evaluate_script_with_result(source.as_slice(), url.serialize().as_slice());
    }

    fn is_javascript(self) -> bool {
        let element: JSRef<Element> = ElementCast::from_ref(self);
        match element.get_attribute(ns!(""), &atom!("type")).root().map(|s| s.Value()) {
            Some(ref s) if s.is_empty() => {
                // type attr exists, but empty means js
                debug!("script type empty, inferring js");
                true
            },
            Some(ref s) => {
                debug!("script type={:s}", *s);
                SCRIPT_JS_MIMES.contains(&s.to_ascii_lower().as_slice().trim_chars(HTML_SPACE_CHARACTERS))
            },
            None => {
                debug!("no script type");
                match element.get_attribute(ns!(""), &atom!("language"))
                             .root()
                             .map(|s| s.Value()) {
                    Some(ref s) if s.is_empty() => {
                        debug!("script language empty, inferring js");
                        true
                    },
                    Some(ref s) => {
                        debug!("script language={:s}", *s);
                        SCRIPT_JS_MIMES.contains(&format!("text/{}", s).to_ascii_lower().as_slice())
                    },
                    None => {
                        debug!("no script type or language, inferring js");
                        true
                    }
                }
            }
        }
    }

    fn mark_already_started(self) {
        self.already_started.set(true);
    }
}

impl<'a> VirtualMethods for JSRef<'a, HTMLScriptElement> {
    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods> {
        let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_borrowed_ref(self);
        Some(htmlelement as &VirtualMethods)
    }

    fn after_set_attr(&self, attr: JSRef<Attr>) {
        match self.super_type() {
            Some(ref s) => s.after_set_attr(attr),
            _ => (),
        }
        let node: JSRef<Node> = NodeCast::from_ref(*self);
        if attr.local_name() == &atom!("src") && !self.parser_inserted.get() && node.is_in_doc() {
            self.prepare();
        }
    }

    fn child_inserted(&self, child: JSRef<Node>) {
        match self.super_type() {
            Some(ref s) => s.child_inserted(child),
            _ => (),
        }
        let node: JSRef<Node> = NodeCast::from_ref(*self);
        if !self.parser_inserted.get() && node.is_in_doc() {
            self.prepare();
        }
    }

    fn bind_to_tree(&self, tree_in_doc: bool) {
        match self.super_type() {
            Some(ref s) => s.bind_to_tree(tree_in_doc),
            _ => ()
        }

        if tree_in_doc && !self.parser_inserted.get() {
            self.prepare();
        }
    }

    fn cloning_steps(&self, copy: JSRef<Node>, maybe_doc: Option<JSRef<Document>>,
                     clone_children: CloneChildrenFlag) {
        match self.super_type() {
            Some(ref s) => s.cloning_steps(copy, maybe_doc, clone_children),
            _ => (),
        }

        // https://whatwg.org/html/#already-started
        if self.already_started.get() {
            let copy_elem: JSRef<HTMLScriptElement> = HTMLScriptElementCast::to_ref(copy).unwrap();
            copy_elem.mark_already_started();
        }
    }
}

impl<'a> HTMLScriptElementMethods for JSRef<'a, HTMLScriptElement> {
    make_url_getter!(Src)

    make_setter!(SetSrc, "src")

    // http://www.whatwg.org/html/#dom-script-text
    fn Text(self) -> DOMString {
        let node: JSRef<Node> = NodeCast::from_ref(self);
        Node::collect_text_contents(node.children())
    }

    // http://www.whatwg.org/html/#dom-script-text
    fn SetText(self, value: DOMString) {
        let node: JSRef<Node> = NodeCast::from_ref(self);
        node.SetTextContent(Some(value))
    }
}

impl Reflectable for HTMLScriptElement {
    fn reflector<'a>(&'a self) -> &'a Reflector {
        self.htmlelement.reflector()
    }
}

The error reported was

htmlscriptelement.rs:126:58: 126:62 error: macro undefined: 'atom!'
htmlscriptelement.rs:126         if was_parser_inserted && element.has_attribute(&atom!("async")) {
                                                                                  ^~~~
htmlscriptelement.rs:131:55: 131:59 error: macro undefined: 'atom!'
htmlscriptelement.rs:131         if text.len() == 0 && !element.has_attribute(&atom!("src")) {
                                                                               ^~~~
htmlscriptelement.rs:163:36: 163:40 error: macro undefined: 'atom!'
htmlscriptelement.rs:163         if (element.has_attribute(&atom!("event")) && element.has_attribute(&atom!("for"))) {
                                                            ^~~~
htmlscriptelement.rs:163:78: 163:82 error: macro undefined: 'atom!'
htmlscriptelement.rs:163         if (element.has_attribute(&atom!("event")) && element.has_attribute(&atom!("for"))) {
                                                                                                      ^~~~
htmlscriptelement.rs:164:56: 164:60 error: macro undefined: 'atom!'
htmlscriptelement.rs:164             event_attr = element.get_string_attribute(&atom!("event")).trim().to_ascii_lower();
                                                                                ^~~~
htmlscriptelement.rs:168:54: 168:58 error: macro undefined: 'atom!'
htmlscriptelement.rs:168             for_attr = element.get_string_attribute(&atom!("for")).trim().to_ascii_lower();
                                                                              ^~~~
htmlscriptelement.rs:187:57: 187:59 error: macro undefined: 'ns!'
htmlscriptelement.rs:187         let (source, url) = match element.get_attribute(ns!(""), &atom!("src")).root() {
                                                                                 ^~
htmlscriptelement.rs:187:67: 187:71 error: macro undefined: 'atom!'
htmlscriptelement.rs:187         let (source, url) = match element.get_attribute(ns!(""), &atom!("src")).root() {
                                                                                           ^~~~
htmlscriptelement.rs:206:33: 206:38 error: macro undefined: 'error!'
htmlscriptelement.rs:206                                 error!("error loading script {}", src.deref().Value());
                                                         ^~~~~
htmlscriptelement.rs:213:25: 213:30 error: macro undefined: 'error!'
htmlscriptelement.rs:213                         error!("error parsing URL for script {}", src.deref().Value());
                                                 ^~~~~
htmlscriptelement.rs:226:37: 226:39 error: macro undefined: 'ns!'
htmlscriptelement.rs:226         match element.get_attribute(ns!(""), &atom!("type")).root().map(|s| s.Value()) {
                                                             ^~
htmlscriptelement.rs:226:47: 226:51 error: macro undefined: 'atom!'
htmlscriptelement.rs:226         match element.get_attribute(ns!(""), &atom!("type")).root().map(|s| s.Value()) {
                                                                       ^~~~
htmlscriptelement.rs:229:17: 229:22 error: macro undefined: 'debug!'
htmlscriptelement.rs:229                 debug!("script type empty, inferring js");
                                         ^~~~~
htmlscriptelement.rs:233:17: 233:22 error: macro undefined: 'debug!'
htmlscriptelement.rs:233                 debug!("script type={:s}", *s);
                                         ^~~~~
htmlscriptelement.rs:237:17: 237:22 error: macro undefined: 'debug!'
htmlscriptelement.rs:237                 debug!("no script type");
                                         ^~~~~
htmlscriptelement.rs:238:45: 238:47 error: macro undefined: 'ns!'
htmlscriptelement.rs:238                 match element.get_attribute(ns!(""), &atom!("language"))
                                                                     ^~
htmlscriptelement.rs:238:55: 238:59 error: macro undefined: 'atom!'
htmlscriptelement.rs:238                 match element.get_attribute(ns!(""), &atom!("language"))
                                                                               ^~~~
htmlscriptelement.rs:242:25: 242:30 error: macro undefined: 'debug!'
htmlscriptelement.rs:242                         debug!("script language empty, inferring js");
                                                 ^~~~~
htmlscriptelement.rs:246:25: 246:30 error: macro undefined: 'debug!'
htmlscriptelement.rs:246                         debug!("script language={:s}", *s);
                                                 ^~~~~
htmlscriptelement.rs:250:25: 250:30 error: macro undefined: 'debug!'
htmlscriptelement.rs:250                         debug!("no script type or language, inferring js");
                                                 ^~~~~
htmlscriptelement.rs:275:34: 275:38 error: macro undefined: 'atom!'
htmlscriptelement.rs:275         if attr.local_name() == &atom!("src") && !self.parser_inserted.get() && node.is_in_doc() {
                                                          ^~~~
htmlscriptelement.rs:318:5: 318:20 error: macro undefined: 'make_url_getter!'
htmlscriptelement.rs:318     make_url_getter!(Src)
                             ^~~~~~~~~~~~~~~
error: internal compiler error: tried to pop without a push
note: the compiler unexpectedly panicked. this is a bug.
note: we would appreciate a bug report: http://doc.rust-lang.org/complement-bugreport.html
note: run with `RUST_BACKTRACE=1` for a backtrace

And the backtrace was

task 'rustc' panicked at 'Box<Any>', /Users/rustbuild/src/rust-buildbot/slave/nightly-mac/build/src/libsyntax/diagnostic.rs:180

stack backtrace:
   1:        0x10f854380 - rt::backtrace::imp::write::hbe4d08f138d707c0Lsy
   2:        0x10f857590 - failure::on_fail::h868d2af5cb92d796nQy
   3:        0x10faaa9f5 - unwind::begin_unwind_inner::h8e9132cd5161ca28lJc
   4:        0x10f0128d7 - unwind::begin_unwind::h7562983727733833076
   5:        0x10f01328f - diagnostic::Handler::bug::hdce737e54ea4c046ubG
   6:        0x10f0efad8 - ext::base::ExtCtxt<'a>::bug::h7311b9eddc579b283r8
   7:        0x10f0b943e - ext::base::ExtCtxt<'a>::bt_pop::h70ba23420105c926mo8
   8:        0x10f1575b9 - ext::expand::MacroExpander<'a, 'b>.Folder::fold_method::h4d254140b60e7bf9qRf
   9:        0x10f151336 - ext::expand::MacroExpander<'a, 'b>.Folder::fold_item_underscore::h0d0ee757905cce1c6Pf
  10:        0x10f14f3d4 - fold::noop_fold_item::closure.54564
  11:        0x10f0023df - ptr::P<T>::map::h5441013841086107152
  12:        0x10f14b341 - ext::expand::expand_item::h1b2b3e29ee635969x4e
  13:        0x10f155527 - fold::noop_fold_mod::closure.54593
  14:        0x10f001b7f - iter::IteratorExt::collect::h17670113594715964984
  15:        0x10f150152 - ext::expand::MacroExpander<'a, 'b>.Folder::fold_item_underscore::h0d0ee757905cce1c6Pf
  16:        0x10f14f3d4 - fold::noop_fold_item::closure.54564
  17:        0x10f0023df - ptr::P<T>::map::h5441013841086107152
  18:        0x10f14b034 - ext::expand::expand_item::h1b2b3e29ee635969x4e
  19:        0x10f191f45 - ext::expand::expand_crate::hea92d1a095b00bf1cTf
  20:        0x10c24f6e2 - driver::phase_2_configure_and_expand::closure.16967
  21:        0x10c20c84f - driver::phase_2_configure_and_expand::he62365fef9b99479Qha
  22:        0x10c1ff67f - driver::compile_input::h9621f58ee716cb79pba
  23:        0x10c29720d - run_compiler::h6d3de3a676f705b7z4b
  24:        0x10c295c6e - run::closure.21247
  25:        0x10c2a70ce - task::TaskBuilder::try_future::closure.22695
  26:        0x10f82d713 - task::TaskBuilder::spawn_internal::closure.31212
  27:        0x10faa859d - task::Task::spawn::closure.5610
  28:        0x10fb1210c - rust_try_inner
  29:        0x10fb120f6 - rust_try
  30:        0x10faa8677 - unwind::try::h0dc7caf9a65e998fExc
  31:        0x10faa844c - task::Task::run::h986874b42196d947rMb
  32:        0x10faa814f - task::Task::spawn::closure.5586
  33:        0x10faa9a57 - thread::thread_start::hd43c648d26329b09u4b
  34:     0x7fff8dbc82fc - _pthread_body
  35:     0x7fff8dbc8279 - _pthread_body

[th0114nd]

I was able to reduce the input file significantly:

impl Trait for Type {
    undef_macro!()
}

[bstrie]

impl Foo { bar!() } does it as well.

[aochagavia]

I think I have a fix for this. Compiling rustc right now.