language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-10-03 08:34:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Extract ModuleImport/IngestedFileImport into structs for reuse

Browse source
This commit is contained in:
Agus Zubiaga 2023-12-26 11:38:18 -03:00
parent 4d6e641864
commit 2d93f0c3f1
No known key found for this signature in database
10 changed files with 917 additions and 816 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -6,7 +6,8 @@ use crate::spaces::{fmt_default_newline, fmt_default_spaces, fmt_spaces, INDENT}
use crate::Buf; use crate::Buf;
use roc_parse::ast::{ use roc_parse::ast::{
AbilityMember, Defs, Expr, ExtractSpaces, ImportAlias, ImportAsKeyword, ImportExposingKeyword, AbilityMember, Defs, Expr, ExtractSpaces, ImportAlias, ImportAsKeyword, ImportExposingKeyword,
ImportedModuleName, Pattern, Spaces, StrLiteral, TypeAnnotation, TypeDef, TypeHeader, ValueDef, ImportedModuleName, IngestedFileImport, ModuleImport, Pattern, Spaces, StrLiteral,
TypeAnnotation, TypeDef, TypeHeader, ValueDef,
}; };
use roc_parse::header::Keyword; use roc_parse::header::Keyword;
use roc_region::all::Loc; use roc_region::all::Loc;
@ -186,6 +187,103 @@ impl<'a> Formattable for TypeHeader<'a> {
} }
} }
impl<'a> Formattable for ModuleImport<'a> {
fn is_multiline(&self) -> bool {
let Self {
before_name,
name,
alias,
exposed,
} = self;
!before_name.is_empty()
|| name.is_multiline()
|| alias.map_or(false, |a| a.is_multiline())
|| exposed.map_or(false, |a| {
a.keyword.is_multiline() || is_collection_multiline(&a.item)
})
}
fn format_with_options(
&self,
buf: &mut Buf,
_parens: Parens,
_newlines: Newlines,
indent: u16,
) {
let Self {
before_name,
name,
alias,
exposed,
} = self;
buf.indent(indent);
buf.push_str("import");
let indent = indent + INDENT;
fmt_default_spaces(buf, before_name, indent);
buf.indent(indent);
name.format(buf, indent);
if let Some(alias) = alias {
alias.format(buf, indent);
}
if let Some(exposed) = exposed {
exposed.keyword.format(buf, indent);
let list_indent = if !before_name.is_empty()
|| alias.is_multiline()
|| exposed.keyword.is_multiline()
{
indent
} else {
// Align list with import keyword
indent - INDENT
};
fmt_collection(buf, list_indent, Braces::Square, exposed.item, Newlines::No);
}
}
}
impl<'a> Formattable for IngestedFileImport<'a> {
fn is_multiline(&self) -> bool {
let Self {
before_path,
path: _,
name,
} = self;
!before_path.is_empty() || name.is_multiline()
}
fn format_with_options(
&self,
buf: &mut Buf,
_parens: Parens,
_newlines: Newlines,
indent: u16,
) {
let Self {
before_path,
path,
name,
} = self;
buf.indent(indent);
buf.push_str("import");
let indent = indent + INDENT;
fmt_default_spaces(buf, before_path, indent);
fmt_str_literal(buf, path.value, indent);
name.format(buf, indent);
}
}
impl<'a> Formattable for ImportedModuleName<'a> { impl<'a> Formattable for ImportedModuleName<'a> {
fn is_multiline(&self) -> bool { fn is_multiline(&self) -> bool {
// No newlines in module name itself. // No newlines in module name itself.
@ -275,24 +373,8 @@ impl<'a> Formattable for ValueDef<'a> {
Expect { condition, .. } => condition.is_multiline(), Expect { condition, .. } => condition.is_multiline(),
ExpectFx { condition, .. } => condition.is_multiline(), ExpectFx { condition, .. } => condition.is_multiline(),
Dbg { condition, .. } => condition.is_multiline(), Dbg { condition, .. } => condition.is_multiline(),
ModuleImport { ModuleImport(module_import) => module_import.is_multiline(),
before_name, IngestedFileImport(ingested_file_import) => ingested_file_import.is_multiline(),
name,
alias,
exposed,
} => {
!before_name.is_empty()
|| name.is_multiline()
|| alias.map_or(false, |a| a.is_multiline())
|| exposed.map_or(false, |a| {
a.keyword.is_multiline() || is_collection_multiline(&a.item)
})
}
IngestedFileImport {
before_path,
path: _,
name,
} => !before_path.is_empty() || name.is_multiline(),
} }
} }
@ -335,56 +417,8 @@ impl<'a> Formattable for ValueDef<'a> {
buf.newline(); buf.newline();
fmt_body(buf, &body_pattern.value, &body_expr.value, indent); fmt_body(buf, &body_pattern.value, &body_expr.value, indent);
} }
ModuleImport { ModuleImport(module_import) => module_import.format(buf, indent),
before_name, IngestedFileImport(ingested_file_import) => ingested_file_import.format(buf, indent),
name,
alias,
exposed,
} => {
buf.indent(indent);
buf.push_str("import");
let indent = indent + INDENT;
fmt_default_spaces(buf, before_name, indent);
buf.indent(indent);
name.format(buf, indent);
if let Some(alias) = alias {
alias.format(buf, indent);
}
if let Some(exposed) = exposed {
exposed.keyword.format(buf, indent);
let list_indent = if !before_name.is_empty()
|| alias.is_multiline()
|| exposed.keyword.is_multiline()
{
indent
} else {
// Align list with import keyword
indent - INDENT
};
fmt_collection(buf, list_indent, Braces::Square, exposed.item, Newlines::No);
}
}
IngestedFileImport {
before_path,
path,
name,
} => {
buf.indent(indent);
buf.push_str("import");
let indent = indent + INDENT;
fmt_default_spaces(buf, before_path, indent);
fmt_str_literal(buf, path.value, indent);
name.format(buf, indent);
}
} }
} }
} }

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

