language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-04 12:18:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Merge remote-tracking branch 'remote/main' into rebuild-platform

Browse source
This commit is contained in:
Luke Boswell 2024-10-24 10:21:08 +11:00
commit 926014518f
No known key found for this signature in database
GPG key ID: F6DB3C9DB47377B0
221 changed files with 2990 additions and 2303 deletions
Download patch file Download diff file Expand all files Collapse all files

10
Cargo.lock generated
View file

@ -2353,6 +2353,7 @@ dependencies = [
"roc_region",
"roc_serialize",
"roc_types",
"soa",
"static_assertions",
"ven_pretty",
]
@ -2441,6 +2442,7 @@ dependencies = [
"im",
"im-rc",
"smallvec",
"soa",
"wyhash",
]
@ -2461,6 +2463,7 @@ dependencies = [
"roc_problem",
"roc_region",
"roc_types",
"soa",
]
[[package]]
@ -2901,6 +2904,7 @@ dependencies = [
"roc_error_macros",
"roc_module",
"roc_region",
"soa",
"tempfile",
]
@ -3113,6 +3117,7 @@ dependencies = [
"roc_target",
"roc_types",
"roc_unify",
"soa",
"tempfile",
"test_solve_helpers",
]
@ -3204,6 +3209,7 @@ dependencies = [
"roc_parse",
"roc_region",
"roc_serialize",
"soa",
"static_assertions",
"ven_pretty",
]
@ -3609,6 +3615,10 @@ version = "1.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a"
[[package]]
name = "soa"
version = "0.0.1"
[[package]]
name = "socket2"
version = "0.4.9"

8
Cargo.toml
View file

@ -22,6 +22,7 @@ members = [
"crates/valgrind_tests",
"crates/tracing",
"crates/utils/*",
"crates/soa",
"crates/docs",
"crates/docs_cli",
"crates/linker",
@ -75,6 +76,8 @@ inkwell = { git = "https://github.com/roc-lang/inkwell", branch = "inkwell-llvm-
"llvm16-0",
] }
soa = { path = "crates/soa" }
arrayvec = "0.7.2" # update roc_std/Cargo.toml on change
backtrace = "0.3.67"
base64-url = "1.4.13"
@ -138,7 +141,10 @@ maplit = "1.0.2"
memmap2 = "0.5.10"
mimalloc = { version = "0.1.34", default-features = false }
nonempty = "0.8.1"
object = { version = "0.32.2", default-features = false, features = ["read", "write"] }
object = { version = "0.32.2", default-features = false, features = [
"read",
"write",
] }
packed_struct = "0.10.1"
page_size = "0.5.0"
palette = "0.6.1"

41
crates/cli/src/lib.rs
View file

