moved all crates into seperate folder + related path fixes

crates/compiler/parse/src/header.rs

@@ -0,0 +1,320 @@
+use crate::ast::{Collection, CommentOrNewline, Spaced, StrLiteral, TypeAnnotation};
+use crate::blankspace::space0_e;
+use crate::ident::{lowercase_ident, UppercaseIdent};
+use crate::parser::Progress::*;
+use crate::parser::{specialize, word1, EPackageEntry, EPackageName, Parser};
+use crate::state::State;
+use crate::string_literal;
+use bumpalo::collections::Vec;
+use roc_module::symbol::Symbol;
+use roc_region::all::Loc;
+
+#[derive(Debug)]
+pub enum HeaderFor<'a> {
+    App {
+        to_platform: To<'a>,
+    },
+    Hosted {
+        generates: UppercaseIdent<'a>,
+        generates_with: &'a [Loc<ExposedName<'a>>],
+    },
+    /// Only created during canonicalization, never actually parsed from source
+    Builtin {
+        generates_with: &'a [Symbol],
+    },
+    Platform {
+        /// usually `pf`
+        config_shorthand: &'a str,
+        /// the type scheme of the main function (required by the platform)
+        /// (currently unused)
+        #[allow(dead_code)]
+        platform_main_type: TypedIdent<'a>,
+        /// provided symbol to host (commonly `mainForHost`)
+        main_for_host: roc_module::symbol::Symbol,
+    },
+    Interface,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+pub enum Version<'a> {
+    Exact(&'a str),
+    Range {
+        min: &'a str,
+        min_comparison: VersionComparison,
+        max: &'a str,
+        max_comparison: VersionComparison,
+    },
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+pub enum VersionComparison {
+    AllowsEqual,
+    DisallowsEqual,
+}
+
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub struct PackageName<'a>(&'a str);
+
+impl<'a> PackageName<'a> {
+    pub fn to_str(self) -> &'a str {
+        self.0
+    }
+
+    pub fn as_str(&self) -> &'a str {
+        self.0
+    }
+}
+
+impl<'a> From<PackageName<'a>> for &'a str {
+    fn from(name: PackageName<'a>) -> &'a str {
+        name.0
+    }
+}
+
+impl<'a> From<&'a str> for PackageName<'a> {
+    fn from(string: &'a str) -> Self {
+        Self(string)
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+pub struct ModuleName<'a>(&'a str);
+
+impl<'a> From<ModuleName<'a>> for &'a str {
+    fn from(name: ModuleName<'a>) -> Self {
+        name.0
+    }
+}
+
+impl<'a> ModuleName<'a> {
+    pub const fn new(name: &'a str) -> Self {
+        ModuleName(name)
+    }
+
+    pub const fn as_str(&'a self) -> &'a str {
+        self.0
+    }
+}
+
+#[derive(Debug)]
+pub enum ModuleNameEnum<'a> {
+    /// A filename
+    App(StrLiteral<'a>),
+    Interface(ModuleName<'a>),
+    Hosted(ModuleName<'a>),
+    Platform,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+pub struct ExposedName<'a>(&'a str);
+
+impl<'a> From<ExposedName<'a>> for &'a str {
+    fn from(name: ExposedName<'a>) -> Self {
+        name.0
+    }
+}
+
+impl<'a> ExposedName<'a> {
+    pub const fn new(name: &'a str) -> Self {
+        ExposedName(name)
+    }
+
+    pub fn as_str(&'a self) -> &'a str {
+        self.0
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct InterfaceHeader<'a> {
+    pub name: Loc<ModuleName<'a>>,
+    pub exposes: Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+    pub imports: Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>,
+
+    // Potential comments and newlines - these will typically all be empty.
+    pub before_header: &'a [CommentOrNewline<'a>],
+    pub after_interface_keyword: &'a [CommentOrNewline<'a>],
+    pub before_exposes: &'a [CommentOrNewline<'a>],
+    pub after_exposes: &'a [CommentOrNewline<'a>],
+    pub before_imports: &'a [CommentOrNewline<'a>],
+    pub after_imports: &'a [CommentOrNewline<'a>],
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct HostedHeader<'a> {
+    pub name: Loc<ModuleName<'a>>,
+    pub exposes: Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+    pub imports: Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>,
+    pub generates: UppercaseIdent<'a>,
+    pub generates_with: Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+
+    // Potential comments and newlines - these will typically all be empty.
+    pub before_header: &'a [CommentOrNewline<'a>],
+    pub after_hosted_keyword: &'a [CommentOrNewline<'a>],
+    pub before_exposes: &'a [CommentOrNewline<'a>],
+    pub after_exposes: &'a [CommentOrNewline<'a>],
+    pub before_imports: &'a [CommentOrNewline<'a>],
+    pub after_imports: &'a [CommentOrNewline<'a>],
+    pub before_generates: &'a [CommentOrNewline<'a>],
+    pub after_generates: &'a [CommentOrNewline<'a>],
+    pub before_with: &'a [CommentOrNewline<'a>],
+    pub after_with: &'a [CommentOrNewline<'a>],
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum To<'a> {
+    ExistingPackage(&'a str),
+    NewPackage(PackageName<'a>),
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct AppHeader<'a> {
+    pub name: Loc<StrLiteral<'a>>,
+    pub packages: Collection<'a, Loc<Spaced<'a, PackageEntry<'a>>>>,
+    pub imports: Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>,
+    pub provides: Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+    pub provides_types: Option<Collection<'a, Loc<Spaced<'a, UppercaseIdent<'a>>>>>,
+    pub to: Loc<To<'a>>,
+
+    // Potential comments and newlines - these will typically all be empty.
+    pub before_header: &'a [CommentOrNewline<'a>],
+    pub after_app_keyword: &'a [CommentOrNewline<'a>],
+    pub before_packages: &'a [CommentOrNewline<'a>],
+    pub after_packages: &'a [CommentOrNewline<'a>],
+    pub before_imports: &'a [CommentOrNewline<'a>],
+    pub after_imports: &'a [CommentOrNewline<'a>],
+    pub before_provides: &'a [CommentOrNewline<'a>],
+    pub after_provides: &'a [CommentOrNewline<'a>],
+    pub before_to: &'a [CommentOrNewline<'a>],
+    pub after_to: &'a [CommentOrNewline<'a>],
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct PackageHeader<'a> {
+    pub name: Loc<PackageName<'a>>,
+    pub exposes: Vec<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+    pub packages: Vec<'a, (Loc<&'a str>, Loc<PackageName<'a>>)>,
+    pub imports: Vec<'a, Loc<ImportsEntry<'a>>>,
+
+    // Potential comments and newlines - these will typically all be empty.
+    pub before_header: &'a [CommentOrNewline<'a>],
+    pub after_package_keyword: &'a [CommentOrNewline<'a>],
+    pub before_exposes: &'a [CommentOrNewline<'a>],
+    pub after_exposes: &'a [CommentOrNewline<'a>],
+    pub before_packages: &'a [CommentOrNewline<'a>],
+    pub after_packages: &'a [CommentOrNewline<'a>],
+    pub before_imports: &'a [CommentOrNewline<'a>],
+    pub after_imports: &'a [CommentOrNewline<'a>],
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct PlatformRequires<'a> {
+    pub rigids: Collection<'a, Loc<Spaced<'a, UppercaseIdent<'a>>>>,
+    pub signature: Loc<Spaced<'a, TypedIdent<'a>>>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct PlatformHeader<'a> {
+    pub name: Loc<PackageName<'a>>,
+    pub requires: PlatformRequires<'a>,
+    pub exposes: Collection<'a, Loc<Spaced<'a, ModuleName<'a>>>>,
+    pub packages: Collection<'a, Loc<Spaced<'a, PackageEntry<'a>>>>,
+    pub imports: Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>,
+    pub provides: Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+
+    // Potential comments and newlines - these will typically all be empty.
+    pub before_header: &'a [CommentOrNewline<'a>],
+    pub after_platform_keyword: &'a [CommentOrNewline<'a>],
+    pub before_requires: &'a [CommentOrNewline<'a>],
+    pub after_requires: &'a [CommentOrNewline<'a>],
+    pub before_exposes: &'a [CommentOrNewline<'a>],
+    pub after_exposes: &'a [CommentOrNewline<'a>],
+    pub before_packages: &'a [CommentOrNewline<'a>],
+    pub after_packages: &'a [CommentOrNewline<'a>],
+    pub before_imports: &'a [CommentOrNewline<'a>],
+    pub after_imports: &'a [CommentOrNewline<'a>],
+    pub before_provides: &'a [CommentOrNewline<'a>],
+    pub after_provides: &'a [CommentOrNewline<'a>],
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum ImportsEntry<'a> {
+    /// e.g. `Task` or `Task.{ Task, after }`
+    Module(
+        ModuleName<'a>,
+        Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+    ),
+
+    /// e.g. `pf.Task` or `pf.Task.{ after }` or `pf.{ Task.{ Task, after } }`
+    Package(
+        &'a str,
+        ModuleName<'a>,
+        Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+    ),
+}
+
+/// e.g.
+///
+/// printLine : Str -> Effect {}
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct TypedIdent<'a> {
+    pub ident: Loc<&'a str>,
+    pub spaces_before_colon: &'a [CommentOrNewline<'a>],
+    pub ann: Loc<TypeAnnotation<'a>>,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct PackageEntry<'a> {
+    pub shorthand: &'a str,
+    pub spaces_after_shorthand: &'a [CommentOrNewline<'a>],
+    pub package_name: Loc<PackageName<'a>>,
+}
+
+pub fn package_entry<'a>() -> impl Parser<'a, Spaced<'a, PackageEntry<'a>>, EPackageEntry<'a>> {
+    move |arena, state| {
+        // You may optionally have a package shorthand,
+        // e.g. "uc" in `uc: roc/unicode 1.0.0`
+        //
+        // (Indirect dependencies don't have a shorthand.)
+        let min_indent = 1;
+
+        let (_, opt_shorthand, state) = maybe!(and!(
+            skip_second!(
+                specialize(|_, pos| EPackageEntry::Shorthand(pos), lowercase_ident()),
+                word1(b':', EPackageEntry::Colon)
+            ),
+            space0_e(min_indent, EPackageEntry::IndentPackage)
+        ))
+        .parse(arena, state)?;
+
+        let (_, package_or_path, state) =
+            loc!(specialize(EPackageEntry::BadPackage, package_name())).parse(arena, state)?;
+
+        let entry = match opt_shorthand {
+            Some((shorthand, spaces_after_shorthand)) => PackageEntry {
+                shorthand,
+                spaces_after_shorthand,
+                package_name: package_or_path,
+            },
+            None => PackageEntry {
+                shorthand: "",
+                spaces_after_shorthand: &[],
+                package_name: package_or_path,
+            },
+        };
+
+        Ok((MadeProgress, Spaced::Item(entry), state))
+    }
+}
+
+pub fn package_name<'a>() -> impl Parser<'a, PackageName<'a>, EPackageName<'a>> {
+    move |arena, state: State<'a>| {
+        let pos = state.pos();
+        specialize(EPackageName::BadPath, string_literal::parse())
+            .parse(arena, state)
+            .and_then(|(progress, text, next_state)| match text {
+                StrLiteral::PlainLine(text) => Ok((progress, PackageName(text), next_state)),
+                StrLiteral::Line(_) => Err((progress, EPackageName::Escapes(pos), next_state)),
+                StrLiteral::Block(_) => Err((progress, EPackageName::Multiline(pos), next_state)),
+            })
+    }
+}