@ -5,9 +5,9 @@ use roc_parse::{
ast::{ ast::{
AbilityImpls, AbilityMember, AssignedField, Collection, CommentOrNewline, Defs, Expr, AbilityImpls, AbilityMember, AssignedField, Collection, CommentOrNewline, Defs, Expr,
Header, Implements, ImplementsAbilities, ImplementsAbility, ImplementsClause, ImportAlias, Header, Implements, ImplementsAbilities, ImplementsAbility, ImplementsClause, ImportAlias,
ImportAsKeyword, ImportExposingKeyword, ImportedModuleName, Module, Pattern, PatternAs, ImportAsKeyword, ImportExposingKeyword, ImportedModuleName, IngestedFileImport, Module,
RecordBuilderField, Spaced, Spaces, StrLiteral, StrSegment, Tag, TypeAnnotation, TypeDef, ModuleImport, Pattern, PatternAs, RecordBuilderField, Spaced, Spaces, StrLiteral,
TypeHeader, ValueDef, WhenBranch, StrSegment, Tag, TypeAnnotation, TypeDef, TypeHeader, ValueDef, WhenBranch,
}, },
header::{ header::{
AppHeader, ExposedName, HostedHeader, ImportsEntry, InterfaceHeader, KeywordItem, AppHeader, ExposedName, HostedHeader, ImportsEntry, InterfaceHeader, KeywordItem,
@ -566,26 +566,31 @@ impl<'a> RemoveSpaces<'a> for ValueDef<'a> {
condition: arena.alloc(condition.remove_spaces(arena)), condition: arena.alloc(condition.remove_spaces(arena)),
preceding_comment: Region::zero(), preceding_comment: Region::zero(),
}, },
ModuleImport { ModuleImport(module_import) => ModuleImport(module_import.remove_spaces(arena)),
before_name: _, IngestedFileImport(ingested_file_import) => {
name, IngestedFileImport(ingested_file_import.remove_spaces(arena))
alias, }
exposed, }
} => ModuleImport { }
before_name: &[], }
name: name.remove_spaces(arena),
alias: alias.remove_spaces(arena), impl<'a> RemoveSpaces<'a> for ModuleImport<'a> {
exposed: exposed.remove_spaces(arena), fn remove_spaces(&self, arena: &'a Bump) -> Self {
}, ModuleImport {
IngestedFileImport { before_name: &[],
before_path: _, name: self.name.remove_spaces(arena),
path, alias: self.alias.remove_spaces(arena),
name, exposed: self.exposed.remove_spaces(arena),
} => IngestedFileImport { }
before_path: &[], }
path: path.remove_spaces(arena), }
name: name.remove_spaces(arena),
}, impl<'a> RemoveSpaces<'a> for IngestedFileImport<'a> {
fn remove_spaces(&self, arena: &'a Bump) -> Self {
IngestedFileImport {
before_path: &[],
path: self.path.remove_spaces(arena),
name: self.name.remove_spaces(arena),
} }
} }
} }

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

