language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-26 13:29:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Parse and format import package shorthand

Browse source 
The original proposal [1] suggested dropping the package shorthand,
but we later decided to keep it [2] to improve UX.

[1] https://docs.google.com/document/d/1E_77fO-44BtoBtXoVeWyGh1xN2KRTWTu8q6i25RNNx0/edit?usp=sharing
[2] 385104011
This commit is contained in:
Agus Zubiaga 2023-12-06 21:39:00 -03:00
parent c56091ee3e
commit 65ce811587
No known key found for this signature in database
15 changed files with 349 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

64
crates/compiler/fmt/src/def.rs
View file

@ -4,10 +4,11 @@ use crate::pattern::fmt_pattern;
use crate::spaces::{fmt_default_newline, fmt_default_spaces, fmt_spaces, INDENT};
use crate::Buf;
use roc_parse::ast::{
AbilityMember, Collection, CommentOrNewline, Defs, Expr, ExtractSpaces, Pattern, Spaced,
Spaces, StrLiteral, TypeAnnotation, TypeDef, TypeHeader, ValueDef,
AbilityMember, Collection, CommentOrNewline, Defs, Expr, ExtractSpaces, ImportAlias,
ImportedModuleName, Pattern, Spaced, Spaces, StrLiteral, TypeAnnotation, TypeDef, TypeHeader,
ValueDef,
};
use roc_parse::header::{ExposedName, ModuleName};
use roc_parse::header::ExposedName;
use roc_region::all::Loc;
/// A Located formattable value is also formattable
@ -185,6 +186,48 @@ impl<'a> Formattable for TypeHeader<'a> {
}
}
impl<'a> Formattable for ImportedModuleName<'a> {
fn is_multiline(&self) -> bool {
// No newlines in module name itself.
false
}
fn format_with_options(
&self,
buf: &mut Buf,
_parens: Parens,
_newlines: Newlines,
indent: u16,
) {
buf.indent(indent);
if let Some(package_shorthand) = self.package {
buf.push_str(package_shorthand);
buf.push_str(".");
}
buf.push_str(self.name);
}
}
impl<'a> Formattable for ImportAlias<'a> {
fn is_multiline(&self) -> bool {
// No newlines in alias itself.
false
}
fn format_with_options(
&self,
buf: &mut Buf,
_parens: Parens,
_newlines: Newlines,
indent: u16,
) {
buf.indent(indent);
buf.push_str(self.as_str());
}
}
impl<'a> Formattable for ValueDef<'a> {
fn is_multiline(&self) -> bool {
use roc_parse::ast::ValueDef::*;
@ -256,7 +299,7 @@ impl<'a> Formattable for ValueDef<'a> {
} => {
buf.indent(indent);
buf.push_str("import");
fmt_import_body(buf, &name, &alias, &exposed, indent + INDENT);
fmt_import_body(buf, name, alias, exposed, indent + INDENT);
}
}
}
@ -264,19 +307,18 @@ impl<'a> Formattable for ValueDef<'a> {
fn fmt_import_body<'a>(
buf: &mut Buf,
name: &'a Loc<Spaced<'a, ModuleName>>,
alias: &'a Option<Loc<Spaced<'a, ModuleName>>>,
name: &'a Loc<Spaced<'a, ImportedModuleName<'a>>>,
alias: &'a Option<Loc<Spaced<'a, ImportAlias<'a>>>>,
exposed: &'a Option<(
&[CommentOrNewline<'a>],
Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
)>,
indent: u16,
) -> () {
) {
let name_spaces = name.extract_spaces();
fmt_default_spaces(buf, name_spaces.before, indent);
buf.indent(indent);
buf.push_str(name.value.item().as_str());
name.value.item().format(buf, indent);
fmt_default_spaces(buf, name_spaces.after, indent);
@ -291,9 +333,7 @@ fn fmt_import_body<'a>(
buf.push_str("as");
fmt_default_spaces(buf, alias_spaces.before, indent + INDENT);
buf.indent(indent + INDENT);
buf.push_str(alias_name.value.item().as_str());
alias_name.value.item().format(buf, indent + INDENT);
fmt_default_spaces(buf, alias_spaces.after, indent);

23
crates/compiler/fmt/src/spaces.rs
View file

@ -4,9 +4,9 @@ use roc_module::called_via::{BinOp, UnaryOp};
use roc_parse::{
ast::{
AbilityImpls, AbilityMember, AssignedField, Collection, CommentOrNewline, Defs, Expr,
Header, Implements, ImplementsAbilities, ImplementsAbility, ImplementsClause, Module,
Pattern, PatternAs, RecordBuilderField, Spaced, Spaces, StrLiteral, StrSegment, Tag,
TypeAnnotation, TypeDef, TypeHeader, ValueDef, WhenBranch,
Header, Implements, ImplementsAbilities, ImplementsAbility, ImplementsClause, ImportAlias,
ImportedModuleName, Module, Pattern, PatternAs, RecordBuilderField, Spaced, Spaces,
StrLiteral, StrSegment, Tag, TypeAnnotation, TypeDef, TypeHeader, ValueDef, WhenBranch,
},
header::{
AppHeader, ExposedName, HostedHeader, ImportsEntry, InterfaceHeader, KeywordItem,
@ -571,7 +571,7 @@ impl<'a> RemoveSpaces<'a> for ValueDef<'a> {
exposed,
} => ModuleImport {
name: name.remove_spaces(arena),
alias: alias.map(|alias_name| alias_name.remove_spaces(arena)),
alias: alias.remove_spaces(arena),
exposed: if let Some((spaces, exposed)) = exposed {
Some((spaces, exposed.remove_spaces(arena)))
} else {
@ -582,6 +582,21 @@ impl<'a> RemoveSpaces<'a> for ValueDef<'a> {
}
}
impl<'a> RemoveSpaces<'a> for ImportedModuleName<'a> {
fn remove_spaces(&self, arena: &'a Bump) -> Self {
ImportedModuleName {
package: self.package.remove_spaces(arena),
name: self.name.remove_spaces(arena),
}
}
}
impl<'a> RemoveSpaces<'a> for ImportAlias<'a> {
fn remove_spaces(&self, _arena: &'a Bump) -> Self {
*self
}
}
impl<'a> RemoveSpaces<'a> for Implements<'a> {
fn remove_spaces(&self, _arena: &'a Bump) -> Self {
Implements::Implements

32
crates/compiler/parse/src/ast.rs
View file

@ -458,8 +458,8 @@ pub enum ValueDef<'a> {
/// e.g. `import InternalHttp as Http exposing [Req]`.
ModuleImport {
name: Loc<Spaced<'a, crate::header::ModuleName<'a>>>,
alias: Option<Loc<Spaced<'a, crate::header::ModuleName<'a>>>>,
name: Loc<Spaced<'a, ImportedModuleName<'a>>>,
alias: Option<Loc<Spaced<'a, ImportAlias<'a>>>>,
exposed: Option<(
&'a [CommentOrNewline<'a>],
Collection<'a, Loc<Spaced<'a, crate::header::ExposedName<'a>>>>,
@ -467,6 +467,25 @@ pub enum ValueDef<'a> {
},
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ImportedModuleName<'a> {
pub package: Option<&'a str>,
pub name: &'a str,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ImportAlias<'a>(&'a str);
impl<'a> ImportAlias<'a> {
pub const fn new(name: &'a str) -> Self {
ImportAlias(name)
}
pub const fn as_str(&'a self) -> &'a str {
self.0
}
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Defs<'a> {
pub tags: std::vec::Vec<EitherIndex<TypeDef<'a>, ValueDef<'a>>>,
@ -1803,13 +1822,10 @@ impl<'a> Malformed for ValueDef<'a> {
preceding_comment: _,
} => condition.is_malformed(),
ValueDef::ModuleImport {
name,
alias,
name: _,
alias: _,
exposed: _,
} => {
name.value.item().contains_dot()
|| alias.map_or(false, |x| x.value.item().contains_dot())
}
} => false,
}
}
}

