Migrate changes from PR #41422

Author: philipturner

include/swift/AST/AutoDiff.h

@@ -364,7 +364,9 @@ class TangentSpace {
   static TangentSpace getTangentVector(Type tangentVectorType) {
     return {Kind::TangentVector, tangentVectorType};
   }
-  static TangentSpace getTuple(TupleType *tupleTy);
+  static TangentSpace getTuple(TupleType *tupleTy) {
+     return {Kind::Tuple, tupleTy};
+   }
 
   bool isTangentVector() const { return kind == Kind::TangentVector; }
   bool isTuple() const { return kind == Kind::Tuple; }

include/swift/AST/DiagnosticsSema.def

@@ -3500,7 +3500,7 @@ ERROR(autodiff_attr_original_void_result,none,
       "cannot differentiate void function %0", (DeclName))
 ERROR(autodiff_attr_original_multiple_semantic_results,none,
       "cannot differentiate functions with both a differentiable 'inout' "
-      "parameter and a result", ())
+      "parameter and a differentiable result", ())
 ERROR(autodiff_attr_result_not_differentiable,none,
       "can only differentiate functions with results that conform to "
       "'Differentiable', but %0 does not conform to 'Differentiable'", (Type))
@@ -5059,13 +5059,17 @@ ERROR(differentiable_function_type_invalid_result,none,
       (StringRef, bool))
 ERROR(differentiable_function_type_multiple_semantic_results,none,
       "'@differentiable' function type cannot have both a differentiable "
-      "'inout' parameter and a result", ())
-ERROR(differentiable_function_type_no_differentiability_parameters, 
-      none,
+      "'inout' parameter and a differentiable result", ())
+ERROR(differentiable_function_type_no_differentiability_parameters,none,
       "'@differentiable' function type requires at least one differentiability "
       "parameter, i.e. a non-'@noDerivative' parameter whose type conforms to "
       "'Differentiable'%select{| with its 'TangentVector' equal to itself}0",
       (/*isLinear*/ bool))
