Sema: Improved check for failure to bind an extension

Calling computeExtendedNominal() won't catch the case where the
extended type did not exist at extension binding time but then
appeared later, like an inferred associated type witness for
example.

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -1919,7 +1919,7 @@ NOTE(extension_stored_property_fixit,none,
      "Remove '=' to make %0 a computed property", (Identifier))
 ERROR(extension_nongeneric_trailing_where,none,
       "trailing 'where' clause for extension of non-generic type %0",
-      (Identifier))
+      (Type))
 ERROR(extension_protocol_inheritance,none,
       "extension of protocol %0 cannot have an inheritance clause",
       (Identifier))
@@ -1935,6 +1935,8 @@ ERROR(invalid_nominal_extension,none,
       (Type, Type))
 NOTE(invalid_nominal_extension_rewrite,none,
      "did you mean to extend %0 instead?", (Type))
+ERROR(synthesized_nominal_extension,none,
+      "cannot extend synthesized type %0", (Type))
 
 // Protocols
 ERROR(type_does_not_conform,none,

lib/AST/ASTVerifier.cpp

@@ -2842,6 +2842,11 @@ class Verifier : public ASTWalker {
         verifyConformance(ext, conformance);
       }
 
+      // Make sure extension binding succeeded.
+      if (!ext->hasBeenBound()) {
+        Out << "ExtensionDecl was not bound\n";
+        abort();
+      }
       verifyCheckedBase(ext);
     }
 

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -3037,11 +3037,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // Produce any diagnostics for the extended type.
     auto extType = ED->getExtendedType();
 
-    auto nominal = ED->computeExtendedNominal();
+    auto *nominal = ED->getExtendedNominal();
     if (nominal == nullptr) {
       const bool wasAlreadyInvalid = ED->isInvalid();
       ED->setInvalid();
-      if (extType && !extType->hasError() && extType->getAnyNominal()) {
+      if (!extType->hasError() && extType->getAnyNominal()) {
         // If we've got here, then we have some kind of extension of a prima
         // fascie non-nominal type.  This can come up when we're projecting
         // typealiases out of bound generic types.
@@ -3051,22 +3051,30 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         //
         // Offer to rewrite it to the underlying nominal type.
         auto canExtType = extType->getCanonicalType();
-        ED->diagnose(diag::invalid_nominal_extension, extType, canExtType)
-          .highlight(ED->getExtendedTypeRepr()->getSourceRange());
-        ED->diagnose(diag::invalid_nominal_extension_rewrite, canExtType)
-          .fixItReplace(ED->getExtendedTypeRepr()->getSourceRange(),
-                        canExtType->getString());
-      } else if (!wasAlreadyInvalid) {
+        if (canExtType.getPointer() != extType.getPointer()) {
+          ED->diagnose(diag::invalid_nominal_extension, extType, canExtType)
+            .highlight(ED->getExtendedTypeRepr()->getSourceRange());
+          ED->diagnose(diag::invalid_nominal_extension_rewrite, canExtType)
+            .fixItReplace(ED->getExtendedTypeRepr()->getSourceRange(),
+                          canExtType->getString());
+          return;
+        }
+      }
+
+      if (!wasAlreadyInvalid) {
         // If nothing else applies, fall back to a generic diagnostic.
         ED->diagnose(diag::non_nominal_extension, extType);
       }
+
       return;
     }
 
-    // Produce any diagnostics for the generic signature.
-    (void) ED->getGenericSignature();
+    // Record a dependency from TypeCheckSourceFileRequest to
+    // ExtendedNominalRequest, since the call to getExtendedNominal()
+    // above doesn't record a dependency when reading a cached value.
+    ED->computeExtendedNominal();
 
-    if (extType && !extType->hasError()) {
+    if (!extType->hasError()) {
       // The first condition catches syntactic forms like
       //     protocol A & B { ... } // may be protocols or typealiases
       // The second condition also looks through typealiases and catches
@@ -3082,9 +3090,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         extTypeNominal && extTypeNominal != nominal;
       if (isa<CompositionTypeRepr>(extTypeRepr)
           || firstNominalIsNotMostSpecific) {
-        auto firstNominalType = nominal->getDeclaredType();
         auto diag = ED->diagnose(diag::composition_in_extended_type,
-                                 firstNominalType);
+                                 nominal->getDeclaredType());
         diag.highlight(extTypeRepr->getSourceRange());
         if (firstNominalIsNotMostSpecific) {
           diag.flush();
@@ -3095,19 +3102,22 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
                           mostSpecificProtocol->getString());
         } else {
           diag.fixItReplace(extTypeRepr->getSourceRange(),
-                            firstNominalType->getString());
+                            nominal->getDeclaredType()->getString());
         }
       }
     }
 
+    // Produce any diagnostics for the generic signature.
+    (void) ED->getGenericSignature();
+
     checkInheritanceClause(ED);
 
     // Only generic and protocol types are permitted to have
     // trailing where clauses.
     if (auto trailingWhereClause = ED->getTrailingWhereClause()) {
       if (!ED->getGenericParams() && !ED->isInvalid()) {
         ED->diagnose(diag::extension_nongeneric_trailing_where,
-                     nominal->getName())
+                     nominal->getDeclaredType())
           .highlight(trailingWhereClause->getSourceRange());
       }
     }

test/AutoDiff/Sema/DerivedConformances/struct_differentiable_member_types.swift

@@ -12,4 +12,9 @@ protocol Protocol {
 struct Struct: Differentiable {
   var weight: Float
 }
+
+// Extending a synthesized type doesn't actually work because of circularity issues.
+// It just wasn't diagnosed before.
+
 extension Struct.TangentVector: Protocol {}
+// expected-error@-1 {{non-nominal type 'Struct.TangentVector' cannot be extended}}

test/decl/ext/extensions.swift

@@ -104,6 +104,7 @@ var c = C()
 var x = c.p1
 c.p1 = 1
 
+// Reject extension of nominal type via inferred associated type
 protocol P3 {
   associatedtype Assoc
   func foo() -> Assoc
@@ -113,6 +114,8 @@ struct X3 : P3 {
 }
 
 extension X3.Assoc {
+// expected-error@-1 {{extension of type 'X3.Assoc' (aka 'Int') must be declared as an extension of 'Int'}}
+// expected-note@-2 {{did you mean to extend 'Int' instead?}}
 }
 
 extension X3 {
@@ -331,7 +334,7 @@ extension ImposeClassReq2 {
   }
 }
 
-// Reject extension of nominal type via parameterized typealias
+// Reject extension of nominal type via typealias with dependent underlying type
 
 struct Nest<Egg> { typealias Contents = Egg }
 struct Tree {