53
crates/compiler/parse/src/expr.rs
View file

@ -1,14 +1,15 @@
use crate::ast::{
AssignedField, Collection, CommentOrNewline, Defs, Expr, ExtractSpaces, Implements,
ImplementsAbilities, Pattern, RecordBuilderField, Spaceable, Spaced, Spaces, TypeAnnotation,
TypeDef, TypeHeader, ValueDef,
ImplementsAbilities, ImportAlias, ImportedModuleName, Pattern, RecordBuilderField, Spaceable,
Spaced, Spaces, TypeAnnotation, TypeDef, TypeHeader, ValueDef,
};
use crate::blankspace::{
space0_after_e, space0_around_e_no_after_indent_check, space0_around_ee, space0_before_e,
space0_before_optional_after, space0_e, spaces, spaces_around, spaces_before,
};
use crate::ident::{
integer_ident, lowercase_ident, parse_ident, unqualified_ident, Accessor, Ident,
integer_ident, lowercase_ident, parse_ident, unqualified_ident, uppercase_ident, Accessor,
Ident,
};
use crate::keyword;
use crate::parser::{
@ -841,22 +842,16 @@ pub fn parse_single_def<'a>(
fn import<'a>() -> impl Parser<'a, ValueDef<'a>, EImport> {
map!(
skip_first!(
crate::parser::keyword_e(crate::keyword::IMPORT, EImport::Import),
parser::keyword_e(keyword::IMPORT, EImport::Import),
and!(
spaces_around(loc!(map!(
crate::module::module_name_help(EImport::ModuleName),
Spaced::Item
))),
spaces_around(loc!(map!(imported_module_name(), Spaced::Item))),
and!(
optional(skip_first!(
crate::parser::keyword_e(crate::keyword::AS, EImport::As),
spaces_around(loc!(map!(
crate::module::module_name_help(EImport::ModuleName),
Spaced::Item
)))
parser::keyword_e(keyword::AS, EImport::As),
spaces_around(loc!(map!(import_alias(), Spaced::Item)))
)),
optional(skip_first!(
crate::parser::keyword_e(crate::keyword::EXPOSING, EImport::Exposing),
parser::keyword_e(keyword::EXPOSING, EImport::Exposing),
and!(
spaces(),
collection_trailing_sep_e!(
@ -871,16 +866,7 @@ fn import<'a>() -> impl Parser<'a, ValueDef<'a>, EImport> {
)
)
),
|(name, (alias, exposed)): (
Loc<Spaced<'a, crate::header::ModuleName<'a>>>,
(
Option<Loc<Spaced<'a, crate::header::ModuleName<'a>>>>,
Option<(
&'a [CommentOrNewline<'a>],
Collection<'a, Loc<Spaced<'a, crate::header::ExposedName<'a>>>>
)>
)
)| {
|(name, (alias, exposed))| {
ValueDef::ModuleImport {
name,
alias,
@ -890,6 +876,25 @@ fn import<'a>() -> impl Parser<'a, ValueDef<'a>, EImport> {
)
}
#[inline(always)]
fn imported_module_name<'a>() -> impl Parser<'a, ImportedModuleName<'a>, EImport> {
record!(ImportedModuleName {
package: optional(skip_second!(
specialize(|_, pos| EImport::PackageShorthand(pos), lowercase_ident()),
word1(b'.', EImport::PackageShorthandDot)
)),
name: specialize(|_, pos| EImport::ModuleName(pos), uppercase_ident()),
})
}
#[inline(always)]
fn import_alias<'a>() -> impl Parser<'a, ImportAlias<'a>, EImport> {
map!(
specialize(|_, pos| EImport::Alias(pos), uppercase_ident()),
ImportAlias::new
)
}
#[inline(always)]
fn import_exposed_name<'a>(
) -> impl Parser<'a, crate::ast::Spaced<'a, crate::header::ExposedName<'a>>, EImport> {

4
crates/compiler/parse/src/header.rs
View file

@ -128,10 +128,6 @@ impl<'a> ModuleName<'a> {
pub const fn as_str(&'a self) -> &'a str {
self.0
}
pub fn contains_dot(&self) -> bool {
self.0.contains('.')
}
}
#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]

2
crates/compiler/parse/src/module.rs
View file

@ -590,7 +590,7 @@ fn shortname<'a>() -> impl Parser<'a, &'a str, EImports> {
specialize(|_, pos| EImports::Shorthand(pos), lowercase_ident())
}
pub fn module_name_help<'a, F, E>(to_expectation: F) -> impl Parser<'a, ModuleName<'a>, E>
fn module_name_help<'a, F, E>(to_expectation: F) -> impl Parser<'a, ModuleName<'a>, E>
where
F: Fn(Position) -> E,
E: 'a,

2
crates/compiler/parse/src/parser.rs
View file

@ -522,6 +522,8 @@ pub enum EExpect<'a> {
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EImport {
Import(Position),
PackageShorthand(Position),
PackageShorthandDot(Position),
ModuleName(Position),
As(Position),
Alias(Position),

7
crates/compiler/test_syntax/tests/snapshots/pass/import.moduledefs.result-ast
View file

@ -15,9 +15,10 @@ Defs {
type_defs: [],
value_defs: [
ModuleImport {
name: @8-12 ModuleName(
"Json",
),
name: @8-12 ImportedModuleName {
package: None,
name: "Json",
},
alias: None,
exposed: None,
},

12
crates/compiler/test_syntax/tests/snapshots/pass/import_from_package.moduledefs.formatted.roc Normal file
View file

@ -0,0 +1,12 @@
import json.Decode
import json.Decode as JD
import json.Decode exposing [
Decoder,
map,
]
import json.Decode as JD exposing [
Decoder,
map,
]

124
crates/compiler/test_syntax/tests/snapshots/pass/import_from_package.moduledefs.result-ast Normal file
View file

@ -0,0 +1,124 @@
Defs {
tags: [
Index(2147483648),
Index(2147483649),
Index(2147483650),
Index(2147483651),
],
regions: [
@0-20,
@20-45,
@45-92,
@93-146,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 0),
Slice(start = 0, length = 0),
Slice(start = 0, length = 1),
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 0),
Slice(start = 0, length = 0),
Slice(start = 1, length = 0),
],
spaces: [
Newline,
],
type_defs: [],
value_defs: [
ModuleImport {
name: @8-19 SpaceAfter(
ImportedModuleName {
package: Some(
"json",
),
name: "Decode",
},
[
Newline,
],
),
alias: None,
exposed: None,
},
ModuleImport {
name: @27-38 ImportedModuleName {
package: Some(
"json",
),
name: "Decode",
},
alias: Some(
@42-44 SpaceAfter(
ImportAlias(
"JD",
),
[
Newline,
],
),
),
exposed: None,
},
ModuleImport {
name: @52-63 ImportedModuleName {
package: Some(
"json",
),
name: "Decode",
},
alias: None,
exposed: Some(
(
[],
[
@74-81 ExposedName(
"Decoder",
),
@88-91 SpaceBefore(
ExposedName(
"map",
),
[
Newline,
],
),
],
),
),
},
ModuleImport {
name: @100-111 ImportedModuleName {
package: Some(
"json",
),
name: "Decode",
},
alias: Some(
@115-117 ImportAlias(
"JD",
),
),
exposed: Some(
(
[],
[
@128-135 ExposedName(
"Decoder",
),
@142-145 SpaceBefore(
ExposedName(
"map",
),
[
Newline,
],
),
],
),
),
},
],
}

6
crates/compiler/test_syntax/tests/snapshots/pass/import_from_package.moduledefs.roc Normal file
View file

@ -0,0 +1,6 @@
import json.Decode
import json.Decode as JD
import json.Decode exposing [Decoder,
map]
import json.Decode as JD exposing [Decoder,
map]

18
crates/compiler/test_syntax/tests/snapshots/pass/import_with_alias.moduledefs.result-ast
View file

@ -19,12 +19,13 @@ Defs {
type_defs: [],
value_defs: [
ModuleImport {
name: @7-17 ModuleName(
"JsonEncode",
),
name: @7-17 ImportedModuleName {
package: None,
name: "JsonEncode",
},
alias: Some(
@21-23 SpaceAfter(
ModuleName(
ImportAlias(
"JE",
),
[
@ -35,11 +36,12 @@ Defs {
exposed: None,
},
ModuleImport {
name: @31-42 ModuleName(
"BytesDecode",
),
name: @31-42 ImportedModuleName {
package: None,
name: "BytesDecode",
},
alias: Some(
@47-49 ModuleName(
@47-49 ImportAlias(
"BD",
),
),

95
crates/compiler/test_syntax/tests/snapshots/pass/import_with_comments.moduledefs.result-ast
View file

@ -75,9 +75,10 @@ Defs {
value_defs: [
ModuleImport {
name: @25-29 SpaceBefore(
ModuleName(
"Json",
),
ImportedModuleName {
package: None,
name: "Json",
},
[
Newline,
LineComment(
@ -86,7 +87,7 @@ Defs {
],
),
alias: Some(
@33-34 ModuleName(
@33-34 ImportAlias(
"J",
),
),
@ -103,9 +104,10 @@ Defs {
},
ModuleImport {
name: @58-62 SpaceAfter(
ModuleName(
"Json",
),
ImportedModuleName {
package: None,
name: "Json",
},
[
Newline,
LineComment(
@ -114,7 +116,7 @@ Defs {
],
),
alias: Some(
@84-85 ModuleName(
@84-85 ImportAlias(
"J",
),
),
@ -130,13 +132,14 @@ Defs {
),
},
ModuleImport {
name: @109-113 ModuleName(
"Json",
),
name: @109-113 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
@135-136 SpaceBefore(
SpaceAfter(
ModuleName(
ImportAlias(
"J",
),
[
@ -155,12 +158,13 @@ Defs {
exposed: None,
},
ModuleImport {
name: @145-149 ModuleName(
"Json",
),
name: @145-149 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
@171-172 SpaceBefore(
ModuleName(
ImportAlias(
"J",
),
[
@ -183,12 +187,13 @@ Defs {
),
},
ModuleImport {
name: @196-200 ModuleName(
"Json",
),
name: @196-200 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
@222-223 SpaceBefore(
ModuleName(
ImportAlias(
"J",
),
[
@ -220,9 +225,10 @@ Defs {
},
ModuleImport {
name: @261-265 SpaceAfter(
ModuleName(
"Json",
),
ImportedModuleName {
package: None,
name: "Json",
},
[
Newline,
LineComment(
@ -251,12 +257,13 @@ Defs {
),
},
ModuleImport {
name: @321-325 ModuleName(
"Json",
),
name: @321-325 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
@329-330 SpaceAfter(
ModuleName(
ImportAlias(
"J",
),
[
@ -279,9 +286,10 @@ Defs {
),
},
ModuleImport {
name: @372-376 ModuleName(
"Json",
),
name: @372-376 ImportedModuleName {
package: None,
name: "Json",
},
alias: None,
exposed: Some(
(
@ -300,11 +308,12 @@ Defs {
),
},
ModuleImport {
name: @418-422 ModuleName(
"Json",
),
name: @418-422 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
@426-427 ModuleName(
@426-427 ImportAlias(
"J",
),
),
@ -325,11 +334,12 @@ Defs {
),
},
ModuleImport {
name: @469-473 ModuleName(
"Json",
),
name: @469-473 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
@477-478 ModuleName(
@477-478 ImportAlias(
"J",
),
),
@ -360,9 +370,10 @@ Defs {
ModuleImport {
name: @542-546 SpaceBefore(
SpaceAfter(
ModuleName(
"Json",
),
ImportedModuleName {
package: None,
name: "Json",
},
[
Newline,
LineComment(
@ -380,7 +391,7 @@ Defs {
alias: Some(
@590-591 SpaceBefore(
SpaceAfter(
ModuleName(
ImportAlias(
"J",
),
[

21
crates/compiler/test_syntax/tests/snapshots/pass/import_with_exposed.moduledefs.result-ast
View file

@ -26,9 +26,10 @@ Defs {
type_defs: [],
value_defs: [
ModuleImport {
name: @7-11 ModuleName(
"Json",
),
name: @7-11 ImportedModuleName {
package: None,
name: "Json",
},
alias: None,
exposed: Some(
(
@ -45,9 +46,10 @@ Defs {
),
},
ModuleImport {
name: @43-47 ModuleName(
"Json",
),
name: @43-47 ImportedModuleName {
package: None,
name: "Json",
},
alias: None,
exposed: Some(
(
@ -69,9 +71,10 @@ Defs {
),
},
ModuleImport {
name: @83-87 ModuleName(
"Json",
),
name: @83-87 ImportedModuleName {
package: None,
name: "Json",
},
alias: None,
exposed: Some(
(

1
crates/compiler/test_syntax/tests/test_snapshots.rs
View file

@ -325,6 +325,7 @@ mod test_snapshots {
pass/highest_int.expr,
pass/if_def.expr,
pass/import.moduledefs,
pass/import_from_package.moduledefs,
pass/import_with_alias.moduledefs,
pass/import_with_comments.moduledefs,
pass/import_with_exposed.moduledefs,