Add comments to tests

Author: Aaron1011

tests/test/functions.rs

@@ -16,42 +16,54 @@ fn function_implement_fn_traits() {
             trait Fn<Args> where Self: FnMut<Args> { }
         }
 
+        // Simple test: make sure a fully monomorphic type implements FnOnce
         goal {
             fn(u8): FnOnce<(u8,)>
         } yields {
             "Unique; substitution [], lifetime constraints []"
         }
 
+        // Same as above, but for FnMut
         goal {
             fn(u8): FnMut<(u8,)>
         } yields {
             "Unique; substitution [], lifetime constraints []"
         }
 
+        // Same as above, but for Fn
         goal {
             fn(u8): Fn<(u8,)>
         } yields {
             "Unique; substitution [], lifetime constraints []"
         }
 
+        // Function pointres implicity return `()` when no return
+        // type is specified - make sure that normalization understands
+        // this
         goal {
             Normalize(<fn(u8) as FnOnce<(u8,)>>::Output -> ())
         } yields {
             "Unique; substitution [], lifetime constraints []"
         }
 
+        // Tests normalizing when an explicit return type is used
         goal {
             Normalize(<fn(u8) -> bool as FnOnce<(u8,)>>::Output -> bool)
         } yields {
             "Unique; substitution [], lifetime constraints []"
         }
 
+        // Tests that we fail to normalize when there's a mismatch with
+        // fully monomorphic types.
         goal {
             Normalize(<fn(u8) -> bool as FnOnce<(u8,)>>::Output -> u8)
         } yields {
             "No possible solution"
         }
 
+        // Ensures that we don't find a solution when doing so would
+        // require us to conclude that two different universally quantified
+        // types (T and V) are equal.
         goal {
             forall<T, V> {
                 Normalize(<fn(u8, V) -> T as FnOnce<(u8, V)>>::Output -> V)
@@ -60,6 +72,7 @@ fn function_implement_fn_traits() {
             "No possible solution"
         }
 
+        // Tests that we can normalize a generic function pointer type
         goal {
             forall<T, V> {
                 exists<U> {
@@ -70,18 +83,25 @@ fn function_implement_fn_traits() {
             "Unique; substitution [?0 := !1_0], lifetime constraints []"
         }
 
+        // Tests that we properly tuple function arguments when constrcting
+        // the `FnOnce` impl
         goal {
             fn(u8, u32): FnOnce<(u8,u32)>
         } yields {
             "Unique; substitution [], lifetime constraints []"
         }
 
+        // Tests that we don't find a solution when fully monomorphic
+        // types are mismatched
         goal {
             fn(i32): FnOnce<(bool,)>
         } yields {
             "No possible solution"
         }
 
+        // Tests function pointer types that use the function's binder
+        // Universally quantified lifetimes that differ only in their
+        // name ('a vs 'b) should be considered equivalent here
         goal {
             forall<'a> {
                 for<'b> fn(&'b u8): FnOnce<(&'a u8,)>
@@ -90,6 +110,10 @@ fn function_implement_fn_traits() {
             "Unique; substitution [], lifetime constraints []"
         }
 
+        // Tests that a 'stricter' function (requires lifetimes to be the same)
+        // can implement `FnOnce` for a 'less strict' signature (dose not require
+        // lifetimes to be the same), provided that the lifetimes are *actually*
+        // the same.
         goal {
             forall<'a, 'b> {
                 for<'c> fn(&'c u8, &'c i32): FnOnce<(&'a u8, &'b i32)>
@@ -98,6 +122,22 @@ fn function_implement_fn_traits() {
             "Unique; substitution [], lifetime constraints [InEnvironment { environment: Env([]), goal: '!1_0: '!1_1 }, InEnvironment { environment: Env([]), goal: '!1_1: '!1_0 }]"
         }
 
+        // Tests the opposite case as the previous test: a 'less strict' function
+        // (does not require lifetimes to be the same) can implement `FnOnce` for
+        // a 'stricter' signature (requires lifetimes to be the same) without
+        // any additional requirements
+        goal {
+            forall<'a> {
+                for<'b, 'c> fn(&'b u8, &'c i32): FnOnce<(&'a u8, &'a i32)>
+            }
+        } yields {
+            "Unique; substitution [], lifetime constraints []"
+        }
+
+        // Similiar to the above test, but for types instead of lifetimes:
+        // a 'stricter' function (requires types to be the same) can never
+        // implement `FnOnce` for a 'less strict' signature (does not require
+        // types to be the same)
         goal {
             forall<T, U> {
                 fn(T, T): FnOnce<(T, U)>
@@ -106,6 +146,9 @@ fn function_implement_fn_traits() {
             "No possible solution"
         }
 
+        // Tests the opposite case as a previous test: a 'less strict'
+        // function can never implement 'FnOnce' for a 'more strict' signature
+        // (does not require types to bthe same)
         goal {
             forall<T, U> {
                 fn(T, U): FnOnce<(T, T)>