nandi.uk / gleam
Fork of daniellemaywood.uk/gleam — Wasm codegen work
2
Fork 0

Configure Feed

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

Add tests for renaming from imports

author
Gavin Morrow committer
Louis Pilfold date (Jul 9, 2026, 6:07 PM +0100) commit 7fe81fb7 parent a5a3616b change-id mwovoqrp
+765
+291
language-server/src/tests/rename.rs
··· 601 601 } 602 602 603 603 #[test] 604 + fn rename_function_from_import() { 605 + assert_rename!( 606 + ( 607 + "mod", 608 + " 609 + pub fn wibble() { 610 + wibble() 611 + } 612 + " 613 + ), 614 + " 615 + import mod.{wibble} 616 + 617 + pub fn main() { 618 + wibble() 619 + mod.wibble() 620 + } 621 + ", 622 + "some_function", 623 + find_position_of("wibble") 624 + ); 625 + } 626 + 627 + #[test] 628 + fn rename_function_from_aliased_import() { 629 + assert_rename!( 630 + ( 631 + "mod", 632 + " 633 + pub fn wibble() { 634 + wibble() 635 + } 636 + " 637 + ), 638 + " 639 + import mod.{wibble as wobble} 640 + 641 + pub fn main() { 642 + wobble() 643 + mod.wibble() 644 + } 645 + ", 646 + "some_function", 647 + find_position_of("wibble") 648 + ); 649 + } 650 + 651 + #[test] 652 + fn rename_function_from_aliased_import_to_original_name() { 653 + assert_rename!( 654 + ( 655 + "mod", 656 + " 657 + pub fn wibble() { 658 + wibble() 659 + } 660 + " 661 + ), 662 + " 663 + import mod.{wibble as wobble} 664 + 665 + pub fn main() { 666 + wobble() 667 + mod.wibble() 668 + } 669 + ", 670 + "wibble", 671 + find_position_of("wibble") 672 + ); 673 + } 674 + 675 + #[test] 604 676 fn rename_aliased_function() { 605 677 assert_rename!( 606 678 ( ··· 808 880 } 809 881 810 882 #[test] 883 + fn rename_constant_from_import() { 884 + assert_rename!( 885 + ( 886 + "mod", 887 + " 888 + pub const something = 10 889 + 890 + fn wibble() { 891 + something 892 + } 893 + " 894 + ), 895 + " 896 + import mod.{something} 897 + 898 + pub fn main() { 899 + something + mod.something 900 + } 901 + ", 902 + "ten", 903 + find_position_of("something") 904 + ); 905 + } 906 + 907 + #[test] 908 + fn rename_constant_from_aliased_import() { 909 + assert_rename!( 910 + ( 911 + "mod", 912 + " 913 + pub const something = 10 914 + 915 + fn wibble() { 916 + something 917 + } 918 + " 919 + ), 920 + " 921 + import mod.{something as smth} 922 + 923 + pub fn main() { 924 + smth + mod.something 925 + } 926 + ", 927 + "ten", 928 + find_position_of("something") 929 + ); 930 + } 931 + 932 + #[test] 933 + fn rename_constant_from_aliased_import_to_original_name() { 934 + assert_rename!( 935 + ( 936 + "mod", 937 + " 938 + pub const something = 10 939 + 940 + fn wibble() { 941 + something 942 + } 943 + " 944 + ), 945 + " 946 + import mod.{something as smth} 947 + 948 + pub fn main() { 949 + smth + mod.something 950 + } 951 + ", 952 + "something", 953 + find_position_of("something") 954 + ); 955 + } 956 + 957 + #[test] 811 958 fn rename_aliased_constant() { 812 959 assert_rename!( 813 960 ( ··· 1014 1161 } 1015 1162 1016 1163 #[test] 1164 + fn rename_type_variant_from_import() { 1165 + assert_rename!( 1166 + ( 1167 + "mod", 1168 + " 1169 + pub type Wibble { 1170 + Constructor(Int) 1171 + } 1172 + 1173 + fn wibble() { 1174 + Constructor(81) 1175 + } 1176 + " 1177 + ), 1178 + " 1179 + import mod.{Constructor} 1180 + 1181 + pub fn main() { 1182 + #(Constructor(75), mod.Constructor(57)) 1183 + } 1184 + ", 1185 + "Number", 1186 + find_position_of("Constructor") 1187 + ); 1188 + } 1189 + 1190 + #[test] 1191 + fn rename_type_variant_from_aliased_import() { 1192 + assert_rename!( 1193 + ( 1194 + "mod", 1195 + " 1196 + pub type Wibble { 1197 + Constructor(Int) 1198 + } 1199 + 1200 + fn wibble() { 1201 + Constructor(81) 1202 + } 1203 + " 1204 + ), 1205 + " 1206 + import mod.{Constructor as C} 1207 + 1208 + pub fn main() { 1209 + #(C(75), mod.Constructor(57)) 1210 + } 1211 + ", 1212 + "Number", 1213 + find_position_of("Constructor") 1214 + ); 1215 + } 1216 + 1217 + #[test] 1218 + fn rename_type_variant_from_aliased_import_to_original_name() { 1219 + assert_rename!( 1220 + ( 1221 + "mod", 1222 + " 1223 + pub type Wibble { 1224 + Constructor(Int) 1225 + } 1226 + 1227 + fn wibble() { 1228 + Constructor(81) 1229 + } 1230 + " 1231 + ), 1232 + " 1233 + import mod.{Constructor as C} 1234 + 1235 + pub fn main() { 1236 + #(C(75), mod.Constructor(57)) 1237 + } 1238 + ", 1239 + "Constructor", 1240 + find_position_of("Constructor") 1241 + ); 1242 + } 1243 + 1244 + #[test] 1017 1245 fn rename_aliased_type_variant() { 1018 1246 assert_rename!( 1019 1247 ( ··· 1339 1567 ", 1340 1568 "SomeType", 1341 1569 find_position_of("Wibble)") 1570 + ); 1571 + } 1572 + 1573 + #[test] 1574 + fn rename_type_from_import() { 1575 + assert_rename!( 1576 + ( 1577 + "mod", 1578 + " 1579 + pub type Wibble { Constructor } 1580 + 1581 + fn wibble(w: Wibble) -> Wibble { todo } 1582 + " 1583 + ), 1584 + " 1585 + import mod.{type Wibble} 1586 + 1587 + pub fn main(w: Wibble) -> mod.Wibble { todo } 1588 + ", 1589 + "SomeType", 1590 + find_position_of("Wibble") 1591 + ); 1592 + } 1593 + 1594 + #[test] 1595 + fn rename_type_from_aliased_import() { 1596 + assert_rename!( 1597 + ( 1598 + "mod", 1599 + " 1600 + pub type Wibble { Constructor } 1601 + 1602 + fn wibble(w: Wibble) -> Wibble { todo } 1603 + " 1604 + ), 1605 + " 1606 + import mod.{type Wibble as Wobble} 1607 + 1608 + pub fn main(w: Wobble) -> mod.Wibble { todo } 1609 + ", 1610 + "SomeType", 1611 + find_position_of("Wibble") 1612 + ); 1613 + } 1614 + 1615 + #[test] 1616 + fn rename_type_from_aliased_import_to_original_name() { 1617 + assert_rename!( 1618 + ( 1619 + "mod", 1620 + " 1621 + pub type Wibble { Constructor } 1622 + 1623 + fn wibble(w: Wibble) -> Wibble { todo } 1624 + " 1625 + ), 1626 + " 1627 + import mod.{type Wibble as Wobble} 1628 + 1629 + pub fn main(w: Wobble) -> mod.Wibble { todo } 1630 + ", 1631 + "Wibble", 1632 + find_position_of("Wibble") 1342 1633 ); 1343 1634 } 1344 1635
+41
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_constant_from_aliased_import.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{something as smth}\n\npub fn main() {\n smth + mod.something\n}\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub const something = 10 9 + 10 + fn wibble() { 11 + something 12 + } 13 + 14 + 15 + -- app.gleam 16 + 17 + import mod.{something as smth} 18 + ↑▔▔▔▔▔▔▔▔ 19 + 20 + pub fn main() { 21 + smth + mod.something 22 + } 23 + 24 + 25 + ----- AFTER RENAME 26 + -- mod.gleam 27 + 28 + pub const something = 10 29 + 30 + fn wibble() { 31 + something 32 + } 33 + 34 + 35 + -- app.gleam 36 + 37 + import mod.{something as ten} 38 + 39 + pub fn main() { 40 + ten + mod.something 41 + }
+41
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_constant_from_aliased_import_to_original_name.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{something as smth}\n\npub fn main() {\n smth + mod.something\n}\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub const something = 10 9 + 10 + fn wibble() { 11 + something 12 + } 13 + 14 + 15 + -- app.gleam 16 + 17 + import mod.{something as smth} 18 + ↑▔▔▔▔▔▔▔▔ 19 + 20 + pub fn main() { 21 + smth + mod.something 22 + } 23 + 24 + 25 + ----- AFTER RENAME 26 + -- mod.gleam 27 + 28 + pub const something = 10 29 + 30 + fn wibble() { 31 + something 32 + } 33 + 34 + 35 + -- app.gleam 36 + 37 + import mod.{something} 38 + 39 + pub fn main() { 40 + something + mod.something 41 + }
+41
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_constant_from_import.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{something}\n\npub fn main() {\n something + mod.something\n}\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub const something = 10 9 + 10 + fn wibble() { 11 + something 12 + } 13 + 14 + 15 + -- app.gleam 16 + 17 + import mod.{something} 18 + ↑▔▔▔▔▔▔▔▔ 19 + 20 + pub fn main() { 21 + something + mod.something 22 + } 23 + 24 + 25 + ----- AFTER RENAME 26 + -- mod.gleam 27 + 28 + pub const something = 10 29 + 30 + fn wibble() { 31 + something 32 + } 33 + 34 + 35 + -- app.gleam 36 + 37 + import mod.{something as ten} 38 + 39 + pub fn main() { 40 + ten + mod.something 41 + }
+39
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_function_from_aliased_import.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{wibble as wobble}\n\npub fn main() {\n wobble()\n mod.wibble()\n}\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub fn wibble() { 9 + wibble() 10 + } 11 + 12 + 13 + -- app.gleam 14 + 15 + import mod.{wibble as wobble} 16 + ↑▔▔▔▔▔ 17 + 18 + pub fn main() { 19 + wobble() 20 + mod.wibble() 21 + } 22 + 23 + 24 + ----- AFTER RENAME 25 + -- mod.gleam 26 + 27 + pub fn wibble() { 28 + wibble() 29 + } 30 + 31 + 32 + -- app.gleam 33 + 34 + import mod.{wibble as some_function} 35 + 36 + pub fn main() { 37 + some_function() 38 + mod.wibble() 39 + }
+39
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_function_from_aliased_import_to_original_name.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{wibble as wobble}\n\npub fn main() {\n wobble()\n mod.wibble()\n}\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub fn wibble() { 9 + wibble() 10 + } 11 + 12 + 13 + -- app.gleam 14 + 15 + import mod.{wibble as wobble} 16 + ↑▔▔▔▔▔ 17 + 18 + pub fn main() { 19 + wobble() 20 + mod.wibble() 21 + } 22 + 23 + 24 + ----- AFTER RENAME 25 + -- mod.gleam 26 + 27 + pub fn wibble() { 28 + wibble() 29 + } 30 + 31 + 32 + -- app.gleam 33 + 34 + import mod.{wibble} 35 + 36 + pub fn main() { 37 + wibble() 38 + mod.wibble() 39 + }
+39
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_function_from_import.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{wibble}\n\npub fn main() {\n wibble()\n mod.wibble()\n}\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub fn wibble() { 9 + wibble() 10 + } 11 + 12 + 13 + -- app.gleam 14 + 15 + import mod.{wibble} 16 + ↑▔▔▔▔▔ 17 + 18 + pub fn main() { 19 + wibble() 20 + mod.wibble() 21 + } 22 + 23 + 24 + ----- AFTER RENAME 25 + -- mod.gleam 26 + 27 + pub fn wibble() { 28 + wibble() 29 + } 30 + 31 + 32 + -- app.gleam 33 + 34 + import mod.{wibble as some_function} 35 + 36 + pub fn main() { 37 + some_function() 38 + mod.wibble() 39 + }
+33
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_type_from_aliased_import.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{type Wibble as Wobble}\n\npub fn main(w: Wobble) -> mod.Wibble { todo }\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub type Wibble { Constructor } 9 + 10 + fn wibble(w: Wibble) -> Wibble { todo } 11 + 12 + 13 + -- app.gleam 14 + 15 + import mod.{type Wibble as Wobble} 16 + ↑▔▔▔▔▔ 17 + 18 + pub fn main(w: Wobble) -> mod.Wibble { todo } 19 + 20 + 21 + ----- AFTER RENAME 22 + -- mod.gleam 23 + 24 + pub type Wibble { Constructor } 25 + 26 + fn wibble(w: Wibble) -> Wibble { todo } 27 + 28 + 29 + -- app.gleam 30 + 31 + import mod.{type Wibble as SomeType} 32 + 33 + pub fn main(w: SomeType) -> mod.Wibble { todo }
+33
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_type_from_aliased_import_to_original_name.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{type Wibble as Wobble}\n\npub fn main(w: Wobble) -> mod.Wibble { todo }\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub type Wibble { Constructor } 9 + 10 + fn wibble(w: Wibble) -> Wibble { todo } 11 + 12 + 13 + -- app.gleam 14 + 15 + import mod.{type Wibble as Wobble} 16 + ↑▔▔▔▔▔ 17 + 18 + pub fn main(w: Wobble) -> mod.Wibble { todo } 19 + 20 + 21 + ----- AFTER RENAME 22 + -- mod.gleam 23 + 24 + pub type Wibble { Constructor } 25 + 26 + fn wibble(w: Wibble) -> Wibble { todo } 27 + 28 + 29 + -- app.gleam 30 + 31 + import mod.{type Wibble} 32 + 33 + pub fn main(w: Wibble) -> mod.Wibble { todo }
+33
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_type_from_import.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{type Wibble}\n\npub fn main(w: Wibble) -> mod.Wibble { todo }\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub type Wibble { Constructor } 9 + 10 + fn wibble(w: Wibble) -> Wibble { todo } 11 + 12 + 13 + -- app.gleam 14 + 15 + import mod.{type Wibble} 16 + ↑▔▔▔▔▔ 17 + 18 + pub fn main(w: Wibble) -> mod.Wibble { todo } 19 + 20 + 21 + ----- AFTER RENAME 22 + -- mod.gleam 23 + 24 + pub type Wibble { Constructor } 25 + 26 + fn wibble(w: Wibble) -> Wibble { todo } 27 + 28 + 29 + -- app.gleam 30 + 31 + import mod.{type Wibble as SomeType} 32 + 33 + pub fn main(w: SomeType) -> mod.Wibble { todo }
+45
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_type_variant_from_aliased_import.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{Constructor as C}\n\npub fn main() {\n #(C(75), mod.Constructor(57))\n}\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub type Wibble { 9 + Constructor(Int) 10 + } 11 + 12 + fn wibble() { 13 + Constructor(81) 14 + } 15 + 16 + 17 + -- app.gleam 18 + 19 + import mod.{Constructor as C} 20 + ↑▔▔▔▔▔▔▔▔▔▔ 21 + 22 + pub fn main() { 23 + #(C(75), mod.Constructor(57)) 24 + } 25 + 26 + 27 + ----- AFTER RENAME 28 + -- mod.gleam 29 + 30 + pub type Wibble { 31 + Constructor(Int) 32 + } 33 + 34 + fn wibble() { 35 + Constructor(81) 36 + } 37 + 38 + 39 + -- app.gleam 40 + 41 + import mod.{Constructor as Number} 42 + 43 + pub fn main() { 44 + #(Number(75), mod.Constructor(57)) 45 + }
+45
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_type_variant_from_aliased_import_to_original_name.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{Constructor as C}\n\npub fn main() {\n #(C(75), mod.Constructor(57))\n}\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub type Wibble { 9 + Constructor(Int) 10 + } 11 + 12 + fn wibble() { 13 + Constructor(81) 14 + } 15 + 16 + 17 + -- app.gleam 18 + 19 + import mod.{Constructor as C} 20 + ↑▔▔▔▔▔▔▔▔▔▔ 21 + 22 + pub fn main() { 23 + #(C(75), mod.Constructor(57)) 24 + } 25 + 26 + 27 + ----- AFTER RENAME 28 + -- mod.gleam 29 + 30 + pub type Wibble { 31 + Constructor(Int) 32 + } 33 + 34 + fn wibble() { 35 + Constructor(81) 36 + } 37 + 38 + 39 + -- app.gleam 40 + 41 + import mod.{Constructor} 42 + 43 + pub fn main() { 44 + #(Constructor(75), mod.Constructor(57)) 45 + }
+45
language-server/src/tests/snapshots/gleam_language_server__tests__rename__rename_type_variant_from_import.snap
··· 1 + --- 2 + source: language-server/src/tests/rename.rs 3 + expression: "\nimport mod.{Constructor}\n\npub fn main() {\n #(Constructor(75), mod.Constructor(57))\n}\n" 4 + --- 5 + ----- BEFORE RENAME 6 + -- mod.gleam 7 + 8 + pub type Wibble { 9 + Constructor(Int) 10 + } 11 + 12 + fn wibble() { 13 + Constructor(81) 14 + } 15 + 16 + 17 + -- app.gleam 18 + 19 + import mod.{Constructor} 20 + ↑▔▔▔▔▔▔▔▔▔▔ 21 + 22 + pub fn main() { 23 + #(Constructor(75), mod.Constructor(57)) 24 + } 25 + 26 + 27 + ----- AFTER RENAME 28 + -- mod.gleam 29 + 30 + pub type Wibble { 31 + Constructor(Int) 32 + } 33 + 34 + fn wibble() { 35 + Constructor(81) 36 + } 37 + 38 + 39 + -- app.gleam 40 + 41 + import mod.{Constructor as Number} 42 + 43 + pub fn main() { 44 + #(Number(75), mod.Constructor(57)) 45 + }