Fix @differentiable attribute requirement type-checking in non-primary files.

Author: dan-zheng

lib/Sema/TypeCheckProtocol.cpp

@@ -544,6 +544,17 @@ swift::matchWitness(
     auto *witnessAFD = dyn_cast<AbstractFunctionDecl>(witness);
     if (auto *witnessASD = dyn_cast<AbstractStorageDecl>(witness))
       witnessAFD = witnessASD->getAccessor(AccessorKind::Get);
+    // NOTE: Validate `@differentiable` attributes by calling
+    // `getParameterIndices`. This is important for type-checking
+    // `@differentiable` attributes in non-primary files to skip invalid
+    // attributes and to resolve derivative configurations, used below.
+    for (auto *witnessDiffAttr :
+         witnessAttrs.getAttributes<DifferentiableAttr>()) {
+      (void)witnessDiffAttr->getParameterIndices();
+    }
+    for (auto *reqDiffAttr : reqAttrs.getAttributes<DifferentiableAttr>()) {
+      (void)reqDiffAttr->getParameterIndices();
+    }
     for (auto *reqDiffAttr : reqAttrs.getAttributes<DifferentiableAttr>()) {
       bool foundExactAttr = false;
       bool foundSupersetAttr = false;
@@ -583,6 +594,14 @@ swift::matchWitness(
           }
         }
         if (!success) {
+          LLVM_DEBUG({
+            llvm::dbgs() << "Protocol requirement match failure: missing "
+                            "`@differentiable` attribute for witness ";
+            witnessAFD->dumpRef(llvm::dbgs());
+            llvm::dbgs() << " from requirement ";
+            req->dumpRef(llvm::dbgs());
+            llvm::dbgs() << '\n';
+          });
           if (auto *vdWitness = dyn_cast<VarDecl>(witness))
             return RequirementMatch(
                 getStandinForAccessor(vdWitness, AccessorKind::Get),

test/AutoDiff/Inputs/differentiable_attr_type_checking_non_primary_file.swift

@@ -0,0 +1,27 @@
+public protocol Layer: Differentiable {
+  associatedtype Input: Differentiable
+  associatedtype Output: Differentiable
+
+  @differentiable
+  func instanceMethod(_ input: Input) -> Output
+
+  @differentiable
+  var computedProperty: Output { get }
+}
+
+struct DummyLayer: Layer {
+  @differentiable
+  func instanceMethod(_ input: Float) -> Float {
+    return input
+  }
+
+  @differentiable
+  var computedProperty: Float { 1 }
+}
+
+public extension Differentiable {
+  @differentiable
+  func sequenced<L: Layer>(through layer: L) -> L.Output where L.Input == Self {
+    return layer.instanceMethod(self)
+  }
+}

test/AutoDiff/differentiable_attr_type_checking_primary_file.swift

@@ -0,0 +1,29 @@
+// RUN: %target-swift-frontend -typecheck -verify %S/Inputs/differentiable_attr_type_checking_non_primary_file.swift -primary-file %s
+
+// Test TF-1043: Type-checking protocol requirement `@differentiable` attributes
+// from non-primary files.
+
+struct OuterLayer: Layer {
+  typealias Input = Float
+  typealias Output = Float
+
+  var dummy: DummyLayer
+
+  @differentiable
+  var computedProperty: Output {
+    // NOTE(TF-1043): Old misleading error:
+    // error: 'Int' is not convertible to 'Float'
+    // return Float(1).sequenced(through: dummy)
+    //        ^~~~~~~~
+    return Float(1).sequenced(through: dummy)
+  }
+
+  @differentiable
+  func instanceMethod(_ input: Input) -> Output {
+    // NOTE(TF-1043): Old misleading error:
+    // error: type of expression is ambiguous without more context
+    // return input.sequenced(through: dummy)
+    //        ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
+    return input.sequenced(through: dummy)
+  }
+}