Migrate tests from -> to : in result type syntax

core-lang · Sep 26, 2020 · c3ae3f1 · c3ae3f1
1 parent c6548fd
commit c3ae3f1
Show file tree

Hide file tree

Showing 159 changed files with 473 additions and 473 deletions.
diff --git a/tests/array/array-for1.dora b/tests/array/array-for1.dora
@@ -4,7 +4,7 @@ fun main() {
     assert(slowLength(Array[Int32](1, 2)) == 2L);
 }
 
-fun slowLength(x: Array[Int32]) -> Int64 {
+fun slowLength(x: Array[Int32]): Int64 {
     var entries = 0L;
     for val in x {
         entries = entries + 1L;

diff --git a/tests/array/array-for2.dora b/tests/array/array-for2.dora
@@ -4,7 +4,7 @@ fun main() {
     assert(slowLength(nil) == 0L);
 }
 
-fun slowLength(x: Array[Int32]) -> Int64 {
+fun slowLength(x: Array[Int32]): Int64 {
     var entries = 0L;
     for val in x {
         entries = entries + 1L;

diff --git a/tests/array/array-for3.dora b/tests/array/array-for3.dora
@@ -4,7 +4,7 @@ fun main() {
     assert(mysum(Array[Int32](1, 2, 3, 4, 5)) == 15);
 }
 
-fun mysum(x: Array[Int32]) -> Int32 {
+fun mysum(x: Array[Int32]): Int32 {
     var entries = 0;
     for val in x {
         entries = entries + val;

diff --git a/tests/array/array-get.dora b/tests/array/array-get.dora
@@ -30,27 +30,27 @@ fun main() {
   assert(foo_array_get(x, 0L) === nil);
 }
 
-fun int32_array_get(x: Array[Int32], idx: Int64) -> Int32 {
+fun int32_array_get(x: Array[Int32], idx: Int64): Int32 {
   return x(idx);
 }
 
-fun int64_array_get(x: Array[Int64], idx: Int64) -> Int64 {
+fun int64_array_get(x: Array[Int64], idx: Int64): Int64 {
   return x(idx);
 }
 
-fun float_array_get(x: Array[Float32], idx: Int64) -> Float32 {
+fun float_array_get(x: Array[Float32], idx: Int64): Float32 {
   return x(idx);
 }
 
-fun double_array_get(x: Array[Float64], idx: Int64) -> Float64 {
+fun double_array_get(x: Array[Float64], idx: Int64): Float64 {
   return x(idx);
 }
 
-fun str_array_get(x: Array[String], idx: Int64) -> String {
+fun str_array_get(x: Array[String], idx: Int64): String {
   return x(idx);
 }
 
-fun foo_array_get(x: Array[Foo], idx: Int64) -> Foo {
+fun foo_array_get(x: Array[Foo], idx: Int64): Foo {
   return x(idx);
 }
 

diff --git a/tests/array/array-length.dora b/tests/array/array-length.dora
@@ -48,27 +48,27 @@ fun main() {
   assert(foo_array_len(x) == 1L);
 }
 
-fun int32_array_len(x: Array[Int32]) -> Int64 {
+fun int32_array_len(x: Array[Int32]): Int64 {
   return x.size();
 }
 
-fun int64_array_len(x: Array[Int64]) -> Int64 {
+fun int64_array_len(x: Array[Int64]): Int64 {
   return x.size();
 }
 
-fun float_array_len(x: Array[Float32]) -> Int64 {
+fun float_array_len(x: Array[Float32]): Int64 {
   return x.size();
 }
 
-fun double_array_len(x: Array[Float64]) -> Int64 {
+fun double_array_len(x: Array[Float64]): Int64 {
   return x.size();
 }
 
-fun str_array_len(x: Array[String]) -> Int64 {
+fun str_array_len(x: Array[String]): Int64 {
   return x.size();
 }
 
-fun foo_array_len(x: Array[Foo]) -> Int64 {
+fun foo_array_len(x: Array[Foo]): Int64 {
   return x.size();
 }
 

diff --git a/tests/array/array-rest1.dora b/tests/array/array-rest1.dora
@@ -5,6 +5,6 @@ fun main() {
     assert(number_args(1, 2, 3, 4, 5) == 5L);
 }
 
-fun number_args(x: Int32...) -> Int64 {
+fun number_args(x: Int32...): Int64 {
     x.size()
 }
diff --git a/tests/array/array-rest2.dora b/tests/array/array-rest2.dora
@@ -5,7 +5,7 @@ fun main() {
     assert(sum_args(1, 2, 3, 4, 5) == 15);
 }
 
-fun sum_args(x: Int32...) -> Int32 {
+fun sum_args(x: Int32...): Int32 {
     var result = 0;
     var idx = 0L;
 

diff --git a/tests/array/array-rest3.dora b/tests/array/array-rest3.dora
@@ -5,7 +5,7 @@ fun main() {
     assert(sum_args(1.0F, 2.0F, 3.0F, 4.0F, 5.0F) == 15.0F);
 }
 
-fun sum_args(x: Float32...) -> Float32 {
+fun sum_args(x: Float32...): Float32 {
     var result = 0.0F;
     var idx = 0L;
 

diff --git a/tests/array/array-rest4.dora b/tests/array/array-rest4.dora
@@ -5,7 +5,7 @@ fun main() {
     assert(sum_args() == 0);
 }
 
-fun sum_args(x: Foo...) -> Int32 {
+fun sum_args(x: Foo...): Int32 {
     var result = 0;
     var idx = 0L;
 

diff --git a/tests/array/array-rest5.dora b/tests/array/array-rest5.dora
@@ -4,7 +4,7 @@ fun main() {
     assert(sum_args((0, 1)) == 1);
 }
 
-fun sum_args(x: (Int32, Int32)...) -> Int32 {
+fun sum_args(x: (Int32, Int32)...): Int32 {
     var result = 0;
     var idx = 0L;
 

diff --git a/tests/array/array-syntax1.dora b/tests/array/array-syntax1.dora
@@ -10,6 +10,6 @@ fun array_set(a: Array[Int32], idx: Int64, value: Int32) {
     a(idx) = value;
 }
 
-fun array_get(a: Array[Int32], idx: Int64) -> Int32 {
+fun array_get(a: Array[Int32], idx: Int64): Int32 {
     return a(idx);
 }
diff --git a/tests/array/array-syntax2.dora b/tests/array/array-syntax2.dora
@@ -2,8 +2,8 @@ fun main() {
     assert(test_call() == 1);
 }
 
-fun test_call() -> Int32 = Foo::bar[Int32]();
+fun test_call(): Int32 = Foo::bar[Int32]();
 
 module Foo {
-    fun bar[T]() -> Int32 = 1;
+    fun bar[T](): Int32 = 1;
 }
diff --git a/tests/array/array11.dora b/tests/array/array11.dora
@@ -5,6 +5,6 @@ fun main() {
     first(nil);
 }
 
-fun first(f: Array[Int32]) -> Int32 {
+fun first(f: Array[Int32]): Int32 {
     return f(0L);
 }
diff --git a/tests/array/array2.dora b/tests/array/array2.dora
@@ -2,4 +2,4 @@ fun main() {
   assert(0L == len(Array::empty[Int32]()));
 }
 
-fun len(a: Array[Int32]) -> Int64 { return a.size(); }
+fun len(a: Array[Int32]): Int64 { return a.size(); }
diff --git a/tests/array/array3.dora b/tests/array/array3.dora
@@ -2,4 +2,4 @@ fun main() {
   assert(1L == len(Array::fill[Int32](1L, 0)));
 }
 
-fun len(a: Array[Int32]) -> Int64 { return a.size(); }
+fun len(a: Array[Int32]): Int64 { return a.size(); }
diff --git a/tests/array/array5.dora b/tests/array/array5.dora
@@ -6,13 +6,13 @@ fun main() {
 }
 
 class A {
-  fun get(index: String) -> Int32 {
+  fun get(index: String): Int32 {
     return 1;
   }
 }
 
 class B {
-  fun get(index: Bool) -> Bool {
+  fun get(index: Bool): Bool {
     return index;
   }
 }
diff --git a/tests/as1.dora b/tests/as1.dora
@@ -7,11 +7,11 @@ fun main() {
   assert(asb(b) === b);
 }
 
-fun asb(a: A) -> B {
+fun asb(a: A): B {
   return a as B;
 }
 
-fun asa(b: B) -> A {
+fun asa(b: B): A {
   return b as A;
 }
 

diff --git a/tests/as2.dora b/tests/as2.dora
@@ -7,7 +7,7 @@ fun main() {
   assert(asb(a) === a);
 }
 
-fun asb(a: A) -> B {
+fun asb(a: A): B {
   return a as B;
 }
 

diff --git a/tests/as3.dora b/tests/as3.dora
@@ -3,7 +3,7 @@ fun main() {
   assert(asl7(l7) === l7);
 }
 
-fun asl7(a: L1) -> L7 {
+fun asl7(a: L1): L7 {
   return a as L7;
 }
 

diff --git a/tests/as4.dora b/tests/as4.dora
@@ -6,7 +6,7 @@ fun main() {
   assert(asl7(l1) === l1);
 }
 
-fun asl7(a: L1) -> L7 {
+fun asl7(a: L1): L7 {
   return a as L7;
 }
 

diff --git a/tests/as5.dora b/tests/as5.dora
@@ -3,7 +3,7 @@ fun main() {
     assert(!test(B(0)));
 }
 
-fun test(a: A) -> Bool {
+fun test(a: A): Bool {
     let a = a as B;
     return a.x != 0;
 }

diff --git a/tests/block-expr-gc.dora b/tests/block-expr-gc.dora
@@ -11,6 +11,6 @@ fun main() {
     };
 }
 
-fun createFoo() -> Foo {
+fun createFoo(): Foo {
     Foo(1)
 }
diff --git a/tests/block1.dora b/tests/block1.dora
@@ -4,7 +4,7 @@ fun main() {
     t3();
 }
 
-fun g() -> Int32 { return 1; }
+fun g(): Int32 { return 1; }
 
 fun t1() {
     let x: Int32 = { g() };

diff --git a/tests/block2.dora b/tests/block2.dora
@@ -14,4 +14,4 @@ fun main() {
     assert(myid[Float64](1.0) == 1.0);
 }
 
-fun myid[T](x: T) -> T { x }
+fun myid[T](x: T): T { x }
diff --git a/tests/boots/hello.dora b/tests/boots/hello.dora
@@ -6,4 +6,4 @@ fun main() {
 }
 
 @optimize_immediately fun f() {}
-@optimize_immediately fun g() -> Int32 { 17 }
+@optimize_immediately fun g(): Int32 { 17 }
diff --git a/tests/cannon/abi1.dora b/tests/cannon/abi1.dora
@@ -11,20 +11,20 @@ fun main() {
     assert(foo.testSelf() === foo);
 }
 
-@cannon fun testInt32(x: Int32) -> Int32 {
+@cannon fun testInt32(x: Int32): Int32 {
     return x;
 }
 
-@cannon fun testFloat32(x: Float32) -> Float32 {
+@cannon fun testFloat32(x: Float32): Float32 {
     return x;
 }
 
-@cannon fun testPtr(x: Foo) -> Foo {
+@cannon fun testPtr(x: Foo): Foo {
     return x;
 }
 
 class Foo() {
-    @cannon fun testSelf() -> Foo {
+    @cannon fun testSelf(): Foo {
         return self;
     }
 }
diff --git a/tests/cannon/abi2.dora b/tests/cannon/abi2.dora
@@ -10,38 +10,38 @@ fun main() {
     assert(abi_9(1, 2, 3, 4, 5, 6, 7, 8, 9) == 9);
 }
 
-@cannon fun abi_1(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32) -> Int32 {
+@cannon fun abi_1(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32): Int32 {
     return x;
 }
 
-@cannon fun abi_2(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32) -> Int32 {
+@cannon fun abi_2(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32): Int32 {
     return y;
 }
 
-@cannon fun abi_3(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32) -> Int32 {
+@cannon fun abi_3(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32): Int32 {
     return z;
 }
 
-@cannon fun abi_4(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32) -> Int32 {
+@cannon fun abi_4(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32): Int32 {
     return a;
 }
 
-@cannon fun abi_5(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32) -> Int32 {
+@cannon fun abi_5(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32): Int32 {
     return b;
 }
 
-@cannon fun abi_6(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32) -> Int32 {
+@cannon fun abi_6(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32): Int32 {
     return c;
 }
 
-@cannon fun abi_7(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32) -> Int32 {
+@cannon fun abi_7(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32): Int32 {
     return i;
 }
 
-@cannon fun abi_8(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32) -> Int32 {
+@cannon fun abi_8(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32): Int32 {
     return j;
 }
 
-@cannon fun abi_9(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32) -> Int32 {
+@cannon fun abi_9(x: Int32, y: Int32, z: Int32, a: Int32, b: Int32, c: Int32, i: Int32, j: Int32, k: Int32): Int32 {
     return k;
 }
diff --git a/tests/cannon/abi3.dora b/tests/cannon/abi3.dora
@@ -10,38 +10,38 @@ fun main() {
     assert(abi_9(1F, 2F, 3F, 4F, 5F, 6F, 7F, 8F, 9F) == 9F);
 }
 
-@cannon fun abi_1(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32) -> Float32 {
+@cannon fun abi_1(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32): Float32 {
     return x;
 }
 
-@cannon fun abi_2(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32) -> Float32 {
+@cannon fun abi_2(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32): Float32 {
     return y;
 }
 
-@cannon fun abi_3(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32) -> Float32 {
+@cannon fun abi_3(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32): Float32 {
     return z;
 }
 
-@cannon fun abi_4(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32) -> Float32 {
+@cannon fun abi_4(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32): Float32 {
     return a;
 }
 
-@cannon fun abi_5(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32) -> Float32 {
+@cannon fun abi_5(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32): Float32 {
     return b;
 }
 
-@cannon fun abi_6(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32) -> Float32 {
+@cannon fun abi_6(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32): Float32 {
     return c;
 }
 
-@cannon fun abi_7(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32) -> Float32 {
+@cannon fun abi_7(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32): Float32 {
     return i;
 }
 
-@cannon fun abi_8(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32) -> Float32 {
+@cannon fun abi_8(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32): Float32 {
     return j;
 }
 
-@cannon fun abi_9(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32) -> Float32 {
+@cannon fun abi_9(x: Float32, y: Float32, z: Float32, a: Float32, b: Float32, c: Float32, i: Float32, j: Float32, k: Float32): Float32 {
     return k;
 }