@ -459,25 +459,31 @@ pub enum ValueDef<'a> {
}, },
/// e.g. `import InternalHttp as Http exposing [Req]`. /// e.g. `import InternalHttp as Http exposing [Req]`.
ModuleImport { ModuleImport(ModuleImport<'a>),
before_name: &'a [CommentOrNewline<'a>],
name: Loc<ImportedModuleName<'a>>,
alias: Option<header::KeywordItem<'a, ImportAsKeyword, Loc<ImportAlias<'a>>>>,
exposed: Option<
header::KeywordItem<
'a,
ImportExposingKeyword,
Collection<'a, Loc<Spaced<'a, header::ExposedName<'a>>>>,
>,
>,
},
/// e.g. `import "path/to/my/file.txt" as myFile : Str` /// e.g. `import "path/to/my/file.txt" as myFile : Str`
IngestedFileImport { IngestedFileImport(IngestedFileImport<'a>),
before_path: &'a [CommentOrNewline<'a>], }
path: Loc<StrLiteral<'a>>,
name: header::KeywordItem<'a, ImportAsKeyword, Loc<Spaced<'a, header::TypedIdent<'a>>>>, #[derive(Debug, Clone, Copy, PartialEq)]
}, pub struct ModuleImport<'a> {
pub before_name: &'a [CommentOrNewline<'a>],
pub name: Loc<ImportedModuleName<'a>>,
pub alias: Option<header::KeywordItem<'a, ImportAsKeyword, Loc<ImportAlias<'a>>>>,
pub exposed: Option<
header::KeywordItem<
'a,
ImportExposingKeyword,
Collection<'a, Loc<Spaced<'a, header::ExposedName<'a>>>>,
>,
>,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct IngestedFileImport<'a> {
pub before_path: &'a [CommentOrNewline<'a>],
pub path: Loc<StrLiteral<'a>>,
pub name: header::KeywordItem<'a, ImportAsKeyword, Loc<Spaced<'a, header::TypedIdent<'a>>>>,
} }
#[derive(Copy, Clone, PartialEq, Eq, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Debug)]
@ -1848,17 +1854,17 @@ impl<'a> Malformed for ValueDef<'a> {
condition, condition,
preceding_comment: _, preceding_comment: _,
} => condition.is_malformed(), } => condition.is_malformed(),
ValueDef::ModuleImport { ValueDef::ModuleImport(ModuleImport {
before_name: _, before_name: _,
name: _, name: _,
alias: _, alias: _,
exposed: _, exposed: _,
} => false, }) => false,
ValueDef::IngestedFileImport { ValueDef::IngestedFileImport(IngestedFileImport {
before_path: _, before_path: _,
path, path,
name: _, name: _,
} => path.is_malformed(), }) => path.is_malformed(),
} }
} }
} }

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

