Adopt ValueDecl in autodiff diagnostics

Author: beccadax

include/swift/AST/DiagnosticsSema.def

@@ -3857,16 +3857,6 @@ ERROR(differentiable_attr_duplicate,none,
       "duplicate '@differentiable' attribute with same parameters", ())
 NOTE(differentiable_attr_duplicate_note,none,
      "other attribute declared here", ())
-ERROR(differentiable_attr_function_not_same_type_context,none,
-      "%0 is not defined in the current type context", (DeclNameRef))
-ERROR(differentiable_attr_derivative_not_function,none,
-      "registered derivative %0 must be a 'func' declaration", (DeclNameRef))
-ERROR(differentiable_attr_class_derivative_not_final,none,
-      "class member derivative must be final", ())
-ERROR(differentiable_attr_invalid_access,none,
-      "derivative function %0 is required to either be public or "
-      "'@usableFromInline' because the original function %1 is public or "
-      "'@usableFromInline'", (DeclNameRef, DeclName))
 ERROR(differentiable_attr_protocol_req_where_clause,none,
       "'@differentiable' attribute on protocol requirement cannot specify "
       "'where' clause", ())
@@ -3880,7 +3870,7 @@ ERROR(differentiable_attr_empty_where_clause,none,
       "empty 'where' clause in '@differentiable' attribute", ())
 ERROR(differentiable_attr_where_clause_for_nongeneric_original,none,
       "'where' clause is valid only when original function is generic %0",
-      (DeclName))
+      (const ValueDecl *))
 ERROR(differentiable_attr_layout_req_unsupported,none,
       "'@differentiable' attribute does not yet support layout requirements",
       ())
@@ -3890,7 +3880,7 @@ NOTE(protocol_witness_missing_differentiable_attr_invalid_context,none,
      "candidate is missing explicit '%0' attribute to satisfy requirement %1 "
      "(in protocol %3); explicit attribute is necessary because candidate is "
      "declared in a different type context or file than the conformance of %2 "
-     "to %3", (StringRef, DeclName, Type, Type))
+     "to %3", (StringRef, const ValueDecl *, Type, Type))
 
 // @derivative
 ERROR(derivative_attr_expected_result_tuple,none,
@@ -3908,11 +3898,12 @@ ERROR(derivative_attr_result_value_not_differentiable,none,
       "'@derivative(of:)' attribute requires function to return a two-element "
       "tuple; first element type %0 must conform to 'Differentiable'", (Type))
 ERROR(derivative_attr_result_func_type_mismatch,none,
-      "function result's %0 type does not match %1", (Identifier, DeclName))
+      "function result's %0 type does not match %1",
+      (Identifier, const ValueDecl *))
 NOTE(derivative_attr_result_func_type_mismatch_note,none,
      "%0 does not have expected type %1", (Identifier, Type))
 NOTE(derivative_attr_result_func_original_note,none,
-     "%0 defined here", (DeclName))
+     "%0 defined here", (const ValueDecl *))
 ERROR(derivative_attr_not_in_same_file_as_original,none,
       "derivative not in the same file as the original function", ())
 ERROR(derivative_attr_original_stored_property_unsupported,none,
@@ -3934,7 +3925,7 @@ NOTE(derivative_attr_protocol_requirement_unsupported,none,
      "cannot yet register derivative default implementation for protocol "
      "requirements", ())
 ERROR(derivative_attr_original_already_has_derivative,none,
-      "a derivative already exists for %0", (DeclName))
+      "a derivative already exists for %0", (const ValueDecl *))
 NOTE(derivative_attr_duplicate_note,none,
      "other attribute declared here", ())
 ERROR(derivative_attr_access_level_mismatch,none,
@@ -3943,31 +3934,29 @@ ERROR(derivative_attr_access_level_mismatch,none,
       "%select{private|fileprivate|internal|package|public|open}3, "
       "but original function %0 is "
       "%select{private|fileprivate|internal|package|public|open}1",
-      (/*original*/ DeclName, /*original*/ AccessLevel,
-       /*derivative*/ DeclName, /*derivative*/ AccessLevel))
+      (/*original*/ const ValueDecl *, /*original*/ AccessLevel,
+       /*derivative*/ const ValueDecl *, /*derivative*/ AccessLevel))
 NOTE(derivative_attr_fix_access,none,
      "mark the derivative function as "
      "'%select{private|fileprivate|internal|package|@usableFromInline|@usableFromInline}0' "
      "to match the original function", (AccessLevel))
 ERROR(derivative_attr_static_method_mismatch_original,none,
       "unexpected derivative function declaration; "
       "%0 requires the derivative function %1 to be %select{an instance|a 'static'}2 method",
-      (/*original*/DeclName, /*derivative*/ DeclName,
+      (/*original*/const ValueDecl *, /*derivative*/ const ValueDecl *,
        /*originalIsStatic*/bool))
 NOTE(derivative_attr_static_method_mismatch_original_note,none,
       "original function %0 is %select{an instance|a 'static'}1 method",
-      (/*original*/ DeclName, /*originalIsStatic*/bool))
+      (/*original*/ const ValueDecl *, /*originalIsStatic*/bool))
 NOTE(derivative_attr_static_method_mismatch_fix,none,
       "make derivative function %0 %select{an instance|a 'static'}1 method",
-      (/*derivative*/ DeclName, /*mustBeStatic*/bool))
+      (/*derivative*/ const ValueDecl *, /*mustBeStatic*/bool))
 
 // @transpose
 ERROR(transpose_attr_invalid_linearity_parameter_or_result,none,
       "cannot transpose with respect to original %select{result|parameter}1 "
       "'%0' that does not conform to 'Differentiable' and satisfy "
       "'%0 == %0.TangentVector'", (StringRef, /*isParameter*/ bool))
