Add Task as a built-in module/type

crates/compiler/parse/src/header.rs

@@ -7,7 +7,7 @@ use crate::ident::{lowercase_ident, UppercaseIdent};
 use crate::parser::{byte, specialize_err, EPackageEntry, EPackageName, Parser};
 use crate::parser::{optional, then};
 use crate::string_literal;
-use roc_module::symbol::{ModuleId, Symbol};
+use roc_module::symbol::ModuleId;
 use roc_region::all::Loc;
 use std::fmt::Debug;
 
@@ -44,14 +44,11 @@ pub enum HeaderType<'a> {
     Hosted {
         name: ModuleName<'a>,
         exposes: &'a [Loc<ExposedName<'a>>],
-        generates: UppercaseIdent<'a>,
-        generates_with: &'a [Loc<ExposedName<'a>>],
     },
     /// Only created during canonicalization, never actually parsed from source
     Builtin {
         name: ModuleName<'a>,
         exposes: &'a [Loc<ExposedName<'a>>],
-        generates_with: &'a [Symbol],
     },
     Package {
         /// usually something other than `pf`
@@ -101,11 +98,9 @@ impl<'a> HeaderType<'a> {
 
     pub fn to_maybe_builtin(self, module_id: ModuleId) -> Self {
         match self {
-            HeaderType::Module { name, exposes } if module_id.is_builtin() => HeaderType::Builtin {
-                name,
-                exposes,
-                generates_with: &[],
-            },
+            HeaderType::Module { name, exposes } if module_id.is_builtin() => {
+                HeaderType::Builtin { name, exposes }
+            }
             _ => self,
         }
     }
@@ -222,8 +217,6 @@ macro_rules! keywords {
 
 keywords! {
     ExposesKeyword => "exposes",
-    WithKeyword => "with",
-    GeneratesKeyword => "generates",
     PackageKeyword => "package",
     PackagesKeyword => "packages",
     RequiresKeyword => "requires",
@@ -267,10 +260,6 @@ pub struct HostedHeader<'a> {
     pub exposes: KeywordItem<'a, ExposesKeyword, Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>>,
 
     pub imports: KeywordItem<'a, ImportsKeyword, Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>>,
-
-    pub generates: KeywordItem<'a, GeneratesKeyword, UppercaseIdent<'a>>,
-    pub generates_with:
-        KeywordItem<'a, WithKeyword, Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>>,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -349,7 +338,7 @@ pub enum ImportsEntry<'a> {
 
 /// e.g.
 ///
-/// printLine : Str -> Effect {}
+/// printLine : Str -> Result {} *
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub struct TypedIdent<'a> {
     pub ident: Loc<&'a str>,

crates/compiler/parse/src/highlight.rs

@@ -365,7 +365,7 @@ fn fast_forward_to(
     tokens.push(Loc::at(Region::between(start, state.pos()), Token::Error));
 }
 
-pub const HEADER_KEYWORDS: [&str; 14] = [
+pub const HEADER_KEYWORDS: [&str; 12] = [
     "interface",
     "app",
     "package",
@@ -373,8 +373,6 @@ pub const HEADER_KEYWORDS: [&str; 14] = [
     "hosted",
     "exposes",
     "imports",
-    "with",
-    "generates",
     "package",
     "packages",
     "requires",

crates/compiler/parse/src/module.rs

@@ -2,18 +2,18 @@ use crate::ast::{Collection, CommentOrNewline, Defs, Header, Module, Spaced, Spa
 use crate::blankspace::{space0_around_ee, space0_before_e, space0_e};
 use crate::expr::merge_spaces;
 use crate::header::{
-    package_entry, package_name, AppHeader, ExposedName, ExposesKeyword, GeneratesKeyword,
-    HostedHeader, ImportsCollection, ImportsEntry, ImportsKeyword, ImportsKeywordItem, Keyword,
-    KeywordItem, ModuleHeader, ModuleName, ModuleParams, PackageEntry, PackageHeader,
-    PackagesKeyword, PlatformHeader, PlatformRequires, ProvidesKeyword, ProvidesTo,
-    RequiresKeyword, To, ToKeyword, TypedIdent, WithKeyword,
+    package_entry, package_name, AppHeader, ExposedName, ExposesKeyword, HostedHeader,
+    ImportsCollection, ImportsEntry, ImportsKeyword, ImportsKeywordItem, Keyword, KeywordItem,
+    ModuleHeader, ModuleName, ModuleParams, PackageEntry, PackageHeader, PackagesKeyword,
+    PlatformHeader, PlatformRequires, ProvidesKeyword, ProvidesTo, RequiresKeyword, To, ToKeyword,
+    TypedIdent,
 };
-use crate::ident::{self, lowercase_ident, unqualified_ident, uppercase, UppercaseIdent};
+use crate::ident::{self, lowercase_ident, unqualified_ident, UppercaseIdent};
 use crate::parser::Progress::{self, *};
 use crate::parser::{
     backtrackable, byte, increment_min_indent, optional, reset_min_indent, specialize_err,
-    two_bytes, EExposes, EGenerates, EGeneratesWith, EHeader, EImports, EPackages, EParams,
-    EProvides, ERequires, ETypedIdent, Parser, SourceError, SpaceProblem, SyntaxError,
+    two_bytes, EExposes, EHeader, EImports, EPackages, EParams, EProvides, ERequires, ETypedIdent,
+    Parser, SourceError, SpaceProblem, SyntaxError,
 };
 use crate::pattern::record_pattern_fields;
 use crate::state::State;
@@ -186,8 +186,6 @@ fn hosted_header<'a>() -> impl Parser<'a, HostedHeader<'a>, EHeader<'a>> {
         name: loc!(module_name_help(EHeader::ModuleName)),
         exposes: specialize_err(EHeader::Exposes, exposes_values_kw()),
         imports: specialize_err(EHeader::Imports, imports()),
-        generates: specialize_err(EHeader::Generates, generates()),
-        generates_with: specialize_err(EHeader::GeneratesWith, generates_with()),
     })
     .trace("hosted_header")
 }
@@ -758,43 +756,6 @@ fn packages_collection<'a>(
     )
 }
 
-#[inline(always)]
-fn generates<'a>(
-) -> impl Parser<'a, KeywordItem<'a, GeneratesKeyword, UppercaseIdent<'a>>, EGenerates> {
-    record!(KeywordItem {
-        keyword: spaces_around_keyword(
-            GeneratesKeyword,
-            EGenerates::Generates,
-            EGenerates::IndentGenerates,
-            EGenerates::IndentTypeStart
-        ),
-        item: specialize_err(|(), pos| EGenerates::Identifier(pos), uppercase())
-    })
-}
-
-#[inline(always)]
-fn generates_with<'a>() -> impl Parser<
-    'a,
-    KeywordItem<'a, WithKeyword, Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>>,
-    EGeneratesWith,
-> {
-    record!(KeywordItem {
-        keyword: spaces_around_keyword(
-            WithKeyword,
-            EGeneratesWith::With,
-            EGeneratesWith::IndentWith,
-            EGeneratesWith::IndentListStart
-        ),
-        item: collection_trailing_sep_e!(
-            byte(b'[', EGeneratesWith::ListStart),
-            exposes_entry(EGeneratesWith::Identifier),
-            byte(b',', EGeneratesWith::ListEnd),
-            byte(b']', EGeneratesWith::ListEnd),
-            Spaced::SpaceBefore
-        )
-    })
-}
-
 #[inline(always)]
 fn imports<'a>() -> impl Parser<
     'a,
@@ -823,7 +784,7 @@ fn imports<'a>() -> impl Parser<
 pub fn typed_ident<'a>() -> impl Parser<'a, Spaced<'a, TypedIdent<'a>>, ETypedIdent<'a>> {
     // e.g.
     //
-    // printLine : Str -> Effect {}
+    // printLine : Str -> Task {} *
     map!(
         and!(
             and!(

crates/compiler/parse/src/parser.rs

@@ -83,8 +83,6 @@ impl_space_problem! {
     EExpect<'a>,
     EExposes,
     EExpr<'a>,
-    EGenerates,
-    EGeneratesWith,
     EHeader<'a>,
     EIf<'a>,
     EImport<'a>,
@@ -122,8 +120,6 @@ pub enum EHeader<'a> {
     Imports(EImports, Position),
     Requires(ERequires<'a>, Position),
     Packages(EPackages<'a>, Position),
-    Generates(EGenerates, Position),
-    GeneratesWith(EGeneratesWith, Position),
 
     Space(BadInputError, Position),
     Start(Position),
@@ -251,30 +247,6 @@ pub enum EImports {
     StrLiteral(Position),
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum EGenerates {
-    Open(Position),
-    Generates(Position),
-    IndentGenerates(Position),
-    Identifier(Position),
-    Space(BadInputError, Position),
-    IndentTypeStart(Position),
-    IndentTypeEnd(Position),
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum EGeneratesWith {
-    Open(Position),
-    With(Position),
-    IndentWith(Position),
-    IndentListStart(Position),
-    IndentListEnd(Position),
-    ListStart(Position),
-    ListEnd(Position),
-    Identifier(Position),
-    Space(BadInputError, Position),
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BadInputError {
     HasTab,