@ -1,8 +1,8 @@
use crate::ast::{ use crate::ast::{
AssignedField, Collection, CommentOrNewline, Defs, Expr, ExtractSpaces, Implements, AssignedField, Collection, CommentOrNewline, Defs, Expr, ExtractSpaces, Implements,
ImplementsAbilities, ImportAlias, ImportAsKeyword, ImportExposingKeyword, ImportedModuleName, ImplementsAbilities, ImportAlias, ImportAsKeyword, ImportExposingKeyword, ImportedModuleName,
Pattern, RecordBuilderField, Spaceable, Spaced, Spaces, TypeAnnotation, TypeDef, TypeHeader, IngestedFileImport, ModuleImport, Pattern, RecordBuilderField, Spaceable, Spaced, Spaces,
ValueDef, TypeAnnotation, TypeDef, TypeHeader, ValueDef,
}; };
use crate::blankspace::{ use crate::blankspace::{
space0_after_e, space0_around_e_no_after_indent_check, space0_around_ee, space0_before_e, space0_after_e, space0_around_e_no_after_indent_check, space0_around_ee, space0_before_e,
@ -848,12 +848,15 @@ fn import<'a>() -> impl Parser<'a, ValueDef<'a>, EImport<'a>> {
} }
fn import_body<'a>() -> impl Parser<'a, ValueDef<'a>, EImport<'a>> { fn import_body<'a>() -> impl Parser<'a, ValueDef<'a>, EImport<'a>> {
record!(ValueDef::ModuleImport { map!(
before_name: space0_e(EImport::IndentStart), record!(ModuleImport {
name: loc!(imported_module_name()), before_name: space0_e(EImport::IndentStart),
alias: optional(backtrackable(import_as())), name: loc!(imported_module_name()),
exposed: optional(backtrackable(import_exposing())) alias: optional(backtrackable(import_as())),
}) exposed: optional(backtrackable(import_exposing()))
}),
ValueDef::ModuleImport
)
} }
#[inline(always)] #[inline(always)]
@ -922,14 +925,17 @@ fn import_exposed_name<'a>(
#[inline(always)] #[inline(always)]
fn import_ingested_file_body<'a>() -> impl Parser<'a, ValueDef<'a>, EImport<'a>> { fn import_ingested_file_body<'a>() -> impl Parser<'a, ValueDef<'a>, EImport<'a>> {
record!(ValueDef::IngestedFileImport { map!(
before_path: space0_e(EImport::IndentStart), record!(IngestedFileImport {
path: loc!(specialize( before_path: space0_e(EImport::IndentStart),
|_, pos| EImport::IngestedPath(pos), path: loc!(specialize(
string_literal::parse_str_literal() |_, pos| EImport::IngestedPath(pos),
)), string_literal::parse_str_literal()
name: import_ingested_file_as(), )),
}) name: import_ingested_file_as(),
}),
ValueDef::IngestedFileImport
)
} }
#[inline(always)] #[inline(always)]

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

@ -14,14 +14,16 @@ Defs {
spaces: [], spaces: [],
type_defs: [], type_defs: [],
value_defs: [ value_defs: [
ModuleImport { ModuleImport(
before_name: [], ModuleImport {
name: @8-12 ImportedModuleName { before_name: [],
package: None, name: @8-12 ImportedModuleName {
name: "Json", package: None,
name: "Json",
},
alias: None,
exposed: None,
}, },
alias: None, ),
exposed: None,
},
], ],
} }

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