-ERROR(transpose_attr_overload_not_found,none,
-      "could not find function %0 with expected type %1", (DeclName, Type))
 ERROR(transpose_attr_cannot_use_named_wrt_params,none,
       "cannot use named 'wrt' parameters in '@transpose(of:)' attribute, found "
       "%0", (Identifier))
@@ -3980,14 +3969,14 @@ NOTE(transpose_attr_wrt_self_self_type_mismatch_note,none,
 ERROR(transpose_attr_static_method_mismatch_original,none,
       "unexpected transpose function declaration; "
       "%0 requires the transpose function %1 to be %select{an instance|a 'static'}2 method",
-      (/*original*/DeclName, /*transpose*/ DeclName,
+      (/*original*/const ValueDecl *, /*transpose*/ const ValueDecl *,
        /*originalIsStatic*/bool))
 NOTE(transpose_attr_static_method_mismatch_original_note,none,
       "original function %0 is %select{an instance|a 'static'}1 method",
-      (/*original*/ DeclName, /*originalIsStatic*/bool))
+      (/*original*/ const ValueDecl *, /*originalIsStatic*/bool))
 NOTE(transpose_attr_static_method_mismatch_fix,none,
       "make transpose function %0 %select{an instance|a 'static'}1 method",
-      (/*transpose*/ DeclName, /*mustBeStatic*/bool))
+      (/*transpose*/ const ValueDecl *, /*mustBeStatic*/bool))
 
 // Automatic differentiation attributes
 ERROR(autodiff_attr_original_decl_ambiguous,none,
@@ -4019,7 +4008,8 @@ ERROR(autodiff_attr_opaque_result_type_unsupported,none,
 
 // differentiation `wrt` parameters clause
 ERROR(diff_function_no_parameters,none,
-      "%0 has no parameters to differentiate with respect to", (DeclName))
+      "%0 has no parameters to differentiate with respect to",
+      (const ValueDecl *))
 ERROR(diff_params_clause_param_name_unknown,none,
       "unknown parameter name %0", (Identifier))
 ERROR(diff_params_clause_self_instance_method_only,none,

lib/Sema/TypeCheckAttr.cpp

@@ -4855,8 +4855,7 @@ static IndexSubset *computeDifferentiabilityParameters(
     // If function is not an instance method, diagnose immediately.
     if (!isInstanceMethod) {
       diags
-          .diagnose(attrLoc, diag::diff_function_no_parameters,
-                    function->getName())
+          .diagnose(attrLoc, diag::diff_function_no_parameters, function)
           .highlight(function->getSignatureSourceRange());
       return nullptr;
     }
@@ -4870,8 +4869,7 @@ static IndexSubset *computeDifferentiabilityParameters(
         selfType = function->mapTypeIntoContext(selfType);
       if (!conformsToDifferentiable(selfType, module)) {
         diags
-            .diagnose(attrLoc, diag::diff_function_no_parameters,
-                      function->getName())
+            .diagnose(attrLoc, diag::diff_function_no_parameters, function)
             .highlight(function->getSignatureSourceRange());
         return nullptr;
       }
@@ -5447,7 +5445,7 @@ bool resolveDifferentiableAttrDerivativeGenericSignature(
           .diagnose(
               attr->getLocation(),
               diag::differentiable_attr_where_clause_for_nongeneric_original,
-              original->getName())
+              original)
           .highlight(whereClause->getSourceRange());
       attr->setInvalid();
       return true;
@@ -6061,16 +6059,15 @@ static bool typeCheckDerivativeAttr(DerivativeAttr *attr) {
     diags
         .diagnose(attr->getOriginalFunctionName().Loc.getBaseNameLoc(),
                   diag::derivative_attr_static_method_mismatch_original,
-                  originalAFD->getName(), derivative->getName(),
-                  derivativeMustBeStatic)
+                  originalAFD, derivative, derivativeMustBeStatic)
         .highlight(attr->getOriginalFunctionName().Loc.getSourceRange());
     diags.diagnose(originalAFD->getNameLoc(),
                    diag::derivative_attr_static_method_mismatch_original_note,
-                   originalAFD->getName(), derivativeMustBeStatic);
+                   originalAFD, derivativeMustBeStatic);
     auto fixItDiag =
         diags.diagnose(derivative->getStartLoc(),
                        diag::derivative_attr_static_method_mismatch_fix,
-                       derivative->getName(), derivativeMustBeStatic);
+                       derivative, derivativeMustBeStatic);
     if (derivativeMustBeStatic) {
       fixItDiag.fixItInsert(derivative->getStartLoc(), "static ");
     } else {
@@ -6098,8 +6095,8 @@ static bool typeCheckDerivativeAttr(DerivativeAttr *attr) {
         derivative->getFormalAccessScope().accessLevelForDiagnostics();
     diags.diagnose(originalName.Loc,
                    diag::derivative_attr_access_level_mismatch,
-                   originalAFD->getName(), originalAccess,
-                   derivative->getName(), derivativeAccess);
+                   originalAFD, originalAccess,
+                   derivative, derivativeAccess);
     auto fixItDiag =
         derivative->diagnose(diag::derivative_attr_fix_access, originalAccess);
     // If original access is public, suggest adding `@usableFromInline` to
@@ -6207,7 +6204,7 @@ static bool typeCheckDerivativeAttr(DerivativeAttr *attr) {
     // Emit differential/pullback type mismatch error on attribute.
     diags.diagnose(attr->getLocation(),
                    diag::derivative_attr_result_func_type_mismatch,
-                   funcResultElt.getName(), originalAFD->getName());
+                   funcResultElt.getName(), originalAFD);
     // Emit note with expected differential/pullback type on actual type
     // location.
     auto *tupleReturnTypeRepr =
@@ -6222,7 +6219,7 @@ static bool typeCheckDerivativeAttr(DerivativeAttr *attr) {
     if (originalAFD->getLoc().isValid())
       diags.diagnose(originalAFD->getLoc(),
                      diag::derivative_attr_result_func_original_note,
-                     originalAFD->getName());
+                     originalAFD);
     return true;
   }
 
@@ -6233,7 +6230,7 @@ static bool typeCheckDerivativeAttr(DerivativeAttr *attr) {
   if (derivativeAttrs.size() > 1) {
     diags.diagnose(attr->getLocation(),
                    diag::derivative_attr_original_already_has_derivative,
-                   originalAFD->getName());
+                   originalAFD);
     for (auto *duplicateAttr : derivativeAttrs) {
       if (duplicateAttr == attr)
         continue;
@@ -6595,15 +6592,14 @@ void AttributeChecker::visitTransposeAttr(TransposeAttr *attr) {
     bool transposeMustBeStatic = !transpose->isStatic();
     diagnose(attr->getOriginalFunctionName().Loc.getBaseNameLoc(),
              diag::transpose_attr_static_method_mismatch_original,
-             originalAFD->getName(), transpose->getName(),
-             transposeMustBeStatic)
+             originalAFD, transpose, transposeMustBeStatic)
         .highlight(attr->getOriginalFunctionName().Loc.getSourceRange());
     diagnose(originalAFD->getNameLoc(),
              diag::transpose_attr_static_method_mismatch_original_note,
-             originalAFD->getName(), transposeMustBeStatic);
+             originalAFD, transposeMustBeStatic);
     auto fixItDiag = diagnose(transpose->getStartLoc(),
                               diag::transpose_attr_static_method_mismatch_fix,
-                              transpose->getName(), transposeMustBeStatic);
+                              transpose, transposeMustBeStatic);
     if (transposeMustBeStatic) {
       fixItDiag.fixItInsert(transpose->getStartLoc(), "static ");
     } else {

lib/Sema/TypeCheckProtocol.cpp

@@ -2827,9 +2827,8 @@ diagnoseMatch(ModuleDecl *module, NormalProtocolConformance *conformance,
     diags
         .diagnose(
             witness,
-            diag::
-                protocol_witness_missing_differentiable_attr_invalid_context,
-            reqDiffAttrString, req->getName(), conformance->getType(),
+            diag::protocol_witness_missing_differentiable_attr_invalid_context,
+            reqDiffAttrString, req, conformance->getType(),
             conformance->getProtocol()->getDeclaredInterfaceType())
         .fixItInsert(match.Witness->getStartLoc(), reqDiffAttrString + ' ');
     break;

test/AutoDiff/Sema/derivative_attr_type_checking.swift

@@ -504,7 +504,7 @@ extension Struct where T: Differentiable & AdditiveArithmetic {
     return (1, { _ in .zero })
   }
 
-  // expected-error @+2 {{a derivative already exists for '_'}}
+  // expected-error @+2 {{a derivative already exists for getter for 'subscript()'}}
   // expected-note @-6 {{other attribute declared here}}
   @derivative(of: subscript)
   func vjpSubscript() -> (value: Float, pullback: (Float) -> TangentVector) {
@@ -521,7 +521,7 @@ extension Struct where T: Differentiable & AdditiveArithmetic {
     return (1, { _ in .zero })
   }
 
-  // expected-error @+2 {{a derivative already exists for '_'}}
+  // expected-error @+2 {{a derivative already exists for getter for 'subscript(float:)'}}
   // expected-note @-6 {{other attribute declared here}}
   @derivative(of: subscript(float:), wrt: self)
   func vjpSubscriptLabeled(float: Float) -> (value: Float, pullback: (Float) -> TangentVector) {
@@ -538,7 +538,7 @@ extension Struct where T: Differentiable & AdditiveArithmetic {
     return (x, { _ in .zero })
   }
 
-  // expected-error @+2 {{a derivative already exists for '_'}}
+  // expected-error @+2 {{a derivative already exists for getter for 'subscript(_:)'}}
   // expected-note @-6 {{other attribute declared here}}
   @derivative(of: subscript(_:), wrt: self)
   func vjpSubscriptGeneric<U: Differentiable>(x: U) -> (value: U, pullback: (U.TangentVector) -> TangentVector)   {
@@ -619,7 +619,7 @@ extension Class where T: Differentiable {
     return (1, { _ in .zero })
   }
 
-  // expected-error @+2 {{a derivative already exists for '_'}}
+  // expected-error @+2 {{a derivative already exists for getter for 'subscript()'}}
   // expected-note @-6 {{other attribute declared here}}
   @derivative(of: subscript)
   func vjpSubscript() -> (value: Float, pullback: (Float) -> TangentVector) {

test/AutoDiff/Sema/differentiable_attr_type_checking.swift

@@ -18,13 +18,13 @@ let globalConst: Float = 1
 var globalVar: Float = 1
 
 func testLocalVariables() {
-  // expected-error @+1 {{'_' has no parameters to differentiate with respect to}}
+  // expected-error @+1 {{getter for 'getter' has no parameters to differentiate with respect to}}
   @differentiable(reverse)
   var getter: Float {
     return 1
   }
 
-  // expected-error @+1 {{'_' has no parameters to differentiate with respect to}}
+  // expected-error @+1 {{getter for 'getterSetter' has no parameters to differentiate with respect to}}
   @differentiable(reverse)
   var getterSetter: Float {
     get { return 1 }