keii.dev / gleam
⭐️ A friendly language for building type-safe, scalable systems!
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

Remove expr_2021

authored by gearsco.de and committed by

Louis Pilfold 8d198695 a7aa4661

+75 -75
+2 -2
compiler-core/src/erlang/tests.rs
··· 122 122 123 123 #[macro_export] 124 124 macro_rules! assert_erl { 125 - (($dep_package:expr_2021, $dep_name:expr_2021, $dep_src:expr_2021), $src:expr_2021 $(,)?) => {{ 125 + (($dep_package:expr, $dep_name:expr, $dep_src:expr), $src:expr $(,)?) => {{ 126 126 let compiled = $crate::erlang::tests::compile_test_project( 127 127 $src, 128 128 "/root/project/test/my/mod.gleam", ··· 135 135 insta::assert_snapshot!(insta::internals::AutoName, output, $src); 136 136 }}; 137 137 138 - ($src:expr_2021 $(,)?) => {{ 138 + ($src:expr $(,)?) => {{ 139 139 let compiled = $crate::erlang::tests::compile_test_project( 140 140 $src, 141 141 "/root/project/test/my/mod.gleam",
+2 -2
compiler-core/src/format/tests.rs
··· 19 19 20 20 #[macro_export] 21 21 macro_rules! assert_format { 22 - ($src:expr_2021 $(,)?) => { 22 + ($src:expr $(,)?) => { 23 23 let mut writer = String::new(); 24 24 $crate::format::pretty(&mut writer, &$src.into(), camino::Utf8Path::new("<stdin>")) 25 25 .unwrap(); ··· 29 29 30 30 #[macro_export] 31 31 macro_rules! assert_format_rewrite { 32 - ($src:expr_2021, $expected:expr_2021 $(,)?) => { 32 + ($src:expr, $expected:expr $(,)?) => { 33 33 let mut writer = String::new(); 34 34 $crate::format::pretty(&mut writer, &$src.into(), camino::Utf8Path::new("<stdin>")) 35 35 .unwrap();
+8 -8
compiler-core/src/javascript/tests.rs
··· 51 51 52 52 #[macro_export] 53 53 macro_rules! assert_js { 54 - (($dep_package:expr_2021, $dep_name:expr_2021, $dep_src:expr_2021), $src:expr_2021 $(,)?) => {{ 54 + (($dep_package:expr, $dep_name:expr, $dep_src:expr), $src:expr $(,)?) => {{ 55 55 let compiled = 56 56 $crate::javascript::tests::compile_js($src, vec![($dep_package, $dep_name, $dep_src)]) 57 57 .expect("compilation failed"); ··· 62 62 insta::assert_snapshot!(insta::internals::AutoName, output, $src); 63 63 }}; 64 64 65 - (($dep_package:expr_2021, $dep_name:expr_2021, $dep_src:expr_2021), $src:expr_2021, $js:expr_2021 $(,)?) => {{ 65 + (($dep_package:expr, $dep_name:expr, $dep_src:expr), $src:expr, $js:expr $(,)?) => {{ 66 66 let output = 67 67 $crate::javascript::tests::compile_js($src, Some(($dep_package, $dep_name, $dep_src))) 68 68 .expect("compilation failed"); 69 69 assert_eq!(($src, output), ($src, $js.to_string())); 70 70 }}; 71 71 72 - ($src:expr_2021 $(,)?) => {{ 72 + ($src:expr $(,)?) => {{ 73 73 let compiled = 74 74 $crate::javascript::tests::compile_js($src, vec![]).expect("compilation failed"); 75 75 let output = format!( ··· 79 79 insta::assert_snapshot!(insta::internals::AutoName, output, $src); 80 80 }}; 81 81 82 - ($src:expr_2021, $js:expr_2021 $(,)?) => {{ 82 + ($src:expr, $js:expr $(,)?) => {{ 83 83 let output = 84 84 $crate::javascript::tests::compile_js($src, vec![]).expect("compilation failed"); 85 85 assert_eq!(($src, output), ($src, $js.to_string())); ··· 88 88 89 89 #[macro_export] 90 90 macro_rules! assert_js_error { 91 - ($src:expr_2021 $(,)?) => {{ 91 + ($src:expr $(,)?) => {{ 92 92 let error = $crate::javascript::tests::expect_js_error($src, vec![]); 93 93 let output = format!("----- SOURCE CODE\n{}\n\n----- ERROR\n{}", $src, error); 94 94 insta::assert_snapshot!(insta::internals::AutoName, output, $src); ··· 97 97 98 98 #[macro_export] 99 99 macro_rules! assert_ts_def { 100 - (($dep_1_package:expr_2021, $dep_1_name:expr_2021, $dep_1_src:expr_2021), ($dep_2_package:expr_2021, $dep_2_name:expr_2021, $dep_2_src:expr_2021), $src:expr_2021 $(,)?) => {{ 100 + (($dep_1_package:expr, $dep_1_name:expr, $dep_1_src:expr), ($dep_2_package:expr, $dep_2_name:expr, $dep_2_src:expr), $src:expr $(,)?) => {{ 101 101 let compiled = $crate::javascript::tests::compile_ts( 102 102 $src, 103 103 vec![ ··· 113 113 insta::assert_snapshot!(insta::internals::AutoName, output, $src); 114 114 }}; 115 115 116 - (($dep_package:expr_2021, $dep_name:expr_2021, $dep_src:expr_2021), $src:expr_2021 $(,)?) => {{ 116 + (($dep_package:expr, $dep_name:expr, $dep_src:expr), $src:expr $(,)?) => {{ 117 117 let compiled = 118 118 $crate::javascript::tests::compile_ts($src, vec![($dep_package, $dep_name, $dep_src)]) 119 119 .expect("compilation failed"); ··· 124 124 insta::assert_snapshot!(insta::internals::AutoName, output, $src); 125 125 }}; 126 126 127 - ($src:expr_2021 $(,)?) => {{ 127 + ($src:expr $(,)?) => {{ 128 128 let compiled = 129 129 $crate::javascript::tests::compile_ts($src, vec![]).expect("compilation failed"); 130 130 let output = format!(
+4 -4
compiler-core/src/language_server/tests/action.rs
··· 81 81 const INTERPOLATE_STRING: &str = "Interpolate string"; 82 82 83 83 macro_rules! assert_code_action { 84 - ($title:expr_2021, $code:literal, $range:expr_2021 $(,)?) => { 84 + ($title:expr, $code:literal, $range:expr $(,)?) => { 85 85 let project = TestProject::for_source($code); 86 86 assert_code_action!($title, project, $range); 87 87 }; 88 88 89 - ($title:expr_2021, $project:expr_2021, $range:expr_2021 $(,)?) => { 89 + ($title:expr, $project:expr, $range:expr $(,)?) => { 90 90 let src = $project.src; 91 91 let range = $range.find_range(src); 92 92 let result = apply_code_action($title, $project, range); ··· 100 100 } 101 101 102 102 macro_rules! assert_no_code_actions { 103 - ($title:ident $(| $titles:ident)*, $code:literal, $range:expr_2021 $(,)?) => { 103 + ($title:ident $(| $titles:ident)*, $code:literal, $range:expr $(,)?) => { 104 104 let project = TestProject::for_source($code); 105 105 assert_no_code_actions!($title $(| $titles)*, project, $range); 106 106 }; 107 107 108 - ($title:ident $(| $titles:ident)*, $project:expr_2021, $range:expr_2021 $(,)?) => { 108 + ($title:ident $(| $titles:ident)*, $project:expr, $range:expr $(,)?) => { 109 109 let src = $project.src; 110 110 let range = $range.find_range(src); 111 111 let all_titles = vec![$title $(, $titles)*];
+4 -4
compiler-core/src/language_server/tests/completion.rs
··· 37 37 38 38 #[macro_export] 39 39 macro_rules! assert_apply_completion { 40 - ($project:expr_2021, $name:literal, $position:expr_2021) => { 40 + ($project:expr, $name:literal, $position:expr) => { 41 41 let src = $project.src; 42 42 let completions = completion($project, $position); 43 43 let output = format!( ··· 51 51 52 52 #[macro_export] 53 53 macro_rules! assert_completion { 54 - ($project:expr_2021) => { 54 + ($project:expr) => { 55 55 let src = $project.src; 56 56 let result = completion_with_prefix($project, ""); 57 57 let output = format!( ··· 61 61 ); 62 62 insta::assert_snapshot!(insta::internals::AutoName, output, src); 63 63 }; 64 - ($project:expr_2021, $position:expr_2021) => { 64 + ($project:expr, $position:expr) => { 65 65 let src = $project.src; 66 66 let result = completion($project, $position); 67 67 let output = format!( ··· 75 75 76 76 #[macro_export] 77 77 macro_rules! assert_completion_with_prefix { 78 - ($project:expr_2021, $prefix:expr_2021) => { 78 + ($project:expr, $prefix:expr) => { 79 79 let src = $project.src; 80 80 let result = completion_with_prefix($project, $prefix); 81 81 let line = 1 + $prefix.lines().count();
+4 -4
compiler-core/src/language_server/tests/definition.rs
··· 94 94 95 95 #[macro_export] 96 96 macro_rules! assert_goto { 97 - ($src:literal, $position:expr_2021) => { 97 + ($src:literal, $position:expr) => { 98 98 let project = TestProject::for_source($src); 99 99 assert_goto!(project, $position); 100 100 }; 101 - ($project:expr_2021, $position:expr_2021) => { 101 + ($project:expr, $position:expr) => { 102 102 let output = pretty_definition($project, $position); 103 103 insta::assert_snapshot!(insta::internals::AutoName, output); 104 104 }; ··· 106 106 107 107 #[macro_export] 108 108 macro_rules! assert_goto_type { 109 - ($src:literal, $position:expr_2021) => { 109 + ($src:literal, $position:expr) => { 110 110 let project = TestProject::for_source($src); 111 111 assert_goto_type!(project, $position); 112 112 }; 113 - ($project:expr_2021, $position:expr_2021) => { 113 + ($project:expr, $position:expr) => { 114 114 let output = pretty_type_definition($project, $position); 115 115 insta::assert_snapshot!(insta::internals::AutoName, output); 116 116 };
+2 -2
compiler-core/src/language_server/tests/hover.rs
··· 51 51 52 52 #[macro_export] 53 53 macro_rules! assert_hover { 54 - ($code:literal, $position:expr_2021 $(,)?) => { 54 + ($code:literal, $position:expr $(,)?) => { 55 55 let project = TestProject::for_source($code); 56 56 assert_hover!(project, $position); 57 57 }; 58 58 59 - ($project:expr_2021, $position:expr_2021 $(,)?) => { 59 + ($project:expr, $position:expr $(,)?) => { 60 60 let src = $project.src; 61 61 let position = $position.find_position(src); 62 62 let result = hover($project, position).expect("no hover produced");
+4 -4
compiler-core/src/language_server/tests/rename.rs
··· 50 50 } 51 51 52 52 macro_rules! assert_rename { 53 - ($code:literal, $new_name:literal, $range:expr_2021 $(,)?) => { 53 + ($code:literal, $new_name:literal, $range:expr $(,)?) => { 54 54 let project = TestProject::for_source($code); 55 55 assert_rename!(project, $new_name, $range); 56 56 }; 57 57 58 - ($project:expr_2021, $new_name:literal, $range:expr_2021 $(,)?) => { 58 + ($project:expr, $new_name:literal, $range:expr $(,)?) => { 59 59 let src = $project.src; 60 60 let range = $range.find_range(src); 61 61 let result = apply_rename($project, $new_name, range.start); ··· 69 69 } 70 70 71 71 macro_rules! assert_no_rename { 72 - ($code:literal, $new_name:literal, $range:expr_2021 $(,)?) => { 72 + ($code:literal, $new_name:literal, $range:expr $(,)?) => { 73 73 let project = TestProject::for_source($code); 74 74 assert_no_rename!(project, $new_name, $range); 75 75 }; 76 76 77 - ($project:expr_2021, $new_name:literal, $range:expr_2021 $(,)?) => { 77 + ($project:expr, $new_name:literal, $range:expr $(,)?) => { 78 78 let src = $project.src; 79 79 let range = $range.find_range(src); 80 80 let result = rename($project, $new_name, range.start);
+4 -4
compiler-core/src/language_server/tests/signature_help.rs
··· 62 62 63 63 #[macro_export] 64 64 macro_rules! assert_signature_help { 65 - ($code:literal, $position:expr_2021 $(,)?) => { 65 + ($code:literal, $position:expr $(,)?) => { 66 66 let project = TestProject::for_source($code); 67 67 assert_signature_help!(project, $position); 68 68 }; 69 69 70 - ($project:expr_2021, $position:expr_2021 $(,)?) => { 70 + ($project:expr, $position:expr $(,)?) => { 71 71 let src = $project.src; 72 72 let position = $position.find_position(src); 73 73 let result = signature_help($project, position).expect("no signature help produced"); ··· 96 96 97 97 #[macro_export] 98 98 macro_rules! assert_no_signature_help { 99 - ($code:literal, $position:expr_2021 $(,)?) => { 99 + ($code:literal, $position:expr $(,)?) => { 100 100 let project = TestProject::for_source($code); 101 101 assert_no_signature_help!(project, $position); 102 102 }; 103 103 104 - ($project:expr_2021, $position:expr_2021 $(,)?) => { 104 + ($project:expr, $position:expr $(,)?) => { 105 105 let src = $project.src; 106 106 let position = $position.find_position(src); 107 107 let result = signature_help($project, position);
+2 -2
compiler-core/src/metadata/module_decoder.rs
··· 23 23 use std::{collections::HashMap, io::BufRead, sync::Arc}; 24 24 25 25 macro_rules! read_vec { 26 - ($reader:expr_2021, $self:expr_2021, $method:ident) => {{ 26 + ($reader:expr, $self:expr, $method:ident) => {{ 27 27 let reader = $reader; 28 28 let mut vec = Vec::with_capacity(reader.len() as usize); 29 29 for reader in reader.into_iter() { ··· 35 35 } 36 36 37 37 macro_rules! read_hashmap { 38 - ($reader:expr_2021, $self:expr_2021, $method:ident) => {{ 38 + ($reader:expr, $self:expr, $method:ident) => {{ 39 39 let reader = $reader; 40 40 let mut map = HashMap::with_capacity(reader.len() as usize); 41 41 for prop in reader.into_iter() {
+4 -4
compiler-core/src/package_interface/tests.rs
··· 19 19 20 20 #[macro_export] 21 21 macro_rules! assert_package_interface_with_name { 22 - ($module_name:expr_2021, $src:expr_2021) => { 22 + ($module_name:expr, $src:expr) => { 23 23 let output = 24 24 $crate::package_interface::tests::compile_package(Some($module_name), $src, None); 25 25 insta::assert_snapshot!(insta::internals::AutoName, output, $src); ··· 28 28 29 29 #[macro_export] 30 30 macro_rules! assert_package_interface { 31 - (($dep_package:expr_2021, $dep_name:expr_2021, $dep_src:expr_2021), $src:expr_2021 $(,)?) => {{ 31 + (($dep_package:expr, $dep_name:expr, $dep_src:expr), $src:expr $(,)?) => {{ 32 32 let output = $crate::package_interface::tests::compile_package( 33 33 None, 34 34 $src, ··· 37 37 insta::assert_snapshot!(insta::internals::AutoName, output, $src); 38 38 }}; 39 39 40 - (($dep_package:expr_2021, $dep_name:expr_2021, $dep_src:expr_2021), $src:expr_2021 $(,)?) => {{ 40 + (($dep_package:expr, $dep_name:expr, $dep_src:expr), $src:expr $(,)?) => {{ 41 41 let output = $crate::package_interface::tests::compile_package( 42 42 None, 43 43 $src, ··· 46 46 insta::assert_snapshot!(insta::internals::AutoName, output, $src); 47 47 }}; 48 48 49 - ($src:expr_2021) => {{ 49 + ($src:expr) => {{ 50 50 let output = $crate::package_interface::tests::compile_package(None, $src, None); 51 51 insta::assert_snapshot!(insta::internals::AutoName, output, $src); 52 52 }};
+5 -5
compiler-core/src/parse/tests.rs
··· 12 12 use pretty_assertions::assert_eq; 13 13 14 14 macro_rules! assert_error { 15 - ($src:expr_2021, $error:expr_2021 $(,)?) => { 15 + ($src:expr, $error:expr $(,)?) => { 16 16 let result = crate::parse::parse_statement_sequence($src).expect_err("should not parse"); 17 17 assert_eq!(($src, $error), ($src, result),); 18 18 }; 19 - ($src:expr_2021) => { 19 + ($src:expr) => { 20 20 let error = $crate::parse::tests::expect_error($src); 21 21 let output = format!("----- SOURCE CODE\n{}\n\n----- ERROR\n{}", $src, error); 22 22 insta::assert_snapshot!(insta::internals::AutoName, output, $src); ··· 24 24 } 25 25 26 26 macro_rules! assert_module_error { 27 - ($src:expr_2021) => { 27 + ($src:expr) => { 28 28 let error = $crate::parse::tests::expect_module_error($src); 29 29 let output = format!("----- SOURCE CODE\n{}\n\n----- ERROR\n{}", $src, error); 30 30 insta::assert_snapshot!(insta::internals::AutoName, output, $src); ··· 32 32 } 33 33 34 34 macro_rules! assert_parse_module { 35 - ($src:expr_2021) => { 35 + ($src:expr) => { 36 36 let result = crate::parse::parse_module( 37 37 camino::Utf8PathBuf::from("test/path"), 38 38 $src, ··· 44 44 } 45 45 46 46 macro_rules! assert_parse { 47 - ($src:expr_2021) => { 47 + ($src:expr) => { 48 48 let result = crate::parse::parse_statement_sequence($src).expect("should parse"); 49 49 insta::assert_snapshot!(insta::internals::AutoName, &format!("{:#?}", result), $src); 50 50 };
+1 -1
compiler-core/src/pretty.rs
··· 28 28 Document::Vec(Vec::new()) 29 29 }; 30 30 31 - ($($x:expr_2021),+ $(,)?) => { 31 + ($($x:expr),+ $(,)?) => { 32 32 Document::Vec(vec![$($x.to_doc()),+]) 33 33 }; 34 34 }
+1 -1
compiler-core/src/type_/pretty.rs
··· 246 246 #[test] 247 247 fn pretty_print_test() { 248 248 macro_rules! assert_string { 249 - ($src:expr_2021, $type_:expr_2021 $(,)?) => { 249 + ($src:expr, $type_:expr $(,)?) => { 250 250 let mut printer = Printer::new(); 251 251 assert_eq!($type_.to_string(), printer.pretty_print(&$src, 0),); 252 252 };
+27 -27
compiler-core/src/type_/tests.rs
··· 38 38 39 39 #[macro_export] 40 40 macro_rules! assert_infer { 41 - ($src:expr_2021, $type_:expr_2021 $(,)?) => { 41 + ($src:expr, $type_:expr $(,)?) => { 42 42 let t = $crate::type_::tests::infer($src); 43 43 assert_eq!(($src, t), ($src, $type_.to_string()),); 44 44 }; ··· 47 47 #[macro_export] 48 48 macro_rules! assert_infer_with_module { 49 49 ( 50 - ($name1:expr_2021, $module_src1:literal), 51 - ($name2:expr_2021, $module_src2:literal), 52 - $src:expr_2021, $module:expr_2021 $(,)? 50 + ($name1:expr, $module_src1:literal), 51 + ($name2:expr, $module_src2:literal), 52 + $src:expr, $module:expr $(,)? 53 53 ) => { 54 54 let constructors = $crate::type_::tests::infer_module( 55 55 $src, ··· 62 62 63 63 assert_eq!(($src, constructors), ($src, expected)); 64 64 }; 65 - (($name:expr_2021, $module_src:literal), $src:expr_2021, $module:expr_2021 $(,)?) => { 65 + (($name:expr, $module_src:literal), $src:expr, $module:expr $(,)?) => { 66 66 let constructors = 67 67 $crate::type_::tests::infer_module($src, vec![("thepackage", $name, $module_src)]); 68 68 let expected = $crate::type_::tests::stringify_tuple_strs($module); ··· 73 73 74 74 #[macro_export] 75 75 macro_rules! assert_module_infer { 76 - ($src:expr_2021, $module:expr_2021 $(,)?) => {{ 76 + ($src:expr, $module:expr $(,)?) => {{ 77 77 let constructors = $crate::type_::tests::infer_module($src, vec![]); 78 78 let expected = $crate::type_::tests::stringify_tuple_strs($module); 79 79 assert_eq!(($src, constructors), ($src, expected)); ··· 82 82 83 83 #[macro_export] 84 84 macro_rules! assert_js_module_infer { 85 - ($src:expr_2021, $module:expr_2021 $(,)?) => {{ 85 + ($src:expr, $module:expr $(,)?) => {{ 86 86 let constructors = $crate::type_::tests::infer_module_with_target( 87 87 "test_module", 88 88 $src, ··· 96 96 97 97 #[macro_export] 98 98 macro_rules! assert_module_error { 99 - ($src:expr_2021) => { 99 + ($src:expr) => { 100 100 let error = $crate::type_::tests::module_error($src, vec![]); 101 101 let output = format!("----- SOURCE CODE\n{}\n\n----- ERROR\n{}", $src, error); 102 102 insta::assert_snapshot!(insta::internals::AutoName, output, $src); ··· 105 105 106 106 #[macro_export] 107 107 macro_rules! assert_internal_module_error { 108 - ($src:expr_2021) => { 108 + ($src:expr) => { 109 109 let error = $crate::type_::tests::internal_module_error($src, vec![]); 110 110 let output = format!("----- SOURCE CODE\n{}\n\n----- ERROR\n{}", $src, error); 111 111 insta::assert_snapshot!(insta::internals::AutoName, output, $src); ··· 114 114 115 115 #[macro_export] 116 116 macro_rules! assert_js_module_error { 117 - ($src:expr_2021) => { 117 + ($src:expr) => { 118 118 let error = $crate::type_::tests::module_error_with_target( 119 119 $src, 120 120 vec![], ··· 127 127 128 128 #[macro_export] 129 129 macro_rules! assert_module_syntax_error { 130 - ($src:expr_2021) => { 130 + ($src:expr) => { 131 131 let error = $crate::type_::tests::syntax_error($src); 132 132 let output = format!("----- SOURCE CODE\n{}\n\n----- ERROR\n{}", $src, error); 133 133 insta::assert_snapshot!(insta::internals::AutoName, output, $src); ··· 136 136 137 137 #[macro_export] 138 138 macro_rules! assert_error { 139 - ($src:expr_2021, $error:expr_2021 $(,)?) => { 139 + ($src:expr, $error:expr $(,)?) => { 140 140 let result = $crate::type_::tests::compile_statement_sequence($src) 141 141 .expect_err("should infer an error"); 142 142 assert_eq!(($src, sort_options($error)), ($src, sort_options(result)),); 143 143 }; 144 144 145 - ($src:expr_2021) => { 145 + ($src:expr) => { 146 146 let (error, names) = $crate::type_::tests::compile_statement_sequence($src) 147 147 .expect_err("should infer an error"); 148 148 let error = $crate::error::Error::Type { ··· 162 162 163 163 #[macro_export] 164 164 macro_rules! assert_with_module_error { 165 - (($name:expr_2021, $module_src:literal), $src:expr_2021 $(,)?) => { 165 + (($name:expr, $module_src:literal), $src:expr $(,)?) => { 166 166 let error = 167 167 $crate::type_::tests::module_error($src, vec![("thepackage", $name, $module_src)]); 168 168 let output = format!( ··· 181 181 }; 182 182 183 183 ( 184 - ($name:expr_2021, $module_src:literal), 185 - ($name2:expr_2021, $module_src2:literal), 186 - $src:expr_2021 $(,)? 184 + ($name:expr, $module_src:literal), 185 + ($name2:expr, $module_src2:literal), 186 + $src:expr $(,)? 187 187 ) => { 188 188 let error = $crate::type_::tests::module_error( 189 189 $src, ··· 271 271 272 272 #[macro_export] 273 273 macro_rules! assert_warning { 274 - ($src:expr_2021) => { 274 + ($src:expr) => { 275 275 let warning = $crate::type_::tests::get_printed_warnings($src, vec![], crate::build::Target::Erlang, None); 276 276 assert!(!warning.is_empty()); 277 277 let output = format!("----- SOURCE CODE\n{}\n\n----- WARNING\n{}", $src, warning); 278 278 insta::assert_snapshot!(insta::internals::AutoName, output, $src); 279 279 }; 280 280 281 - ($(($name:expr_2021, $module_src:literal)),+, $src:expr_2021) => { 281 + ($(($name:expr, $module_src:literal)),+, $src:expr) => { 282 282 let warning = $crate::type_::tests::get_printed_warnings( 283 283 $src, 284 284 vec![$(("thepackage", $name, $module_src)),*], ··· 290 290 insta::assert_snapshot!(insta::internals::AutoName, output, $src); 291 291 }; 292 292 293 - ($(($package:expr_2021, $name:expr_2021, $module_src:literal)),+, $src:expr_2021) => { 293 + ($(($package:expr, $name:expr, $module_src:literal)),+, $src:expr) => { 294 294 let warning = $crate::type_::tests::get_printed_warnings( 295 295 $src, 296 296 vec![$(($package, $name, $module_src)),*], ··· 305 305 306 306 #[macro_export] 307 307 macro_rules! assert_js_warning { 308 - ($src:expr_2021) => { 308 + ($src:expr) => { 309 309 let warning = $crate::type_::tests::get_printed_warnings( 310 310 $src, 311 311 vec![], ··· 320 320 321 321 #[macro_export] 322 322 macro_rules! assert_js_no_warnings { 323 - ($src:expr_2021) => { 323 + ($src:expr) => { 324 324 let warning = $crate::type_::tests::get_printed_warnings( 325 325 $src, 326 326 vec![], ··· 333 333 334 334 #[macro_export] 335 335 macro_rules! assert_warnings_with_gleam_version { 336 - ($gleam_version:expr_2021, $src:expr_2021$(,)?) => { 336 + ($gleam_version:expr, $src:expr$(,)?) => { 337 337 let warning = $crate::type_::tests::get_printed_warnings( 338 338 $src, 339 339 vec![], ··· 348 348 349 349 #[macro_export] 350 350 macro_rules! assert_js_warnings_with_gleam_version { 351 - ($gleam_version:expr_2021, $src:expr_2021$(,)?) => { 351 + ($gleam_version:expr, $src:expr$(,)?) => { 352 352 let warning = $crate::type_::tests::get_printed_warnings( 353 353 $src, 354 354 vec![], ··· 363 363 364 364 #[macro_export] 365 365 macro_rules! assert_js_no_warnings_with_gleam_version { 366 - ($gleam_version:expr_2021, $src:expr_2021$(,)?) => { 366 + ($gleam_version:expr, $src:expr$(,)?) => { 367 367 let warning = $crate::type_::tests::get_printed_warnings( 368 368 $src, 369 369 vec![], ··· 376 376 377 377 #[macro_export] 378 378 macro_rules! assert_no_warnings { 379 - ($src:expr_2021 $(,)?) => { 379 + ($src:expr $(,)?) => { 380 380 let warnings = $crate::type_::tests::get_warnings($src, vec![], crate::build::Target::Erlang, None); 381 381 assert_eq!(warnings, vec![]); 382 382 }; 383 - ($(($package:expr_2021, $name:expr_2021, $module_src:literal)),+, $src:expr_2021 $(,)?) => { 383 + ($(($package:expr, $name:expr, $module_src:literal)),+, $src:expr $(,)?) => { 384 384 let warnings = $crate::type_::tests::get_warnings( 385 385 $src, 386 386 vec![$(($package, $name, $module_src)),*],
+1 -1
compiler-core/src/type_/tests/target_implementations.rs
··· 8 8 use super::compile_module_with_opts; 9 9 10 10 macro_rules! assert_targets { 11 - ($src:expr_2021, $implementations:expr_2021 $(,)?) => { 11 + ($src:expr, $implementations:expr $(,)?) => { 12 12 let result = $crate::type_::tests::target_implementations::implementations($src); 13 13 let expected = $implementations 14 14 .iter()