@ -30,113 +30,121 @@ Defs {
], ],
type_defs: [], type_defs: [],
value_defs: [ value_defs: [
ModuleImport { ModuleImport(
before_name: [], ModuleImport {
name: @8-19 ImportedModuleName { before_name: [],
package: Some( name: @8-19 ImportedModuleName {
"json", package: Some(
), "json",
name: "Decode",
},
alias: None,
exposed: None,
},
ModuleImport {
before_name: [],
name: @27-38 ImportedModuleName {
package: Some(
"json",
),
name: "Decode",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @42-44 ImportAlias(
"JD",
), ),
name: "Decode",
}, },
), alias: None,
exposed: None, exposed: None,
},
ModuleImport {
before_name: [],
name: @52-63 ImportedModuleName {
package: Some(
"json",
),
name: "Decode",
}, },
alias: None, ),
exposed: Some( ModuleImport(
KeywordItem { ModuleImport {
keyword: Spaces { before_name: [],
before: [], name: @27-38 ImportedModuleName {
item: ImportExposingKeyword, package: Some(
after: [], "json",
},
item: [
@74-81 ExposedName(
"Decoder",
),
@88-91 SpaceBefore(
ExposedName(
"map",
),
[
Newline,
],
),
],
},
),
},
ModuleImport {
before_name: [],
name: @100-111 ImportedModuleName {
package: Some(
"json",
),
name: "Decode",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @115-117 ImportAlias(
"JD",
), ),
name: "Decode",
}, },
), alias: Some(
exposed: Some( KeywordItem {
KeywordItem { keyword: Spaces {
keyword: Spaces { before: [],
before: [], item: ImportAsKeyword,
item: ImportExposingKeyword, after: [],
after: [], },
item: @42-44 ImportAlias(
"JD",
),
}, },
item: [ ),
@128-135 ExposedName( exposed: None,
"Decoder", },
), ),
@142-145 SpaceBefore( ModuleImport(
ExposedName( ModuleImport {
"map", before_name: [],
), name: @52-63 ImportedModuleName {
[ package: Some(
Newline, "json",
], ),
), name: "Decode",
],
}, },
), alias: None,
}, exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@74-81 ExposedName(
"Decoder",
),
@88-91 SpaceBefore(
ExposedName(
"map",
),
[
Newline,
],
),
],
},
),
},
),
ModuleImport(
ModuleImport {
before_name: [],
name: @100-111 ImportedModuleName {
package: Some(
"json",
),
name: "Decode",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @115-117 ImportAlias(
"JD",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@128-135 ExposedName(
"Decoder",
),
@142-145 SpaceBefore(
ExposedName(
"map",
),
[
Newline,
],
),
],
},
),
},
),
], ],
} }

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

@ -20,45 +20,49 @@ Defs {
], ],
type_defs: [], type_defs: [],
value_defs: [ value_defs: [
ModuleImport { ModuleImport(
before_name: [], ModuleImport {
name: @7-17 ImportedModuleName { before_name: [],
package: None, name: @7-17 ImportedModuleName {
name: "JsonEncode", package: None,
}, name: "JsonEncode",
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @21-23 ImportAlias(
"JE",
),
}, },
), alias: Some(
exposed: None, KeywordItem {
}, keyword: Spaces {
ModuleImport { before: [],
before_name: [], item: ImportAsKeyword,
name: @31-42 ImportedModuleName { after: [],
package: None, },
name: "BytesDecode", item: @21-23 ImportAlias(
}, "JE",
alias: Some( ),
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
}, },
item: @47-49 ImportAlias( ),
"BD", exposed: None,
), },
),
ModuleImport(
ModuleImport {
before_name: [],
name: @31-42 ImportedModuleName {
package: None,
name: "BytesDecode",
}, },
), alias: Some(
exposed: None, KeywordItem {
}, keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @47-49 ImportAlias(
"BD",
),
},
),
exposed: None,
},
),
], ],
} }

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

