wasmtime 24.0.0 → 25.0.0

data/ext/cargo-vendor/wit-parser-0.217.0/src/ast.rs

@@ -0,0 +1,1886 @@
+use crate::{Error, UnresolvedPackageGroup};
+use anyhow::{bail, Context, Result};
+use lex::{Span, Token, Tokenizer};
+use semver::Version;
+use std::borrow::Cow;
+use std::fmt;
+use std::mem;
+use std::path::{Path, PathBuf};
+
+pub mod lex;
+
+pub use resolve::Resolver;
+mod resolve;
+pub mod toposort;
+
+pub use lex::validate_id;
+
+/// Representation of a single WIT `*.wit` file and nested packages.
+struct PackageFile<'a> {
+    /// Optional `package foo:bar;` header
+    package_id: Option<PackageName<'a>>,
+    /// Other AST items.
+    decl_list: DeclList<'a>,
+}
+
+impl<'a> PackageFile<'a> {
+    /// Parse a standalone file represented by `tokens`.
+    ///
+    /// This will optionally start with `package foo:bar;` and then will have a
+    /// list of ast items after it.
+    fn parse(tokens: &mut Tokenizer<'a>) -> Result<Self> {
+        let mut package_name_tokens_peek = tokens.clone();
+        let docs = parse_docs(&mut package_name_tokens_peek)?;
+
+        // Parse `package foo:bar;` but throw it out if it's actually
+        // `package foo:bar { ... }` since that's an ast item instead.
+        let package_id = if package_name_tokens_peek.eat(Token::Package)? {
+            let name = PackageName::parse(&mut package_name_tokens_peek, docs)?;
+            if package_name_tokens_peek.eat(Token::Semicolon)? {
+                *tokens = package_name_tokens_peek;
+                Some(name)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+        let decl_list = DeclList::parse_until(tokens, None)?;
+        Ok(PackageFile {
+            package_id,
+            decl_list,
+        })
+    }
+
+    /// Parse a nested package of the form `package foo:bar { ... }`
+    fn parse_nested(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        let span = tokens.expect(Token::Package)?;
+        if !attributes.is_empty() {
+            bail!(Error::new(
+                span,
+                format!("cannot place attributes on nested packages"),
+            ));
+        }
+        let package_id = PackageName::parse(tokens, docs)?;
+        tokens.expect(Token::LeftBrace)?;
+        let decl_list = DeclList::parse_until(tokens, Some(Token::RightBrace))?;
+        Ok(PackageFile {
+            package_id: Some(package_id),
+            decl_list,
+        })
+    }
+}
+
+/// Stores all of the declarations in a package's scope. In AST terms, this
+/// means everything except the `package` declaration that demarcates a package
+/// scope. In the traditional implicit format, these are all of the declarations
+/// non-`package` declarations in the file:
+///
+/// ```wit
+/// package foo:name;
+///
+/// /* START DECL LIST */
+/// // Some comment...
+/// interface i {}
+/// world w {}
+/// /* END DECL LIST */
+/// ```
+///
+/// In the nested package style, a [`DeclList`] is everything inside of each
+/// `package` element's brackets:
+///
+/// ```wit
+/// package foo:name {
+///   /* START FIRST DECL LIST */
+///   // Some comment...
+///   interface i {}
+///   world w {}
+///   /* END FIRST DECL LIST */
+/// }
+///
+/// package bar:name {
+///   /* START SECOND DECL LIST */
+///   // Some comment...
+///   interface i {}
+///   world w {}
+///   /* END SECOND DECL LIST */
+/// }
+/// ```
+#[derive(Default)]
+pub struct DeclList<'a> {
+    items: Vec<AstItem<'a>>,
+}
+
+impl<'a> DeclList<'a> {
+    fn parse_until(tokens: &mut Tokenizer<'a>, end: Option<Token>) -> Result<DeclList<'a>> {
+        let mut items = Vec::new();
+        let mut docs = parse_docs(tokens)?;
+        loop {
+            match end {
+                Some(end) => {
+                    if tokens.eat(end)? {
+                        break;
+                    }
+                }
+                None => {
+                    if tokens.clone().next()?.is_none() {
+                        break;
+                    }
+                }
+            }
+            items.push(AstItem::parse(tokens, docs)?);
+            docs = parse_docs(tokens)?;
+        }
+        Ok(DeclList { items })
+    }
+
+    fn for_each_path<'b>(
+        &'b self,
+        f: &mut dyn FnMut(
+            Option<&'b Id<'a>>,
+            &'b UsePath<'a>,
+            Option<&'b [UseName<'a>]>,
+            WorldOrInterface,
+        ) -> Result<()>,
+    ) -> Result<()> {
+        for item in self.items.iter() {
+            match item {
+                AstItem::World(world) => {
+                    // Visit imports here first before exports to help preserve
+                    // round-tripping of documents because printing a world puts
+                    // imports first but textually they can be listed with
+                    // exports first.
+                    let mut imports = Vec::new();
+                    let mut exports = Vec::new();
+                    for item in world.items.iter() {
+                        match item {
+                            WorldItem::Use(u) => {
+                                f(None, &u.from, Some(&u.names), WorldOrInterface::Interface)?
+                            }
+                            WorldItem::Include(i) => {
+                                f(Some(&world.name), &i.from, None, WorldOrInterface::World)?
+                            }
+                            WorldItem::Type(_) => {}
+                            WorldItem::Import(Import { kind, .. }) => imports.push(kind),
+                            WorldItem::Export(Export { kind, .. }) => exports.push(kind),
+                        }
+                    }
+
+                    let mut visit_kind = |kind: &'b ExternKind<'a>| match kind {
+                        ExternKind::Interface(_, items) => {
+                            for item in items {
+                                match item {
+                                    InterfaceItem::Use(u) => f(
+                                        None,
+                                        &u.from,
+                                        Some(&u.names),
+                                        WorldOrInterface::Interface,
+                                    )?,
+                                    _ => {}
+                                }
+                            }
+                            Ok(())
+                        }
+                        ExternKind::Path(path) => f(None, path, None, WorldOrInterface::Interface),
+                        ExternKind::Func(..) => Ok(()),
+                    };
+
+                    for kind in imports {
+                        visit_kind(kind)?;
+                    }
+                    for kind in exports {
+                        visit_kind(kind)?;
+                    }
+                }
+                AstItem::Interface(i) => {
+                    for item in i.items.iter() {
+                        match item {
+                            InterfaceItem::Use(u) => f(
+                                Some(&i.name),
+                                &u.from,
+                                Some(&u.names),
+                                WorldOrInterface::Interface,
+                            )?,
+                            _ => {}
+                        }
+                    }
+                }
+                AstItem::Use(u) => {
+                    // At the top-level, we don't know if this is a world or an interface
+                    // It is up to the resolver to decides how to handle this ambiguity.
+                    f(None, &u.item, None, WorldOrInterface::Unknown)?;
+                }
+
+                AstItem::Package(pkg) => pkg.decl_list.for_each_path(f)?,
+            }
+        }
+        Ok(())
+    }
+}
+
+enum AstItem<'a> {
+    Interface(Interface<'a>),
+    World(World<'a>),
+    Use(ToplevelUse<'a>),
+    Package(PackageFile<'a>),
+}
+
+impl<'a> AstItem<'a> {
+    fn parse(tokens: &mut Tokenizer<'a>, docs: Docs<'a>) -> Result<Self> {
+        let attributes = Attribute::parse_list(tokens)?;
+        match tokens.clone().next()? {
+            Some((_span, Token::Interface)) => {
+                Interface::parse(tokens, docs, attributes).map(Self::Interface)
+            }
+            Some((_span, Token::World)) => World::parse(tokens, docs, attributes).map(Self::World),
+            Some((_span, Token::Use)) => ToplevelUse::parse(tokens, attributes).map(Self::Use),
+            Some((_span, Token::Package)) => {
+                PackageFile::parse_nested(tokens, docs, attributes).map(Self::Package)
+            }
+            other => Err(err_expected(tokens, "`world`, `interface` or `use`", other).into()),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct PackageName<'a> {
+    docs: Docs<'a>,
+    span: Span,
+    namespace: Id<'a>,
+    name: Id<'a>,
+    version: Option<(Span, Version)>,
+}
+
+impl<'a> PackageName<'a> {
+    fn parse(tokens: &mut Tokenizer<'a>, docs: Docs<'a>) -> Result<Self> {
+        let namespace = parse_id(tokens)?;
+        tokens.expect(Token::Colon)?;
+        let name = parse_id(tokens)?;
+        let version = parse_opt_version(tokens)?;
+        Ok(PackageName {
+            docs,
+            span: Span {
+                start: namespace.span.start,
+                end: version
+                    .as_ref()
+                    .map(|(s, _)| s.end)
+                    .unwrap_or(name.span.end),
+            },
+            namespace,
+            name,
+            version,
+        })
+    }
+
+    fn package_name(&self) -> crate::PackageName {
+        crate::PackageName {
+            namespace: self.namespace.name.to_string(),
+            name: self.name.name.to_string(),
+            version: self.version.as_ref().map(|(_, v)| v.clone()),
+        }
+    }
+}
+
+struct ToplevelUse<'a> {
+    span: Span,
+    attributes: Vec<Attribute<'a>>,
+    item: UsePath<'a>,
+    as_: Option<Id<'a>>,
+}
+
+impl<'a> ToplevelUse<'a> {
+    fn parse(tokens: &mut Tokenizer<'a>, attributes: Vec<Attribute<'a>>) -> Result<Self> {
+        let span = tokens.expect(Token::Use)?;
+        let item = UsePath::parse(tokens)?;
+        let as_ = if tokens.eat(Token::As)? {
+            Some(parse_id(tokens)?)
+        } else {
+            None
+        };
+        tokens.expect_semicolon()?;
+        Ok(ToplevelUse {
+            span,
+            attributes,
+            item,
+            as_,
+        })
+    }
+}
+
+struct World<'a> {
+    docs: Docs<'a>,
+    attributes: Vec<Attribute<'a>>,
+    name: Id<'a>,
+    items: Vec<WorldItem<'a>>,
+}
+
+impl<'a> World<'a> {
+    fn parse(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        tokens.expect(Token::World)?;
+        let name = parse_id(tokens)?;
+        let items = Self::parse_items(tokens)?;
+        Ok(World {
+            docs,
+            attributes,
+            name,
+            items,
+        })
+    }
+
+    fn parse_items(tokens: &mut Tokenizer<'a>) -> Result<Vec<WorldItem<'a>>> {
+        tokens.expect(Token::LeftBrace)?;
+        let mut items = Vec::new();
+        loop {
+            let docs = parse_docs(tokens)?;
+            if tokens.eat(Token::RightBrace)? {
+                break;
+            }
+            let attributes = Attribute::parse_list(tokens)?;
+            items.push(WorldItem::parse(tokens, docs, attributes)?);
+        }
+        Ok(items)
+    }
+}
+
+enum WorldItem<'a> {
+    Import(Import<'a>),
+    Export(Export<'a>),
+    Use(Use<'a>),
+    Type(TypeDef<'a>),
+    Include(Include<'a>),
+}
+
+impl<'a> WorldItem<'a> {
+    fn parse(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<WorldItem<'a>> {
+        match tokens.clone().next()? {
+            Some((_span, Token::Import)) => {
+                Import::parse(tokens, docs, attributes).map(WorldItem::Import)
+            }
+            Some((_span, Token::Export)) => {
+                Export::parse(tokens, docs, attributes).map(WorldItem::Export)
+            }
+            Some((_span, Token::Use)) => Use::parse(tokens, attributes).map(WorldItem::Use),
+            Some((_span, Token::Type)) => {
+                TypeDef::parse(tokens, docs, attributes).map(WorldItem::Type)
+            }
+            Some((_span, Token::Flags)) => {
+                TypeDef::parse_flags(tokens, docs, attributes).map(WorldItem::Type)
+            }
+            Some((_span, Token::Resource)) => {
+                TypeDef::parse_resource(tokens, docs, attributes).map(WorldItem::Type)
+            }
+            Some((_span, Token::Record)) => {
+                TypeDef::parse_record(tokens, docs, attributes).map(WorldItem::Type)
+            }
+            Some((_span, Token::Variant)) => {
+                TypeDef::parse_variant(tokens, docs, attributes).map(WorldItem::Type)
+            }
+            Some((_span, Token::Enum)) => {
+                TypeDef::parse_enum(tokens, docs, attributes).map(WorldItem::Type)
+            }
+            Some((_span, Token::Include)) => {
+                Include::parse(tokens, attributes).map(WorldItem::Include)
+            }
+            other => Err(err_expected(
+                tokens,
+                "`import`, `export`, `include`, `use`, or type definition",
+                other,
+            )
+            .into()),
+        }
+    }
+}
+
+struct Import<'a> {
+    docs: Docs<'a>,
+    attributes: Vec<Attribute<'a>>,
+    kind: ExternKind<'a>,
+}
+
+impl<'a> Import<'a> {
+    fn parse(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Import<'a>> {
+        tokens.expect(Token::Import)?;
+        let kind = ExternKind::parse(tokens)?;
+        Ok(Import {
+            docs,
+            attributes,
+            kind,
+        })
+    }
+}
+
+struct Export<'a> {
+    docs: Docs<'a>,
+    attributes: Vec<Attribute<'a>>,
+    kind: ExternKind<'a>,
+}
+
+impl<'a> Export<'a> {
+    fn parse(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Export<'a>> {
+        tokens.expect(Token::Export)?;
+        let kind = ExternKind::parse(tokens)?;
+        Ok(Export {
+            docs,
+            attributes,
+            kind,
+        })
+    }
+}
+
+enum ExternKind<'a> {
+    Interface(Id<'a>, Vec<InterfaceItem<'a>>),
+    Path(UsePath<'a>),
+    Func(Id<'a>, Func<'a>),
+}
+
+impl<'a> ExternKind<'a> {
+    fn parse(tokens: &mut Tokenizer<'a>) -> Result<ExternKind<'a>> {
+        // Create a copy of the token stream to test out if this is a function
+        // or an interface import. In those situations the token stream gets
+        // reset to the state of the clone and we continue down those paths.
+        //
+        // If neither a function nor an interface appears here though then the
+        // clone is thrown away and the original token stream is parsed for an
+        // interface. This will redo the original ID parse and the original
+        // colon parse, but that shouldn't be too too bad perf-wise.
+        let mut clone = tokens.clone();
+        let id = parse_id(&mut clone)?;
+        if clone.eat(Token::Colon)? {
+            // import foo: func(...)
+            if clone.clone().eat(Token::Func)? {
+                *tokens = clone;
+                let ret = ExternKind::Func(id, Func::parse(tokens)?);
+                tokens.expect_semicolon()?;
+                return Ok(ret);
+            }
+
+            // import foo: interface { ... }
+            if clone.eat(Token::Interface)? {
+                *tokens = clone;
+                return Ok(ExternKind::Interface(id, Interface::parse_items(tokens)?));
+            }
+        }
+
+        // import foo
+        // import foo/bar
+        // import foo:bar/baz
+        let ret = ExternKind::Path(UsePath::parse(tokens)?);
+        tokens.expect_semicolon()?;
+        Ok(ret)
+    }
+
+    fn span(&self) -> Span {
+        match self {
+            ExternKind::Interface(id, _) => id.span,
+            ExternKind::Path(UsePath::Id(id)) => id.span,
+            ExternKind::Path(UsePath::Package { name, .. }) => name.span,
+            ExternKind::Func(id, _) => id.span,
+        }
+    }
+}
+
+struct Interface<'a> {
+    docs: Docs<'a>,
+    attributes: Vec<Attribute<'a>>,
+    name: Id<'a>,
+    items: Vec<InterfaceItem<'a>>,
+}
+
+impl<'a> Interface<'a> {
+    fn parse(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        tokens.expect(Token::Interface)?;
+        let name = parse_id(tokens)?;
+        let items = Self::parse_items(tokens)?;
+        Ok(Interface {
+            docs,
+            attributes,
+            name,
+            items,
+        })
+    }
+
+    pub(super) fn parse_items(tokens: &mut Tokenizer<'a>) -> Result<Vec<InterfaceItem<'a>>> {
+        tokens.expect(Token::LeftBrace)?;
+        let mut items = Vec::new();
+        loop {
+            let docs = parse_docs(tokens)?;
+            if tokens.eat(Token::RightBrace)? {
+                break;
+            }
+            let attributes = Attribute::parse_list(tokens)?;
+            items.push(InterfaceItem::parse(tokens, docs, attributes)?);
+        }
+        Ok(items)
+    }
+}
+
+#[derive(Debug)]
+pub enum WorldOrInterface {
+    World,
+    Interface,
+    Unknown,
+}
+
+enum InterfaceItem<'a> {
+    TypeDef(TypeDef<'a>),
+    Func(NamedFunc<'a>),
+    Use(Use<'a>),
+}
+
+struct Use<'a> {
+    attributes: Vec<Attribute<'a>>,
+    from: UsePath<'a>,
+    names: Vec<UseName<'a>>,
+}
+
+#[derive(Debug)]
+enum UsePath<'a> {
+    Id(Id<'a>),
+    Package { id: PackageName<'a>, name: Id<'a> },
+}
+
+impl<'a> UsePath<'a> {
+    fn parse(tokens: &mut Tokenizer<'a>) -> Result<Self> {
+        let id = parse_id(tokens)?;
+        if tokens.eat(Token::Colon)? {
+            // `foo:bar/baz@1.0`
+            let namespace = id;
+            let pkg_name = parse_id(tokens)?;
+            tokens.expect(Token::Slash)?;
+            let name = parse_id(tokens)?;
+            let version = parse_opt_version(tokens)?;
+            Ok(UsePath::Package {
+                id: PackageName {
+                    docs: Default::default(),
+                    span: Span {
+                        start: namespace.span.start,
+                        end: pkg_name.span.end,
+                    },
+                    namespace,
+                    name: pkg_name,
+                    version,
+                },
+                name,
+            })
+        } else {
+            // `foo`
+            Ok(UsePath::Id(id))
+        }
+    }
+
+    fn name(&self) -> &Id<'a> {
+        match self {
+            UsePath::Id(id) => id,
+            UsePath::Package { name, .. } => name,
+        }
+    }
+}
+
+struct UseName<'a> {
+    name: Id<'a>,
+    as_: Option<Id<'a>>,
+}
+
+impl<'a> Use<'a> {
+    fn parse(tokens: &mut Tokenizer<'a>, attributes: Vec<Attribute<'a>>) -> Result<Self> {
+        tokens.expect(Token::Use)?;
+        let from = UsePath::parse(tokens)?;
+        tokens.expect(Token::Period)?;
+        tokens.expect(Token::LeftBrace)?;
+
+        let mut names = Vec::new();
+        while !tokens.eat(Token::RightBrace)? {
+            let mut name = UseName {
+                name: parse_id(tokens)?,
+                as_: None,
+            };
+            if tokens.eat(Token::As)? {
+                name.as_ = Some(parse_id(tokens)?);
+            }
+            names.push(name);
+            if !tokens.eat(Token::Comma)? {
+                tokens.expect(Token::RightBrace)?;
+                break;
+            }
+        }
+        tokens.expect_semicolon()?;
+        Ok(Use {
+            attributes,
+            from,
+            names,
+        })
+    }
+}
+
+struct Include<'a> {
+    from: UsePath<'a>,
+    attributes: Vec<Attribute<'a>>,
+    names: Vec<IncludeName<'a>>,
+}
+
+struct IncludeName<'a> {
+    name: Id<'a>,
+    as_: Id<'a>,
+}
+
+impl<'a> Include<'a> {
+    fn parse(tokens: &mut Tokenizer<'a>, attributes: Vec<Attribute<'a>>) -> Result<Self> {
+        tokens.expect(Token::Include)?;
+        let from = UsePath::parse(tokens)?;
+
+        let names = if tokens.eat(Token::With)? {
+            parse_list(
+                tokens,
+                Token::LeftBrace,
+                Token::RightBrace,
+                |_docs, tokens| {
+                    let name = parse_id(tokens)?;
+                    tokens.expect(Token::As)?;
+                    let as_ = parse_id(tokens)?;
+                    Ok(IncludeName { name, as_ })
+                },
+            )?
+        } else {
+            tokens.expect_semicolon()?;
+            Vec::new()
+        };
+
+        Ok(Include {
+            attributes,
+            from,
+            names,
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Id<'a> {
+    name: &'a str,
+    span: Span,
+}
+
+impl<'a> From<&'a str> for Id<'a> {
+    fn from(s: &'a str) -> Id<'a> {
+        Id {
+            name: s.into(),
+            span: Span { start: 0, end: 0 },
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Docs<'a> {
+    docs: Vec<Cow<'a, str>>,
+    span: Span,
+}
+
+impl<'a> Default for Docs<'a> {
+    fn default() -> Self {
+        Self {
+            docs: Default::default(),
+            span: Span { start: 0, end: 0 },
+        }
+    }
+}
+
+struct TypeDef<'a> {
+    docs: Docs<'a>,
+    attributes: Vec<Attribute<'a>>,
+    name: Id<'a>,
+    ty: Type<'a>,
+}
+
+enum Type<'a> {
+    Bool(Span),
+    U8(Span),
+    U16(Span),
+    U32(Span),
+    U64(Span),
+    S8(Span),
+    S16(Span),
+    S32(Span),
+    S64(Span),
+    F32(Span),
+    F64(Span),
+    Char(Span),
+    String(Span),
+    Name(Id<'a>),
+    List(List<'a>),
+    Handle(Handle<'a>),
+    Resource(Resource<'a>),
+    Record(Record<'a>),
+    Flags(Flags<'a>),
+    Variant(Variant<'a>),
+    Tuple(Tuple<'a>),
+    Enum(Enum<'a>),
+    Option(Option_<'a>),
+    Result(Result_<'a>),
+    Future(Future<'a>),
+    Stream(Stream<'a>),
+}
+
+enum Handle<'a> {
+    Own { resource: Id<'a> },
+    Borrow { resource: Id<'a> },
+}
+
+impl Handle<'_> {
+    fn span(&self) -> Span {
+        match self {
+            Handle::Own { resource } | Handle::Borrow { resource } => resource.span,
+        }
+    }
+}
+
+struct Resource<'a> {
+    span: Span,
+    funcs: Vec<ResourceFunc<'a>>,
+}
+
+enum ResourceFunc<'a> {
+    Method(NamedFunc<'a>),
+    Static(NamedFunc<'a>),
+    Constructor(NamedFunc<'a>),
+}
+
+impl<'a> ResourceFunc<'a> {
+    fn parse(
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+        tokens: &mut Tokenizer<'a>,
+    ) -> Result<Self> {
+        match tokens.clone().next()? {
+            Some((span, Token::Constructor)) => {
+                tokens.expect(Token::Constructor)?;
+                tokens.expect(Token::LeftParen)?;
+                let params = parse_list_trailer(tokens, Token::RightParen, |_docs, tokens| {
+                    let name = parse_id(tokens)?;
+                    tokens.expect(Token::Colon)?;
+                    let ty = Type::parse(tokens)?;
+                    Ok((name, ty))
+                })?;
+                tokens.expect_semicolon()?;
+                Ok(ResourceFunc::Constructor(NamedFunc {
+                    docs,
+                    attributes,
+                    name: Id {
+                        span,
+                        name: "constructor",
+                    },
+                    func: Func {
+                        span,
+                        params,
+                        results: ResultList::Named(Vec::new()),
+                    },
+                }))
+            }
+            Some((_span, Token::Id | Token::ExplicitId)) => {
+                let name = parse_id(tokens)?;
+                tokens.expect(Token::Colon)?;
+                let ctor = if tokens.eat(Token::Static)? {
+                    ResourceFunc::Static
+                } else {
+                    ResourceFunc::Method
+                };
+                let func = Func::parse(tokens)?;
+                tokens.expect_semicolon()?;
+                Ok(ctor(NamedFunc {
+                    docs,
+                    attributes,
+                    name,
+                    func,
+                }))
+            }
+            other => Err(err_expected(tokens, "`constructor` or identifier", other).into()),
+        }
+    }
+
+    fn named_func(&self) -> &NamedFunc<'a> {
+        use ResourceFunc::*;
+        match self {
+            Method(f) | Static(f) | Constructor(f) => f,
+        }
+    }
+}
+
+struct Record<'a> {
+    span: Span,
+    fields: Vec<Field<'a>>,
+}
+
+struct Field<'a> {
+    docs: Docs<'a>,
+    name: Id<'a>,
+    ty: Type<'a>,
+}
+
+struct Flags<'a> {
+    span: Span,
+    flags: Vec<Flag<'a>>,
+}
+
+struct Flag<'a> {
+    docs: Docs<'a>,
+    name: Id<'a>,
+}
+
+struct Variant<'a> {
+    span: Span,
+    cases: Vec<Case<'a>>,
+}
+
+struct Case<'a> {
+    docs: Docs<'a>,
+    name: Id<'a>,
+    ty: Option<Type<'a>>,
+}
+
+struct Enum<'a> {
+    span: Span,
+    cases: Vec<EnumCase<'a>>,
+}
+
+struct EnumCase<'a> {
+    docs: Docs<'a>,
+    name: Id<'a>,
+}
+
+struct Option_<'a> {
+    span: Span,
+    ty: Box<Type<'a>>,
+}
+
+struct List<'a> {
+    span: Span,
+    ty: Box<Type<'a>>,
+}
+
+struct Future<'a> {
+    span: Span,
+    ty: Option<Box<Type<'a>>>,
+}
+
+struct Tuple<'a> {
+    span: Span,
+    types: Vec<Type<'a>>,
+}
+
+struct Result_<'a> {
+    span: Span,
+    ok: Option<Box<Type<'a>>>,
+    err: Option<Box<Type<'a>>>,
+}
+
+struct Stream<'a> {
+    span: Span,
+    element: Option<Box<Type<'a>>>,
+    end: Option<Box<Type<'a>>>,
+}
+
+struct NamedFunc<'a> {
+    docs: Docs<'a>,
+    attributes: Vec<Attribute<'a>>,
+    name: Id<'a>,
+    func: Func<'a>,
+}
+
+type ParamList<'a> = Vec<(Id<'a>, Type<'a>)>;
+
+enum ResultList<'a> {
+    Named(ParamList<'a>),
+    Anon(Type<'a>),
+}
+
+struct Func<'a> {
+    span: Span,
+    params: ParamList<'a>,
+    results: ResultList<'a>,
+}
+
+impl<'a> Func<'a> {
+    fn parse(tokens: &mut Tokenizer<'a>) -> Result<Func<'a>> {
+        fn parse_params<'a>(tokens: &mut Tokenizer<'a>, left_paren: bool) -> Result<ParamList<'a>> {
+            if left_paren {
+                tokens.expect(Token::LeftParen)?;
+            };
+            parse_list_trailer(tokens, Token::RightParen, |_docs, tokens| {
+                let name = parse_id(tokens)?;
+                tokens.expect(Token::Colon)?;
+                let ty = Type::parse(tokens)?;
+                Ok((name, ty))
+            })
+        }
+
+        let span = tokens.expect(Token::Func)?;
+        let params = parse_params(tokens, true)?;
+        let results = if tokens.eat(Token::RArrow)? {
+            // If we eat a '(', parse the remainder of the named
+            // result types. Otherwise parse a single anonymous type.
+            if tokens.eat(Token::LeftParen)? {
+                let results = parse_params(tokens, false)?;
+                ResultList::Named(results)
+            } else {
+                let ty = Type::parse(tokens)?;
+                ResultList::Anon(ty)
+            }
+        } else {
+            ResultList::Named(Vec::new())
+        };
+        Ok(Func {
+            span,
+            params,
+            results,
+        })
+    }
+}
+
+impl<'a> InterfaceItem<'a> {
+    fn parse(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<InterfaceItem<'a>> {
+        match tokens.clone().next()? {
+            Some((_span, Token::Type)) => {
+                TypeDef::parse(tokens, docs, attributes).map(InterfaceItem::TypeDef)
+            }
+            Some((_span, Token::Flags)) => {
+                TypeDef::parse_flags(tokens, docs, attributes).map(InterfaceItem::TypeDef)
+            }
+            Some((_span, Token::Enum)) => {
+                TypeDef::parse_enum(tokens, docs, attributes).map(InterfaceItem::TypeDef)
+            }
+            Some((_span, Token::Variant)) => {
+                TypeDef::parse_variant(tokens, docs, attributes).map(InterfaceItem::TypeDef)
+            }
+            Some((_span, Token::Resource)) => {
+                TypeDef::parse_resource(tokens, docs, attributes).map(InterfaceItem::TypeDef)
+            }
+            Some((_span, Token::Record)) => {
+                TypeDef::parse_record(tokens, docs, attributes).map(InterfaceItem::TypeDef)
+            }
+            Some((_span, Token::Id)) | Some((_span, Token::ExplicitId)) => {
+                NamedFunc::parse(tokens, docs, attributes).map(InterfaceItem::Func)
+            }
+            Some((_span, Token::Use)) => Use::parse(tokens, attributes).map(InterfaceItem::Use),
+            other => Err(err_expected(tokens, "`type`, `resource` or `func`", other).into()),
+        }
+    }
+}
+
+impl<'a> TypeDef<'a> {
+    fn parse(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        tokens.expect(Token::Type)?;
+        let name = parse_id(tokens)?;
+        tokens.expect(Token::Equals)?;
+        let ty = Type::parse(tokens)?;
+        tokens.expect_semicolon()?;
+        Ok(TypeDef {
+            docs,
+            attributes,
+            name,
+            ty,
+        })
+    }
+
+    fn parse_flags(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        tokens.expect(Token::Flags)?;
+        let name = parse_id(tokens)?;
+        let ty = Type::Flags(Flags {
+            span: name.span,
+            flags: parse_list(
+                tokens,
+                Token::LeftBrace,
+                Token::RightBrace,
+                |docs, tokens| {
+                    let name = parse_id(tokens)?;
+                    Ok(Flag { docs, name })
+                },
+            )?,
+        });
+        Ok(TypeDef {
+            docs,
+            attributes,
+            name,
+            ty,
+        })
+    }
+
+    fn parse_resource(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        tokens.expect(Token::Resource)?;
+        let name = parse_id(tokens)?;
+        let mut funcs = Vec::new();
+        if tokens.eat(Token::LeftBrace)? {
+            while !tokens.eat(Token::RightBrace)? {
+                let docs = parse_docs(tokens)?;
+                let attributes = Attribute::parse_list(tokens)?;
+                funcs.push(ResourceFunc::parse(docs, attributes, tokens)?);
+            }
+        } else {
+            tokens.expect_semicolon()?;
+        }
+        let ty = Type::Resource(Resource {
+            span: name.span,
+            funcs,
+        });
+        Ok(TypeDef {
+            docs,
+            attributes,
+            name,
+            ty,
+        })
+    }
+
+    fn parse_record(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        tokens.expect(Token::Record)?;
+        let name = parse_id(tokens)?;
+        let ty = Type::Record(Record {
+            span: name.span,
+            fields: parse_list(
+                tokens,
+                Token::LeftBrace,
+                Token::RightBrace,
+                |docs, tokens| {
+                    let name = parse_id(tokens)?;
+                    tokens.expect(Token::Colon)?;
+                    let ty = Type::parse(tokens)?;
+                    Ok(Field { docs, name, ty })
+                },
+            )?,
+        });
+        Ok(TypeDef {
+            docs,
+            attributes,
+            name,
+            ty,
+        })
+    }
+
+    fn parse_variant(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        tokens.expect(Token::Variant)?;
+        let name = parse_id(tokens)?;
+        let ty = Type::Variant(Variant {
+            span: name.span,
+            cases: parse_list(
+                tokens,
+                Token::LeftBrace,
+                Token::RightBrace,
+                |docs, tokens| {
+                    let name = parse_id(tokens)?;
+                    let ty = if tokens.eat(Token::LeftParen)? {
+                        let ty = Type::parse(tokens)?;
+                        tokens.expect(Token::RightParen)?;
+                        Some(ty)
+                    } else {
+                        None
+                    };
+                    Ok(Case { docs, name, ty })
+                },
+            )?,
+        });
+        Ok(TypeDef {
+            docs,
+            attributes,
+            name,
+            ty,
+        })
+    }
+
+    fn parse_enum(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        tokens.expect(Token::Enum)?;
+        let name = parse_id(tokens)?;
+        let ty = Type::Enum(Enum {
+            span: name.span,
+            cases: parse_list(
+                tokens,
+                Token::LeftBrace,
+                Token::RightBrace,
+                |docs, tokens| {
+                    let name = parse_id(tokens)?;
+                    Ok(EnumCase { docs, name })
+                },
+            )?,
+        });
+        Ok(TypeDef {
+            docs,
+            attributes,
+            name,
+            ty,
+        })
+    }
+}
+
+impl<'a> NamedFunc<'a> {
+    fn parse(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        let name = parse_id(tokens)?;
+        tokens.expect(Token::Colon)?;
+        let func = Func::parse(tokens)?;
+        tokens.expect_semicolon()?;
+        Ok(NamedFunc {
+            docs,
+            attributes,
+            name,
+            func,
+        })
+    }
+}
+
+fn parse_id<'a>(tokens: &mut Tokenizer<'a>) -> Result<Id<'a>> {
+    match tokens.next()? {
+        Some((span, Token::Id)) => Ok(Id {
+            name: tokens.parse_id(span)?,
+            span,
+        }),
+        Some((span, Token::ExplicitId)) => Ok(Id {
+            name: tokens.parse_explicit_id(span)?,
+            span,
+        }),
+        other => Err(err_expected(tokens, "an identifier or string", other).into()),
+    }
+}
+
+fn parse_opt_version(tokens: &mut Tokenizer<'_>) -> Result<Option<(Span, Version)>> {
+    if tokens.eat(Token::At)? {
+        parse_version(tokens).map(Some)
+    } else {
+        Ok(None)
+    }
+}
+
+fn parse_version(tokens: &mut Tokenizer<'_>) -> Result<(Span, Version)> {
+    let start = tokens.expect(Token::Integer)?.start;
+    tokens.expect(Token::Period)?;
+    tokens.expect(Token::Integer)?;
+    tokens.expect(Token::Period)?;
+    let end = tokens.expect(Token::Integer)?.end;
+    let mut span = Span { start, end };
+    eat_ids(tokens, Token::Minus, &mut span)?;
+    eat_ids(tokens, Token::Plus, &mut span)?;
+    let string = tokens.get_span(span);
+    let version = Version::parse(string).map_err(|e| Error::new(span, e.to_string()))?;
+    return Ok((span, version));
+
+    // According to `semver.org` this is what we're parsing:
+    //
+    // ```ebnf
+    // <pre-release> ::= <dot-separated pre-release identifiers>
+    //
+    // <dot-separated pre-release identifiers> ::= <pre-release identifier>
+    //                                           | <pre-release identifier> "." <dot-separated pre-release identifiers>
+    //
+    // <build> ::= <dot-separated build identifiers>
+    //
+    // <dot-separated build identifiers> ::= <build identifier>
+    //                                     | <build identifier> "." <dot-separated build identifiers>
+    //
+    // <pre-release identifier> ::= <alphanumeric identifier>
+    //                            | <numeric identifier>
+    //
+    // <build identifier> ::= <alphanumeric identifier>
+    //                      | <digits>
+    //
+    // <alphanumeric identifier> ::= <non-digit>
+    //                             | <non-digit> <identifier characters>
+    //                             | <identifier characters> <non-digit>
+    //                             | <identifier characters> <non-digit> <identifier characters>
+    //
+    // <numeric identifier> ::= "0"
+    //                        | <positive digit>
+    //                        | <positive digit> <digits>
+    //
+    // <identifier characters> ::= <identifier character>
+    //                           | <identifier character> <identifier characters>
+    //
+    // <identifier character> ::= <digit>
+    //                          | <non-digit>
+    //
+    // <non-digit> ::= <letter>
+    //               | "-"
+    //
+    // <digits> ::= <digit>
+    //            | <digit> <digits>
+    // ```
+    //
+    // This is loosely based on WIT syntax and an approximation is parsed here:
+    //
+    // * This function starts by parsing the optional leading `-` and `+` which
+    //   indicates pre-release and build metadata.
+    // * Afterwards all of $id, $integer, `-`, and `.` are chomped. The only
+    //   exception here is that if `.` isn't followed by $id, $integer, or `-`
+    //   then it's assumed that it's something like `use a:b@1.0.0-a.{...}`
+    //   where the `.` is part of WIT syntax, not semver.
+    //
+    // Note that this additionally doesn't try to return any first-class errors.
+    // Instead this bails out on something unrecognized for something else in
+    // the system to return an error.
+    fn eat_ids(tokens: &mut Tokenizer<'_>, prefix: Token, end: &mut Span) -> Result<()> {
+        if !tokens.eat(prefix)? {
+            return Ok(());
+        }
+        loop {
+            let mut clone = tokens.clone();
+            match clone.next()? {
+                Some((span, Token::Id | Token::Integer | Token::Minus)) => {
+                    end.end = span.end;
+                    *tokens = clone;
+                }
+                Some((_span, Token::Period)) => match clone.next()? {
+                    Some((span, Token::Id | Token::Integer | Token::Minus)) => {
+                        end.end = span.end;
+                        *tokens = clone;
+                    }
+                    _ => break Ok(()),
+                },
+                _ => break Ok(()),
+            }
+        }
+    }
+}
+
+fn parse_docs<'a>(tokens: &mut Tokenizer<'a>) -> Result<Docs<'a>> {
+    let mut docs = Docs::default();
+    let mut clone = tokens.clone();
+    let mut started = false;
+    while let Some((span, token)) = clone.next_raw()? {
+        match token {
+            Token::Whitespace => {}
+            Token::Comment => {
+                let comment = tokens.get_span(span);
+                if !started {
+                    docs.span.start = span.start;
+                    started = true;
+                }
+                let trailing_ws = comment
+                    .bytes()
+                    .rev()
+                    .take_while(|ch| ch.is_ascii_whitespace())
+                    .count();
+                docs.span.end = span.end - (trailing_ws as u32);
+                docs.docs.push(comment.into());
+            }
+            _ => break,
+        };
+        *tokens = clone.clone();
+    }
+    Ok(docs)
+}
+
+impl<'a> Type<'a> {
+    fn parse(tokens: &mut Tokenizer<'a>) -> Result<Self> {
+        match tokens.next()? {
+            Some((span, Token::U8)) => Ok(Type::U8(span)),
+            Some((span, Token::U16)) => Ok(Type::U16(span)),
+            Some((span, Token::U32)) => Ok(Type::U32(span)),
+            Some((span, Token::U64)) => Ok(Type::U64(span)),
+            Some((span, Token::S8)) => Ok(Type::S8(span)),
+            Some((span, Token::S16)) => Ok(Type::S16(span)),
+            Some((span, Token::S32)) => Ok(Type::S32(span)),
+            Some((span, Token::S64)) => Ok(Type::S64(span)),
+            Some((span, Token::F32)) => Ok(Type::F32(span)),
+            Some((span, Token::F64)) => Ok(Type::F64(span)),
+            Some((span, Token::Char)) => Ok(Type::Char(span)),
+
+            // tuple<T, U, ...>
+            Some((span, Token::Tuple)) => {
+                let types = parse_list(
+                    tokens,
+                    Token::LessThan,
+                    Token::GreaterThan,
+                    |_docs, tokens| Type::parse(tokens),
+                )?;
+                Ok(Type::Tuple(Tuple { span, types }))
+            }
+
+            Some((span, Token::Bool)) => Ok(Type::Bool(span)),
+            Some((span, Token::String_)) => Ok(Type::String(span)),
+
+            // list<T>
+            Some((span, Token::List)) => {
+                tokens.expect(Token::LessThan)?;
+                let ty = Type::parse(tokens)?;
+                tokens.expect(Token::GreaterThan)?;
+                Ok(Type::List(List {
+                    span,
+                    ty: Box::new(ty),
+                }))
+            }
+
+            // option<T>
+            Some((span, Token::Option_)) => {
+                tokens.expect(Token::LessThan)?;
+                let ty = Type::parse(tokens)?;
+                tokens.expect(Token::GreaterThan)?;
+                Ok(Type::Option(Option_ {
+                    span,
+                    ty: Box::new(ty),
+                }))
+            }
+
+            // result<T, E>
+            // result<_, E>
+            // result<T>
+            // result
+            Some((span, Token::Result_)) => {
+                let mut ok = None;
+                let mut err = None;
+
+                if tokens.eat(Token::LessThan)? {
+                    if tokens.eat(Token::Underscore)? {
+                        tokens.expect(Token::Comma)?;
+                        err = Some(Box::new(Type::parse(tokens)?));
+                    } else {
+                        ok = Some(Box::new(Type::parse(tokens)?));
+                        if tokens.eat(Token::Comma)? {
+                            err = Some(Box::new(Type::parse(tokens)?));
+                        }
+                    };
+                    tokens.expect(Token::GreaterThan)?;
+                };
+                Ok(Type::Result(Result_ { span, ok, err }))
+            }
+
+            // future<T>
+            // future
+            Some((span, Token::Future)) => {
+                let mut ty = None;
+
+                if tokens.eat(Token::LessThan)? {
+                    ty = Some(Box::new(Type::parse(tokens)?));
+                    tokens.expect(Token::GreaterThan)?;
+                };
+                Ok(Type::Future(Future { span, ty }))
+            }
+
+            // stream<T, Z>
+            // stream<_, Z>
+            // stream<T>
+            // stream
+            Some((span, Token::Stream)) => {
+                let mut element = None;
+                let mut end = None;
+
+                if tokens.eat(Token::LessThan)? {
+                    if tokens.eat(Token::Underscore)? {
+                        tokens.expect(Token::Comma)?;
+                        end = Some(Box::new(Type::parse(tokens)?));
+                    } else {
+                        element = Some(Box::new(Type::parse(tokens)?));
+                        if tokens.eat(Token::Comma)? {
+                            end = Some(Box::new(Type::parse(tokens)?));
+                        }
+                    };
+                    tokens.expect(Token::GreaterThan)?;
+                };
+                Ok(Type::Stream(Stream { span, element, end }))
+            }
+
+            // own<T>
+            Some((_span, Token::Own)) => {
+                tokens.expect(Token::LessThan)?;
+                let resource = parse_id(tokens)?;
+                tokens.expect(Token::GreaterThan)?;
+                Ok(Type::Handle(Handle::Own { resource }))
+            }
+
+            // borrow<T>
+            Some((_span, Token::Borrow)) => {
+                tokens.expect(Token::LessThan)?;
+                let resource = parse_id(tokens)?;
+                tokens.expect(Token::GreaterThan)?;
+                Ok(Type::Handle(Handle::Borrow { resource }))
+            }
+
+            // `foo`
+            Some((span, Token::Id)) => Ok(Type::Name(Id {
+                name: tokens.parse_id(span)?.into(),
+                span,
+            })),
+            // `%foo`
+            Some((span, Token::ExplicitId)) => Ok(Type::Name(Id {
+                name: tokens.parse_explicit_id(span)?.into(),
+                span,
+            })),
+
+            other => Err(err_expected(tokens, "a type", other).into()),
+        }
+    }
+
+    fn span(&self) -> Span {
+        match self {
+            Type::Bool(span)
+            | Type::U8(span)
+            | Type::U16(span)
+            | Type::U32(span)
+            | Type::U64(span)
+            | Type::S8(span)
+            | Type::S16(span)
+            | Type::S32(span)
+            | Type::S64(span)
+            | Type::F32(span)
+            | Type::F64(span)
+            | Type::Char(span)
+            | Type::String(span) => *span,
+            Type::Name(id) => id.span,
+            Type::List(l) => l.span,
+            Type::Handle(h) => h.span(),
+            Type::Resource(r) => r.span,
+            Type::Record(r) => r.span,
+            Type::Flags(f) => f.span,
+            Type::Variant(v) => v.span,
+            Type::Tuple(t) => t.span,
+            Type::Enum(e) => e.span,
+            Type::Option(o) => o.span,
+            Type::Result(r) => r.span,
+            Type::Future(f) => f.span,
+            Type::Stream(s) => s.span,
+        }
+    }
+}
+
+fn parse_list<'a, T>(
+    tokens: &mut Tokenizer<'a>,
+    start: Token,
+    end: Token,
+    parse: impl FnMut(Docs<'a>, &mut Tokenizer<'a>) -> Result<T>,
+) -> Result<Vec<T>> {
+    tokens.expect(start)?;
+    parse_list_trailer(tokens, end, parse)
+}
+
+fn parse_list_trailer<'a, T>(
+    tokens: &mut Tokenizer<'a>,
+    end: Token,
+    mut parse: impl FnMut(Docs<'a>, &mut Tokenizer<'a>) -> Result<T>,
+) -> Result<Vec<T>> {
+    let mut items = Vec::new();
+    loop {
+        // get docs before we skip them to try to eat the end token
+        let docs = parse_docs(tokens)?;
+
+        // if we found an end token then we're done
+        if tokens.eat(end)? {
+            break;
+        }
+
+        let item = parse(docs, tokens)?;
+        items.push(item);
+
+        // if there's no trailing comma then this is required to be the end,
+        // otherwise we go through the loop to try to get another item
+        if !tokens.eat(Token::Comma)? {
+            tokens.expect(end)?;
+            break;
+        }
+    }
+    Ok(items)
+}
+
+fn err_expected(
+    tokens: &Tokenizer<'_>,
+    expected: &'static str,
+    found: Option<(Span, Token)>,
+) -> Error {
+    match found {
+        Some((span, token)) => Error::new(
+            span,
+            format!("expected {}, found {}", expected, token.describe()),
+        ),
+        None => Error::new(
+            tokens.eof_span(),
+            format!("expected {}, found eof", expected),
+        ),
+    }
+}
+
+enum Attribute<'a> {
+    Since { span: Span, version: Version },
+    Unstable { span: Span, feature: Id<'a> },
+    Deprecated { span: Span, version: Version },
+}
+
+impl<'a> Attribute<'a> {
+    fn parse_list(tokens: &mut Tokenizer<'a>) -> Result<Vec<Attribute<'a>>> {
+        let mut ret = Vec::new();
+        while tokens.eat(Token::At)? {
+            let id = parse_id(tokens)?;
+            let attr = match id.name {
+                "since" => {
+                    tokens.expect(Token::LeftParen)?;
+                    eat_id(tokens, "version")?;
+                    tokens.expect(Token::Equals)?;
+                    let (_span, version) = parse_version(tokens)?;
+                    tokens.expect(Token::RightParen)?;
+                    Attribute::Since {
+                        span: id.span,
+                        version,
+                    }
+                }
+                "unstable" => {
+                    tokens.expect(Token::LeftParen)?;
+                    eat_id(tokens, "feature")?;
+                    tokens.expect(Token::Equals)?;
+                    let feature = parse_id(tokens)?;
+                    tokens.expect(Token::RightParen)?;
+                    Attribute::Unstable {
+                        span: id.span,
+                        feature,
+                    }
+                }
+                "deprecated" => {
+                    tokens.expect(Token::LeftParen)?;
+                    eat_id(tokens, "version")?;
+                    tokens.expect(Token::Equals)?;
+                    let (_span, version) = parse_version(tokens)?;
+                    tokens.expect(Token::RightParen)?;
+                    Attribute::Deprecated {
+                        span: id.span,
+                        version,
+                    }
+                }
+                other => {
+                    bail!(Error::new(id.span, format!("unknown attribute `{other}`"),))
+                }
+            };
+            ret.push(attr);
+        }
+        Ok(ret)
+    }
+
+    fn span(&self) -> Span {
+        match self {
+            Attribute::Since { span, .. }
+            | Attribute::Unstable { span, .. }
+            | Attribute::Deprecated { span, .. } => *span,
+        }
+    }
+}
+
+fn eat_id(tokens: &mut Tokenizer<'_>, expected: &str) -> Result<Span> {
+    let id = parse_id(tokens)?;
+    if id.name != expected {
+        bail!(Error::new(
+            id.span,
+            format!("expected `{expected}`, found `{}`", id.name),
+        ));
+    }
+    Ok(id.span)
+}
+
+/// A listing of source files which are used to get parsed into an
+/// [`UnresolvedPackage`].
+#[derive(Clone, Default)]
+pub struct SourceMap {
+    sources: Vec<Source>,
+    offset: u32,
+    require_semicolons: Option<bool>,
+    require_f32_f64: Option<bool>,
+}
+
+#[derive(Clone)]
+struct Source {
+    offset: u32,
+    path: PathBuf,
+    contents: String,
+}
+
+impl SourceMap {
+    /// Creates a new empty source map.
+    pub fn new() -> SourceMap {
+        SourceMap::default()
+    }
+
+    #[doc(hidden)] // NB: only here for a transitionary period
+    pub fn set_require_semicolons(&mut self, enable: bool) {
+        self.require_semicolons = Some(enable);
+    }
+
+    #[doc(hidden)] // NB: only here for a transitionary period
+    pub fn set_require_f32_f64(&mut self, enable: bool) {
+        self.require_f32_f64 = Some(enable);
+    }
+
+    /// Reads the file `path` on the filesystem and appends its contents to this
+    /// [`SourceMap`].
+    pub fn push_file(&mut self, path: &Path) -> Result<()> {
+        let contents = std::fs::read_to_string(path)
+            .with_context(|| format!("failed to read file {path:?}"))?;
+        self.push(path, contents);
+        Ok(())
+    }
+
+    /// Appends the given contents with the given path into this source map.
+    ///
+    /// The `path` provided is not read from the filesystem and is instead only
+    /// used during error messages. Each file added to a [`SourceMap`] is
+    /// used to create the final parsed package namely by unioning all the
+    /// interfaces and worlds defined together. Note that each file has its own
+    /// personal namespace, however, for top-level `use` and such.
+    pub fn push(&mut self, path: &Path, contents: impl Into<String>) {
+        let mut contents = contents.into();
+        // Guarantee that there's at least one character in these contents by
+        // appending a single newline to the end. This is excluded from
+        // tokenization below so it's only here to ensure that spans which point
+        // one byte beyond the end of a file (eof) point to the same original
+        // file.
+        contents.push('\n');
+        let new_offset = self.offset + u32::try_from(contents.len()).unwrap();
+        self.sources.push(Source {
+            offset: self.offset,
+            path: path.to_path_buf(),
+            contents,
+        });
+        self.offset = new_offset;
+    }
+
+    /// Parses the files added to this source map into a
+    /// [`UnresolvedPackageGroup`].
+    pub fn parse(self) -> Result<UnresolvedPackageGroup> {
+        let mut nested = Vec::new();
+        let main = self.rewrite_error(|| {
+            let mut resolver = Resolver::default();
+            let mut srcs = self.sources.iter().collect::<Vec<_>>();
+            srcs.sort_by_key(|src| &src.path);
+
+            // Parse each source file individually. A tokenizer is created here
+            // form settings and then `PackageFile` is used to parse the whole
+            // stream of tokens.
+            for src in srcs {
+                let mut tokens = Tokenizer::new(
+                    // chop off the forcibly appended `\n` character when
+                    // passing through the source to get tokenized.
+                    &src.contents[..src.contents.len() - 1],
+                    src.offset,
+                    self.require_semicolons,
+                    self.require_f32_f64,
+                )
+                .with_context(|| format!("failed to tokenize path: {}", src.path.display()))?;
+                let mut file = PackageFile::parse(&mut tokens)?;
+
+                // Filter out any nested packages and resolve them separately.
+                // Nested packages have only a single "file" so only one item
+                // is pushed into a `Resolver`. Note that a nested `Resolver`
+                // is used here, not the outer one.
+                //
+                // Note that filtering out `Package` items is required due to
+                // how the implementation of disallowing nested packages in
+                // nested packages currently works.
+                for item in mem::take(&mut file.decl_list.items) {
+                    match item {
+                        AstItem::Package(nested_pkg) => {
+                            let mut resolve = Resolver::default();
+                            resolve.push(nested_pkg).with_context(|| {
+                                format!(
+                                    "failed to handle nested package in: {}",
+                                    src.path.display()
+                                )
+                            })?;
+
+                            nested.push(resolve.resolve()?);
+                        }
+                        other => file.decl_list.items.push(other),
+                    }
+                }
+
+                // With nested packages handled push this file into the
+                // resolver.
+                resolver.push(file).with_context(|| {
+                    format!("failed to start resolving path: {}", src.path.display())
+                })?;
+            }
+            Ok(resolver.resolve()?)
+        })?;
+        Ok(UnresolvedPackageGroup {
+            main,
+            nested,
+            source_map: self,
+        })
+    }
+
+    pub(crate) fn rewrite_error<F, T>(&self, f: F) -> Result<T>
+    where
+        F: FnOnce() -> Result<T>,
+    {
+        let mut err = match f() {
+            Ok(t) => return Ok(t),
+            Err(e) => e,
+        };
+        if let Some(parse) = err.downcast_mut::<Error>() {
+            if parse.highlighted.is_none() {
+                let msg = self.highlight_err(parse.span.start, Some(parse.span.end), &parse.msg);
+                parse.highlighted = Some(msg);
+            }
+        }
+        if let Some(_) = err.downcast_mut::<Error>() {
+            return Err(err);
+        }
+
+        if let Some(lex) = err.downcast_ref::<lex::Error>() {
+            let pos = match lex {
+                lex::Error::Unexpected(at, _)
+                | lex::Error::UnterminatedComment(at)
+                | lex::Error::Wanted { at, .. }
+                | lex::Error::InvalidCharInId(at, _)
+                | lex::Error::IdPartEmpty(at)
+                | lex::Error::InvalidEscape(at, _) => *at,
+            };
+            let msg = self.highlight_err(pos, None, lex);
+            bail!("{msg}")
+        }
+
+        if let Some(sort) = err.downcast_ref::<toposort::Error>() {
+            let span = match sort {
+                toposort::Error::NonexistentDep { span, .. }
+                | toposort::Error::Cycle { span, .. } => *span,
+            };
+            let msg = self.highlight_err(span.start, Some(span.end), sort);
+            bail!("{msg}")
+        }
+
+        Err(err)
+    }
+
+    fn highlight_err(&self, start: u32, end: Option<u32>, err: impl fmt::Display) -> String {
+        let src = self.source_for_offset(start);
+        let start = src.to_relative_offset(start);
+        let end = end.map(|end| src.to_relative_offset(end));
+        let (line, col) = src.linecol(start);
+        let snippet = src.contents.lines().nth(line).unwrap_or("");
+        let mut msg = format!(
+            "\
+{err}
+     --> {file}:{line}:{col}
+      |
+ {line:4} | {snippet}
+      | {marker:>0$}",
+            col + 1,
+            file = src.path.display(),
+            line = line + 1,
+            col = col + 1,
+            marker = "^",
+        );
+        if let Some(end) = end {
+            if let Some(s) = src.contents.get(start..end) {
+                for _ in s.chars().skip(1) {
+                    msg.push('-');
+                }
+            }
+        }
+        return msg;
+    }
+
+    pub(crate) fn render_location(&self, span: Span) -> String {
+        let src = self.source_for_offset(span.start);
+        let start = src.to_relative_offset(span.start);
+        let (line, col) = src.linecol(start);
+        format!(
+            "{file}:{line}:{col}",
+            file = src.path.display(),
+            line = line + 1,
+            col = col + 1,
+        )
+    }
+
+    fn source_for_offset(&self, start: u32) -> &Source {
+        let i = match self.sources.binary_search_by_key(&start, |src| src.offset) {
+            Ok(i) => i,
+            Err(i) => i - 1,
+        };
+        &self.sources[i]
+    }
+
+    /// Returns an iterator over all filenames added to this source map.
+    pub fn source_files(&self) -> impl Iterator<Item = &Path> {
+        self.sources.iter().map(|src| src.path.as_path())
+    }
+}
+
+impl Source {
+    fn to_relative_offset(&self, offset: u32) -> usize {
+        usize::try_from(offset - self.offset).unwrap()
+    }
+
+    fn linecol(&self, relative_offset: usize) -> (usize, usize) {
+        let mut cur = 0;
+        // Use split_terminator instead of lines so that if there is a `\r`,
+        // it is included in the offset calculation. The `+1` values below
+        // account for the `\n`.
+        for (i, line) in self.contents.split_terminator('\n').enumerate() {
+            if cur + line.len() + 1 > relative_offset {
+                return (i, relative_offset - cur);
+            }
+            cur += line.len() + 1;
+        }
+        (self.contents.lines().count(), 0)
+    }
+}
+
+pub enum ParsedUsePath {
+    Name(String),
+    Package(crate::PackageName, String),
+}
+
+pub fn parse_use_path(s: &str) -> Result<ParsedUsePath> {
+    let mut tokens = Tokenizer::new(s, 0, Some(true), None)?;
+    let path = UsePath::parse(&mut tokens)?;
+    if tokens.next()?.is_some() {
+        bail!("trailing tokens in path specifier");
+    }
+    Ok(match path {
+        UsePath::Id(id) => ParsedUsePath::Name(id.name.to_string()),
+        UsePath::Package { id, name } => {
+            ParsedUsePath::Package(id.package_name(), name.name.to_string())
+        }
+    })
+}