[stdlib] Add PointwiseMultiplicative protocol. (#25772)

`PointwiseMultiplicative` represents a ring over multiplication with
identity element "one" and a multiplicative inverse (reciprocal).

Conform `Differentiable` synthesized struct types to
`PointwiseMultiplicative` protocol if possible.

Enables revamping optimizers, which requires division
(i.e. multiplication with multiplicative inverse).

Author: dan-zheng

include/swift/AST/DiagnosticsSema.def

@@ -2548,26 +2548,22 @@ ERROR(broken_encodable_requirement,none,
 ERROR(broken_decodable_requirement,none,
       "Decodable protocol is broken: unexpected requirement", ())
 // SWIFT_ENABLE_TENSORFLOW
-ERROR(broken_key_path_iterable_requirement,none,
-      "KeyPathIterable protocol is broken: unexpected requirement", ())
-ERROR(broken_tensor_array_protocol_requirement,none,
-      "TensorArrayProtocol protocol is broken: unexpected requirement", ())
-ERROR(broken_tensor_group_requirement,none,
-      "TensorGroup protocol is broken: unexpected requirement", ())
-ERROR(parameterized_no_parameters_struct,none,
-      "cannot automatically synthesize %0 because 'Parameters' struct does not "
-      "exist", (Type))
-ERROR(parameterized_invalid_parameters_struct,none,
-      "cannot automatically synthesize %0 because 'Parameters' struct is "
-      "invalid", (Type))
 ERROR(broken_additive_arithmetic_requirement,none,
       "AdditiveArithmetic protocol is broken: unexpected requirement", ())
+ERROR(broken_pointwise_multiplicative_requirement,none,
+      "PointwiseMultiplicative protocol is broken: unexpected requirement", ())
 ERROR(broken_elementary_functions_requirement,none,
       "ElementaryFunctions protocol is broken: unexpected requirement", ())
 ERROR(broken_vector_protocol_requirement,none,
       "VectorProtocol protocol is broken: unexpected requirement", ())
 ERROR(broken_differentiable_requirement,none,
       "Differentiable protocol is broken: unexpected requirement", ())
+ERROR(broken_key_path_iterable_requirement,none,
+      "KeyPathIterable protocol is broken: unexpected requirement", ())
+ERROR(broken_tensor_array_protocol_requirement,none,
+      "TensorArrayProtocol protocol is broken: unexpected requirement", ())
+ERROR(broken_tensor_group_requirement,none,
+      "TensorGroup protocol is broken: unexpected requirement", ())
 WARNING(differentiable_nondiff_type_implicit_noderivative_fixit,none,
       "stored property %0 has no derivative because it does not conform to "
       "'Differentiable'; add an explicit '@noDerivative' attribute"

include/swift/AST/KnownIdentifiers.def

@@ -139,8 +139,10 @@ IDENTIFIER_(unpackTensorHandles)
 IDENTIFIER_(tensorHandleCount)
 // TensorGroup
 IDENTIFIER_(typeList)
-// AdditiveArithmetic, VectorProtocol
+// AdditiveArithmetic, PointwiseMultiplicative, VectorProtocol
 IDENTIFIER(zero)
+IDENTIFIER(one)
+IDENTIFIER(reciprocal)
 IDENTIFIER(VectorSpaceScalar)
 IDENTIFIER(adding)
 IDENTIFIER(subtracting)

include/swift/AST/KnownProtocols.def

@@ -78,6 +78,7 @@ PROTOCOL(Encodable)
 PROTOCOL(Decodable)
 // SWIFT_ENABLE_TENSORFLOW
 PROTOCOL(AdditiveArithmetic)
+PROTOCOL(PointwiseMultiplicative)
 PROTOCOL(ElementaryFunctions)
 PROTOCOL(KeyPathIterable)
 PROTOCOL(TensorArrayProtocol)

lib/IRGen/GenMeta.cpp

@@ -4206,6 +4206,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::StringInterpolationProtocol:
   // SWIFT_ENABLE_TENSORFLOW
   case KnownProtocolKind::AdditiveArithmetic:
+  case KnownProtocolKind::PointwiseMultiplicative:
   case KnownProtocolKind::ElementaryFunctions:
   case KnownProtocolKind::KeyPathIterable:
   case KnownProtocolKind::TensorArrayProtocol:

lib/Sema/CMakeLists.txt

@@ -28,7 +28,7 @@ add_swift_host_library(swiftSema STATIC
   DerivedConformanceEquatableHashable.cpp
   DerivedConformanceError.cpp
   # SWIFT_ENABLE_TENSORFLOW
-  DerivedConformanceAdditiveArithmetic.cpp
+  DerivedConformanceRingMathProtocols.cpp
   DerivedConformanceElementaryFunctions.cpp
   DerivedConformanceVectorProtocol.cpp
   DerivedConformanceDifferentiable.cpp

lib/Sema/DerivedConformanceDifferentiable.cpp

@@ -568,14 +568,17 @@ getOrSynthesizeSingleAssociatedStruct(DerivedConformance &derived,
   auto diffableType = TypeLoc::withoutLoc(diffableProto->getDeclaredType());
   auto *addArithProto = C.getProtocol(KnownProtocolKind::AdditiveArithmetic);
   auto addArithType = TypeLoc::withoutLoc(addArithProto->getDeclaredType());
+  auto *pointMulProto =
+      C.getProtocol(KnownProtocolKind::PointwiseMultiplicative);
+  auto pointMulType = TypeLoc::withoutLoc(pointMulProto->getDeclaredType());
   auto *mathProto = C.getProtocol(KnownProtocolKind::ElementaryFunctions);
   auto mathType = TypeLoc::withoutLoc(mathProto->getDeclaredType());
   auto *vectorProto = C.getProtocol(KnownProtocolKind::VectorProtocol);
   auto vectorType = TypeLoc::withoutLoc(vectorProto->getDeclaredType());
   auto *kpIterableProto = C.getProtocol(KnownProtocolKind::KeyPathIterable);
   auto kpIterableType = TypeLoc::withoutLoc(kpIterableProto->getDeclaredType());
 
-  SmallVector<TypeLoc, 3> inherited{diffableType};
+  SmallVector<TypeLoc, 4> inherited{diffableType};
 
   // Cache original members and their associated types for later use.
   SmallVector<VarDecl *, 8> diffProperties;
@@ -594,6 +597,14 @@ getOrSynthesizeSingleAssociatedStruct(DerivedConformance &derived,
                                      addArithProto, parentDC, None);
       });
 
+  // Associated struct can derive `PointwiseMultiplicative` if the associated
+  // types of all stored properties conform to `PointwiseMultiplicative`.
+  bool canDerivePointwiseMultiplicative =
+      llvm::all_of(diffProperties, [&](VarDecl *vd) {
+        return TC.conformsToProtocol(getAssociatedType(vd, parentDC, id),
+                                     pointMulProto, parentDC, None);
+      });
+
   // Associated struct can derive `ElementaryFunctions` if the associated types
   // of all stored properties conform to `ElementaryFunctions`.
   bool canDeriveElementaryFunctions =
@@ -634,6 +645,10 @@ getOrSynthesizeSingleAssociatedStruct(DerivedConformance &derived,
                               None))
       inherited.push_back(kpIterableType);
   }
+  // If all members conform to `PointwiseMultiplicative`, make the associated
+  // struct conform to `PointwiseMultiplicative`.
+  if (canDerivePointwiseMultiplicative)
+    inherited.push_back(pointMulType);
   // If all members conform to `ElementaryFunctions`, make the associated struct
   // conform to `ElementaryFunctions`.
   if (canDeriveElementaryFunctions)