@ -90,463 +90,489 @@ Defs {
], ],
type_defs: [], type_defs: [],
value_defs: [ value_defs: [
ModuleImport { ModuleImport(
before_name: [ ModuleImport {
Newline, before_name: [
LineComment( Newline,
" comment", LineComment(
" comment",
),
],
name: @25-29 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @33-34 ImportAlias(
"J",
),
},
), ),
], exposed: Some(
name: @25-29 ImportedModuleName { KeywordItem {
package: None, keyword: Spaces {
name: "Json", before: [],
}, item: ImportExposingKeyword,
alias: Some( after: [],
KeywordItem { },
keyword: Spaces { item: [
before: [], @45-48 ExposedName(
item: ImportAsKeyword, "map",
after: [],
},
item: @33-34 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@45-48 ExposedName(
"map",
),
],
},
),
},
ModuleImport {
before_name: [],
name: @58-62 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [
Newline,
LineComment(
" comment",
),
],
item: ImportAsKeyword,
after: [],
},
item: @84-85 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@96-99 ExposedName(
"map",
),
],
},
),
},
ModuleImport {
before_name: [],
name: @109-113 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [
Newline,
LineComment(
" comment",
), ),
], ],
}, },
item: @135-136 ImportAlias( ),
"J",
),
},
),
exposed: None,
},
ModuleImport {
before_name: [],
name: @145-149 ImportedModuleName {
package: None,
name: "Json",
}, },
alias: Some( ),
KeywordItem { ModuleImport(
keyword: Spaces { ModuleImport {
before: [], before_name: [],
item: ImportAsKeyword, name: @58-62 ImportedModuleName {
after: [ package: None,
Newline, name: "Json",
LineComment(
" comment",
),
],
},
item: @171-172 ImportAlias(
"J",
),
}, },
), alias: Some(
exposed: Some( KeywordItem {
KeywordItem { keyword: Spaces {
keyword: Spaces { before: [
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@183-186 ExposedName(
"map",
),
],
},
),
},
ModuleImport {
before_name: [],
name: @196-200 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [
Newline,
LineComment(
" comment",
),
],
},
item: @222-223 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@234-237 ExposedName(
"map",
),
@247-251 SpaceBefore(
ExposedName(
"map2",
),
[
Newline,
],
),
],
},
),
},
ModuleImport {
before_name: [],
name: @261-265 ImportedModuleName {
package: None,
name: "Json",
},
alias: None,
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [
Newline,
LineComment(
" comment",
),
],
item: ImportExposingKeyword,
after: [],
},
item: [
@294-297 ExposedName(
"map",
),
@307-311 SpaceBefore(
ExposedName(
"map2",
),
[
Newline,
],
),
],
},
),
},
ModuleImport {
before_name: [],
name: @321-325 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @329-330 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [
Newline,
LineComment(
" comment",
),
],
item: ImportExposingKeyword,
after: [],
},
item: [
@359-362 ExposedName(
"map",
),
],
},
),
},
ModuleImport {
before_name: [],
name: @372-376 ImportedModuleName {
package: None,
name: "Json",
},
alias: None,
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [
Newline,
LineComment(
" comment",
),
],
},
item: [
@405-408 ExposedName(
"map",
),
],
},
),
},
ModuleImport {
before_name: [],
name: @418-422 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @426-427 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [
Newline,
LineComment(
" comment",
),
],
},
item: [
@456-459 ExposedName(
"map",
),
],
},
),
},
ModuleImport {
before_name: [],
name: @469-473 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @477-478 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@508-511 SpaceBefore(
SpaceAfter(
ExposedName(
"map",
),
[
Newline,
],
),
[
Newline, Newline,
LineComment( LineComment(
" comment", " comment",
), ),
], ],
item: ImportAsKeyword,
after: [],
},
item: @84-85 ImportAlias(
"J",
), ),
], },
}, ),
), exposed: Some(
}, KeywordItem {
ModuleImport { keyword: Spaces {
before_name: [ before: [],
Newline, item: ImportExposingKeyword,
LineComment( after: [],
" comment 1", },
item: [
@96-99 ExposedName(
"map",
),
],
},
), ),
],
name: @542-546 ImportedModuleName {
package: None,
name: "Json",
}, },
alias: Some( ),
KeywordItem { ModuleImport(
keyword: Spaces { ModuleImport {
before: [ before_name: [],
Newline, name: @109-113 ImportedModuleName {
LineComment( package: None,
" comment 2", name: "Json",
),
],
item: ImportAsKeyword,
after: [
Newline,
LineComment(
" comment 3",
),
],
},
item: @590-591 ImportAlias(
"J",
),
}, },
), alias: Some(
exposed: Some( KeywordItem {
KeywordItem { keyword: Spaces {
keyword: Spaces { before: [],
before: [ item: ImportAsKeyword,
Newline, after: [
LineComment( Newline,
" comment 4", LineComment(
), " comment",
], ),
item: ImportExposingKeyword, ],
after: [ },
Newline, item: @135-136 ImportAlias(
LineComment( "J",
" comment 5", ),
},
),
exposed: None,
},
),
ModuleImport(
ModuleImport {
before_name: [],
name: @145-149 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [
Newline,
LineComment(
" comment",
),
],
},
item: @171-172 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@183-186 ExposedName(
"map",
), ),
], ],
}, },
item: [ ),
@663-666 SpaceBefore( },
SpaceAfter( ),
ModuleImport(
ModuleImport {
before_name: [],
name: @196-200 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [
Newline,
LineComment(
" comment",
),
],
},
item: @222-223 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@234-237 ExposedName(
"map",
),
@247-251 SpaceBefore(
ExposedName( ExposedName(
"map", "map2",
), ),
[ [
Newline, Newline,
], ],
), ),
[ ],
},
),
},
),
ModuleImport(
ModuleImport {
before_name: [],
name: @261-265 ImportedModuleName {
package: None,
name: "Json",
},
alias: None,
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [
Newline, Newline,
LineComment( LineComment(
" comment 6", " comment",
), ),
], ],
), item: ImportExposingKeyword,
], after: [],
},
item: [
@294-297 ExposedName(
"map",
),
@307-311 SpaceBefore(
ExposedName(
"map2",
),
[
Newline,
],
),
],
},
),
},
),
ModuleImport(
ModuleImport {
before_name: [],
name: @321-325 ImportedModuleName {
package: None,
name: "Json",
}, },
), alias: Some(
}, KeywordItem {
ModuleImport { keyword: Spaces {
before_name: [], before: [],
name: @682-683 ImportedModuleName { item: ImportAsKeyword,
package: None, after: [],
name: "A", },
item: @329-330 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [
Newline,
LineComment(
" comment",
),
],
item: ImportExposingKeyword,
after: [],
},
item: [
@359-362 ExposedName(
"map",
),
],
},
),
}, },
alias: None, ),
exposed: None, ModuleImport(
}, ModuleImport {
ModuleImport { before_name: [],
before_name: [], name: @372-376 ImportedModuleName {
name: @717-718 ImportedModuleName { package: None,
package: None, name: "Json",
name: "B", },
alias: None,
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [
Newline,
LineComment(
" comment",
),
],
},
item: [
@405-408 ExposedName(
"map",
),
],
},
),
}, },
alias: None, ),
exposed: None, ModuleImport(
}, ModuleImport {
before_name: [],
name: @418-422 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @426-427 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [
Newline,
LineComment(
" comment",
),
],
},
item: [
@456-459 ExposedName(
"map",
),
],
},
),
},
),
ModuleImport(
ModuleImport {
before_name: [],
name: @469-473 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportAsKeyword,
after: [],
},
item: @477-478 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@508-511 SpaceBefore(
SpaceAfter(
ExposedName(
"map",
),
[
Newline,
],
),
[
Newline,
LineComment(
" comment",
),
],
),
],
},
),
},
),
ModuleImport(
ModuleImport {
before_name: [
Newline,
LineComment(
" comment 1",
),
],
name: @542-546 ImportedModuleName {
package: None,
name: "Json",
},
alias: Some(
KeywordItem {
keyword: Spaces {
before: [
Newline,
LineComment(
" comment 2",
),
],
item: ImportAsKeyword,
after: [
Newline,
LineComment(
" comment 3",
),
],
},
item: @590-591 ImportAlias(
"J",
),
},
),
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [
Newline,
LineComment(
" comment 4",
),
],
item: ImportExposingKeyword,
after: [
Newline,
LineComment(
" comment 5",
),
],
},
item: [
@663-666 SpaceBefore(
SpaceAfter(
ExposedName(
"map",
),
[
Newline,
],
),
[
Newline,
LineComment(
" comment 6",
),
],
),
],
},
),
},
),
ModuleImport(
ModuleImport {
before_name: [],
name: @682-683 ImportedModuleName {
package: None,
name: "A",
},
alias: None,
exposed: None,
},
),
ModuleImport(
ModuleImport {
before_name: [],
name: @717-718 ImportedModuleName {
package: None,
name: "B",
},
alias: None,
exposed: None,
},
),
], ],
} }

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