+ERROR(differentiable_function_type_no_differentiable_result,none,
+      "'@differentiable' function type requires a differentiable result, i.e. "
+      "a non-'Void' type that conforms to 'Differentiable'%select{| with its "
+      "'TangentVector' equal to itself}0",
+      (/*isLinear*/ bool))
 
 // SIL
 ERROR(opened_non_protocol,none,

lib/AST/AutoDiff.cpp

@@ -366,13 +366,6 @@ GenericSignature autodiff::getDifferentiabilityWitnessGenericSignature(
   return derivativeGenSig;
 }
 
-TangentSpace TangentSpace::getTuple(TupleType *tupleTy) {
-  assert(!tupleTy->isVoid() &&
-         "Attempted to get tangent space of 'Void', which cannot be "
-         "differentiated.");
-  return {Kind::Tuple, tupleTy};
-}
-
 Type TangentSpace::getType() const {
   switch (kind) {
   case Kind::TangentVector:

lib/AST/Type.cpp

@@ -6177,7 +6177,8 @@ TypeBase::getAutoDiffTangentSpace(LookupConformanceFn lookupConformance) {
       newElts.push_back(elt.getWithType(eltSpace->getType()));
     }
     if (newElts.empty())
-      return cache(None);
+      return cache(
+          TangentSpace::getTuple(ctx.TheEmptyTupleType->castTo<TupleType>()));
     if (newElts.size() == 1)
       return cache(TangentSpace::getTangentVector(newElts.front().getType()));
     auto *tupleType = TupleType::get(newElts, ctx)->castTo<TupleType>();

lib/Sema/TypeChecker.cpp

@@ -618,15 +618,15 @@ bool TypeChecker::diagnoseInvalidFunctionType(FunctionType *fnTy, SourceLoc loc,
                                            dc, stage);
     }) != params.end();
     bool alreadyDiagnosedOneParam = false;
-    bool hasInoutDiffParameter = false;
+    bool hasInoutDifferentiableParameter = false;
     for (unsigned i = 0, end = fnTy->getNumParams(); i != end; ++i) {
       auto param = params[i];
       if (param.isNoDerivative())
         continue;
       auto paramType = param.getPlainType();
       if (TypeChecker::isDifferentiable(paramType, isLinear, dc, stage)) {
         if (param.isInOut())
-          hasInoutDiffParameter = true;
+          hasInoutDifferentiableParameter = true;
         continue;
       }
       auto diagLoc =
@@ -656,12 +656,13 @@ bool TypeChecker::diagnoseInvalidFunctionType(FunctionType *fnTy, SourceLoc loc,
     }
 
     // Check the result.
-    bool resultIsDifferentiable =
-        isDifferentiable(result, /*tangentVectorEqualsSelf*/ isLinear, dc,
-        stage);
+    bool resultExists = !(result->isVoid());
+    bool resultIsDifferentiable = TypeChecker::isDifferentiable(
+        result, /*tangentVectorEqualsSelf*/ isLinear, dc, stage);
+    bool differentiableResultExists = resultExists && resultIsDifferentiable;
 
     // Reject the case where there are multiple semantic results.
-    if (resultIsDifferentiable && hasInoutDiffParameter) {
+    if (differentiableResultExists && hasInoutDifferentiableParameter) {
       auto diagLoc = repr ? (*repr)->getArgsTypeRepr()->getLoc() : loc;
       auto diag = ctx.Diags.diagnose(
           diagLoc,
@@ -673,8 +674,8 @@ bool TypeChecker::diagnoseInvalidFunctionType(FunctionType *fnTy, SourceLoc loc,
       }
     }
 
-    // Reject the case where there are no semantic results.
-    if (!resultIsDifferentiable && !hasInoutDiffParameter) {
+    // Reject the case where the semantic result is not differentiable.
+    if (!resultIsDifferentiable && !hasInoutDifferentiableParameter) {
       auto diagLoc = repr ? (*repr)->getResultTypeRepr()->getLoc() : loc;
       auto resultStr = fnTy->getResult()->getString();
       auto diag = ctx.Diags.diagnose(
@@ -686,6 +687,19 @@ bool TypeChecker::diagnoseInvalidFunctionType(FunctionType *fnTy, SourceLoc loc,
           diag.highlight((*repr)->getResultTypeRepr()->getSourceRange());
       }
     }
+
+    // Reject the case where there are no semantic results.
+    if (!resultExists && !hasInoutDifferentiableParameter) {
+      auto diagLoc = repr ? (*repr)->getResultTypeRepr()->getLoc() : loc;
+      auto diag = ctx.Diags.diagnose(
+          diagLoc, diag::differentiable_function_type_no_differentiable_result,
+          isLinear);
+      hadAnyError = true;
+
+      if (repr) {
+          diag.highlight((*repr)->getResultTypeRepr()->getSourceRange());
+      }
+    }
   }
 
   return hadAnyError;

test/AutoDiff/Sema/derivative_attr_type_checking.swift

@@ -746,7 +746,7 @@ extension ProtocolRequirementDerivative {
 func multipleSemanticResults(_ x: inout Float) -> Float {
   return x
 }
-// expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a result}}
+// expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a differentiable result}}
 @derivative(of: multipleSemanticResults)
 func vjpMultipleSemanticResults(x: inout Float) -> (
   value: Float, pullback: (Float) -> Float
@@ -885,14 +885,14 @@ func vjpNoSemanticResults(_ x: Float) -> (value: Void, pullback: Void) {}
 
 extension InoutParameters {
   func multipleSemanticResults(_ x: inout Float) -> Float { x }
-  // expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a result}}
+  // expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a differentiable result}}
   @derivative(of: multipleSemanticResults)
   func vjpMultipleSemanticResults(_ x: inout Float) -> (
     value: Float, pullback: (inout Float) -> Void
   ) { fatalError() }
 
   func inoutVoid(_ x: Float, _ void: inout Void) -> Float {}
-  // expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a result}}
+  // expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a differentiable result}}
   @derivative(of: inoutVoid)
   func vjpInoutVoidParameter(_ x: Float, _ void: inout Void) -> (
     value: Float, pullback: (inout Float) -> Void

test/AutoDiff/Sema/differentiable_attr_type_checking.swift

@@ -528,7 +528,7 @@ func two9(x: Float, y: Float) -> Float {
 func inout1(x: Float, y: inout Float) -> Void {
   let _ = x + y
 }
-// expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a result}}
+// expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a differentiable result}}
 @differentiable(reverse, wrt: y)
 func inout2(x: Float, y: inout Float) -> Float {
   let _ = x + y
@@ -670,11 +670,11 @@ final class FinalClass: Differentiable {
 @differentiable(reverse, wrt: y)
 func inoutVoid(x: Float, y: inout Float) {}
 
-// expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a result}}
+// expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a differentiable result}}
 @differentiable(reverse)
 func multipleSemanticResults(_ x: inout Float) -> Float { x }
 
-// expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a result}}
+// expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a differentiable result}}
 @differentiable(reverse, wrt: y)
 func swap(x: inout Float, y: inout Float) {}
 
@@ -687,7 +687,7 @@ extension InoutParameters {
   @differentiable(reverse)
   static func staticMethod(_ lhs: inout Self, rhs: Self) {}
 
-  // expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a result}}
+  // expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a differentiable result}}
   @differentiable(reverse)
   static func multipleSemanticResults(_ lhs: inout Self, rhs: Self) -> Self {}
 }
@@ -696,7 +696,7 @@ extension InoutParameters {
   @differentiable(reverse)
   mutating func mutatingMethod(_ other: Self) {}
 
-  // expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a result}}
+  // expected-error @+1 {{cannot differentiate functions with both a differentiable 'inout' parameter and a differentiable result}}
   @differentiable(reverse)
   mutating func mutatingMethod(_ other: Self) -> Self {}
 }

test/AutoDiff/Sema/differentiable_func_type.swift

@@ -28,6 +28,12 @@ let _: @differentiable(reverse) (Float, NonDiffType) -> Float
 // expected-error @+1 {{result type 'NonDiffType' does not conform to 'Differentiable' and satisfy 'NonDiffType == NonDiffType.TangentVector', but the enclosing function type is '@differentiable(_linear)'}}
 let _: @differentiable(_linear) (Float) -> NonDiffType
 
+// expected-error @+1 {{'@differentiable' function type cannot have both a differentiable 'inout' parameter and a differentiable result}}
+let _: @differentiable(reverse) (inout Float) -> Float
+
+// expected-error @+1 {{'@differentiable' function type cannot have both a differentiable 'inout' parameter and a differentiable result}}
+let _: @differentiable(_linear) (inout Float) -> Float
+
 // Emit `@noDerivative` fixit iff there is at least one valid linearity parameter.
 // expected-error @+1 {{parameter type 'NonDiffType' does not conform to 'Differentiable' and satisfy 'NonDiffType == NonDiffType.TangentVector', but the enclosing function type is '@differentiable(_linear)'; did you want to add '@noDerivative' to this parameter?}} {{41-41=@noDerivative }}
 let _: @differentiable(_linear) (Float, NonDiffType) -> Float
@@ -40,10 +46,10 @@ let _: @differentiable(_linear) (Float) -> NonDiffType
 
 let _: @differentiable(_linear) (Float) -> Float
 
-// expected-error @+1 {{'@differentiable' function type cannot have both a differentiable 'inout' parameter and a result}}
+// expected-error @+1 {{'@differentiable' function type cannot have both a differentiable 'inout' parameter and a differentiable result}}
 let _: @differentiable(reverse) (inout Float) -> Float
 
-// expected-error @+1 {{'@differentiable' function type cannot have both a differentiable 'inout' parameter and a result}}
+// expected-error @+1 {{'@differentiable' function type cannot have both a differentiable 'inout' parameter and a differentiable result}}
 let _: @differentiable(_linear) (inout Float) -> Float
 
 // expected-error @+1 {{result type '@differentiable(reverse) (U) -> Float' does not conform to 'Differentiable', but the enclosing function type is '@differentiable'}}

test/AutoDiff/compiler_crashers_fixed/sr15808-non-differentiable-closure-parameters.swift

@@ -1,23 +1,18 @@
 // RUN: %target-swift-frontend -emit-sil -verify %s
-
 // SR-15808: In AST, type checking skips a closure with non-differentiable input
 // where `Void` is included as a parameter without being marked `@noDerivative`.
 // It also crashes when the output is `Void` and no input is `inout`. As a
 // result, the compiler crashes during Sema.
-
 import _Differentiation
 
-// expected-error @+2 {{parameter type '()' does not conform to 'Differentiable', but the enclosing function type is '@differentiable'}}
-// expected-error @+1 {{result type 'Void' does not conform to 'Differentiable', but the enclosing function type is '@differentiable'}}
+// expected-error @+1 {{'@differentiable' function type requires a differentiable result, i.e. a non-'Void' type that conforms to 'Differentiable'}}
 func helloWorld(_ x: @differentiable(reverse) (()) -> Void) {}
 
-// expected-error @+1 {{parameter type '()' does not conform to 'Differentiable', but the enclosing function type is '@differentiable'}}
 func helloWorld(_ x: @differentiable(reverse) (()) -> Float) {}
 
-// expected-error @+1 {{result type 'Void' does not conform to 'Differentiable', but the enclosing function type is '@differentiable'}}
+// expected-error @+1 {{'@differentiable' function type requires a differentiable result, i.e. a non-'Void' type that conforms to 'Differentiable'}}
 func helloWorld(_ x: @differentiable(reverse) (Float) -> Void) {}
 
-// expected-error @+1 {{parameter type 'Void' does not conform to 'Differentiable', but the enclosing function type is '@differentiable'}}
 func helloWorld(_ x: @differentiable(reverse) (@noDerivative Float, Void) -> Float) {}
 
 // Original crash:

test/AutoDiff/compiler_crashers_fixed/sr15818-inout-noderivative-closure-parameter.swift

@@ -1,14 +1,13 @@
 // RUN: %target-swift-frontend -emit-sil -verify %s
-
 import _Differentiation
 
-// expected-error @+1 {{result type 'Void' does not conform to 'Differentiable', but the enclosing function type is '@differentiable'}}
+// expected-error @+1 {{@differentiable' function type requires a differentiable result, i.e. a non-'Void' type that conforms to 'Differentiable'}}
 typealias MyType = @differentiable(reverse) (inout @noDerivative Float, Float) -> Void
 
 @differentiable(reverse)
-func myFunc(_ x:  inout @noDerivative Float, _ q: Float) -> Void {}
+func myFunc(_ x: inout @noDerivative Float, _ q: Float) -> Void {}
 
-print(myFunc as MyType)
+let castedFunc = myFunc as MyType
 
 // Original crash:
 // Assertion failed: (Index < Length && "Invalid index!"), function operator[], file ArrayRef.h, line 257.