Generic inference (#2475)

* Change generic symbol resolution.
* Infer generic parameters lhs -> rhs: `List{int} x = list::NOHEAP`.
* Regression: Compiler segfault when assigning struct literal with too few members #2483

test/unit/stdlib/collections/bitset.c3

@@ -4,31 +4,31 @@ import std::collections::growablebitset;
 import std::collections::list;
 import std::io;
 
-alias List = List {usz};
+alias List2 = List {usz};
 
-alias BitSet = BitSet {2048};
+alias BitSet2 = BitSet {2048};
 
 fn void bit_ops_assign()
 {
-	BitSet bs;
-	BitSet bs2;
+	BitSet2 bs;
+	BitSet2 bs2;
 	bs.set(4);
 	bs.set(6);
 	bs2.set(4);
 	bs2.set(8);
-	BitSet bs3 = bs;
+	BitSet2 bs3 = bs;
 	bs3 ^= bs2;
 	assert(!bs3.get(4));
 	assert(!bs3.get(5));
 	assert(bs3.get(6));
 	assert(bs3.get(8));
-	BitSet bs4 = bs;
+	BitSet2 bs4 = bs;
 	bs4 |= bs2;
 	assert(bs4.get(4));
 	assert(!bs4.get(5));
 	assert(bs4.get(6));
 	assert(bs4.get(8));
-	BitSet bs5 = bs;
+	BitSet2 bs5 = bs;
 	bs5 &= bs2;
 	assert(bs5.get(4));
 	assert(!bs5.get(5));
@@ -38,23 +38,23 @@ fn void bit_ops_assign()
 
 fn void bit_ops()
 {
-	BitSet bs;
-	BitSet bs2;
+	BitSet2 bs;
+	BitSet2 bs2;
 	bs.set(4);
 	bs.set(6);
 	bs2.set(4);
 	bs2.set(8);
-	BitSet bs3 = bs ^ bs2;
+	BitSet2 bs3 = bs ^ bs2;
 	assert(!bs3.get(4));
 	assert(!bs3.get(5));
 	assert(bs3.get(6));
 	assert(bs3.get(8));
-	BitSet bs4 = bs | bs2;
+	BitSet2 bs4 = bs | bs2;
 	assert(bs4.get(4));
 	assert(!bs4.get(5));
 	assert(bs4.get(6));
 	assert(bs4.get(8));
-	BitSet bs5 = bs & bs2;
+	BitSet2 bs5 = bs & bs2;
 	assert(bs5.get(4));
 	assert(!bs5.get(5));
 	assert(!bs5.get(6));
@@ -62,7 +62,7 @@ fn void bit_ops()
 }
 fn void set_get()
 {
-	BitSet bs;
+	BitSet2 bs;
 	assert(bs.cardinality() == 0);
 
 	assert(!bs.get(0));
@@ -75,7 +75,7 @@ fn void set_get()
 	assert(bs.get(2000));
 	assert(bs.cardinality() == 2);
 
-	List found;
+	List2 found;
 	foreach (i, x : bs)
 	{
 		switch (i)
@@ -97,10 +97,10 @@ fn void set_get()
 	assert(bs.cardinality() == 0);
 }
 
-alias GrowableBitSet = GrowableBitSet{char};
+alias GrowableBitSetChar = GrowableBitSet{char};
 fn void growable_set_get()
 {
-	GrowableBitSet bs;
+	GrowableBitSetChar bs;
 	bs.tinit();
 	assert(bs.cardinality() == 0, "Invalid cardinality");
 
@@ -118,7 +118,7 @@ fn void growable_set_get()
 	assert(bs.data.len() == 251, "Len should be 251");
 	assert(bs.len() == 2001, "Len should be 2001");
 
-	List found;
+	List2 found;
 	foreach (i, x : bs)
 	{
 		switch (i)

test/unit/stdlib/collections/linked_map.c3

@@ -11,7 +11,7 @@ struct MapTest
 	String key;
 	usz value;
 }
-alias List = List{MapTest};
+alias ListMap = List{MapTest};
 
 fn void linked_map_basic()
 {

test/unit/stdlib/collections/map.c3

@@ -11,7 +11,7 @@ struct MapTest
     String key;
     usz value;
 }
-alias List = List{MapTest};
+alias ListMap = List{MapTest};
 
 fn void map()
 {
@@ -40,7 +40,7 @@ fn void map()
         assert(tc.value == v);
     }
 
-    List list;
+    ListMap list;
     list.tinit();
     m.@each(;String key, usz value)
     {

test/unit/stdlib/io/stream.c3

@@ -6,24 +6,56 @@ fn void read_ushort_test()
 	assert(io::read_be_ushort(&reader)!! == 0x348a);
 }
 
+fn void read_le_ushort_test()
+{
+	ByteReader reader = io::wrap_bytes({0x34, 0x8a});
+	assert(io::read_le_ushort(&reader)!! == 0x8a34);
+}
+
 fn void read_uint_test()
 {
 	ByteReader reader = io::wrap_bytes({0x34, 0x8a, 0xef, 0xcc});
 	assert(io::read_be_uint(&reader)!! == 0x348aefcc);
 }
 
+fn void read_le_uint_test()
+{
+	ByteReader reader = io::wrap_bytes({0x34, 0x8a, 0xef, 0xcc});
+	assert(io::read_le_uint(&reader)!! == 0xccef8a34);
+}
+
+fn void read_skip_test()
+{
+	ByteReader reader = io::wrap_bytes({0x34, 0x8a, 0xef, 0xcc});
+	io::skip(&reader, 0)!!;
+	io::skip(&reader, 1)!!;
+	assert(io::read_le_ushort(&reader)!! == 0xef8a);
+}
+
 fn void read_ulong_test()
 {
 	ByteReader reader = io::wrap_bytes({0x34, 0x8a, 0xef, 0xcc, 0x34, 0x8a, 0xef, 0xcc});
 	assert(io::read_be_ulong(&reader)!! == 0x348aefcc348aefcc);
 }
 
+fn void read_le_ulong_test()
+{
+	ByteReader reader = io::wrap_bytes({0x34, 0x8a, 0xef, 0xcc, 0x34, 0x8a, 0xef, 0xcc});
+	assert(io::read_le_ulong(&reader)!! == 0xccef8a34ccef8a34);
+}
+
 fn void read_uint128_test()
 {
 	ByteReader reader = io::wrap_bytes({0x34, 0x8a, 0xef, 0xcc, 0x34, 0x8a, 0xef, 0xcc, 0x34, 0x8a, 0xef, 0xcc, 0x34, 0x8a, 0xef, 0xcc});
 	assert(io::read_be_uint128(&reader)!! == 0x348aefcc348aefcc348aefcc348aefcc);
 }
 
+fn void read_le_uint128_test()
+{
+	ByteReader reader = io::wrap_bytes({0x34, 0x8a, 0xef, 0xcc, 0x34, 0x8a, 0xef, 0xcc, 0x34, 0x8a, 0xef, 0xcc, 0x34, 0x8a, 0xef, 0xcc});
+	test::eq(io::read_le_uint128(&reader)!!, 0xccef8a34ccef8a34ccef8a34ccef8a34);
+}
+
 fn void write_ushort_test()
 {
 	ByteWriter bw;
@@ -32,6 +64,14 @@ fn void write_ushort_test()
 	assert(bw.str_view() == &&x'348a');
 }
 
+fn void write_le_ushort_test()
+{
+	ByteWriter bw;
+	bw.tinit();
+	io::write_le_short(&bw, 0x348a)!!;
+	assert(bw.str_view() == &&x'8a34');
+}
+
 fn void write_uint_test()
 {
 	ByteWriter bw;
@@ -40,6 +80,14 @@ fn void write_uint_test()
 	assert(bw.str_view() == &&x'3421348a');
 }
 
+fn void write_le_uint_test()
+{
+	ByteWriter bw;
+	bw.tinit();
+	io::write_le_int(&bw, 0x3421348a)!!;
+	assert(bw.str_view() == &&x'8a342134');
+}
+
 fn void write_ulong_test()
 {
 	ByteWriter bw;
@@ -48,6 +96,14 @@ fn void write_ulong_test()
 	assert(bw.str_view() == &&x'aabbccdd3421348a');
 }
 
+fn void write_le_ulong_test()
+{
+	ByteWriter bw;
+	bw.tinit();
+	io::write_le_long(&bw, 0xaabbccdd3421348a)!!;
+	assert(bw.str_view() == &&x'8a342134ddccbbaa');
+}
+
 fn void write_uint128_test()
 {
 	ByteWriter bw;
@@ -56,6 +112,14 @@ fn void write_uint128_test()
 	assert(bw.str_view() == &&x'aabbccdd3421348aaabbccdd3421348a');
 }
 
+fn void write_le_uint128_test()
+{
+	ByteWriter bw;
+	bw.tinit();
+	io::write_le_int128(&bw, 0xaabbccdd3421348aaabbccdd3421348a)!!;
+	assert(bw.str_view() == &&x'8a342134ddccbbaa8a342134ddccbbaa');
+}
+
 fn void write_tiny_bytearray_test()
 {
 	ByteWriter bw;

test/unit/stdlib/sort/quicksort.c3

@@ -78,11 +78,11 @@ fn void quicksort_with_lambda()
     }
 }
 
-alias List = List{int};
+alias List2 = List{int};
 
 fn void quicksort_list()
 {
-    List list;
+    List2 list;
     list.push_all({ 2, 1, 3});
     sort::quicksort(list, &sort::cmp_int_value);
     assert(check::int_sort(list.array_view()));