@ -25,78 +25,84 @@ Defs {
], ],
type_defs: [], type_defs: [],
value_defs: [ value_defs: [
ModuleImport { ModuleImport(
before_name: [], ModuleImport {
name: @7-11 ImportedModuleName { before_name: [],
package: None, name: @7-11 ImportedModuleName {
name: "Json", package: None,
}, name: "Json",
alias: None,
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@22-25 ExposedName(
"map",
),
@27-34 ExposedName(
"Decoder",
),
],
}, },
), alias: None,
}, exposed: Some(
ModuleImport { KeywordItem {
before_name: [], keyword: Spaces {
name: @43-47 ImportedModuleName { before: [],
package: None, item: ImportExposingKeyword,
name: "Json", after: [],
}, },
alias: None, item: [
exposed: Some( @22-25 ExposedName(
KeywordItem { "map",
keyword: Spaces { ),
before: [], @27-34 ExposedName(
item: ImportExposingKeyword,
after: [],
},
item: [
@58-61 ExposedName(
"map",
),
@67-74 SpaceBefore(
ExposedName(
"Decoder", "Decoder",
), ),
[ ],
Newline,
],
),
],
},
),
},
ModuleImport {
before_name: [],
name: @83-87 ImportedModuleName {
package: None,
name: "Json",
},
alias: None,
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
}, },
item: [], ),
},
),
ModuleImport(
ModuleImport {
before_name: [],
name: @43-47 ImportedModuleName {
package: None,
name: "Json",
}, },
), alias: None,
}, exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [
@58-61 ExposedName(
"map",
),
@67-74 SpaceBefore(
ExposedName(
"Decoder",
),
[
Newline,
],
),
],
},
),
},
),
ModuleImport(
ModuleImport {
before_name: [],
name: @83-87 ImportedModuleName {
package: None,
name: "Json",
},
alias: None,
exposed: Some(
KeywordItem {
keyword: Spaces {
before: [],
item: ImportExposingKeyword,
after: [],
},
item: [],
},
),
},
),
], ],
} }

