moved all crates into seperate folder + related path fixes

crates/compiler/parse/src/module.rs

@@ -0,0 +1,894 @@
+use crate::ast::{Collection, CommentOrNewline, Defs, Module, Spaced};
+use crate::blankspace::{space0_around_ee, space0_before_e, space0_e};
+use crate::header::{
+    package_entry, package_name, AppHeader, ExposedName, HostedHeader, ImportsEntry,
+    InterfaceHeader, ModuleName, PackageEntry, PlatformHeader, PlatformRequires, To, TypedIdent,
+};
+use crate::ident::{self, lowercase_ident, unqualified_ident, uppercase, UppercaseIdent};
+use crate::parser::Progress::{self, *};
+use crate::parser::{
+    backtrackable, optional, specialize, specialize_region, word1, EExposes, EGenerates,
+    EGeneratesWith, EHeader, EImports, EPackages, EProvides, ERequires, ETypedIdent, Parser,
+    SourceError, SpaceProblem, SyntaxError,
+};
+use crate::state::State;
+use crate::string_literal;
+use crate::type_annotation;
+use roc_region::all::{Loc, Position};
+
+fn end_of_file<'a>() -> impl Parser<'a, (), SyntaxError<'a>> {
+    |_arena, state: State<'a>| {
+        if state.has_reached_end() {
+            Ok((NoProgress, (), state))
+        } else {
+            Err((NoProgress, SyntaxError::NotEndOfFile(state.pos()), state))
+        }
+    }
+}
+
+#[inline(always)]
+pub fn module_defs<'a>() -> impl Parser<'a, Defs<'a>, SyntaxError<'a>> {
+    let min_indent = 0;
+    skip_second!(
+        specialize_region(
+            |e, r| SyntaxError::Expr(e, r.start()),
+            crate::expr::toplevel_defs(min_indent),
+        ),
+        end_of_file()
+    )
+}
+
+pub fn parse_header<'a>(
+    arena: &'a bumpalo::Bump,
+    state: State<'a>,
+) -> Result<(Module<'a>, State<'a>), SourceError<'a, EHeader<'a>>> {
+    match header().parse(arena, state) {
+        Ok((_, module, state)) => Ok((module, state)),
+        Err((_, fail, state)) => Err(SourceError::new(fail, &state)),
+    }
+}
+
+fn header<'a>() -> impl Parser<'a, Module<'a>, EHeader<'a>> {
+    use crate::parser::keyword_e;
+
+    type Clos<'b> = Box<(dyn FnOnce(&'b [CommentOrNewline]) -> Module<'b> + 'b)>;
+
+    map!(
+        and!(
+            space0_e(0, EHeader::IndentStart),
+            one_of![
+                map!(
+                    skip_first!(keyword_e("interface", EHeader::Start), interface_header()),
+                    |mut header: InterfaceHeader<'a>| -> Clos<'a> {
+                        Box::new(|spaces| {
+                            header.before_header = spaces;
+                            Module::Interface { header }
+                        })
+                    }
+                ),
+                map!(
+                    skip_first!(keyword_e("app", EHeader::Start), app_header()),
+                    |mut header: AppHeader<'a>| -> Clos<'a> {
+                        Box::new(|spaces| {
+                            header.before_header = spaces;
+                            Module::App { header }
+                        })
+                    }
+                ),
+                map!(
+                    skip_first!(keyword_e("platform", EHeader::Start), platform_header()),
+                    |mut header: PlatformHeader<'a>| -> Clos<'a> {
+                        Box::new(|spaces| {
+                            header.before_header = spaces;
+                            Module::Platform { header }
+                        })
+                    }
+                ),
+                map!(
+                    skip_first!(keyword_e("hosted", EHeader::Start), hosted_header()),
+                    |mut header: HostedHeader<'a>| -> Clos<'a> {
+                        Box::new(|spaces| {
+                            header.before_header = spaces;
+                            Module::Hosted { header }
+                        })
+                    }
+                )
+            ]
+        ),
+        |(spaces, make_header): (&'a [CommentOrNewline], Clos<'a>)| { make_header(spaces) }
+    )
+}
+
+#[inline(always)]
+fn interface_header<'a>() -> impl Parser<'a, InterfaceHeader<'a>, EHeader<'a>> {
+    |arena, state| {
+        let min_indent = 1;
+
+        let (_, after_interface_keyword, state) =
+            space0_e(min_indent, EHeader::IndentStart).parse(arena, state)?;
+        let (_, name, state) = loc!(module_name_help(EHeader::ModuleName)).parse(arena, state)?;
+
+        let (_, ((before_exposes, after_exposes), exposes), state) =
+            specialize(EHeader::Exposes, exposes_values()).parse(arena, state)?;
+        let (_, ((before_imports, after_imports), imports), state) =
+            specialize(EHeader::Imports, imports()).parse(arena, state)?;
+
+        let header = InterfaceHeader {
+            name,
+            exposes,
+            imports,
+            before_header: &[] as &[_],
+            after_interface_keyword,
+            before_exposes,
+            after_exposes,
+            before_imports,
+            after_imports,
+        };
+
+        Ok((MadeProgress, header, state))
+    }
+}
+
+#[inline(always)]
+fn hosted_header<'a>() -> impl Parser<'a, HostedHeader<'a>, EHeader<'a>> {
+    |arena, state| {
+        let min_indent = 1;
+
+        let (_, after_hosted_keyword, state) =
+            space0_e(min_indent, EHeader::IndentStart).parse(arena, state)?;
+        let (_, name, state) = loc!(module_name_help(EHeader::ModuleName)).parse(arena, state)?;
+
+        let (_, ((before_exposes, after_exposes), exposes), state) =
+            specialize(EHeader::Exposes, exposes_values()).parse(arena, state)?;
+        let (_, ((before_imports, after_imports), imports), state) =
+            specialize(EHeader::Imports, imports()).parse(arena, state)?;
+        let (_, ((before_generates, after_generates), generates), state) =
+            specialize(EHeader::Generates, generates()).parse(arena, state)?;
+        let (_, ((before_with, after_with), generates_with), state) =
+            specialize(EHeader::GeneratesWith, generates_with()).parse(arena, state)?;
+
+        let header = HostedHeader {
+            name,
+            exposes,
+            imports,
+            generates,
+            generates_with,
+            before_header: &[] as &[_],
+            after_hosted_keyword,
+            before_exposes,
+            after_exposes,
+            before_imports,
+            after_imports,
+            before_generates,
+            after_generates,
+            before_with,
+            after_with,
+        };
+
+        Ok((MadeProgress, header, state))
+    }
+}
+
+fn chomp_module_name(buffer: &[u8]) -> Result<&str, Progress> {
+    use encode_unicode::CharExt;
+
+    let mut chomped = 0;
+
+    if let Ok((first_letter, width)) = char::from_utf8_slice_start(&buffer[chomped..]) {
+        if first_letter.is_uppercase() {
+            chomped += width;
+        } else {
+            return Err(Progress::NoProgress);
+        }
+    }
+
+    while let Ok((ch, width)) = char::from_utf8_slice_start(&buffer[chomped..]) {
+        // After the first character, only these are allowed:
+        //
+        // * Unicode alphabetic chars - you might include `鹏` if that's clear to your readers
+        // * ASCII digits - e.g. `1` but not `¾`, both of which pass .is_numeric()
+        // * A '.' separating module parts
+        if ch.is_alphabetic() || ch.is_ascii_digit() {
+            chomped += width;
+        } else if ch == '.' {
+            chomped += width;
+
+            if let Ok((first_letter, width)) = char::from_utf8_slice_start(&buffer[chomped..]) {
+                if first_letter.is_uppercase() {
+                    chomped += width;
+                } else if first_letter == '{' {
+                    // the .{ starting a `Foo.{ bar, baz }` importing clauses
+                    chomped -= width;
+                    break;
+                } else {
+                    return Err(Progress::MadeProgress);
+                }
+            }
+        } else {
+            // we're done
+            break;
+        }
+    }
+
+    let name = unsafe { std::str::from_utf8_unchecked(&buffer[..chomped]) };
+
+    Ok(name)
+}
+
+#[inline(always)]
+fn module_name<'a>() -> impl Parser<'a, ModuleName<'a>, ()> {
+    |_, mut state: State<'a>| match chomp_module_name(state.bytes()) {
+        Ok(name) => {
+            let width = name.len();
+            state = state.advance(width);
+
+            Ok((MadeProgress, ModuleName::new(name), state))
+        }
+        Err(progress) => Err((progress, (), state)),
+    }
+}
+
+#[inline(always)]
+fn app_header<'a>() -> impl Parser<'a, AppHeader<'a>, EHeader<'a>> {
+    |arena, state| {
+        let min_indent = 1;
+
+        let (_, after_app_keyword, state) =
+            space0_e(min_indent, EHeader::IndentStart).parse(arena, state)?;
+        let (_, name, state) = loc!(crate::parser::specialize(
+            EHeader::AppName,
+            string_literal::parse()
+        ))
+        .parse(arena, state)?;
+
+        let (_, opt_pkgs, state) =
+            maybe!(specialize(EHeader::Packages, packages())).parse(arena, state)?;
+        let (_, opt_imports, state) =
+            maybe!(specialize(EHeader::Imports, imports())).parse(arena, state)?;
+        let (_, provides, state) =
+            specialize(EHeader::Provides, provides_to()).parse(arena, state)?;
+
+        let (before_packages, after_packages, packages) = match opt_pkgs {
+            Some(pkgs) => {
+                let pkgs: Packages<'a> = pkgs; // rustc must be told the type here
+
+                (
+                    pkgs.before_packages_keyword,
+                    pkgs.after_packages_keyword,
+                    pkgs.entries,
+                )
+            }
+            None => (&[] as _, &[] as _, Collection::empty()),
+        };
+
+        // rustc must be told the type here
+        #[allow(clippy::type_complexity)]
+        let opt_imports: Option<(
+            (&'a [CommentOrNewline<'a>], &'a [CommentOrNewline<'a>]),
+            Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>,
+        )> = opt_imports;
+
+        let ((before_imports, after_imports), imports) =
+            opt_imports.unwrap_or_else(|| ((&[] as _, &[] as _), Collection::empty()));
+        let provides: ProvidesTo<'a> = provides; // rustc must be told the type here
+
+        let header = AppHeader {
+            name,
+            packages,
+            imports,
+            provides: provides.entries,
+            provides_types: provides.types,
+            to: provides.to,
+            before_header: &[] as &[_],
+            after_app_keyword,
+            before_packages,
+            after_packages,
+            before_imports,
+            after_imports,
+            before_provides: provides.before_provides_keyword,
+            after_provides: provides.after_provides_keyword,
+            before_to: provides.before_to_keyword,
+            after_to: provides.after_to_keyword,
+        };
+
+        Ok((MadeProgress, header, state))
+    }
+}
+
+#[inline(always)]
+fn platform_header<'a>() -> impl Parser<'a, PlatformHeader<'a>, EHeader<'a>> {
+    |arena, state| {
+        let min_indent = 1;
+
+        let (_, after_platform_keyword, state) =
+            space0_e(min_indent, EHeader::IndentStart).parse(arena, state)?;
+        let (_, name, state) =
+            loc!(specialize(EHeader::PlatformName, package_name())).parse(arena, state)?;
+
+        let (_, ((before_requires, after_requires), requires), state) =
+            specialize(EHeader::Requires, requires()).parse(arena, state)?;
+
+        let (_, ((before_exposes, after_exposes), exposes), state) =
+            specialize(EHeader::Exposes, exposes_modules()).parse(arena, state)?;
+
+        let (_, packages, state) = specialize(EHeader::Packages, packages()).parse(arena, state)?;
+
+        let (_, ((before_imports, after_imports), imports), state) =
+            specialize(EHeader::Imports, imports()).parse(arena, state)?;
+
+        let (_, ((before_provides, after_provides), (provides, _provides_type)), state) =
+            specialize(EHeader::Provides, provides_without_to()).parse(arena, state)?;
+
+        let header = PlatformHeader {
+            name,
+            requires,
+            exposes,
+            packages: packages.entries,
+            imports,
+            provides,
+            before_header: &[] as &[_],
+            after_platform_keyword,
+            before_requires,
+            after_requires,
+            before_exposes,
+            after_exposes,
+            before_packages: packages.before_packages_keyword,
+            after_packages: packages.after_packages_keyword,
+            before_imports,
+            after_imports,
+            before_provides,
+            after_provides,
+        };
+
+        Ok((MadeProgress, header, state))
+    }
+}
+
+#[derive(Debug)]
+struct ProvidesTo<'a> {
+    entries: Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+    types: Option<Collection<'a, Loc<Spaced<'a, UppercaseIdent<'a>>>>>,
+    to: Loc<To<'a>>,
+
+    before_provides_keyword: &'a [CommentOrNewline<'a>],
+    after_provides_keyword: &'a [CommentOrNewline<'a>],
+    before_to_keyword: &'a [CommentOrNewline<'a>],
+    after_to_keyword: &'a [CommentOrNewline<'a>],
+}
+
+fn provides_to_package<'a>() -> impl Parser<'a, To<'a>, EProvides<'a>> {
+    one_of![
+        specialize(
+            |_, pos| EProvides::Identifier(pos),
+            map!(lowercase_ident(), To::ExistingPackage)
+        ),
+        specialize(EProvides::Package, map!(package_name(), To::NewPackage))
+    ]
+}
+
+#[inline(always)]
+fn provides_to<'a>() -> impl Parser<'a, ProvidesTo<'a>, EProvides<'a>> {
+    let min_indent = 1;
+
+    map!(
+        and!(
+            provides_without_to(),
+            and!(
+                spaces_around_keyword(
+                    min_indent,
+                    "to",
+                    EProvides::To,
+                    EProvides::IndentTo,
+                    EProvides::IndentListStart
+                ),
+                loc!(provides_to_package())
+            )
+        ),
+        |(
+            ((before_provides_keyword, after_provides_keyword), (entries, provides_types)),
+            ((before_to_keyword, after_to_keyword), to),
+        )| {
+            ProvidesTo {
+                entries,
+                types: provides_types,
+                to,
+                before_provides_keyword,
+                after_provides_keyword,
+                before_to_keyword,
+                after_to_keyword,
+            }
+        }
+    )
+}
+
+#[inline(always)]
+fn provides_without_to<'a>() -> impl Parser<
+    'a,
+    (
+        (&'a [CommentOrNewline<'a>], &'a [CommentOrNewline<'a>]),
+        (
+            Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+            Option<Collection<'a, Loc<Spaced<'a, UppercaseIdent<'a>>>>>,
+        ),
+    ),
+    EProvides<'a>,
+> {
+    let min_indent = 1;
+    and!(
+        spaces_around_keyword(
+            min_indent,
+            "provides",
+            EProvides::Provides,
+            EProvides::IndentProvides,
+            EProvides::IndentListStart
+        ),
+        and!(
+            collection_trailing_sep_e!(
+                word1(b'[', EProvides::ListStart),
+                exposes_entry(EProvides::Identifier),
+                word1(b',', EProvides::ListEnd),
+                word1(b']', EProvides::ListEnd),
+                min_indent,
+                EProvides::Open,
+                EProvides::IndentListEnd,
+                Spaced::SpaceBefore
+            ),
+            // Optionally
+            optional(provides_types())
+        )
+    )
+}
+
+#[inline(always)]
+fn provides_types<'a>(
+) -> impl Parser<'a, Collection<'a, Loc<Spaced<'a, UppercaseIdent<'a>>>>, EProvides<'a>> {
+    let min_indent = 1;
+
+    skip_first!(
+        // We only support spaces here, not newlines, because this is not intended
+        // to be the design forever. Someday it will hopefully work like Elm,
+        // where platform authors can provide functions like Browser.sandbox which
+        // present an API based on ordinary-looking type variables.
+        zero_or_more!(word1(
+            b' ',
+            // HACK: If this errors, EProvides::Provides is not an accurate reflection
+            // of what went wrong. However, this is both skipped and zero_or_more,
+            // so this error should never be visible to anyone in practice!
+            EProvides::Provides
+        )),
+        collection_trailing_sep_e!(
+            word1(b'{', EProvides::ListStart),
+            provides_type_entry(EProvides::Identifier),
+            word1(b',', EProvides::ListEnd),
+            word1(b'}', EProvides::ListEnd),
+            min_indent,
+            EProvides::Open,
+            EProvides::IndentListEnd,
+            Spaced::SpaceBefore
+        )
+    )
+}
+
+fn provides_type_entry<'a, F, E>(
+    to_expectation: F,
+) -> impl Parser<'a, Loc<Spaced<'a, UppercaseIdent<'a>>>, E>
+where
+    F: Fn(Position) -> E,
+    F: Copy,
+    E: 'a,
+{
+    loc!(map!(
+        specialize(|_, pos| to_expectation(pos), ident::uppercase()),
+        Spaced::Item
+    ))
+}
+
+fn exposes_entry<'a, F, E>(
+    to_expectation: F,
+) -> impl Parser<'a, Loc<Spaced<'a, ExposedName<'a>>>, E>
+where
+    F: Fn(Position) -> E,
+    F: Copy,
+    E: 'a,
+{
+    loc!(map!(
+        specialize(|_, pos| to_expectation(pos), unqualified_ident()),
+        |n| Spaced::Item(ExposedName::new(n))
+    ))
+}
+
+#[inline(always)]
+fn requires<'a>() -> impl Parser<
+    'a,
+    (
+        (&'a [CommentOrNewline<'a>], &'a [CommentOrNewline<'a>]),
+        PlatformRequires<'a>,
+    ),
+    ERequires<'a>,
+> {
+    let min_indent = 0;
+    and!(
+        spaces_around_keyword(
+            min_indent,
+            "requires",
+            ERequires::Requires,
+            ERequires::IndentRequires,
+            ERequires::IndentListStart
+        ),
+        platform_requires()
+    )
+}
+
+#[inline(always)]
+fn platform_requires<'a>() -> impl Parser<'a, PlatformRequires<'a>, ERequires<'a>> {
+    map!(
+        and!(
+            skip_second!(requires_rigids(0), space0_e(0, ERequires::ListStart)),
+            requires_typed_ident()
+        ),
+        |(rigids, signature)| { PlatformRequires { rigids, signature } }
+    )
+}
+
+#[inline(always)]
+fn requires_rigids<'a>(
+    min_indent: u32,
+) -> impl Parser<'a, Collection<'a, Loc<Spaced<'a, UppercaseIdent<'a>>>>, ERequires<'a>> {
+    collection_trailing_sep_e!(
+        word1(b'{', ERequires::ListStart),
+        specialize(
+            |_, pos| ERequires::Rigid(pos),
+            loc!(map!(ident::uppercase(), Spaced::Item))
+        ),
+        word1(b',', ERequires::ListEnd),
+        word1(b'}', ERequires::ListEnd),
+        min_indent,
+        ERequires::Open,
+        ERequires::IndentListEnd,
+        Spaced::SpaceBefore
+    )
+}
+
+#[inline(always)]
+fn requires_typed_ident<'a>() -> impl Parser<'a, Loc<Spaced<'a, TypedIdent<'a>>>, ERequires<'a>> {
+    skip_first!(
+        word1(b'{', ERequires::ListStart),
+        skip_second!(
+            space0_around_ee(
+                specialize(ERequires::TypedIdent, loc!(typed_ident()),),
+                0,
+                ERequires::ListStart,
+                ERequires::ListEnd
+            ),
+            word1(b'}', ERequires::ListStart)
+        )
+    )
+}
+
+#[inline(always)]
+fn exposes_values<'a>() -> impl Parser<
+    'a,
+    (
+        (&'a [CommentOrNewline<'a>], &'a [CommentOrNewline<'a>]),
+        Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+    ),
+    EExposes,
+> {
+    let min_indent = 1;
+
+    and!(
+        spaces_around_keyword(
+            min_indent,
+            "exposes",
+            EExposes::Exposes,
+            EExposes::IndentExposes,
+            EExposes::IndentListStart
+        ),
+        collection_trailing_sep_e!(
+            word1(b'[', EExposes::ListStart),
+            exposes_entry(EExposes::Identifier),
+            word1(b',', EExposes::ListEnd),
+            word1(b']', EExposes::ListEnd),
+            min_indent,
+            EExposes::Open,
+            EExposes::IndentListEnd,
+            Spaced::SpaceBefore
+        )
+    )
+}
+
+fn spaces_around_keyword<'a, E>(
+    min_indent: u32,
+    keyword: &'static str,
+    expectation: fn(Position) -> E,
+    indent_problem1: fn(Position) -> E,
+    indent_problem2: fn(Position) -> E,
+) -> impl Parser<'a, (&'a [CommentOrNewline<'a>], &'a [CommentOrNewline<'a>]), E>
+where
+    E: 'a + SpaceProblem,
+{
+    and!(
+        skip_second!(
+            backtrackable(space0_e(min_indent, indent_problem1)),
+            crate::parser::keyword_e(keyword, expectation)
+        ),
+        space0_e(min_indent, indent_problem2)
+    )
+}
+
+#[inline(always)]
+fn exposes_modules<'a>() -> impl Parser<
+    'a,
+    (
+        (&'a [CommentOrNewline<'a>], &'a [CommentOrNewline<'a>]),
+        Collection<'a, Loc<Spaced<'a, ModuleName<'a>>>>,
+    ),
+    EExposes,
+> {
+    let min_indent = 1;
+
+    and!(
+        spaces_around_keyword(
+            min_indent,
+            "exposes",
+            EExposes::Exposes,
+            EExposes::IndentExposes,
+            EExposes::IndentListStart
+        ),
+        collection_trailing_sep_e!(
+            word1(b'[', EExposes::ListStart),
+            exposes_module(EExposes::Identifier),
+            word1(b',', EExposes::ListEnd),
+            word1(b']', EExposes::ListEnd),
+            min_indent,
+            EExposes::Open,
+            EExposes::IndentListEnd,
+            Spaced::SpaceBefore
+        )
+    )
+}
+
+fn exposes_module<'a, F, E>(
+    to_expectation: F,
+) -> impl Parser<'a, Loc<Spaced<'a, ModuleName<'a>>>, E>
+where
+    F: Fn(Position) -> E,
+    F: Copy,
+    E: 'a,
+{
+    loc!(map!(
+        specialize(|_, pos| to_expectation(pos), module_name()),
+        Spaced::Item
+    ))
+}
+
+#[derive(Debug)]
+struct Packages<'a> {
+    entries: Collection<'a, Loc<Spaced<'a, PackageEntry<'a>>>>,
+    before_packages_keyword: &'a [CommentOrNewline<'a>],
+    after_packages_keyword: &'a [CommentOrNewline<'a>],
+}
+
+#[inline(always)]
+fn packages<'a>() -> impl Parser<'a, Packages<'a>, EPackages<'a>> {
+    let min_indent = 1;
+
+    map!(
+        and!(
+            spaces_around_keyword(
+                min_indent,
+                "packages",
+                EPackages::Packages,
+                EPackages::IndentPackages,
+                EPackages::IndentListStart
+            ),
+            collection_trailing_sep_e!(
+                word1(b'{', EPackages::ListStart),
+                specialize(EPackages::PackageEntry, loc!(package_entry())),
+                word1(b',', EPackages::ListEnd),
+                word1(b'}', EPackages::ListEnd),
+                min_indent,
+                EPackages::Open,
+                EPackages::IndentListEnd,
+                Spaced::SpaceBefore
+            )
+        ),
+        |((before_packages_keyword, after_packages_keyword), entries): (
+            (_, _),
+            Collection<'a, _>
+        )| {
+            Packages {
+                entries,
+                before_packages_keyword,
+                after_packages_keyword,
+            }
+        }
+    )
+}
+
+#[inline(always)]
+fn generates<'a>() -> impl Parser<
+    'a,
+    (
+        (&'a [CommentOrNewline<'a>], &'a [CommentOrNewline<'a>]),
+        UppercaseIdent<'a>,
+    ),
+    EGenerates,
+> {
+    let min_indent = 1;
+
+    and!(
+        spaces_around_keyword(
+            min_indent,
+            "generates",
+            EGenerates::Generates,
+            EGenerates::IndentGenerates,
+            EGenerates::IndentTypeStart
+        ),
+        specialize(|(), pos| EGenerates::Identifier(pos), uppercase())
+    )
+}
+
+#[inline(always)]
+fn generates_with<'a>() -> impl Parser<
+    'a,
+    (
+        (&'a [CommentOrNewline<'a>], &'a [CommentOrNewline<'a>]),
+        Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+    ),
+    EGeneratesWith,
+> {
+    let min_indent = 1;
+
+    and!(
+        spaces_around_keyword(
+            min_indent,
+            "with",
+            EGeneratesWith::With,
+            EGeneratesWith::IndentWith,
+            EGeneratesWith::IndentListStart
+        ),
+        collection_trailing_sep_e!(
+            word1(b'[', EGeneratesWith::ListStart),
+            exposes_entry(EGeneratesWith::Identifier),
+            word1(b',', EGeneratesWith::ListEnd),
+            word1(b']', EGeneratesWith::ListEnd),
+            min_indent,
+            EGeneratesWith::Open,
+            EGeneratesWith::IndentListEnd,
+            Spaced::SpaceBefore
+        )
+    )
+}
+
+#[inline(always)]
+fn imports<'a>() -> impl Parser<
+    'a,
+    (
+        (&'a [CommentOrNewline<'a>], &'a [CommentOrNewline<'a>]),
+        Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>,
+    ),
+    EImports,
+> {
+    let min_indent = 1;
+
+    and!(
+        spaces_around_keyword(
+            min_indent,
+            "imports",
+            EImports::Imports,
+            EImports::IndentImports,
+            EImports::IndentListStart
+        ),
+        collection_trailing_sep_e!(
+            word1(b'[', EImports::ListStart),
+            loc!(imports_entry()),
+            word1(b',', EImports::ListEnd),
+            word1(b']', EImports::ListEnd),
+            min_indent,
+            EImports::Open,
+            EImports::IndentListEnd,
+            Spaced::SpaceBefore
+        )
+    )
+}
+
+#[inline(always)]
+fn typed_ident<'a>() -> impl Parser<'a, Spaced<'a, TypedIdent<'a>>, ETypedIdent<'a>> {
+    // e.g.
+    //
+    // printLine : Str -> Effect {}
+    let min_indent = 0;
+
+    map!(
+        and!(
+            and!(
+                loc!(specialize(
+                    |_, pos| ETypedIdent::Identifier(pos),
+                    lowercase_ident()
+                )),
+                space0_e(min_indent, ETypedIdent::IndentHasType)
+            ),
+            skip_first!(
+                word1(b':', ETypedIdent::HasType),
+                space0_before_e(
+                    specialize(
+                        ETypedIdent::Type,
+                        type_annotation::located(min_indent, true)
+                    ),
+                    min_indent,
+                    ETypedIdent::IndentType,
+                )
+            )
+        ),
+        |((ident, spaces_before_colon), ann)| {
+            Spaced::Item(TypedIdent {
+                ident,
+                spaces_before_colon,
+                ann,
+            })
+        }
+    )
+}
+
+fn shortname<'a>() -> impl Parser<'a, &'a str, EImports> {
+    specialize(|_, pos| EImports::Shorthand(pos), lowercase_ident())
+}
+
+fn module_name_help<'a, F, E>(to_expectation: F) -> impl Parser<'a, ModuleName<'a>, E>
+where
+    F: Fn(Position) -> E,
+    E: 'a,
+    F: 'a,
+{
+    specialize(move |_, pos| to_expectation(pos), module_name())
+}
+
+#[inline(always)]
+fn imports_entry<'a>() -> impl Parser<'a, Spaced<'a, ImportsEntry<'a>>, EImports> {
+    let min_indent = 1;
+
+    type Temp<'a> = (
+        (Option<&'a str>, ModuleName<'a>),
+        Option<Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>>,
+    );
+
+    map_with_arena!(
+        and!(
+            and!(
+                // e.g. `pf.`
+                maybe!(skip_second!(
+                    shortname(),
+                    word1(b'.', EImports::ShorthandDot)
+                )),
+                // e.g. `Task`
+                module_name_help(EImports::ModuleName)
+            ),
+            // e.g. `.{ Task, after}`
+            maybe!(skip_first!(
+                word1(b'.', EImports::ExposingDot),
+                collection_trailing_sep_e!(
+                    word1(b'{', EImports::SetStart),
+                    exposes_entry(EImports::Identifier),
+                    word1(b',', EImports::SetEnd),
+                    word1(b'}', EImports::SetEnd),
+                    min_indent,
+                    EImports::Open,
+                    EImports::IndentSetEnd,
+                    Spaced::SpaceBefore
+                )
+            ))
+        ),
+        |_arena, ((opt_shortname, module_name), opt_values): Temp<'a>| {
+            let exposed_values = opt_values.unwrap_or_else(Collection::empty);
+
+            let entry = match opt_shortname {
+                Some(shortname) => ImportsEntry::Package(shortname, module_name, exposed_values),
+
+                None => ImportsEntry::Module(module_name, exposed_values),
+            };
+
+            Spaced::Item(entry)
+        }
+    )
+}