@ -973,7 +973,15 @@ pub fn build(
// ManuallyDrop will leak the bytes because we don't drop manually
let bytes = &ManuallyDrop::new(std::fs::read(&binary_path).unwrap());
roc_run(&arena, opt_level, target, args, bytes, expect_metadata)
roc_run(
&arena,
path,
opt_level,
target,
args,
bytes,
expect_metadata,
)
}
BuildAndRunIfNoErrors => {
if problems.fatally_errored {
@ -1008,7 +1016,15 @@ pub fn build(
// ManuallyDrop will leak the bytes because we don't drop manually
let bytes = &ManuallyDrop::new(std::fs::read(&binary_path).unwrap());
roc_run(&arena, opt_level, target, args, bytes, expect_metadata)
roc_run(
&arena,
path,
opt_level,
target,
args,
bytes,
expect_metadata,
)
}
}
}
@ -1021,6 +1037,7 @@ pub fn build(
fn roc_run<'a, I: IntoIterator<Item = &'a OsStr>>(
arena: &Bump,
script_path: &Path,
opt_level: OptLevel,
target: Target,
args: I,
@ -1060,7 +1077,14 @@ fn roc_run<'a, I: IntoIterator<Item = &'a OsStr>>(
Ok(0)
}
_ => roc_run_native(arena, opt_level, args, binary_bytes, expect_metadata),
_ => roc_run_native(
arena,
script_path,
opt_level,
args,
binary_bytes,
expect_metadata,
),
}
}
@ -1077,7 +1101,7 @@ fn os_str_as_utf8_bytes(os_str: &OsStr) -> &[u8] {
fn make_argv_envp<'a, I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
arena: &'a Bump,
executable: &ExecutableFile,
script_path: &Path,
args: I,
) -> (
bumpalo::collections::Vec<'a, CString>,
@ -1085,8 +1109,7 @@ fn make_argv_envp<'a, I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
) {
use bumpalo::collections::CollectIn;
let path = executable.as_path();
let path_cstring = CString::new(os_str_as_utf8_bytes(path.as_os_str())).unwrap();
let path_cstring = CString::new(os_str_as_utf8_bytes(script_path.as_os_str())).unwrap();
// argv is an array of pointers to strings passed to the new program
// as its command-line arguments. By convention, the first of these
@ -1124,6 +1147,7 @@ fn make_argv_envp<'a, I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
#[cfg(target_family = "unix")]
fn roc_run_native<I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
arena: &Bump,
script_path: &Path,
opt_level: OptLevel,
args: I,
binary_bytes: &[u8],
@ -1132,7 +1156,7 @@ fn roc_run_native<I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
use bumpalo::collections::CollectIn;
let executable = roc_run_executable_file_path(binary_bytes)?;
let (argv_cstrings, envp_cstrings) = make_argv_envp(arena, &executable, args);
let (argv_cstrings, envp_cstrings) = make_argv_envp(arena, script_path, args);
let argv: bumpalo::collections::Vec<*const c_char> = argv_cstrings
.iter()
@ -1387,6 +1411,7 @@ fn roc_run_executable_file_path(binary_bytes: &[u8]) -> std::io::Result<Executab
#[cfg(not(target_family = "unix"))]
fn roc_run_native<I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
arena: &Bump, // This should be passed an owned value, not a reference, so we can usefully mem::forget it!
script_path: &Path,
opt_level: OptLevel,
args: I,
binary_bytes: &[u8],
@ -1398,7 +1423,7 @@ fn roc_run_native<I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
let executable = roc_run_executable_file_path(binary_bytes)?;
// TODO forward the arguments
let (argv_cstrings, envp_cstrings) = make_argv_envp(&arena, &executable, args);
let (argv_cstrings, envp_cstrings) = make_argv_envp(&arena, script_path, args);
let argv: bumpalo::collections::Vec<*const c_char> = argv_cstrings
.iter()

99
crates/cli/src/main.rs
View file

@ -17,10 +17,12 @@ use roc_load::{LoadingProblem, Threading};
use roc_packaging::cache::{self, RocCacheDir};
use roc_target::Target;
use std::fs::{self, FileType};
use std::io::BufRead;
use std::io::{self, Read, Write};
use std::path::{Path, PathBuf};
use std::str::FromStr;
use target_lexicon::Triple;
use tempfile::Builder;
#[global_allocator]
static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
@ -205,26 +207,89 @@ fn main() -> io::Result<()> {
let opt_main_path = matches.get_one::<PathBuf>(FLAG_MAIN);
match check_file(
&arena,
roc_file_path.to_owned(),
opt_main_path.cloned(),
emit_timings,
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
threading,
) {
Ok((problems, total_time)) => {
problems.print_error_warning_count(total_time);
Ok(problems.exit_code())
}
match roc_file_path.extension().and_then(OsStr::to_str) {
Some("md") => {
// Extract the blocks of roc code
let file = fs::File::open(roc_file_path.as_path())?;
let markdown_file_reader = io::BufReader::new(file);
let mut roc_blocks: Vec<String> = Vec::new();
let mut in_roc_block: bool = false;
let mut current_block = String::new();
Err(LoadingProblem::FormattedReport(report)) => {
print!("{report}");
for line in markdown_file_reader.lines() {
let line = line.unwrap();
if line == "```roc" {
in_roc_block = true;
} else if (line == "```") & in_roc_block {
in_roc_block = false;
roc_blocks.push(current_block);
current_block = String::new();
} else if in_roc_block {
current_block.push_str(&line);
current_block.push_str("\n");
}
}
Ok(1)
// now check each block, we exit early if any single block does not check
let mut exit_code = 0;
for block in roc_blocks.iter() {
let mut file = Builder::new().suffix(".roc").tempfile()?;
write!(file, "{}", block)?;
match check_file(
&arena,
file.path().to_owned(),
opt_main_path.cloned(),
emit_timings,
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
threading,
) {
Ok((problems, total_time)) => {
problems.print_error_warning_count(total_time);
exit_code = problems.exit_code();
}
Err(LoadingProblem::FormattedReport(report)) => {
print!("{report}");
exit_code = 1;
}
Err(other) => {
panic!("build_file failed with error:\n{other:?}");
}
}
if exit_code != 0 {
break;
}
}
Ok(exit_code)
}
Err(other) => {
panic!("build_file failed with error:\n{other:?}");
_ => {
match check_file(
&arena,
roc_file_path.to_owned(),
opt_main_path.cloned(),
emit_timings,
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
threading,
) {
Ok((problems, total_time)) => {
problems.print_error_warning_count(total_time);
Ok(problems.exit_code())
}
Err(LoadingProblem::FormattedReport(report)) => {
print!("{report}");
Ok(1)
}
Err(other) => {
panic!("build_file failed with error:\n{other:?}");
}
}
}
}
}

910
crates/cli/tests/cli_tests.rs
View file

File diff suppressed because it is too large Load diff

17
crates/cli/tests/markdown/form.md Normal file
View file

@ -0,0 +1,17 @@
# A Simple Markdown Example
This file contains `form.roc` embedded as a block in Markdown. It lets us test that `roc check` works with Markdown.
```roc
module [foo]
foo = "Foo"
```
Excitingly, we can have another block of Roc code as well! (In this case it is the same one...)
```roc
module [bar]
bar = "Bar"
```

2
crates/compiler/builtins/roc/Dict.roc
View file

@ -512,7 +512,7 @@ removeHelper = \buckets, bucketIndex, distAndFingerprint, data, key ->
## alterValue : Result Bool [Missing] -> Result Bool [Missing]
## alterValue = \possibleValue ->
## when possibleValue is
## Err -> Ok Bool.false
## Err Missing -> Ok Bool.false
## Ok value -> if value then Err Missing else Ok Bool.true
##
## expect Dict.update (Dict.empty {}) "a" alterValue == Dict.single "a" Bool.false

2
crates/compiler/can/Cargo.toml
View file

@ -24,6 +24,8 @@ bitvec.workspace = true
bumpalo.workspace = true
static_assertions.workspace = true
soa.workspace = true
[dev-dependencies]
indoc.workspace = true
insta.workspace = true

10
crates/compiler/can/src/abilities.rs
View file

@ -683,7 +683,7 @@ impl IAbilitiesStore<Pending> {
}
mod serialize {
use roc_collections::{MutMap, VecMap};
use roc_collections::{soa::slice_extend_new, MutMap, VecMap};
use roc_module::symbol::Symbol;
use roc_region::all::Region;
use roc_serialize::bytes;
@ -1034,11 +1034,11 @@ mod serialize {
specialization_lambda_sets,
} in spec_info
{
let regions = SubsSlice::extend_new(
let regions = slice_extend_new(
&mut spec_lambda_sets_regions,
specialization_lambda_sets.keys().copied(),
);
let vars = SubsSlice::extend_new(
let vars = slice_extend_new(
&mut spec_lambda_sets_vars,
specialization_lambda_sets.values().copied(),
);
@ -1168,11 +1168,11 @@ mod serialize {
symbol,
specialization_lambda_sets,
}) => {
let regions = SubsSlice::extend_new(
let regions = slice_extend_new(
&mut spec_lambda_sets_regions,
specialization_lambda_sets.keys().copied(),
);
let vars = SubsSlice::extend_new(
let vars = slice_extend_new(
&mut spec_lambda_sets_vars,
specialization_lambda_sets.values().copied(),
);

35
crates/compiler/can/src/constraint.rs
View file

@ -5,12 +5,13 @@ use std::sync::Arc;
use crate::abilities::SpecializationId;
use crate::exhaustive::{ExhaustiveContext, SketchedRows};
use crate::expected::{Expected, PExpected};
use roc_collections::soa::{EitherIndex, Index, Slice};
use roc_collections::soa::{index_push_new, slice_extend_new};
use roc_module::ident::TagName;
use roc_module::symbol::{ModuleId, Symbol};
use roc_region::all::{Loc, Region};
use roc_types::subs::{ExhaustiveMark, IllegalCycleMark, Variable};
use roc_types::types::{Category, PatternCategory, TypeTag, Types};
use soa::{EitherIndex, Index, Slice};
pub struct Constraints {
pub constraints: Vec<Constraint>,
@ -205,11 +206,11 @@ impl Constraints {
}
pub fn push_expected_type(&mut self, expected: Expected<TypeOrVar>) -> ExpectedTypeIndex {
Index::push_new(&mut self.expectations, expected)
index_push_new(&mut self.expectations, expected)
}
pub fn push_pat_expected_type(&mut self, expected: PExpected<TypeOrVar>) -> PExpectedTypeIndex {
Index::push_new(&mut self.pattern_expectations, expected)
index_push_new(&mut self.pattern_expectations, expected)
}
#[inline(always)]
@ -229,7 +230,7 @@ impl Constraints {
Category::List => Self::CATEGORY_LIST,
Category::Str => Self::CATEGORY_STR,
Category::Character => Self::CATEGORY_CHARACTER,
other => Index::push_new(&mut self.categories, other),
other => index_push_new(&mut self.categories, other),
}
}
@ -247,7 +248,7 @@ impl Constraints {
PatternCategory::Int => Self::PCATEGORY_INT,
PatternCategory::Float => Self::PCATEGORY_FLOAT,
PatternCategory::Character => Self::PCATEGORY_CHARACTER,
other => Index::push_new(&mut self.pattern_categories, other),
other => index_push_new(&mut self.pattern_categories, other),
}
}
@ -320,7 +321,7 @@ impl Constraints {
category: PatternCategory,
region: Region,
) -> Constraint {
let category_index = Index::push_new(&mut self.pattern_categories, category);
let category_index = index_push_new(&mut self.pattern_categories, category);
Constraint::PatternPresence(type_index, expected_index, category_index, region)
}
@ -337,7 +338,7 @@ impl Constraints {
category: PatternCategory,
region: Region,
) -> Constraint {
let category_index = Index::push_new(&mut self.pattern_categories, category);
let category_index = index_push_new(&mut self.pattern_categories, category);
let includes_tag = IncludesTag {
type_index,
@ -347,7 +348,7 @@ impl Constraints {
region,
};
let includes_tag_index = Index::push_new(&mut self.includes_tags, includes_tag);
let includes_tag_index = index_push_new(&mut self.includes_tags, includes_tag);
Constraint::IncludesTag(includes_tag_index)
}
@ -614,7 +615,7 @@ impl Constraints {
filename: &'static str,
line_number: u32,
) -> Constraint {
let string_index = Index::push_new(&mut self.strings, filename);
let string_index = index_push_new(&mut self.strings, filename);
Constraint::Store(type_index, variable, string_index, line_number)
}
@ -632,19 +633,19 @@ impl Constraints {
exhaustive: ExhaustiveMark,
) -> Constraint {
let real_var = Self::push_type_variable(real_var);
let sketched_rows = Index::push_new(&mut self.sketched_rows, sketched_rows);
let sketched_rows = index_push_new(&mut self.sketched_rows, sketched_rows);
let equality = match category_and_expectation {
Ok((category, expected)) => {
let category = Index::push_new(&mut self.categories, category);
let category = index_push_new(&mut self.categories, category);
let equality = Eq(real_var, expected, category, real_region);
let equality = Index::push_new(&mut self.eq, equality);
let equality = index_push_new(&mut self.eq, equality);
Ok(equality)
}
Err((category, expected)) => {
let category = Index::push_new(&mut self.pattern_categories, category);
let category = index_push_new(&mut self.pattern_categories, category);
let equality = PatternEq(real_var, expected, category, real_region);
let equality = Index::push_new(&mut self.pattern_eq, equality);
let equality = index_push_new(&mut self.pattern_eq, equality);
Err(equality)
}
};
@ -662,18 +663,18 @@ impl Constraints {
I: IntoIterator<Item = (Symbol, Region)>,
I1: IntoIterator<Item = Region>,
{
let def_names = Slice::extend_new(&mut self.loc_symbols, loc_symbols);
let def_names = slice_extend_new(&mut self.loc_symbols, loc_symbols);
// we add a dummy symbol to these regions, so we can store the data in the loc_symbols vec
let it = expr_regions.into_iter().map(|r| (Symbol::ATTR_ATTR, r));
let expr_regions = Slice::extend_new(&mut self.loc_symbols, it);
let expr_regions = slice_extend_new(&mut self.loc_symbols, it);
let expr_regions = Slice::new(expr_regions.start() as _, expr_regions.len() as _);
let cycle = Cycle {
def_names,
expr_regions,
};
let cycle_index = Index::push_new(&mut self.cycles, cycle);
let cycle_index = index_push_new(&mut self.cycles, cycle);
Constraint::CheckCycle(cycle_index, cycle_mark)
}

67
crates/compiler/can/src/copy.rs
View file

@ -5,6 +5,7 @@ use crate::{
},
pattern::{DestructType, ListPatterns, Pattern, RecordDestruct, TupleDestruct},
};
use roc_collections::soa::{index_push_new, slice_extend_new};
use roc_module::{
ident::{Lowercase, TagName},
symbol::Symbol,
@ -12,7 +13,7 @@ use roc_module::{
use roc_types::{
subs::{
self, AliasVariables, Descriptor, GetSubsSlice, OptVariable, RecordFields, Subs, SubsIndex,
SubsSlice, TupleElems, UnionLambdas, UnionTags, Variable, VariableSubsSlice,
SubsSlice, TupleElems, UnionLambdas, UnionTags, Variable,
},
types::{RecordField, Uls},
};
@ -155,12 +156,12 @@ impl<'a> CopyEnv for AcrossSubs<'a> {
#[inline(always)]
fn clone_name(&mut self, name: SubsIndex<Lowercase>) -> SubsIndex<Lowercase> {
SubsIndex::push_new(&mut self.target.field_names, self.source[name].clone())
index_push_new(&mut self.target.field_names, self.source[name].clone())
}
#[inline(always)]
fn clone_field_names(&mut self, field_names: SubsSlice<Lowercase>) -> SubsSlice<Lowercase> {
SubsSlice::extend_new(
slice_extend_new(
&mut self.target.field_names,
self.source.get_subs_slice(field_names).iter().cloned(),
)
@ -171,7 +172,7 @@ impl<'a> CopyEnv for AcrossSubs<'a> {
&mut self,
tuple_elem_indices: SubsSlice<usize>,
) -> SubsSlice<usize> {
SubsSlice::extend_new(
slice_extend_new(
&mut self.target.tuple_elem_indices,
self.source
.get_subs_slice(tuple_elem_indices)
@ -182,7 +183,7 @@ impl<'a> CopyEnv for AcrossSubs<'a> {
#[inline(always)]
fn clone_tag_names(&mut self, tag_names: SubsSlice<TagName>) -> SubsSlice<TagName> {
SubsSlice::extend_new(
slice_extend_new(
&mut self.target.tag_names,
self.source.get_subs_slice(tag_names).iter().cloned(),
)
@ -190,7 +191,7 @@ impl<'a> CopyEnv for AcrossSubs<'a> {
#[inline(always)]
fn clone_lambda_names(&mut self, lambda_names: SubsSlice<Symbol>) -> SubsSlice<Symbol> {
SubsSlice::extend_new(
slice_extend_new(
&mut self.target.symbol_names,
self.source.get_subs_slice(lambda_names).iter().cloned(),
)
@ -201,7 +202,7 @@ impl<'a> CopyEnv for AcrossSubs<'a> {
&mut self,
record_fields: SubsSlice<RecordField<()>>,
) -> SubsSlice<RecordField<()>> {
SubsSlice::extend_new(
slice_extend_new(
&mut self.target.record_fields,
self.source.get_subs_slice(record_fields).iter().copied(),
)
@ -919,8 +920,7 @@ fn deep_copy_type_vars<C: CopyEnv>(
macro_rules! clone_var_slice {
($slice:expr) => {{
let new_arguments =
VariableSubsSlice::reserve_into_subs(env.target(), $slice.len());
let new_arguments = env.target().reserve_into_vars($slice.len());
for (target_index, var_index) in (new_arguments.indices()).zip($slice) {
let var = env.source()[var_index];
let copy_var = env.get_copy(var).into_variable().unwrap_or(var);
@ -994,9 +994,9 @@ fn deep_copy_type_vars<C: CopyEnv>(
let new_fields = {
RecordFields {
length: fields.length,
field_names_start: new_field_names.start,
variables_start: new_variables.start,
field_types_start: new_record_fields.start,
field_names_start: new_field_names.start(),
variables_start: new_variables.start(),
field_types_start: new_record_fields.start(),
}
};
@ -1015,8 +1015,8 @@ fn deep_copy_type_vars<C: CopyEnv>(
let new_elems = {
TupleElems {
length: elems.length,
variables_start: new_variables.start,
elem_index_start: new_elem_indices.start,
variables_start: new_variables.start(),
elem_index_start: new_elem_indices.start(),
}
};
@ -1032,8 +1032,7 @@ fn deep_copy_type_vars<C: CopyEnv>(
}
perform_clone!({
let new_variable_slices =
SubsSlice::reserve_variable_slices(env.target(), tags.len());
let new_variable_slices = env.target().reserve_variable_slices(tags.len());
let it = (new_variable_slices.indices()).zip(tags.variables());
for (target_index, index) in it {
let slice = env.source()[index];
@ -1058,8 +1057,7 @@ fn deep_copy_type_vars<C: CopyEnv>(
}
perform_clone!({
let new_variable_slices =
SubsSlice::reserve_variable_slices(env.target(), tags.len());
let new_variable_slices = env.target().reserve_variable_slices(tags.len());
let it = (new_variable_slices.indices()).zip(tags.variables());
for (target_index, index) in it {
let slice = env.source()[index];
@ -1109,7 +1107,7 @@ fn deep_copy_type_vars<C: CopyEnv>(
perform_clone!({
let new_variables = clone_var_slice!(arguments.all_variables());
let new_arguments = AliasVariables {
variables_start: new_variables.start,
variables_start: new_variables.start(),
..arguments
};
@ -1135,8 +1133,7 @@ fn deep_copy_type_vars<C: CopyEnv>(
let new_ambient_function = descend_var!(ambient_function);
perform_clone!({
let new_variable_slices =
SubsSlice::reserve_variable_slices(env.target(), solved.len());
let new_variable_slices = env.target().reserve_variable_slices(solved.len());
let it = (new_variable_slices.indices()).zip(solved.variables());
for (target_index, index) in it {
let slice = env.source()[index];
@ -1150,8 +1147,7 @@ fn deep_copy_type_vars<C: CopyEnv>(
let new_solved =
UnionLambdas::from_slices(new_solved_labels, new_variable_slices);
let new_unspecialized =
SubsSlice::reserve_uls_slice(env.target(), unspecialized.len());
let new_unspecialized = env.target().reserve_uls_slice(unspecialized.len());
for (target_index, uls_index) in
(new_unspecialized.into_iter()).zip(unspecialized.into_iter())
{
@ -1192,13 +1188,14 @@ mod test {
};
use super::{deep_copy_expr_across_subs, deep_copy_type_vars};
use roc_collections::soa::{index_push_new, slice_extend_new};
use roc_error_macros::internal_error;
use roc_module::{ident::TagName, symbol::Symbol};
use roc_region::all::Loc;
use roc_types::{
subs::{
self, Content, Content::*, Descriptor, FlatType, GetSubsSlice, Mark, OptVariable, Rank,
Subs, SubsIndex, SubsSlice, Variable,
Subs, Variable,
},
types::Uls,
};
@ -1217,7 +1214,7 @@ mod test {
fn copy_flex_var() {
let mut subs = Subs::new();
let field_name = SubsIndex::push_new(&mut subs.field_names, "a".into());
let field_name = index_push_new(&mut subs.field_names, "a".into());
let var = new_var(&mut subs, FlexVar(Some(field_name)));
let mut copied = vec![];
@ -1238,7 +1235,7 @@ mod test {
fn copy_rigid_var() {
let mut subs = Subs::new();
let field_name = SubsIndex::push_new(&mut subs.field_names, "a".into());
let field_name = index_push_new(&mut subs.field_names, "a".into());
let var = new_var(&mut subs, RigidVar(field_name));
let mut copied = vec![];
@ -1259,8 +1256,8 @@ mod test {
fn copy_flex_able_var() {
let mut subs = Subs::new();
let field_name = SubsIndex::push_new(&mut subs.field_names, "a".into());
let abilities = SubsSlice::extend_new(&mut subs.symbol_names, [Symbol::UNDERSCORE]);
let field_name = index_push_new(&mut subs.field_names, "a".into());
let abilities = slice_extend_new(&mut subs.symbol_names, [Symbol::UNDERSCORE]);
let var = new_var(&mut subs, FlexAbleVar(Some(field_name), abilities));
let mut copied = vec![];
@ -1282,8 +1279,8 @@ mod test {
fn copy_rigid_able_var() {
let mut subs = Subs::new();
let field_name = SubsIndex::push_new(&mut subs.field_names, "a".into());
let abilities = SubsSlice::extend_new(&mut subs.symbol_names, [Symbol::UNDERSCORE]);
let field_name = index_push_new(&mut subs.field_names, "a".into());
let abilities = slice_extend_new(&mut subs.symbol_names, [Symbol::UNDERSCORE]);
let var = new_var(&mut subs, RigidAbleVar(field_name, abilities));
let mut copied = vec![];
@ -1304,8 +1301,8 @@ mod test {
fn copy_deep_expr() {
let mut subs = Subs::new();
let a = SubsIndex::push_new(&mut subs.field_names, "a".into());
let b = SubsIndex::push_new(&mut subs.field_names, "b".into());
let a = index_push_new(&mut subs.field_names, "a".into());
let b = index_push_new(&mut subs.field_names, "b".into());
let var1 = new_var(&mut subs, FlexVar(Some(a)));
let var2 = new_var(&mut subs, FlexVar(Some(b)));
@ -1390,8 +1387,8 @@ mod test {
let mut source = Subs::new();
let mut target = Subs::new();
let a = SubsIndex::push_new(&mut source.field_names, "a".into());
let b = SubsIndex::push_new(&mut source.field_names, "b".into());
let a = index_push_new(&mut source.field_names, "a".into());
let b = index_push_new(&mut source.field_names, "b".into());
let var1 = new_var(&mut source, FlexVar(Some(a)));
let var2 = new_var(&mut source, FlexVar(Some(b)));
@ -1472,7 +1469,7 @@ mod test {
let mut target = Subs::new();
let a = new_var(&mut source, FlexVar(None));
let uls = SubsSlice::extend_new(
let uls = slice_extend_new(
&mut source.unspecialized_lambda_sets,
vec![Uls(a, Symbol::UNDERSCORE, 3)],
);

14
crates/compiler/can/src/desugar.rs
View file

@ -1045,20 +1045,6 @@ fn desugar_str_segments<'a>(
StrSegment::Plaintext(_) | StrSegment::Unicode(_) | StrSegment::EscapedChar(_) => {
*segment
}
StrSegment::DeprecatedInterpolated(loc_expr) => {
let loc_desugared = desugar_expr(
env,
scope,
env.arena.alloc(Loc {
region: loc_expr.region,
value: *loc_expr.value,
}),
);
StrSegment::DeprecatedInterpolated(Loc {
region: loc_desugared.region,
value: env.arena.alloc(loc_desugared.value),
})
}
StrSegment::Interpolated(loc_expr) => {
let loc_desugared = desugar_expr(
env,

19
crates/compiler/can/src/expr.rs
View file

@ -12,7 +12,7 @@ use crate::pattern::{canonicalize_pattern, BindingsFromPattern, Pattern, PermitS
use crate::procedure::{QualifiedReference, References};
use crate::scope::{Scope, SymbolLookup};
use crate::traverse::{walk_expr, Visitor};
use roc_collections::soa::Index;
use roc_collections::soa::index_push_new;
use roc_collections::{SendMap, VecMap, VecSet};
use roc_error_macros::internal_error;
use roc_module::called_via::CalledVia;
@ -27,6 +27,7 @@ use roc_region::all::{Loc, Region};
use roc_types::num::SingleQuoteBound;
use roc_types::subs::{ExhaustiveMark, IllegalCycleMark, RedundantMark, VarStore, Variable};
use roc_types::types::{Alias, Category, IndexOrField, LambdaSet, OptAbleVar, Type};
use soa::Index;
use std::fmt::{Debug, Display};
use std::path::PathBuf;
use std::sync::Arc;
@ -2515,9 +2516,7 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool {
| ast::StrSegment::Plaintext(_) => true,
// Disallow nested interpolation. Alternatively, we could allow it but require
// a comment above it apologizing to the next person who has to read the code.
ast::StrSegment::Interpolated(_) | ast::StrSegment::DeprecatedInterpolated(_) => {
false
}
ast::StrSegment::Interpolated(_) => false,
})
}
ast::Expr::Record(fields) => fields.iter().all(|loc_field| match loc_field.value {
@ -2648,7 +2647,7 @@ fn flatten_str_lines<'a>(
);
}
},
Interpolated(loc_expr) | DeprecatedInterpolated(loc_expr) => {
Interpolated(loc_expr) => {
if is_valid_interpolation(loc_expr.value) {
// Interpolations desugar to Str.concat calls
output.references.insert_call(Symbol::STR_CONCAT);
@ -2852,7 +2851,7 @@ impl Declarations {
let loc_function_def = Loc::at(loc_closure_data.region, function_def);
let function_def_index = Index::push_new(&mut self.function_bodies, loc_function_def);
let function_def_index = index_push_new(&mut self.function_bodies, loc_function_def);
let tag = match loc_closure_data.value.recursive {
Recursive::NotRecursive | Recursive::Recursive => {
@ -2903,7 +2902,7 @@ impl Declarations {
let loc_function_def = Loc::at(loc_closure_data.region, function_def);
let function_def_index = Index::push_new(&mut self.function_bodies, loc_function_def);
let function_def_index = index_push_new(&mut self.function_bodies, loc_function_def);
if let Some(annotation) = host_annotation {
self.host_exposed_annotations
@ -3009,7 +3008,7 @@ impl Declarations {
pattern_vars,
};
let destructure_def_index = Index::push_new(&mut self.destructs, destruct_def);
let destructure_def_index = index_push_new(&mut self.destructs, destruct_def);
self.declarations
.push(DeclarationTag::Destructure(destructure_def_index));
@ -3081,7 +3080,7 @@ impl Declarations {
let loc_function_def = Loc::at(def.loc_expr.region, function_def);
let function_def_index =
Index::push_new(&mut self.function_bodies, loc_function_def);
index_push_new(&mut self.function_bodies, loc_function_def);
self.declarations[index] = DeclarationTag::Function(function_def_index);
self.expressions[index] = *closure_data.loc_body;
@ -3133,7 +3132,7 @@ impl Declarations {
let loc_function_def = Loc::at(region, function_def);
let function_def_index =
Index::push_new(&mut self.function_bodies, loc_function_def);
index_push_new(&mut self.function_bodies, loc_function_def);
if let Some(annotation) = &mut self.annotations[index] {
annotation.convert_to_fn(new_args_len, var_store);

2
crates/compiler/can/src/pattern.rs
View file

@ -1109,7 +1109,7 @@ fn flatten_str_lines(lines: &[&[StrSegment<'_>]]) -> Pattern {
Unicode(loc_digits) => {
todo!("parse unicode digits {:?}", loc_digits);
}
Interpolated(loc_expr) | DeprecatedInterpolated(loc_expr) => {
Interpolated(loc_expr) => {
return Pattern::UnsupportedPattern(loc_expr.region);
}
EscapedChar(escaped) => buf.push(escaped.unescape()),

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__apply_argument_multiple.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-28,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -59,16 +59,16 @@ Defs {
@15-22 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@15-22,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__apply_argument_single.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-25,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -43,16 +43,16 @@ Defs {
@15-19 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@15-19,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__apply_argument_suffixed.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-43,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -53,16 +53,16 @@ Defs {
@15-33 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@15-33,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__apply_function_suffixed.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-45,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -53,16 +53,16 @@ Defs {
@15-35 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@15-35,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__bang_in_pipe_root.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-28,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -43,16 +43,16 @@ Defs {
@15-22 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@15-22,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__basic.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-26,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -33,16 +33,16 @@ Defs {
@11-15 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@11-15,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__body_parens_apply.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-42,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -43,16 +43,16 @@ Defs {
@16-35 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@16-35,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

18
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__closure_simple.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-69,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -27,16 +27,16 @@ Defs {
@11-69 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@15-57,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],
@ -60,16 +60,16 @@ Defs {
@31-42 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@31-42,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

18
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__closure_with_annotations.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-114,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -27,16 +27,16 @@ Defs {
@11-114 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@39-101,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],
@ -77,16 +77,16 @@ Defs {
@56-91 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@82-91,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

24
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__closure_with_defs.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-143,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -27,16 +27,16 @@ Defs {
@12-143 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@56-119,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],
@ -105,16 +105,16 @@ Defs {
@76-83 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@76-83,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],
@ -174,16 +174,16 @@ Defs {
@92-99 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@92-99,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

19
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__dbg_expr.snap
View file

@ -1,20 +1,19 @@
---
source: crates/compiler/can/tests/test_suffixed.rs
assertion_line: 463
expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-26,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -28,16 +27,16 @@ Defs {
@11-26 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@15-26,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],
@ -50,16 +49,16 @@ Defs {
Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@20-25,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__dbg_simple.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-49,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,

6
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__dbg_stmt_arg.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-24,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,

6
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__deep_when.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-99,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,

30
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__defs_suffixed_middle.snap
View file

@ -4,20 +4,20 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
Index(2147483649),
EitherIndex(2147483648),
EitherIndex(2147483649),
],
regions: [
@0-54,
@56-98,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 2),
Slice { start: 0, length: 0 },
Slice { start: 0, length: 2 },
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 2, length = 1),
Slice { start: 0, length: 0 },
Slice { start: 2, length: 1 },
],
spaces: [
Newline,
@ -33,16 +33,16 @@ Defs {
@11-54 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@15-20,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],
@ -68,16 +68,16 @@ Defs {
@25-39 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@25-39,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],
@ -145,16 +145,16 @@ Defs {
@71-98 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@75-80,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__deps_final_expr.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-158,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -39,16 +39,16 @@ Defs {
value: @46-130 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@50-52,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__expect_then_bang.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-31,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -27,16 +27,16 @@ Defs {
@11-31 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@11-24,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

36
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__if_complex.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-307,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -27,9 +27,9 @@ Defs {
@11-307 Defs(
Defs {
tags: [
Index(2147483648),
Index(2147483649),
Index(2147483650),
EitherIndex(2147483648),
EitherIndex(2147483649),
EitherIndex(2147483650),
],
regions: [
@20-37,
@ -37,14 +37,14 @@ Defs {
@109-298,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 1),
Slice(start = 1, length = 1),
Slice { start: 0, length: 0 },
Slice { start: 0, length: 1 },
Slice { start: 1, length: 1 },
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 1, length = 0),
Slice(start = 2, length = 0),
Slice { start: 0, length: 0 },
Slice { start: 1, length: 0 },
Slice { start: 2, length: 0 },
],
spaces: [
Newline,
@ -165,16 +165,16 @@ Defs {
@140-152 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@140-152,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],
@ -287,16 +287,16 @@ Defs {
@227-239 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@227-239,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

18
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__if_simple.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-189,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -27,20 +27,20 @@ Defs {
@11-189 Defs(
Defs {
tags: [
Index(2147483648),
Index(2147483649),
EitherIndex(2147483648),
EitherIndex(2147483649),
],
regions: [
@20-37,
@52-70,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 1),
Slice { start: 0, length: 0 },
Slice { start: 0, length: 1 },
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 1, length = 0),
Slice { start: 0, length: 0 },
Slice { start: 1, length: 0 },
],
spaces: [
Newline,

30
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__issue_7081.snap
View file

@ -4,9 +4,9 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
Index(2147483649),
Index(2147483650),
EitherIndex(2147483648),
EitherIndex(2147483649),
EitherIndex(2147483650),
],
regions: [
@0-80,
@ -14,14 +14,14 @@ Defs {
@229-266,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 2),
Slice(start = 2, length = 2),
Slice { start: 0, length: 0 },
Slice { start: 0, length: 2 },
Slice { start: 2, length: 2 },
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 2, length = 0),
Slice(start = 4, length = 1),
Slice { start: 0, length: 0 },
Slice { start: 2, length: 0 },
Slice { start: 4, length: 1 },
],
spaces: [
Newline,
@ -112,20 +112,20 @@ Defs {
condition: @93-227 Defs(
Defs {
tags: [
Index(2147483648),
Index(2147483649),
EitherIndex(2147483648),
EitherIndex(2147483649),
],
regions: [
@99-189,
@203-208,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 1),
Slice { start: 0, length: 0 },
Slice { start: 0, length: 1 },
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 1, length = 0),
Slice { start: 0, length: 0 },
Slice { start: 1, length: 0 },
],
spaces: [
Newline,

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__issue_7103.snap
View file

@ -4,20 +4,20 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
Index(2147483649),
EitherIndex(2147483648),
EitherIndex(2147483649),
],
regions: [
@0-33,
@35-45,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 2),
Slice { start: 0, length: 0 },
Slice { start: 0, length: 2 },
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 2, length = 1),
Slice { start: 0, length: 0 },
Slice { start: 2, length: 1 },
],
spaces: [
Newline,

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__last_stmt_not_top_level_suffixed.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-26,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -27,16 +27,16 @@ Defs {
@11-26 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@15-17,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

18
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__last_suffixed_multiple.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-33,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -33,16 +33,16 @@ Defs {
@11-15 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@11-15,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],
@ -93,16 +93,16 @@ Defs {
@20-24 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@20-24,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__last_suffixed_single.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-26,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__multi_defs_stmts.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-72,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -33,16 +33,16 @@ Defs {
@11-23 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@11-23,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__multiple_def_first_suffixed.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-51,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -27,16 +27,16 @@ Defs {
@11-51 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@17-24,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__multiple_suffix.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-24,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -33,16 +33,16 @@ Defs {
@11-16 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@11-16,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__nested_complex.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-61,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__nested_defs.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-49,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -27,16 +27,16 @@ Defs {
@11-49 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@23-42,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__nested_simple.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-22,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,

19
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__pizza_dbg.snap
View file

@ -1,20 +1,19 @@
---
source: crates/compiler/can/tests/test_suffixed.rs
assertion_line: 473
expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-51,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -28,16 +27,16 @@ Defs {
@11-51 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@11-40,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],
@ -55,16 +54,16 @@ Defs {
@11-23 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@11-12,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__simple_pizza.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-73,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -33,16 +33,16 @@ Defs {
@11-56 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@11-56,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__trailing_binops.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-67,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -42,16 +42,16 @@ Defs {
@19-30 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@19-30,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__trailing_suffix_inside_when.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-154,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__type_annotation.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-44,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -39,16 +39,16 @@ Defs {
@14-30 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@28-30,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__var_suffixes.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-45,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,

12
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__when_branches.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-120,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,
@ -61,16 +61,16 @@ Defs {
@54-65 Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@54-65,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__when_simple.snap
View file

@ -4,16 +4,16 @@ expression: snapshot
---
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-74,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
Newline,

14
crates/compiler/checkmate/www/package-lock.json generated
View file

@ -6560,9 +6560,9 @@
"dev": true
},
"node_modules/cookie": {
"version": "0.6.0",
"resolved": "https://registry.npmjs.org/cookie/-/cookie-0.6.0.tgz",
"integrity": "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==",
"version": "0.7.1",
"resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
"integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
"dev": true,
"engines": {
"node": ">= 0.6"
@ -8690,9 +8690,9 @@
}
},
"node_modules/express": {
"version": "4.21.0",
"resolved": "https://registry.npmjs.org/express/-/express-4.21.0.tgz",
"integrity": "sha512-VqcNGcj/Id5ZT1LZ/cfihi3ttTn+NJmkli2eZADigjq29qTlWi/hAQ43t/VLPq8+UX06FCEx3ByOYet6ZFblng==",
"version": "4.21.1",
"resolved": "https://registry.npmjs.org/express/-/express-4.21.1.tgz",
"integrity": "sha512-YSFlK1Ee0/GC8QaO91tHcDxJiE/X4FbpAyQWkxAvG6AXCuR65YzK8ua6D9hvi/TzUfZMpc+BwuM1IPw8fmQBiQ==",
"dev": true,
"dependencies": {
"accepts": "~1.3.8",
@ -8700,7 +8700,7 @@
"body-parser": "1.20.3",
"content-disposition": "0.5.4",
"content-type": "~1.0.4",
"cookie": "0.6.0",
"cookie": "0.7.1",
"cookie-signature": "1.0.6",
"debug": "2.6.9",
"depd": "2.0.0",

2
crates/compiler/collections/Cargo.toml
View file

@ -16,3 +16,5 @@ im-rc.workspace = true
im.workspace = true
wyhash.workspace = true
smallvec.workspace = true
soa.workspace = true

211
crates/compiler/collections/src/soa.rs
View file

@ -1,191 +1,30 @@
use std::usize;
/// Push to a std::vec::Vec<T> and then return an index to that new element's
/// position in the Vec.
///
/// This is not a method on soa::Index because the `soa` is `no_std` by design.
/// Long-term, our arena-allocated vectors should have this as a method!
pub fn index_push_new<T>(vector: &mut Vec<T>, value: T) -> soa::Index<T> {
let index = soa::Index::new(vector.len() as u32);
pub struct Index<T> {
index: u32,
_marker: std::marker::PhantomData<T>,
vector.push(value);
index
}
impl<T> Eq for Index<T> {}
/// Extend a std::vec::Vec<T> and then return a slice to the new elements'
/// positions in the Vec.
///
/// This is not a method on soa::Slice because the `soa` is `no_std` by design.
/// Long-term, our arena-allocated vectors should have this as a method!
pub fn slice_extend_new<T>(
vector: &mut Vec<T>,
values: impl IntoIterator<Item = T>,
) -> soa::Slice<T> {
let start = vector.len() as u32;
impl<T> PartialEq for Index<T> {
fn eq(&self, other: &Self) -> bool {
self.index == other.index
}
}
impl<T> std::hash::Hash for Index<T> {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.index.hash(state);
}
}
impl<T> Clone for Index<T> {
fn clone(&self) -> Self {
*self
}
}
impl<T> Copy for Index<T> {}
impl<T> std::fmt::Debug for Index<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Index({})", self.index)
}
}
impl<T> Index<T> {
pub const fn new(index: u32) -> Self {
Self {
index,
_marker: std::marker::PhantomData,
}
}
pub const fn index(self) -> usize {
self.index as usize
}
pub fn push_new(vector: &mut Vec<T>, value: T) -> Index<T> {
let index = Self::new(vector.len() as _);
vector.push(value);
index
}
pub const fn as_slice(self) -> Slice<T> {
Slice::new(self.index, 1)
}
}
#[derive(PartialEq, Eq)]
pub struct Slice<T> {
length: u16,
start: u32,
_marker: std::marker::PhantomData<T>,
}
impl<T> Clone for Slice<T> {
fn clone(&self) -> Self {
*self
}
}
impl<T> Copy for Slice<T> {}
impl<T> std::fmt::Debug for Slice<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Slice(start = {}, length = {})", self.start, self.length)
}
}
impl<T> Default for Slice<T> {
fn default() -> Self {
Self::empty()
}
}
impl<T> Slice<T> {
pub const fn empty() -> Self {
Self::new(0, 0)
}
pub const fn new(start: u32, length: u16) -> Self {
Self {
start,
length,
_marker: std::marker::PhantomData,
}
}
pub fn extend_new<I>(vector: &mut Vec<T>, values: I) -> Slice<T>
where
I: IntoIterator<Item = T>,
{
let start = vector.len() as u32;
vector.extend(values);
let end = vector.len() as u32;
Self::new(start, (end - start) as u16)
}
pub const fn len(&self) -> usize {
self.length as _
}
pub const fn start(&self) -> usize {
self.start as _
}
pub const fn is_empty(&self) -> bool {
self.length == 0
}
pub const fn indices(&self) -> std::ops::Range<usize> {
self.start as usize..(self.start as usize + self.length as usize)
}
pub fn into_iter(&self) -> impl Iterator<Item = Index<T>> {
self.indices().map(|i| Index::new(i as _))
}
pub const fn at(&self, i: usize) -> Index<T> {
Index::new(self.start + i as u32)
}
}
#[derive(PartialEq, Eq)]
pub struct EitherIndex<T, U> {
index: u32,
_marker: std::marker::PhantomData<(T, U)>,
}
impl<T, U> Clone for EitherIndex<T, U> {
fn clone(&self) -> Self {
*self
}
}
impl<T, U> Copy for EitherIndex<T, U> {}
impl<T, U> std::fmt::Debug for EitherIndex<T, U> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Index({})", self.index)
}
}
impl<T, U> EitherIndex<T, U> {
const MASK: u32 = 1 << 31;
pub const fn from_left(input: Index<T>) -> Self {
assert!(input.index & Self::MASK == 0);
Self {
index: input.index,
_marker: std::marker::PhantomData,
}
}
pub const fn from_right(input: Index<U>) -> Self {
assert!(input.index & Self::MASK == 0);
Self {
index: input.index | Self::MASK,
_marker: std::marker::PhantomData,
}
}
pub const fn split(self) -> Result<Index<T>, Index<U>> {
if self.index & Self::MASK == 0 {
Ok(Index::new(self.index))
} else {
Err(Index::new(self.index ^ Self::MASK))
}
}
pub fn decrement_index(&mut self) {
self.index = self.index.saturating_sub(1);
}
vector.extend(values);
let end = vector.len() as u32;
soa::Slice::new(start, (end - start) as u16)
}

2
crates/compiler/constrain/Cargo.toml
View file

@ -18,3 +18,5 @@ roc_region = { path = "../region" }
roc_types = { path = "../types" }
arrayvec.workspace = true
soa.workspace = true

6
crates/compiler/constrain/src/expr.rs
View file

@ -22,7 +22,6 @@ use roc_can::expr::{
use roc_can::pattern::Pattern;
use roc_can::traverse::symbols_introduced_from_pattern;
use roc_collections::all::{HumanIndex, MutMap, SendMap};
use roc_collections::soa::{Index, Slice};
use roc_collections::VecMap;
use roc_module::ident::Lowercase;
use roc_module::symbol::{ModuleId, Symbol};
@ -33,6 +32,7 @@ use roc_types::types::{
AliasKind, AnnotationSource, Category, IndexOrField, OptAbleType, PReason, Reason, RecordField,
TypeExtension, TypeTag, Types,
};
use soa::{Index, Slice};
/// This is for constraining Defs
#[derive(Default, Debug)]
@ -2969,7 +2969,7 @@ fn constrain_typed_function_arguments(
None
};
let it = arguments.iter().zip(arg_types.into_iter()).enumerate();
let it = arguments.iter().zip(arg_types).enumerate();
for (index, ((pattern_var, annotated_mark, loc_pattern), ann)) in it {
let pattern_var_index = constraints.push_variable(*pattern_var);
let ann_index = constraints.push_type(types, ann);
@ -3123,7 +3123,7 @@ fn constrain_typed_function_arguments_simple(
arguments: &[(Variable, AnnotatedMark, Loc<Pattern>)],
arg_types: Slice<TypeTag>,
) {
let it = arguments.iter().zip(arg_types.into_iter()).enumerate();
let it = arguments.iter().zip(arg_types).enumerate();
for (index, ((pattern_var, annotated_mark, loc_pattern), ann)) in it {
let pattern_var_index = constraints.push_variable(*pattern_var);
let ann_index = constraints.push_type(types, ann);

11
crates/compiler/constrain/src/pattern.rs
View file

@ -5,7 +5,6 @@ use roc_can::expected::{Expected, PExpected};
use roc_can::pattern::Pattern::{self, *};
use roc_can::pattern::{DestructType, ListPatterns, RecordDestruct, TupleDestruct};
use roc_collections::all::{HumanIndex, SendMap};
use roc_collections::soa::Index;
use roc_collections::VecMap;
use roc_module::ident::Lowercase;
use roc_module::symbol::Symbol;
@ -15,6 +14,7 @@ use roc_types::types::{
AliasKind, AliasShared, Category, OptAbleType, PReason, PatternCategory, Reason, RecordField,
Type, TypeExtension, TypeTag, Types,
};
use soa::Index;
#[derive(Default, Debug)]
pub struct PatternState {
@ -171,8 +171,10 @@ fn headers_from_annotation_help(
return false;
}
arguments.iter().zip(arg_types_slice.into_iter()).all(
|(arg_pattern, arg_type)| {
arguments
.iter()
.zip(arg_types_slice)
.all(|(arg_pattern, arg_type)| {
headers_from_annotation_help(
types,
constraints,
@ -180,8 +182,7 @@ fn headers_from_annotation_help(
&Loc::at(annotation.region, arg_type),
headers,
)
},
)
})
} else {
false
}

7
crates/compiler/derive/src/decoding.rs
View file

@ -68,7 +68,8 @@ fn wrap_in_decode_custom_decode_with(
// Decode.decodeWith : bytes, inner_decoder, fmt -> DecoderResult (List val)
let this_decode_with_var_slice =
SubsSlice::insert_into_subs(env.subs, [bytes_var, inner_decoder_var, fmt_var]);
env.subs
.insert_into_vars([bytes_var, inner_decoder_var, fmt_var]);
let this_decode_with_clos_var = env.subs.fresh_unnamed_flex_var();
let this_decode_with_ret_var = env.subs.fresh_unnamed_flex_var();
let this_decode_with_fn_var = synth_var(
@ -131,7 +132,7 @@ fn wrap_in_decode_custom_decode_with(
);
// bytes, fmt -[[fn_name]]-> DecoderResult (List elem)
let args_slice = SubsSlice::insert_into_subs(env.subs, [bytes_var, fmt_var]);
let args_slice = env.subs.insert_into_vars([bytes_var, fmt_var]);
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(
@ -173,7 +174,7 @@ fn wrap_in_decode_custom_decode_with(
let decode_custom_type = env.import_builtin_symbol_var(Symbol::DECODE_CUSTOM);
// (List U8, fmt -> DecodeResult (List elem)) -> Decoder (List elem) fmt
let this_decode_custom_args = SubsSlice::insert_into_subs(env.subs, [custom_var]);
let this_decode_custom_args = env.subs.insert_into_vars([custom_var]);
let this_decode_custom_clos_var = env.subs.fresh_unnamed_flex_var();
let this_decode_custom_ret_var = env.subs.fresh_unnamed_flex_var();
let this_decode_custom_fn_var = synth_var(

4
crates/compiler/derive/src/decoding/list.rs
View file

@ -5,7 +5,7 @@ use roc_module::called_via::CalledVia;
use roc_module::symbol::Symbol;
use roc_region::all::Loc;
use roc_types::subs::{Content, FlatType, GetSubsSlice, SubsSlice, Variable};
use roc_types::subs::{Content, FlatType, GetSubsSlice, Variable};
use roc_types::types::AliasKind;
use crate::decoding::wrap_in_decode_custom_decode_with;
@ -56,7 +56,7 @@ pub(crate) fn decoder(env: &mut Env<'_>, _def_symbol: Symbol) -> (Expr, Variable
let decode_list_fn_var = env.import_builtin_symbol_var(Symbol::DECODE_LIST);
// Decoder elem fmt -a-> b
let elem_decoder_var_slice = SubsSlice::insert_into_subs(env.subs, [elem_decoder_var]);
let elem_decoder_var_slice = env.subs.insert_into_vars([elem_decoder_var]);
let this_decode_list_clos_var = env.subs.fresh_unnamed_flex_var();
let this_decode_list_ret_var = env.subs.fresh_unnamed_flex_var();
let this_decode_list_fn_var = synth_var(

26
crates/compiler/derive/src/decoding/record.rs
View file

@ -9,8 +9,8 @@ use roc_module::ident::Lowercase;
use roc_module::symbol::Symbol;
use roc_region::all::{Loc, Region};
use roc_types::subs::{
Content, ExhaustiveMark, FlatType, LambdaSet, OptVariable, RecordFields, RedundantMark,
SubsSlice, TagExt, UnionLambdas, UnionTags, Variable,
Content, ExhaustiveMark, FlatType, LambdaSet, OptVariable, RecordFields, RedundantMark, TagExt,
UnionLambdas, UnionTags, Variable,
};
use roc_types::types::RecordField;
@ -66,7 +66,7 @@ use super::wrap_in_decode_custom_decode_with;
/// Ok f1 -> Ok { f1, f0 }
/// Err _ -> Err TooShort
/// Err _ -> Err TooShort
///
///
/// Decode.custom \bytes, fmt -> Decode.decodeWith bytes (Decode.record initialState stepField finalizer) fmt
///```
pub(crate) fn decoder(
@ -108,7 +108,8 @@ pub(crate) fn decoder(
let decode_record_var = env.import_builtin_symbol_var(Symbol::DECODE_RECORD);
let this_decode_record_var = {
let flat_type = FlatType::Func(
SubsSlice::insert_into_subs(env.subs, [initial_state_var, step_var, finalizer_var]),
env.subs
.insert_into_vars([initial_state_var, step_var, finalizer_var]),
decode_record_lambda_set,
record_decoder_var,
);
@ -200,7 +201,7 @@ pub(super) fn step_field(
let mut branches = Vec::with_capacity(fields.len() + 1);
let keep_payload_var = env.subs.fresh_unnamed_flex_var();
let keep_or_skip_var = {
let keep_payload_subs_slice = SubsSlice::insert_into_subs(env.subs, [keep_payload_var]);
let keep_payload_subs_slice = env.subs.insert_into_vars([keep_payload_var]);
let flat_type = FlatType::TagUnion(
UnionTags::insert_slices_into_subs(
env.subs,
@ -337,7 +338,7 @@ pub(super) fn step_field(
};
{
let args_slice = SubsSlice::insert_into_subs(env.subs, [state_record_var, Variable::STR]);
let args_slice = env.subs.insert_into_vars([state_record_var, Variable::STR]);
env.subs.set_content(
function_type,
@ -403,7 +404,7 @@ fn custom_decoder(env: &mut Env<'_>, args: DecodingFieldArgs) -> (Variable, Expr
let decode_custom_var = env.import_builtin_symbol_var(Symbol::DECODE_CUSTOM);
let decode_custom_closure_var = env.subs.fresh_unnamed_flex_var();
let this_decode_custom_var = {
let subs_slice = SubsSlice::insert_into_subs(env.subs, [this_custom_callback_var]);
let subs_slice = env.subs.insert_into_vars([this_custom_callback_var]);
let flat_type =
FlatType::Func(subs_slice, decode_custom_closure_var, decode_custom_ret_var);
@ -566,7 +567,7 @@ fn custom_decoder_lambda(env: &mut Env<'_>, args: DecodingFieldArgs) -> (Variabl
ambient_function: this_custom_callback_var,
});
let custom_callback_lambda_set_var = synth_var(env.subs, content);
let subs_slice = SubsSlice::insert_into_subs(env.subs, [bytes_arg_var, fmt_arg_var]);
let subs_slice = env.subs.insert_into_vars([bytes_arg_var, fmt_arg_var]);
env.subs.set_content(
this_custom_callback_var,
@ -979,7 +980,7 @@ pub(super) fn finalizer(
};
let closure_type = synth_var(env.subs, Content::LambdaSet(lambda_set));
let flat_type = FlatType::Func(
SubsSlice::insert_into_subs(env.subs, [state_record_var, fmt_arg_var]),
env.subs.insert_into_vars([state_record_var, fmt_arg_var]),
closure_type,
return_type_var,
);
@ -1020,7 +1021,7 @@ pub(super) fn finalizer(
/// decRec-> decRec.result
/// Ok a -> Ok a
/// ```
/// Tries to decode the field with a zero byte input if it missing,
/// Tries to decode the field with a zero byte input if it missing,
/// this allows the decoder to decode types that have a state for "missing", such as
/// an "Option" type.
///
@ -1266,8 +1267,9 @@ fn make_decode_with_vars(
let decode_with_var = env.import_builtin_symbol_var(Symbol::DECODE_DECODE_WITH);
let lambda_set_var = env.subs.fresh_unnamed_flex_var();
let this_decode_with_var = {
let subs_slice =
SubsSlice::insert_into_subs(env.subs, [bytes_arg_var, decoder_var, fmt_arg_var]);
let subs_slice = env
.subs
.insert_into_vars([bytes_arg_var, decoder_var, fmt_arg_var]);
let this_decode_with_var = synth_var(
env.subs,
Content::Structure(FlatType::Func(subs_slice, lambda_set_var, rec_var)),

25
crates/compiler/derive/src/decoding/tuple.rs
View file

@ -9,8 +9,8 @@ use roc_module::ident::Lowercase;
use roc_module::symbol::Symbol;
use roc_region::all::{Loc, Region};
use roc_types::subs::{
Content, ExhaustiveMark, FlatType, LambdaSet, OptVariable, RecordFields, RedundantMark,
SubsSlice, TagExt, TupleElems, UnionLambdas, UnionTags, Variable,
Content, ExhaustiveMark, FlatType, LambdaSet, OptVariable, RecordFields, RedundantMark, TagExt,
TupleElems, UnionLambdas, UnionTags, Variable,
};
use roc_types::types::RecordField;
@ -98,7 +98,8 @@ pub(crate) fn decoder(env: &mut Env, _def_symbol: Symbol, arity: u32) -> (Expr,
let decode_record_var = env.import_builtin_symbol_var(Symbol::DECODE_TUPLE);
let this_decode_record_var = {
let flat_type = FlatType::Func(
SubsSlice::insert_into_subs(env.subs, [state_var, step_var, finalizer_var]),
env.subs
.insert_into_vars([state_var, step_var, finalizer_var]),
decode_record_lambda_set,
tuple_decoder_var,
);
@ -190,7 +191,7 @@ fn step_elem(
let mut branches = Vec::with_capacity(index_vars.len() + 1);
let keep_payload_var = env.subs.fresh_unnamed_flex_var();
let keep_or_skip_var = {
let keep_payload_subs_slice = SubsSlice::insert_into_subs(env.subs, [keep_payload_var]);
let keep_payload_subs_slice = env.subs.insert_into_vars([keep_payload_var]);
let flat_type = FlatType::TagUnion(
UnionTags::insert_slices_into_subs(
env.subs,
@ -270,10 +271,9 @@ fn step_elem(
let decode_with_var = env.import_builtin_symbol_var(Symbol::DECODE_DECODE_WITH);
let lambda_set_var = env.subs.fresh_unnamed_flex_var();
let this_decode_with_var = {
let subs_slice = SubsSlice::insert_into_subs(
env.subs,
[bytes_arg_var, decoder_var, fmt_arg_var],
);
let subs_slice =
env.subs
.insert_into_vars([bytes_arg_var, decoder_var, fmt_arg_var]);
let this_decode_with_var = synth_var(
env.subs,
Content::Structure(FlatType::Func(subs_slice, lambda_set_var, rec_var)),
@ -537,8 +537,7 @@ fn step_elem(
ambient_function: this_custom_callback_var,
});
let custom_callback_lambda_set_var = synth_var(env.subs, content);
let subs_slice =
SubsSlice::insert_into_subs(env.subs, [bytes_arg_var, fmt_arg_var]);
let subs_slice = env.subs.insert_into_vars([bytes_arg_var, fmt_arg_var]);
env.subs.set_content(
this_custom_callback_var,
@ -581,7 +580,7 @@ fn step_elem(
let decode_custom_var = env.import_builtin_symbol_var(Symbol::DECODE_CUSTOM);
let decode_custom_closure_var = env.subs.fresh_unnamed_flex_var();
let this_decode_custom_var = {
let subs_slice = SubsSlice::insert_into_subs(env.subs, [this_custom_callback_var]);
let subs_slice = env.subs.insert_into_vars([this_custom_callback_var]);
let flat_type =
FlatType::Func(subs_slice, decode_custom_closure_var, decode_custom_ret_var);
@ -699,7 +698,7 @@ fn step_elem(
};
{
let args_slice = SubsSlice::insert_into_subs(env.subs, [state_record_var, Variable::U64]);
let args_slice = env.subs.insert_into_vars([state_record_var, Variable::U64]);
env.subs.set_content(
function_type,
@ -884,7 +883,7 @@ fn finalizer(
};
let closure_type = synth_var(env.subs, Content::LambdaSet(lambda_set));
let flat_type = FlatType::Func(
SubsSlice::insert_into_subs(env.subs, [state_record_var]),
env.subs.insert_into_vars([state_record_var]),
closure_type,
return_type_var,
);

52
crates/compiler/derive/src/encoding.rs
View file

@ -71,8 +71,7 @@ pub(crate) fn derive_to_encoder(
let flex_tag_labels = tags
.into_iter()
.map(|(label, arity)| {
let variables_slice =
VariableSubsSlice::reserve_into_subs(env.subs, arity.into());
let variables_slice = env.subs.reserve_into_vars(arity.into());
for var_index in variables_slice {
env.subs[var_index] = env.subs.fresh_unnamed_flex_var();
}
@ -114,7 +113,7 @@ fn to_encoder_list(env: &mut Env<'_>, fn_name: Symbol) -> (Expr, Variable) {
// List elem
let elem_var = env.subs.fresh_unnamed_flex_var();
let elem_var_slice = SubsSlice::insert_into_subs(env.subs, [elem_var]);
let elem_var_slice = env.subs.insert_into_vars([elem_var]);
let list_var = synth_var(
env.subs,
Content::Structure(FlatType::Apply(Symbol::LIST_LIST, elem_var_slice)),
@ -205,8 +204,9 @@ fn to_encoder_list(env: &mut Env<'_>, fn_name: Symbol) -> (Expr, Variable) {
let encode_list_fn_var = env.import_builtin_symbol_var(Symbol::ENCODE_LIST);
// List elem, to_elem_encoder_fn_var -[clos]-> t1
let this_encode_list_args_slice =
VariableSubsSlice::insert_into_subs(env.subs, [list_var, to_elem_encoder_fn_var]);
let this_encode_list_args_slice = env
.subs
.insert_into_vars([list_var, to_elem_encoder_fn_var]);
let this_encode_list_clos_var = env.subs.fresh_unnamed_flex_var(); // clos
let this_list_encoder_var = env.subs.fresh_unnamed_flex_var(); // t1
let this_encode_list_fn_var = synth_var(
@ -266,7 +266,7 @@ fn to_encoder_list(env: &mut Env<'_>, fn_name: Symbol) -> (Expr, Variable) {
}),
);
// List elem -[fn_name]-> Encoder fmt
let list_var_slice = SubsSlice::insert_into_subs(env.subs, once(list_var));
let list_var_slice = env.subs.insert_into_vars(once(list_var));
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(
@ -318,7 +318,7 @@ fn to_encoder_record(
.map(|(field_name_index, field_var_index, _)| {
let field_name = env.subs[field_name_index].clone();
let field_var = env.subs[field_var_index];
let field_var_slice = VariableSubsSlice::new(field_var_index.index, 1);
let field_var_slice = VariableSubsSlice::new(field_var_index.index() as u32, 1);
// key: "a"
let key_field = Field {
@ -407,7 +407,7 @@ fn to_encoder_record(
.collect::<Vec<_>>();
// typeof [ { key: .., value: .. }, { key: .., value: .. } ]
let fields_rcd_var_slice = VariableSubsSlice::insert_into_subs(env.subs, once(whole_rcd_var));
let fields_rcd_var_slice = env.subs.insert_into_vars(once(whole_rcd_var));
let fields_list_var = synth_var(
env.subs,
Content::Structure(FlatType::Apply(Symbol::LIST_LIST, fields_rcd_var_slice)),
@ -424,8 +424,7 @@ fn to_encoder_record(
let encode_record_fn_var = env.import_builtin_symbol_var(Symbol::ENCODE_RECORD);
// fields_list_var -[clos]-> t1
let fields_list_var_slice =
VariableSubsSlice::insert_into_subs(env.subs, once(fields_list_var));
let fields_list_var_slice = env.subs.insert_into_vars(once(fields_list_var));
let encode_record_clos_var = env.subs.fresh_unnamed_flex_var(); // clos
let encoder_var = env.subs.fresh_unnamed_flex_var(); // t1
let this_encode_record_fn_var = synth_var(
@ -476,7 +475,7 @@ fn to_encoder_record(
}),
);
// typeof rcd -[fn_name]-> (typeof Encode.record [ .. ] = Encoder fmt)
let record_var_slice = SubsSlice::insert_into_subs(env.subs, once(record_var));
let record_var_slice = env.subs.insert_into_vars(once(record_var));
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(
@ -528,7 +527,7 @@ fn to_encoder_tuple(
.map(|(elem_index, elem_var_index)| {
let index = env.subs[elem_index];
let elem_var = env.subs[elem_var_index];
let elem_var_slice = VariableSubsSlice::new(elem_var_index.index, 1);
let elem_var_slice = VariableSubsSlice::new(elem_var_index.index() as u32, 1);
// tup.0
let tuple_access = TupleAccess {
@ -587,7 +586,7 @@ fn to_encoder_tuple(
// typeof [ toEncoder tup.0, toEncoder tup.1 ]
let whole_encoder_in_list_var_slice =
VariableSubsSlice::insert_into_subs(env.subs, once(whole_encoder_in_list_var));
env.subs.insert_into_vars(once(whole_encoder_in_list_var));
let elem_encoders_list_var = synth_var(
env.subs,
Content::Structure(FlatType::Apply(
@ -607,8 +606,7 @@ fn to_encoder_tuple(
let encode_tuple_fn_var = env.import_builtin_symbol_var(Symbol::ENCODE_TUPLE);
// elem_encoders_list_var -[clos]-> t1
let elem_encoders_list_var_slice =
VariableSubsSlice::insert_into_subs(env.subs, once(elem_encoders_list_var));
let elem_encoders_list_var_slice = env.subs.insert_into_vars(once(elem_encoders_list_var));
let encode_tuple_clos_var = env.subs.fresh_unnamed_flex_var(); // clos
let encoder_var = env.subs.fresh_unnamed_flex_var(); // t1
let this_encode_tuple_fn_var = synth_var(
@ -659,7 +657,7 @@ fn to_encoder_tuple(
}),
);
// typeof tup -[fn_name]-> (typeof Encode.tuple [ .. ] = Encoder fmt)
let tuple_var_slice = SubsSlice::insert_into_subs(env.subs, once(tuple_var));
let tuple_var_slice = env.subs.insert_into_vars(once(tuple_var));
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(
@ -746,8 +744,7 @@ fn to_encoder_tag_union(
env.import_builtin_symbol_var(Symbol::ENCODE_TO_ENCODER);
// wanted: t1 -[clos]-> t'
let var_slice_of_sym_var =
VariableSubsSlice::insert_into_subs(env.subs, [sym_var]); // [ t1 ]
let var_slice_of_sym_var = env.subs.insert_into_vars([sym_var]); // [ t1 ]
let to_encoder_clos_var = env.subs.fresh_unnamed_flex_var(); // clos
let encoder_var = env.subs.fresh_unnamed_flex_var(); // t'
let this_to_encoder_fn_var = synth_var(
@ -788,8 +785,7 @@ fn to_encoder_tag_union(
.collect();
// typeof [ Encode.toEncoder v1, Encode.toEncoder v2 ]
let whole_encoders_var_slice =
VariableSubsSlice::insert_into_subs(env.subs, [whole_payload_encoders_var]);
let whole_encoders_var_slice = env.subs.insert_into_vars([whole_payload_encoders_var]);
let payload_encoders_list_var = synth_var(
env.subs,
Content::Structure(FlatType::Apply(Symbol::LIST_LIST, whole_encoders_var_slice)),
@ -806,10 +802,9 @@ fn to_encoder_tag_union(
let encode_tag_fn_var = env.import_builtin_symbol_var(Symbol::ENCODE_TAG);
// wanted: Str, List whole_encoders_var -[clos]-> t'
let this_encode_tag_args_var_slice = VariableSubsSlice::insert_into_subs(
env.subs,
[Variable::STR, payload_encoders_list_var],
);
let this_encode_tag_args_var_slice = env
.subs
.insert_into_vars([Variable::STR, payload_encoders_list_var]);
let this_encode_tag_clos_var = env.subs.fresh_unnamed_flex_var(); // -[clos]->
let this_encoder_var = env.subs.fresh_unnamed_flex_var(); // t'
let this_encode_tag_fn_var = synth_var(
@ -899,7 +894,7 @@ fn to_encoder_tag_union(
}),
);
// tag_union_var -[fn_name]-> whole_tag_encoders_var
let tag_union_var_slice = SubsSlice::insert_into_subs(env.subs, once(tag_union_var));
let tag_union_var_slice = env.subs.insert_into_vars(once(tag_union_var));
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(
@ -964,7 +959,8 @@ fn wrap_in_encode_custom(
// wanted: Encode.appendWith : List U8, encoder_var, fmt -[clos]-> List U8 where fmt implements EncoderFormatting
let this_append_with_args_var_slice =
VariableSubsSlice::insert_into_subs(env.subs, [Variable::LIST_U8, encoder_var, fmt_var]);
env.subs
.insert_into_vars([Variable::LIST_U8, encoder_var, fmt_var]);
let this_append_with_clos_var = env.subs.fresh_unnamed_flex_var(); // -[clos]->
let this_append_with_fn_var = synth_var(
env.subs,
@ -1018,7 +1014,7 @@ fn wrap_in_encode_custom(
);
// bytes, fmt -[[FN_name captured_var]]-> Encode.appendWith bytes encoder fmt
let args_slice = SubsSlice::insert_into_subs(env.subs, vec![bytes_var, fmt_var]);
let args_slice = env.subs.insert_into_vars(vec![bytes_var, fmt_var]);
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(args_slice, fn_clos_var, Variable::LIST_U8)),
@ -1054,7 +1050,7 @@ fn wrap_in_encode_custom(
let custom_fn_var = env.import_builtin_symbol_var(Symbol::ENCODE_CUSTOM);
// wanted: Encode.custom : fn_var -[clos]-> t'
let this_custom_args_var_slice = VariableSubsSlice::insert_into_subs(env.subs, [fn_var]);
let this_custom_args_var_slice = env.subs.insert_into_vars([fn_var]);
let this_custom_clos_var = env.subs.fresh_unnamed_flex_var(); // -[clos]->
let this_custom_encoder_var = env.subs.fresh_unnamed_flex_var(); // t'
let this_custom_fn_var = synth_var(

17
crates/compiler/derive/src/hash.rs
View file

@ -7,6 +7,7 @@ use roc_can::{
num::{IntBound, IntLitWidth},
pattern::Pattern,
};
use roc_collections::soa::{index_push_new, slice_extend_new};
use roc_derive_key::hash::FlatHashKey;
use roc_error_macros::internal_error;
use roc_module::{
@ -19,8 +20,7 @@ use roc_types::{
num::int_lit_width_to_variable,
subs::{
Content, ExhaustiveMark, FlatType, GetSubsSlice, LambdaSet, OptVariable, RecordFields,
RedundantMark, Subs, SubsIndex, SubsSlice, TagExt, TupleElems, UnionLambdas, UnionTags,
Variable, VariableSubsSlice,
RedundantMark, Subs, SubsSlice, TagExt, TupleElems, UnionLambdas, UnionTags, Variable,
},
types::RecordField,
};
@ -206,7 +206,7 @@ fn hash_tag_union(
let flex_tag_labels = tags
.into_iter()
.map(|(label, arity)| {
let variables_slice = VariableSubsSlice::reserve_into_subs(env.subs, arity.into());
let variables_slice = env.subs.reserve_into_vars(arity.into());
for var_index in variables_slice {
env.subs[var_index] = env.subs.fresh_unnamed_flex_var();
}
@ -366,14 +366,14 @@ fn hash_newtype_tag_union(
let (union_var, tag_name, payload_variables) = {
let (label, arity) = tag;
let variables_slice = VariableSubsSlice::reserve_into_subs(env.subs, arity.into());
let variables_slice = env.subs.reserve_into_vars(arity.into());
for var_index in variables_slice {
env.subs[var_index] = env.subs.fresh_unnamed_flex_var();
}
let variables_slices_slice =
SubsSlice::extend_new(&mut env.subs.variable_slices, [variables_slice]);
let tag_name_index = SubsIndex::push_new(&mut env.subs.tag_names, label.clone());
slice_extend_new(&mut env.subs.variable_slices, [variables_slice]);
let tag_name_index = index_push_new(&mut env.subs.tag_names, label.clone());
let union_tags = UnionTags::from_slices(tag_name_index.as_slice(), variables_slices_slice);
let tag_union_var = synth_var(
@ -466,8 +466,7 @@ fn call_hash_ability_member(
let exposed_hash_fn_var = env.import_builtin_symbol_var(member);
// (typeof body), (typeof field) -[clos]-> hasher_result
let this_arguments_slice =
VariableSubsSlice::insert_into_subs(env.subs, [in_hasher_var, in_val_var]);
let this_arguments_slice = env.subs.insert_into_vars([in_hasher_var, in_val_var]);
let this_hash_clos_var = env.subs.fresh_unnamed_flex_var();
let this_out_hasher_var = env.subs.fresh_unnamed_flex_var();
let this_hash_fn_var = synth_var(
@ -530,7 +529,7 @@ fn build_outer_derived_closure(
);
// hasher, rcd_var -[fn_name]-> (hasher = body_var)
let args_slice = SubsSlice::insert_into_subs(env.subs, [hasher_var, val_var]);
let args_slice = env.subs.insert_into_vars([hasher_var, val_var]);
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(args_slice, fn_clos_var, body_var)),

53
crates/compiler/derive/src/inspect.rs
View file

@ -71,8 +71,7 @@ pub(crate) fn derive_to_inspector(
let flex_tag_labels = tags
.into_iter()
.map(|(label, arity)| {
let variables_slice =
VariableSubsSlice::reserve_into_subs(env.subs, arity.into());
let variables_slice = env.subs.reserve_into_vars(arity.into());
for var_index in variables_slice {
env.subs[var_index] = env.subs.fresh_unnamed_flex_var();
}
@ -119,7 +118,7 @@ fn to_inspector_list(env: &mut Env<'_>, fn_name: Symbol) -> (Expr, Variable) {
// List elem
let elem_var = env.subs.fresh_unnamed_flex_var();
let elem_var_slice = SubsSlice::insert_into_subs(env.subs, [elem_var]);
let elem_var_slice = env.subs.insert_into_vars([elem_var]);
let list_var = synth_var(
env.subs,
Content::Structure(FlatType::Apply(Symbol::LIST_LIST, elem_var_slice)),
@ -212,10 +211,9 @@ fn to_inspector_list(env: &mut Env<'_>, fn_name: Symbol) -> (Expr, Variable) {
// List elem, List.walk, to_elem_inspector_fn_var -[clos]-> t1
let list_walk_fn_var = env.import_builtin_symbol_var(Symbol::LIST_WALK);
let this_inspect_list_args_slice = VariableSubsSlice::insert_into_subs(
env.subs,
[list_var, list_walk_fn_var, to_elem_inspector_fn_var],
);
let this_inspect_list_args_slice =
env.subs
.insert_into_vars([list_var, list_walk_fn_var, to_elem_inspector_fn_var]);
let this_inspect_list_clos_var = env.subs.fresh_unnamed_flex_var(); // clos
let this_list_inspector_var = env.subs.fresh_unnamed_flex_var(); // t1
let this_inspect_list_fn_var = synth_var(
@ -279,7 +277,7 @@ fn to_inspector_list(env: &mut Env<'_>, fn_name: Symbol) -> (Expr, Variable) {
}),
);
// List elem -[fn_name]-> Inspector fmt
let list_var_slice = SubsSlice::insert_into_subs(env.subs, once(list_var));
let list_var_slice = env.subs.insert_into_vars(once(list_var));
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(
@ -331,7 +329,7 @@ fn to_inspector_record(
.map(|(field_name_index, field_var_index, _)| {
let field_name = env.subs[field_name_index].clone();
let field_var = env.subs[field_var_index];
let field_var_slice = VariableSubsSlice::new(field_var_index.index, 1);
let field_var_slice = VariableSubsSlice::new(field_var_index.index() as u32, 1);
// key: "a"
let key_field = Field {
@ -421,7 +419,7 @@ fn to_inspector_record(
.collect::<Vec<_>>();
// typeof [ { key: .., value: .. }, { key: .., value: .. } ]
let fields_rcd_var_slice = VariableSubsSlice::insert_into_subs(env.subs, once(whole_rcd_var));
let fields_rcd_var_slice = env.subs.insert_into_vars(once(whole_rcd_var));
let fields_list_var = synth_var(
env.subs,
Content::Structure(FlatType::Apply(Symbol::LIST_LIST, fields_rcd_var_slice)),
@ -438,8 +436,7 @@ fn to_inspector_record(
let inspect_record_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_RECORD);
// fields_list_var -[clos]-> t1
let fields_list_var_slice =
VariableSubsSlice::insert_into_subs(env.subs, once(fields_list_var));
let fields_list_var_slice = env.subs.insert_into_vars(once(fields_list_var));
let inspect_record_clos_var = env.subs.fresh_unnamed_flex_var(); // clos
let inspector_var = env.subs.fresh_unnamed_flex_var(); // t1
let this_inspect_record_fn_var = synth_var(
@ -490,7 +487,7 @@ fn to_inspector_record(
}),
);
// typeof rcd -[fn_name]-> (typeof Inspect.record [ .. ] = Inspector fmt)
let record_var_slice = SubsSlice::insert_into_subs(env.subs, once(record_var));
let record_var_slice = env.subs.insert_into_vars(once(record_var));
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(
@ -542,7 +539,7 @@ fn to_inspector_tuple(
.map(|(elem_index, elem_var_index)| {
let index = env.subs[elem_index];
let elem_var = env.subs[elem_var_index];
let elem_var_slice = VariableSubsSlice::new(elem_var_index.index, 1);
let elem_var_slice = VariableSubsSlice::new(elem_var_index.index() as u32, 1);
// tup.0
let tuple_access = TupleAccess {
@ -602,7 +599,7 @@ fn to_inspector_tuple(
// typeof [ toInspector tup.0, toInspector tup.1 ]
let whole_inspector_in_list_var_slice =
VariableSubsSlice::insert_into_subs(env.subs, once(whole_inspector_in_list_var));
env.subs.insert_into_vars(once(whole_inspector_in_list_var));
let elem_inspectors_list_var = synth_var(
env.subs,
Content::Structure(FlatType::Apply(
@ -622,8 +619,7 @@ fn to_inspector_tuple(
let inspect_tuple_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_TUPLE);
// elem_inspectors_list_var -[clos]-> t1
let elem_inspectors_list_var_slice =
VariableSubsSlice::insert_into_subs(env.subs, once(elem_inspectors_list_var));
let elem_inspectors_list_var_slice = env.subs.insert_into_vars(once(elem_inspectors_list_var));
let inspect_tuple_clos_var = env.subs.fresh_unnamed_flex_var(); // clos
let inspector_var = env.subs.fresh_unnamed_flex_var(); // t1
let this_inspect_tuple_fn_var = synth_var(
@ -674,7 +670,7 @@ fn to_inspector_tuple(
}),
);
// typeof tup -[fn_name]-> (typeof Inspect.tuple [ .. ] = Inspector fmt)
let tuple_var_slice = SubsSlice::insert_into_subs(env.subs, once(tuple_var));
let tuple_var_slice = env.subs.insert_into_vars(once(tuple_var));
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(
@ -761,8 +757,7 @@ fn to_inspector_tag_union(
env.import_builtin_symbol_var(Symbol::INSPECT_TO_INSPECTOR);
// wanted: t1 -[clos]-> t'
let var_slice_of_sym_var =
VariableSubsSlice::insert_into_subs(env.subs, [sym_var]); // [ t1 ]
let var_slice_of_sym_var = env.subs.insert_into_vars([sym_var]); // [ t1 ]
let to_inspector_clos_var = env.subs.fresh_unnamed_flex_var(); // clos
let inspector_var = env.subs.fresh_unnamed_flex_var(); // t'
let this_to_inspector_fn_var = synth_var(
@ -804,7 +799,7 @@ fn to_inspector_tag_union(
// typeof [ Inspect.toInspector v1, Inspect.toInspector v2 ]
let whole_inspectors_var_slice =
VariableSubsSlice::insert_into_subs(env.subs, [whole_payload_inspectors_var]);
env.subs.insert_into_vars([whole_payload_inspectors_var]);
let payload_inspectors_list_var = synth_var(
env.subs,
Content::Structure(FlatType::Apply(
@ -824,10 +819,9 @@ fn to_inspector_tag_union(
let inspect_tag_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_TAG);
// wanted: Str, List whole_inspectors_var -[clos]-> t'
let this_inspect_tag_args_var_slice = VariableSubsSlice::insert_into_subs(
env.subs,
[Variable::STR, payload_inspectors_list_var],
);
let this_inspect_tag_args_var_slice = env
.subs
.insert_into_vars([Variable::STR, payload_inspectors_list_var]);
let this_inspect_tag_clos_var = env.subs.fresh_unnamed_flex_var(); // -[clos]->
let this_inspector_var = env.subs.fresh_unnamed_flex_var(); // t'
let this_inspect_tag_fn_var = synth_var(
@ -917,7 +911,7 @@ fn to_inspector_tag_union(
}),
);
// tag_union_var -[fn_name]-> whole_tag_inspectors_var
let tag_union_var_slice = SubsSlice::insert_into_subs(env.subs, once(tag_union_var));
let tag_union_var_slice = env.subs.insert_into_vars(once(tag_union_var));
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(
@ -972,8 +966,7 @@ fn wrap_in_inspect_custom(
let apply_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_APPLY);
// wanted: Inspect.apply : inspector_var, fmt -[clos]-> fmt where fmt implements InspectorFormatter
let this_apply_args_var_slice =
VariableSubsSlice::insert_into_subs(env.subs, [inspector_var, fmt_var]);
let this_apply_args_var_slice = env.subs.insert_into_vars([inspector_var, fmt_var]);
let this_apply_clos_var = env.subs.fresh_unnamed_flex_var(); // -[clos]->
let this_apply_fn_var = synth_var(
env.subs,
@ -1025,7 +1018,7 @@ fn wrap_in_inspect_custom(
);
// fmt -[[FN_name captured_var]]-> Inspect.apply inspector fmt
let args_slice = SubsSlice::insert_into_subs(env.subs, vec![fmt_var]);
let args_slice = env.subs.insert_into_vars(vec![fmt_var]);
env.subs.set_content(
fn_var,
Content::Structure(FlatType::Func(args_slice, fn_clos_var, fmt_var)),
@ -1054,7 +1047,7 @@ fn wrap_in_inspect_custom(
let custom_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_CUSTOM);
// wanted: Inspect.custom : fn_var -[clos]-> t'
let this_custom_args_var_slice = VariableSubsSlice::insert_into_subs(env.subs, [fn_var]);
let this_custom_args_var_slice = env.subs.insert_into_vars([fn_var]);
let this_custom_clos_var = env.subs.fresh_unnamed_flex_var(); // -[clos]->
let this_custom_inspector_var = env.subs.fresh_unnamed_flex_var(); // t'
let this_custom_fn_var = synth_var(

2
crates/compiler/fmt/src/expr.rs
View file

@ -662,7 +662,7 @@ fn format_str_segment(seg: &StrSegment, buf: &mut Buf, indent: u16) {
buf.push('\\');
buf.push(escaped.to_parsed_char());
}
DeprecatedInterpolated(loc_expr) | Interpolated(loc_expr) => {
Interpolated(loc_expr) => {
buf.push_str("$(");
// e.g. (name) in "Hi, $(name)!"
loc_expr.value.format_with_options(

2
crates/compiler/gen_dev/src/generic64/mod.rs
View file

@ -1786,7 +1786,7 @@ impl<
fn build_num_neg(&mut self, dst: &Symbol, src: &Symbol, layout: &InLayout<'a>) {
match self.layout_interner.get_repr(*layout) {
LayoutRepr::Builtin(Builtin::Int(IntWidth::I64 | IntWidth::U64)) => {
LayoutRepr::Builtin(Builtin::Int(quadword_and_smaller!())) => {
let dst_reg = self.storage_manager.claim_general_reg(&mut self.buf, dst);
let src_reg = self.storage_manager.load_to_general_reg(&mut self.buf, src);
ASM::neg_reg64_reg64(&mut self.buf, dst_reg, src_reg);

5
crates/compiler/load/tests/test_reporting.rs
View file

@ -5657,7 +5657,7 @@ mod test_reporting {
test_report!(
weird_escape,
r#""abc\qdef""#,
@r###"
@r#"
── WEIRD ESCAPE in tmp/weird_escape/Test.roc ───────────────────────────────────
I was partway through parsing a string literal, but I got stuck here:
@ -5674,8 +5674,7 @@ mod test_reporting {
- An escaped quote: \"
- An escaped backslash: \\
- A unicode code point: \u(00FF)
- An interpolated string: $(myVariable)
"###
"#
);
test_report!(

5
crates/compiler/load_internal/src/file.rs
View file

@ -20,6 +20,7 @@ use roc_can::module::{
canonicalize_module_defs, ExposedByModule, ExposedForModule, ExposedModuleTypes, Module,
ModuleParams, ResolvedImplementations, TypeState,
};
use roc_collections::soa::slice_extend_new;
use roc_collections::{default_hasher, BumpMap, MutMap, MutSet, VecMap, VecSet};
use roc_constrain::module::constrain_module;
use roc_debug_flags::dbg_do;
@ -4372,7 +4373,7 @@ fn synth_list_len_type(subs: &mut Subs) -> Variable {
// List.len : List a -> U64
let a = synth_import(subs, Content::FlexVar(None));
let a_slice = SubsSlice::extend_new(&mut subs.variables, [a]);
let a_slice = slice_extend_new(&mut subs.variables, [a]);
let list_a = synth_import(
subs,
Content::Structure(FlatType::Apply(Symbol::LIST_LIST, a_slice)),
@ -4388,7 +4389,7 @@ fn synth_list_len_type(subs: &mut Subs) -> Variable {
ambient_function: fn_var,
}),
);
let fn_args_slice = SubsSlice::extend_new(&mut subs.variables, [list_a]);
let fn_args_slice = slice_extend_new(&mut subs.variables, [list_a]);
subs.set_content(
fn_var,
Content::Structure(FlatType::Func(fn_args_slice, clos_list_len, Variable::U64)),

4
crates/compiler/mono/src/ir.rs
View file

@ -10124,7 +10124,7 @@ fn find_lambda_sets_help(
| FlatType::RecursiveTagUnion(_, union_tags, ext) => {
for tag in union_tags.variables() {
stack.extend(
subs.get_subs_slice(subs.variable_slices[tag.index as usize])
subs.get_subs_slice(subs.variable_slices[tag.index()])
.iter()
.rev(),
);
@ -10146,7 +10146,7 @@ fn find_lambda_sets_help(
// the lambda set itself should already be caught by Func above, but the
// capture can itself contain more lambda sets
for index in lambda_set.solved.variables() {
let subs_slice = subs.variable_slices[index.index as usize];
let subs_slice = subs.variable_slices[index.index()];
stack.extend(subs.variables[subs_slice.indices()].iter());
}
}

2
crates/compiler/parse/Cargo.toml
View file

@ -16,6 +16,8 @@ roc_module = { path = "../module" }
roc_region = { path = "../region" }
roc_error_macros = { path = "../../error_macros" }
soa.workspace = true
bumpalo.workspace = true
encode_unicode.workspace = true

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

@ -8,11 +8,12 @@ use crate::ident::Accessor;
use crate::parser::ESingleQuote;
use bumpalo::collections::{String, Vec};
use bumpalo::Bump;
use roc_collections::soa::{EitherIndex, Index, Slice};
use roc_collections::soa::{index_push_new, slice_extend_new};
use roc_error_macros::internal_error;
use roc_module::called_via::{BinOp, CalledVia, UnaryOp};
use roc_module::ident::QualifiedModuleName;
use roc_region::all::{Loc, Position, Region};
use soa::{EitherIndex, Slice};
#[derive(Debug, Clone)]
pub struct FullAst<'a> {
@ -281,11 +282,10 @@ pub struct WhenPattern<'a> {
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum StrSegment<'a> {
Plaintext(&'a str), // e.g. "foo"
Unicode(Loc<&'a str>), // e.g. "00A0" in "\u(00A0)"
EscapedChar(EscapedChar), // e.g. '\n' in "Hello!\n"
Interpolated(Loc<&'a Expr<'a>>),
DeprecatedInterpolated(Loc<&'a Expr<'a>>), // The old "$(...)" syntax - will be removed someday
Plaintext(&'a str), // e.g. "foo"
Unicode(Loc<&'a str>), // e.g. "00A0" in "\u(00A0)"
EscapedChar(EscapedChar), // e.g. '\n' in "Hello!\n"
Interpolated(Loc<&'a Expr<'a>>), // e.g. "$(expr)"
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
@ -379,7 +379,6 @@ impl<'a> TryFrom<StrSegment<'a>> for SingleQuoteSegment<'a> {
StrSegment::Unicode(s) => Ok(SingleQuoteSegment::Unicode(s)),
StrSegment::EscapedChar(s) => Ok(SingleQuoteSegment::EscapedChar(s)),
StrSegment::Interpolated(_) => Err(ESingleQuote::InterpolationNotAllowed),
StrSegment::DeprecatedInterpolated(_) => Err(ESingleQuote::InterpolationNotAllowed),
}
}
}
@ -1313,10 +1312,10 @@ impl<'a> Defs<'a> {
self.regions.push(region);
let before = Slice::extend_new(&mut self.spaces, spaces_before.iter().copied());
let before = slice_extend_new(&mut self.spaces, spaces_before.iter().copied());
self.space_before.push(before);
let after = Slice::extend_new(&mut self.spaces, spaces_after.iter().copied());
let after = slice_extend_new(&mut self.spaces, spaces_after.iter().copied());
self.space_after.push(after);
}
@ -1327,7 +1326,7 @@ impl<'a> Defs<'a> {
spaces_before: &[CommentOrNewline<'a>],
spaces_after: &[CommentOrNewline<'a>],
) {
let value_def_index = Index::push_new(&mut self.value_defs, value_def);
let value_def_index = index_push_new(&mut self.value_defs, value_def);
let tag = EitherIndex::from_right(value_def_index);
self.push_def_help(tag, region, spaces_before, spaces_after)
}
@ -1361,7 +1360,7 @@ impl<'a> Defs<'a> {
spaces_before: &[CommentOrNewline<'a>],
spaces_after: &[CommentOrNewline<'a>],
) {
let type_def_index = Index::push_new(&mut self.type_defs, type_def);
let type_def_index = index_push_new(&mut self.type_defs, type_def);
let tag = EitherIndex::from_left(type_def_index);
self.push_def_help(tag, region, spaces_before, spaces_after)
}
@ -1376,13 +1375,13 @@ impl<'a> Defs<'a> {
for (tag_index, tag) in self.tags.iter().enumerate() {
let region = self.regions[tag_index];
let space_before = {
let start = self.space_before[tag_index].start();
let start = self.space_before[tag_index].start() as usize;
let len = self.space_before[tag_index].len();
&self.spaces[start..(start + len)]
};
let space_after = {
let start = self.space_after[tag_index].start();
let start = self.space_after[tag_index].start() as usize;
let len = self.space_after[tag_index].len();
&self.spaces[start..(start + len)]
@ -1395,13 +1394,13 @@ impl<'a> Defs<'a> {
match tag_index.cmp(&target) {
std::cmp::Ordering::Less => {
// before
let type_def_index = Index::push_new(&mut before.type_defs, type_def);
let type_def_index = index_push_new(&mut before.type_defs, type_def);
let tag = EitherIndex::from_left(type_def_index);
before.push_def_help(tag, region, space_before, space_after);
}
std::cmp::Ordering::Greater => {
// after
let type_def_index = Index::push_new(&mut after.type_defs, type_def);
let type_def_index = index_push_new(&mut after.type_defs, type_def);
let tag = EitherIndex::from_left(type_def_index);
after.push_def_help(tag, region, space_before, space_after);
}
@ -1417,14 +1416,14 @@ impl<'a> Defs<'a> {
std::cmp::Ordering::Less => {
// before
let new_value_def_index =
Index::push_new(&mut before.value_defs, value_def);
index_push_new(&mut before.value_defs, value_def);
let tag = EitherIndex::from_right(new_value_def_index);
before.push_def_help(tag, region, space_before, space_after);
}
std::cmp::Ordering::Greater => {
// after
let new_value_def_index =
Index::push_new(&mut after.value_defs, value_def);
index_push_new(&mut after.value_defs, value_def);
let tag = EitherIndex::from_right(new_value_def_index);
after.push_def_help(tag, region, space_before, space_after);
}
@ -2516,9 +2515,7 @@ impl<'a> Malformed for StrSegment<'a> {
fn is_malformed(&self) -> bool {
match self {
StrSegment::Plaintext(_) | StrSegment::Unicode(_) | StrSegment::EscapedChar(_) => false,
StrSegment::Interpolated(expr) | StrSegment::DeprecatedInterpolated(expr) => {
expr.is_malformed()
}
StrSegment::Interpolated(expr) => expr.is_malformed(),
}
}
}

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

@ -28,7 +28,7 @@ use crate::type_annotation;
use crate::{header, keyword};
use bumpalo::collections::Vec;
use bumpalo::Bump;
use roc_collections::soa::Slice;
use roc_collections::soa::slice_extend_new;
use roc_error_macros::internal_error;
use roc_module::called_via::{BinOp, CalledVia, UnaryOp};
use roc_region::all::{Loc, Position, Region};
@ -2286,7 +2286,7 @@ pub fn parse_top_level_defs<'a>(
}
if output.tags.len() > existing_len {
let after = Slice::extend_new(&mut output.spaces, last_space.iter().copied());
let after = slice_extend_new(&mut output.spaces, last_space.iter().copied());
let last = output.tags.len() - 1;
debug_assert!(output.space_after[last].is_empty() || after.is_empty());
output.space_after[last] = after;

8
crates/compiler/parse/src/normalize.rs
View file

@ -649,13 +649,6 @@ fn normalize_str_segments<'a>(
}
new_segments.push(StrSegment::Interpolated(e.normalize(arena)));
}
StrSegment::DeprecatedInterpolated(e) => {
if !last_text.is_empty() {
let text = std::mem::replace(last_text, String::new_in(arena));
new_segments.push(StrSegment::Plaintext(text.into_bump_str()));
}
new_segments.push(StrSegment::Interpolated(e.normalize(arena)));
}
}
}
}
@ -680,7 +673,6 @@ impl<'a> Normalize<'a> for StrSegment<'a> {
StrSegment::Unicode(t) => StrSegment::Unicode(t.normalize(arena)),
StrSegment::EscapedChar(c) => StrSegment::EscapedChar(c),
StrSegment::Interpolated(t) => StrSegment::Interpolated(t.normalize(arena)),
StrSegment::DeprecatedInterpolated(t) => StrSegment::Interpolated(t.normalize(arena)),
}
}
}

34
crates/compiler/parse/src/string_literal.rs
View file

@ -364,36 +364,6 @@ pub fn parse_str_like_literal<'a>() -> impl Parser<'a, StrLikeLiteral<'a>, EStri
// This is the start of a new escape. Look at the next byte
// to figure out what type of escape it is.
match bytes.next() {
Some(b'(') => {
// Advance past the `\(` before using the expr parser
state.advance_mut(2);
let original_byte_count = state.bytes().len();
// This is an interpolated variable.
// Parse an arbitrary expression, then give a
// canonicalization error if that expression variant
// is not allowed inside a string interpolation.
let (_progress, loc_expr, new_state) = skip_second(
specialize_err_ref(
EString::Format,
loc(allocated(reset_min_indent(expr::expr_help()))),
),
byte(b')', EString::FormatEnd),
)
.parse(arena, state, min_indent)?;
// Advance the iterator past the expr we just parsed.
for _ in 0..(original_byte_count - new_state.bytes().len()) {
bytes.next();
}
segments.push(StrSegment::DeprecatedInterpolated(loc_expr));
// Reset the segment
segment_parsed_bytes = 0;
state = new_state;
}
Some(b'u') => {
// Advance past the `\u` before using the expr parser
state.advance_mut(2);
@ -444,8 +414,8 @@ pub fn parse_str_like_literal<'a>() -> impl Parser<'a, StrLikeLiteral<'a>, EStri
}
_ => {
// Invalid escape! A backslash must be followed
// by either an open paren or else one of the
// escapable characters (\n, \t, \", \\, etc)
// by one of these escapable characters:
// (\n, \t, \", \\, etc)
return Err((MadeProgress, EString::UnknownEscape(state.pos())));
}
}

2
crates/compiler/solve/Cargo.toml
View file

@ -27,6 +27,8 @@ roc_unify = { path = "../unify" }
arrayvec.workspace = true
bumpalo.workspace = true
soa.workspace = true
[dev-dependencies]
roc_builtins = { path = "../builtins" }
roc_derive = { path = "../derive", features = ["debug-derived-symbols"] }

5
crates/compiler/solve/src/aliases.rs
View file

@ -1,5 +1,5 @@
use roc_can::abilities::AbilitiesStore;
use roc_collections::{soa::Index, MutMap};
use roc_collections::{soa::slice_extend_new, MutMap};
use roc_error_macros::internal_error;
use roc_module::symbol::Symbol;
use roc_solve_problem::TypeError;
@ -7,6 +7,7 @@ use roc_types::{
subs::{AliasVariables, Content, FlatType, Rank, Subs, SubsSlice, TagExt, UnionTags, Variable},
types::{Alias, AliasKind, OptAbleVar, Type, TypeTag, Types},
};
use soa::Index;
use crate::to_var::type_to_var_help;
use crate::{ability::ObligationCache, env::InferenceEnv};
@ -131,7 +132,7 @@ impl Aliases {
let ok_slice = SubsSlice::new(alias_variables.variables_start, 1);
let variable_slices =
SubsSlice::extend_new(&mut env.subs.variable_slices, [err_slice, ok_slice]);
slice_extend_new(&mut env.subs.variable_slices, [err_slice, ok_slice]);
let union_tags = UnionTags::from_slices(tag_names_slice, variable_slices);
let ext_var = TagExt::Any(Variable::EMPTY_TAG_UNION);

19
crates/compiler/solve/src/deep_copy.rs
View file

@ -1,11 +1,12 @@
use std::ops::ControlFlow;
use bumpalo::Bump;
use roc_collections::soa::slice_extend_new;
use roc_error_macros::internal_error;
use roc_types::{
subs::{
self, AliasVariables, Content, Descriptor, FlatType, GetSubsSlice, Mark, OptVariable, Rank,
RecordFields, Subs, SubsSlice, TagExt, TupleElems, UnionLabels, Variable,
RecordFields, Subs, TagExt, TupleElems, UnionLabels, Variable,
},
types::{RecordField, Uls},
};
@ -121,7 +122,7 @@ fn deep_copy_var_help(
macro_rules! copy_sequence {
($length:expr, $variables:expr) => {{
let new_variables = SubsSlice::reserve_into_subs(subs, $length as _);
let new_variables = subs.reserve_into_vars($length as _);
for (target_index, var_index) in (new_variables.indices()).zip($variables) {
let var = subs[var_index];
let copy_var = work!(var);
@ -134,7 +135,7 @@ fn deep_copy_var_help(
macro_rules! copy_union {
($tags:expr) => {{
let new_variable_slices = SubsSlice::reserve_variable_slices(subs, $tags.len());
let new_variable_slices = subs.reserve_variable_slices($tags.len());
let it = (new_variable_slices.indices()).zip($tags.variables());
for (target_index, index) in it {
@ -201,7 +202,7 @@ fn deep_copy_var_help(
let new_field_types_start = if has_rigid_optional_field {
let field_types = field_types.to_vec();
let slice = SubsSlice::extend_new(
let slice = slice_extend_new(
&mut subs.record_fields,
field_types.into_iter().map(|f| match f {
RecordField::RigidOptional(())
@ -212,7 +213,7 @@ fn deep_copy_var_help(
| RecordField::Optional(_) => f,
}),
);
slice.start
slice.start()
} else {
fields.field_types_start
};
@ -220,7 +221,7 @@ fn deep_copy_var_help(
RecordFields {
length: fields.length,
field_names_start: fields.field_names_start,
variables_start: new_variables.start,
variables_start: new_variables.start(),
field_types_start: new_field_types_start,
}
};
@ -234,7 +235,7 @@ fn deep_copy_var_help(
TupleElems {
length: elems.length,
variables_start: new_variables.start,
variables_start: new_variables.start(),
elem_index_start: elems.elem_index_start,
}
};
@ -291,7 +292,7 @@ fn deep_copy_var_help(
copy_sequence!(arguments.all_variables_len, arguments.all_variables());
let new_arguments = AliasVariables {
variables_start: new_variables.start,
variables_start: new_variables.start(),
..arguments
};
@ -311,7 +312,7 @@ fn deep_copy_var_help(
let new_solved = copy_union!(solved);
let new_rec_var = recursion_var.map(|v| work!(v));
let new_unspecialized = SubsSlice::reserve_uls_slice(subs, unspecialized.len());
let new_unspecialized = subs.reserve_uls_slice(unspecialized.len());
for (new_uls_index, uls_index) in
(new_unspecialized.into_iter()).zip(unspecialized.into_iter())

13
crates/compiler/solve/src/specialize.rs
View file

@ -3,7 +3,7 @@
use std::collections::VecDeque;
use roc_can::abilities::{AbilitiesStore, ImplKey};
use roc_collections::{VecMap, VecSet};
use roc_collections::{soa::slice_extend_new, VecMap, VecSet};
use roc_debug_flags::dbg_do;
#[cfg(debug_assertions)]
use roc_debug_flags::ROC_TRACE_COMPACTION;
@ -14,7 +14,7 @@ use roc_solve_schema::UnificationMode;
use roc_types::{
subs::{
get_member_lambda_sets_at_region, Content, Descriptor, GetSubsSlice, LambdaSet, Mark,
OptVariable, Rank, Subs, SubsSlice, UlsOfVar, Variable,
OptVariable, Rank, Subs, UlsOfVar, Variable,
},
types::{AliasKind, MemberImpl, Polarity, Uls},
};
@ -360,7 +360,7 @@ pub fn compact_lambda_sets_of_vars<P: Phase>(
// The first lambda set contains one concrete lambda, plus all solved
// lambdas, plus all other unspecialized lambdas.
// l' = [solved_lambdas + t1 + ... + tm + C:f:r]
let unspecialized = SubsSlice::extend_new(
let unspecialized = slice_extend_new(
&mut env.subs.unspecialized_lambda_sets,
not_concrete
.drain(..)
@ -371,7 +371,7 @@ pub fn compact_lambda_sets_of_vars<P: Phase>(
// All the other lambda sets consists only of their respective concrete
// lambdas.
// ln = [[] + C:fn:rn]
let unspecialized = SubsSlice::extend_new(
let unspecialized = slice_extend_new(
&mut env.subs.unspecialized_lambda_sets,
[concrete_lambda],
);
@ -521,10 +521,7 @@ fn compact_lambda_set<P: Phase>(
let t_f1_lambda_set_without_concrete = LambdaSet {
solved,
recursion_var,
unspecialized: SubsSlice::extend_new(
&mut env.subs.unspecialized_lambda_sets,
new_unspecialized,
),
unspecialized: slice_extend_new(&mut env.subs.unspecialized_lambda_sets, new_unspecialized),
ambient_function: t_f1,
};
env.subs.set_content(

63
crates/compiler/solve/src/to_var.rs
View file

@ -1,7 +1,7 @@
use std::cell::RefCell;
use roc_can::{abilities::AbilitiesStore, constraint::TypeOrVar, expected::Expected};
use roc_collections::soa::{Index, Slice};
use roc_collections::soa::slice_extend_new;
use roc_error_macros::internal_error;
use roc_module::{ident::TagName, symbol::Symbol};
use roc_region::all::Loc;
@ -19,6 +19,7 @@ use roc_types::{
},
};
use roc_unify::unify::{unify, Unified};
use soa::{Index, Slice};
use crate::{
ability::{AbilityImplError, ObligationCache},
@ -329,7 +330,7 @@ pub(crate) fn type_to_var_help(
region: _,
} => {
let arguments = types.get_type_arguments(typ_index);
let new_arguments = VariableSubsSlice::reserve_into_subs(env.subs, arguments.len());
let new_arguments = env.subs.reserve_into_vars(arguments.len());
for (target_index, var_index) in
(new_arguments.indices()).zip(arguments.into_iter())
{
@ -372,7 +373,7 @@ pub(crate) fn type_to_var_help(
}
}
UnspecializedLambdaSet { unspecialized } => {
let unspecialized_slice = SubsSlice::extend_new(
let unspecialized_slice = slice_extend_new(
&mut env.subs.unspecialized_lambda_sets,
std::iter::once(unspecialized),
);
@ -403,7 +404,7 @@ pub(crate) fn type_to_var_help(
// This case is important for the rank of boolean variables
Function(closure_type, ret_type) => {
let arguments = types.get_type_arguments(typ_index);
let new_arguments = VariableSubsSlice::reserve_into_subs(env.subs, arguments.len());
let new_arguments = env.subs.reserve_into_vars(arguments.len());
for (target_index, var_index) in
(new_arguments.indices()).zip(arguments.into_iter())
{
@ -545,8 +546,8 @@ pub(crate) fn type_to_var_help(
unreachable!("we assert that the ext var is empty; otherwise we'd already know it was a tag union!");
}
let tag_names = SubsSlice::extend_new(&mut env.subs.tag_names, [tag_name]);
let symbols = SubsSlice::extend_new(&mut env.subs.symbol_names, [symbol]);
let tag_names = slice_extend_new(&mut env.subs.tag_names, [tag_name]);
let symbols = slice_extend_new(&mut env.subs.symbol_names, [symbol]);
let content =
Content::Structure(FlatType::FunctionOrTagUnion(tag_names, symbols, ext));
@ -603,8 +604,7 @@ pub(crate) fn type_to_var_help(
let all_vars_length = type_arguments.len()
+ lambda_set_variables.len()
+ infer_ext_in_output_variables.len();
let new_variables =
VariableSubsSlice::reserve_into_subs(env.subs, all_vars_length);
let new_variables = env.subs.reserve_into_vars(all_vars_length);
let type_arguments_offset = 0;
let lambda_set_vars_offset = type_arguments_offset + type_arguments.len();
@ -652,7 +652,7 @@ pub(crate) fn type_to_var_help(
}
AliasVariables {
variables_start: new_variables.start,
variables_start: new_variables.start(),
type_variables_len: type_arguments.len() as _,
lambda_set_variables_len: lambda_set_variables.len() as _,
all_variables_len: all_vars_length as _,
@ -704,8 +704,7 @@ pub(crate) fn type_to_var_help(
let lambda_set_vars_offset = type_arguments_offset + type_arguments.len();
let infer_ext_vars_offset = lambda_set_vars_offset + lambda_set_variables.len();
let new_variables =
VariableSubsSlice::reserve_into_subs(env.subs, all_vars_length);
let new_variables = env.subs.reserve_into_vars(all_vars_length);
for (((target_index, typ), region), abilities) in
(new_variables.indices().skip(type_arguments_offset))
@ -736,7 +735,7 @@ pub(crate) fn type_to_var_help(
}
AliasVariables {
variables_start: new_variables.start,
variables_start: new_variables.start(),
type_variables_len: type_arguments.len() as _,
lambda_set_variables_len: lambda_set_variables.len() as _,
all_variables_len: all_vars_length as _,
@ -765,10 +764,8 @@ pub(crate) fn type_to_var_help(
match *env.subs.get_content_unchecked(var) {
Content::RigidVar(a) => {
// TODO(multi-abilities): check run cache
let abilities_slice = SubsSlice::extend_new(
&mut env.subs.symbol_names,
abilities.sorted_iter().copied(),
);
let abilities_slice =
slice_extend_new(&mut env.subs.symbol_names, abilities.sorted_iter().copied());
env.subs
.set_content(var, Content::RigidAbleVar(a, abilities_slice));
}
@ -778,10 +775,8 @@ pub(crate) fn type_to_var_help(
// pass, already bound
}
_ => {
let abilities_slice = SubsSlice::extend_new(
&mut env.subs.symbol_names,
abilities.sorted_iter().copied(),
);
let abilities_slice =
slice_extend_new(&mut env.subs.symbol_names, abilities.sorted_iter().copied());
let flex_ability = env.register(rank, Content::FlexAbleVar(None, abilities_slice));
@ -969,7 +964,7 @@ fn find_tag_name_run(slice: &[TagName], subs: &mut Subs) -> Option<SubsSlice<Tag
Some(occupied) => {
let subs_slice = *occupied;
let prefix_slice = SubsSlice::new(subs_slice.start, slice.len() as _);
let prefix_slice = SubsSlice::new(subs_slice.start(), slice.len() as _);
if slice.len() == 1 {
return Some(prefix_slice);
@ -978,7 +973,7 @@ fn find_tag_name_run(slice: &[TagName], subs: &mut Subs) -> Option<SubsSlice<Tag
match slice.len().cmp(&subs_slice.len()) {
Ordering::Less => {
// we might have a prefix
let tag_names = &subs.tag_names[subs_slice.start as usize..];
let tag_names = &subs.tag_names[subs_slice.start() as usize..];
for (from_subs, from_slice) in tag_names.iter().zip(slice.iter()) {
if from_subs != from_slice {
@ -1025,8 +1020,8 @@ fn register_tag_arguments(
if arguments.is_empty() {
VariableSubsSlice::default()
} else {
let new_variables = VariableSubsSlice::reserve_into_subs(env.subs, arguments.len());
let it = new_variables.indices().zip(arguments.into_iter());
let new_variables = env.subs.reserve_into_vars(arguments.len());
let it = new_variables.indices().zip(arguments);
for (target_index, argument) in it {
let var = RegisterVariable::with_stack(env, rank, arena, types, argument, stack);
@ -1056,8 +1051,7 @@ fn insert_tags_fast_path(
let variable_slice =
register_tag_arguments(env, rank, arena, types, stack, arguments_slice);
let new_variable_slices =
SubsSlice::extend_new(&mut env.subs.variable_slices, [variable_slice]);
let new_variable_slices = slice_extend_new(&mut env.subs.variable_slices, [variable_slice]);
macro_rules! subs_tag_name {
($tag_name_slice:expr) => {
@ -1075,10 +1069,10 @@ fn insert_tags_fast_path(
}
}
let new_variable_slices = SubsSlice::reserve_variable_slices(env.subs, tags.len());
let new_variable_slices = env.subs.reserve_variable_slices(tags.len());
match find_tag_name_run(&types[tags], env.subs) {
Some(new_tag_names) => {
let it = (new_variable_slices.indices()).zip(payload_slices.into_iter());
let it = (new_variable_slices.indices()).zip(payload_slices);
for (variable_slice_index, arguments_index) in it {
let arguments = types[arguments_index];
@ -1089,12 +1083,12 @@ fn insert_tags_fast_path(
UnionTags::from_slices(new_tag_names, new_variable_slices)
}
None => {
let new_tag_names = SubsSlice::reserve_tag_names(env.subs, tags.len());
let new_tag_names = env.subs.reserve_tag_names(tags.len());
let it = (new_variable_slices.indices())
.zip(new_tag_names.indices())
.zip(tags.into_iter())
.zip(payload_slices.into_iter());
.zip(tags)
.zip(payload_slices);
for (((variable_slice_index, tag_name_index), tag_name), arguments_index) in it {
let arguments = types[arguments_index];
@ -1124,7 +1118,7 @@ fn insert_tags_slow_path(
{
let tag_argument_types = &types[tag_argument_types_index];
let new_slice = VariableSubsSlice::reserve_into_subs(env.subs, tag_argument_types.len());
let new_slice = env.subs.reserve_into_vars(tag_argument_types.len());
for (i, arg) in (new_slice.indices()).zip(tag_argument_types.into_iter()) {
let var = RegisterVariable::with_stack(env, rank, arena, types, arg, stack);
@ -1208,10 +1202,9 @@ fn create_union_lambda(
stack: &mut bumpalo::collections::Vec<'_, TypeToVar>,
) -> UnionLambdas {
let variable_slice = register_tag_arguments(env, rank, arena, types, stack, capture_types);
let new_variable_slices =
SubsSlice::extend_new(&mut env.subs.variable_slices, [variable_slice]);
let new_variable_slices = slice_extend_new(&mut env.subs.variable_slices, [variable_slice]);
let lambda_name_slice = SubsSlice::extend_new(&mut env.subs.symbol_names, [closure]);
let lambda_name_slice = slice_extend_new(&mut env.subs.symbol_names, [closure]);
UnionLambdas::from_slices(lambda_name_slice, new_variable_slices)
}

5
crates/compiler/test_derive/Cargo.toml
View file

@ -17,7 +17,10 @@ roc_can = { path = "../can" }
roc_collections = { path = "../collections" }
roc_constrain = { path = "../constrain" }
roc_debug_flags = { path = "../debug_flags" }
roc_derive = { path = "../derive", features = ["debug-derived-symbols", "open-extension-vars"] }
roc_derive = { path = "../derive", features = [
"debug-derived-symbols",
"open-extension-vars",
] }
roc_derive_key = { path = "../derive_key" }
roc_load_internal = { path = "../load_internal" }
roc_module = { path = "../module" }

19
crates/compiler/test_derive/src/util.rs
View file

@ -1,12 +1,11 @@
use std::fmt::Write as _; // import without risk of name clashing
use std::path::PathBuf;
use bumpalo::Bump;
use roc_packaging::cache::RocCacheDir;
use roc_solve::{
module::{SolveConfig, SolveOutput},
FunctionKind,
};
use std::fmt::Write as _;
use std::path::PathBuf;
use ven_pretty::DocAllocator;
use roc_can::{
@ -116,12 +115,12 @@ macro_rules! v {
}
}};
([ $($tag:ident $($payload:expr)*),* ] as $rec_var:ident) => {{
use roc_types::subs::{Subs, SubsIndex, Variable, Content, FlatType, TagExt, UnionTags};
use roc_types::subs::{Subs, Variable, Content, FlatType, TagExt, UnionTags};
use roc_module::ident::TagName;
|subs: &mut Subs| {
let $rec_var = subs.fresh_unnamed_flex_var();
let rec_name_index =
SubsIndex::push_new(&mut subs.field_names, stringify!($rec).into());
roc_collections::soa::index_push_new(&mut subs.field_names, stringify!($rec).into());
$(
let $tag = vec![ $( $payload(subs), )* ];
@ -158,11 +157,11 @@ macro_rules! v {
}
}};
(Symbol::$sym:ident $($arg:expr)*) => {{
use roc_types::subs::{Subs, SubsSlice, Content, FlatType};
use roc_types::subs::{Subs, Content, FlatType};
use roc_module::symbol::Symbol;
|subs: &mut Subs| {
let $sym = vec![ $( $arg(subs) ,)* ];
let var_slice = SubsSlice::insert_into_subs(subs, $sym);
let var_slice = subs.insert_into_vars($sym);
roc_derive::synth_var(subs, Content::Structure(FlatType::Apply(Symbol::$sym, var_slice)))
}
}};
@ -193,12 +192,12 @@ macro_rules! v {
|subs: &mut Subs| { roc_derive::synth_var(subs, Content::FlexVar(None)) }
}};
($name:ident implements $ability:path) => {{
use roc_types::subs::{Subs, SubsIndex, SubsSlice, Content};
use roc_types::subs::{Subs, Content};
|subs: &mut Subs| {
let name_index =
SubsIndex::push_new(&mut subs.field_names, stringify!($name).into());
roc_collections::soa::index_push_new(&mut subs.field_names, stringify!($name).into());
let abilities_slice = SubsSlice::extend_new(&mut subs.symbol_names, [$ability]);
let abilities_slice = roc_collections::soa::slice_extend_new(&mut subs.symbol_names, [$ability]);
roc_derive::synth_var(subs, Content::FlexAbleVar(Some(name_index), abilities_slice))
}

23
crates/compiler/test_gen/src/gen_num.rs
View file

@ -1605,20 +1605,21 @@ fn tail_call_elimination() {
);
}
#[test]
#[cfg(feature = "gen-dev")]
fn int_negate_dev() {
// TODO
// dev backend yet to have `Num.maxI64` or `Num.minI64`.
// add the "gen-dev" feature to the test below after implementing them both.
assert_evals_to!("Num.neg 123", -123, i64);
assert_evals_to!("Num.neg -123", 123, i64);
assert_evals_to!("Num.neg 0", 0, i64);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
fn int_negate() {
assert_evals_to!("Num.neg 123i8", -123, i8);
assert_evals_to!("Num.neg Num.maxI8", -i8::MAX, i8);
assert_evals_to!("Num.neg (Num.minI8 + 1)", i8::MAX, i8);
assert_evals_to!("Num.neg 123i16", -123, i16);
assert_evals_to!("Num.neg Num.maxI16", -i16::MAX, i16);
assert_evals_to!("Num.neg (Num.minI16 + 1)", i16::MAX, i16);
assert_evals_to!("Num.neg 123i32", -123, i32);
assert_evals_to!("Num.neg Num.maxI32", -i32::MAX, i32);
assert_evals_to!("Num.neg (Num.minI32 + 1)", i32::MAX, i32);
assert_evals_to!("Num.neg 123", -123, i64);
assert_evals_to!("Num.neg Num.maxI64", -i64::MAX, i64);
assert_evals_to!("Num.neg (Num.minI64 + 1)", i64::MAX, i64);

7
crates/compiler/test_gen/src/helpers/llvm.rs
View file

@ -540,6 +540,7 @@ pub fn try_run_lib_function<T>(
}
}
#[allow(dead_code)]
// only used in tests
pub(crate) fn llvm_evals_to<T, U, F>(
src: &str,
@ -589,6 +590,7 @@ pub(crate) fn llvm_evals_to<T, U, F>(
}
}
#[allow(unused_macros)]
macro_rules! assert_llvm_evals_to {
($src:expr, $expected:expr, $ty:ty, $transform:expr, $ignore_problems:expr) => {
crate::helpers::llvm::llvm_evals_to::<$ty, _, _>(
@ -653,6 +655,7 @@ macro_rules! assert_evals_to {
}};
}
#[allow(unused_macros)]
macro_rules! assert_evals_to_erased {
($src:expr, $expected:expr, $ty:ty) => {{
crate::helpers::llvm::llvm_evals_to::<$ty, _, _>(
@ -665,12 +668,16 @@ macro_rules! assert_evals_to_erased {
}};
}
#[allow(dead_code)]
pub fn identity<T>(value: T) -> T {
value
}
#[allow(unused_imports)]
pub(crate) use assert_evals_to;
#[allow(unused_imports)]
pub(crate) use assert_evals_to_erased;
#[allow(unused_imports)]
pub(crate) use assert_llvm_evals_to;
#[cfg(feature = "gen-llvm-wasm")]
pub(crate) use assert_wasm_evals_to;

1
crates/compiler/test_syntax/tests/snapshots/fail/deprecated_interpolated_string.expr.result-ast Normal file
View file

@ -0,0 +1 @@
Expr(Str(UnknownEscape(@1), @0), @0)

1
crates/compiler/test_syntax/tests/snapshots/fail/deprecated_interpolated_string.expr.roc Normal file
View file

@ -0,0 +1 @@
"\(e)"

6
crates/compiler/test_syntax/tests/snapshots/malformed/underscore_expr_in_def.expr.result-ast
View file

@ -1,16 +1,16 @@
Defs(
Defs {
tags: [
Index(0),
EitherIndex(0),
],
regions: [
@0-3,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [

6
crates/compiler/test_syntax/tests/snapshots/pass/ability_demand_signature_is_multiline.expr.result-ast
View file

@ -2,16 +2,16 @@ SpaceAfter(
Defs(
Defs {
tags: [
Index(0),
EitherIndex(0),
],
regions: [
@0-43,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [

6
crates/compiler/test_syntax/tests/snapshots/pass/ability_multi_line.expr.result-ast
View file

@ -2,16 +2,16 @@ SpaceAfter(
Defs(
Defs {
tags: [
Index(0),
EitherIndex(0),
],
regions: [
@0-52,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [

6
crates/compiler/test_syntax/tests/snapshots/pass/ability_single_line.expr.result-ast
View file

@ -2,16 +2,16 @@ SpaceAfter(
Defs(
Defs {
tags: [
Index(0),
EitherIndex(0),
],
regions: [
@0-55,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [

12
crates/compiler/test_syntax/tests/snapshots/pass/ability_two_in_a_row.expr.result-ast
View file

@ -2,20 +2,20 @@ SpaceAfter(
Defs(
Defs {
tags: [
Index(0),
Index(1),
EitherIndex(0),
EitherIndex(1),
],
regions: [
@0-51,
@53-104,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 2),
Slice { start: 0, length: 0 },
Slice { start: 0, length: 2 },
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 2, length = 0),
Slice { start: 0, length: 0 },
Slice { start: 2, length: 0 },
],
spaces: [
Newline,

6
crates/compiler/test_syntax/tests/snapshots/pass/ann_closed_union.expr.result-ast
View file

@ -1,16 +1,16 @@
Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-38,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/test_syntax/tests/snapshots/pass/ann_open_union.expr.result-ast
View file

@ -1,16 +1,16 @@
Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-39,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/test_syntax/tests/snapshots/pass/annotated_record_destructure.expr.result-ast
View file

@ -2,16 +2,16 @@ SpaceAfter(
Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-49,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/test_syntax/tests/snapshots/pass/annotated_tag_destructure.expr.result-ast
View file

@ -2,16 +2,16 @@ SpaceAfter(
Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-46,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/test_syntax/tests/snapshots/pass/annotated_tuple_destructure.expr.result-ast
View file

@ -2,16 +2,16 @@ SpaceAfter(
Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-41,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/test_syntax/tests/snapshots/pass/basic_docs.expr.result-ast
View file

@ -3,16 +3,16 @@ SpaceBefore(
Defs(
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@107-112,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [],

6
crates/compiler/test_syntax/tests/snapshots/pass/comma_prefixed_indented_record.expr.result-ast
View file

@ -2,16 +2,16 @@ SpaceAfter(
Defs(
Defs {
tags: [
Index(0),
EitherIndex(0),
],
regions: [
@0-164,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [

6
crates/compiler/test_syntax/tests/snapshots/pass/comment_after_annotation.expr.result-ast
View file

@ -1,16 +1,16 @@
Defs(
Defs {
tags: [
Index(0),
EitherIndex(0),
],
regions: [
@0-3,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
spaces: [],
type_defs: [

6
crates/compiler/test_syntax/tests/snapshots/pass/comment_after_def.moduledefs.result-ast
View file

@ -1,15 +1,15 @@
Defs {
tags: [
Index(2147483648),
EitherIndex(2147483648),
],
regions: [
@0-7,
],
space_before: [
Slice(start = 0, length = 0),
Slice { start: 0, length: 0 },
],
space_after: [
Slice(start = 0, length = 1),
Slice { start: 0, length: 1 },
],
spaces: [
LineComment(

Some files were not shown because too many files have changed in this diff Show more