96
crates/compiler/test_syntax/tests/snapshots/pass/ingested_file.moduledefs.result-ast
View file

@ -20,55 +20,59 @@ Defs {
], ],
type_defs: [], type_defs: [],
value_defs: [ value_defs: [
IngestedFileImport { IngestedFileImport(
before_path: [], IngestedFileImport {
path: @7-25 PlainLine( before_path: [],
"path/to/file.txt", path: @7-25 PlainLine(
), "path/to/file.txt",
name: KeywordItem { ),
keyword: Spaces { name: KeywordItem {
before: [], keyword: Spaces {
item: ImportAsKeyword, before: [],
after: [], item: ImportAsKeyword,
}, after: [],
item: @29-39 TypedIdent { },
ident: @29-33 "file", item: @29-39 TypedIdent {
spaces_before_colon: [], ident: @29-33 "file",
ann: @36-39 Apply( spaces_before_colon: [],
"", ann: @36-39 Apply(
"Str", "",
[], "Str",
), [],
),
},
}, },
}, },
}, ),
IngestedFileImport { IngestedFileImport(
before_path: [], IngestedFileImport {
path: @47-65 PlainLine( before_path: [],
"path/to/file.txt", path: @47-65 PlainLine(
), "path/to/file.txt",
name: KeywordItem { ),
keyword: Spaces { name: KeywordItem {
before: [], keyword: Spaces {
item: ImportAsKeyword, before: [],
after: [], item: ImportAsKeyword,
}, after: [],
item: @70-85 TypedIdent { },
ident: @70-74 "file", item: @70-85 TypedIdent {
spaces_before_colon: [], ident: @70-74 "file",
ann: @78-85 Apply( spaces_before_colon: [],
"", ann: @78-85 Apply(
"List", "",
[ "List",
@83-85 Apply( [
"", @83-85 Apply(
"U8", "",
[], "U8",
), [],
], ),
), ],
),
},
}, },
}, },
}, ),
], ],
} }