Add AST copier review coverage tests

Author: csyonghe

tests/language-feature/generics/variadic-pack-count-constraint.slang

@@ -115,6 +115,15 @@ float packCountDifferentiableLiteralBwd<each TIndex>(float x)
     return x * float(countof(TIndex));
 }
 
+struct NestedPackCount<let each N : int>
+{
+    [BackwardDifferentiable]
+    static float scale<each TIndex>(float x) where countof(TIndex) == countof(N)
+    {
+        return x * float(countof(TIndex));
+    }
+}
+
 void main()
 {
     printf("%d\n", load<3>(1, 2, 3));
@@ -161,4 +170,9 @@ void main()
     bwd_diff(packCountDifferentiableLiteralBwd<int, int>)(literalDpx, 1.0);
     printf("%f\n", literalDpx.d);
     // CHECK: 2.000000
+
+    var nestedDpx = diffPair(5.0, 0.0);
+    bwd_diff(NestedPackCount<1, 2, 3>::scale<int, float, bool>)(nestedDpx, 1.0);
+    printf("%f\n", nestedDpx.d);
+    // CHECK: 3.000000
 }

tests/language-feature/interfaces/default-itensor-load-backward-differentiable.slang

@@ -58,6 +58,96 @@ struct CountedImpl : ICounted<3>
     }
 }
 
+interface IHasIntValue
+{
+    int getValue();
+}
+
+struct CoerceFrom
+{
+    int value;
+
+    __init(int value)
+    {
+        this.value = value;
+    }
+}
+
+struct CoerceTo : IHasIntValue
+{
+    int value;
+
+    __implicit_conversion(100)
+    __init(CoerceFrom from)
+    {
+        value = from.value + 5;
+    }
+
+    int getValue()
+    {
+        return value;
+    }
+}
+
+interface IOptionalValue
+{
+    int getOptionalValue();
+}
+
+struct OptionalValue : IOptionalValue
+{
+    int value;
+
+    __init(int value)
+    {
+        this.value = value;
+    }
+
+    int getOptionalValue()
+    {
+        return value;
+    }
+}
+
+struct PlainValue
+{
+    int value;
+
+    __init(int value)
+    {
+        this.value = value;
+    }
+}
+
+interface IConstraintDefaults
+{
+    associatedtype Stored : IHasIntValue;
+
+    int coerceDefault<ToType, FromType>(ToType input)
+        where ToType(FromType) implicit
+        where ToType : IHasIntValue
+    {
+        return input.getValue();
+    }
+
+    int optionalDefault<T>(T value) where optional T : IOptionalValue
+    {
+        if (T is IOptionalValue)
+            return value.getOptionalValue();
+        return -7;
+    }
+
+    int assocDefault<U>(U value) where U == Stored
+    {
+        return value.getValue();
+    }
+}
+
+struct ConstraintDefaultsImpl : IConstraintDefaults
+{
+    typealias Stored = CoerceTo;
+}
+
 [BackwardDifferentiable]
 float useTensor<T : ITensor<1>>(no_diff T tensor, float x)
 {
@@ -86,4 +176,17 @@ void main()
     CountedImpl counted;
     printf("%d\n", counted.reportInner<int, float, bool>());
     // CHECK: 106
+
+    ConstraintDefaultsImpl defaults;
+    printf("%d\n", defaults.coerceDefault<CoerceTo, CoerceFrom>(CoerceFrom(11)));
+    // CHECK: 16
+
+    printf("%d\n", defaults.optionalDefault<OptionalValue>(OptionalValue(8)));
+    // CHECK: 8
+
+    printf("%d\n", defaults.optionalDefault<PlainValue>(PlainValue(9)));
+    // CHECK: -7
+
+    printf("%d\n", defaults.assocDefault<CoerceTo>(CoerceTo(CoerceFrom(17))));
+    // CHECK: 22
 }