Merge pull request #83301 from slavapestov/fix-macro-fuzzer-crash

Sema: Fix crash with invalid reference to macro

Author: slavapestov

lib/AST/SubstitutionMap.cpp

@@ -267,6 +267,8 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
 
   // If the protocol is invertible, fall back to a global lookup instead of
   // evaluating a conformance path, to avoid an infinite substitution issue.
+  //
+  // FIXME: Figure out a more principled way of breaking this cycle.
   if (proto->getInvertibleProtocolKind())
     return swift::lookupConformance(type.subst(*this), proto);
 

lib/Sema/AssociatedTypeInference.cpp

@@ -2653,12 +2653,11 @@ AssociatedTypeInference::computeDerivedTypeWitness(
     return std::make_pair(Type(), nullptr);
 
   // Can we derive conformances for this protocol and adoptee?
-  NominalTypeDecl *derivingTypeDecl = dc->getSelfNominalTypeDecl();
-  if (!DerivedConformance::derivesProtocolConformance(dc, derivingTypeDecl,
-                                                      proto))
+  if (!DerivedConformance::derivesProtocolConformance(conformance))
     return std::make_pair(Type(), nullptr);
 
   // Try to derive the type witness.
+  NominalTypeDecl *derivingTypeDecl = dc->getSelfNominalTypeDecl();
   auto result = deriveTypeWitness(conformance, derivingTypeDecl, assocType);
   if (!result.first)
     return std::make_pair(Type(), nullptr);

lib/Sema/DerivedConformance/DerivedConformance.cpp

@@ -72,9 +72,10 @@ Type DerivedConformance::getProtocolType() const {
   return Protocol->getDeclaredInterfaceType();
 }
 
-bool DerivedConformance::derivesProtocolConformance(DeclContext *DC,
-                                                    NominalTypeDecl *Nominal,
-                                                    ProtocolDecl *Protocol) {
+bool DerivedConformance::derivesProtocolConformance(
+      NormalProtocolConformance *Conformance) {
+  auto *Protocol = Conformance->getProtocol();
+
   const auto derivableKind = Protocol->getKnownDerivableProtocolKind();
   if (!derivableKind)
     return false;
@@ -85,6 +86,9 @@ bool DerivedConformance::derivesProtocolConformance(DeclContext *DC,
     return false;
   }
 
+  auto *DC = Conformance->getDeclContext();
+  auto *Nominal = DC->getSelfNominalTypeDecl();
+
   if (*derivableKind == KnownDerivableProtocolKind::Hashable) {
     // We can always complete a partial Hashable implementation, and we can
     // synthesize a full Hashable implementation for structs and enums with
@@ -299,10 +303,10 @@ ValueDecl *DerivedConformance::getDerivableRequirement(NominalTypeDecl *nominal,
 
     auto conformance = lookupConformance(
         nominal->getDeclaredInterfaceType(), proto);
-    if (conformance) {
-      auto DC = conformance.getConcrete()->getDeclContext();
+    if (conformance.isConcrete()) {
       // Check whether this nominal type derives conformances to the protocol.
-      if (!DerivedConformance::derivesProtocolConformance(DC, nominal, proto))
+      if (!DerivedConformance::derivesProtocolConformance(
+            conformance.getConcrete()->getRootNormalConformance()))
         return nullptr;
     }
 

lib/Sema/DerivedConformance/DerivedConformance.h

@@ -95,16 +95,11 @@ class DerivedConformance {
   /// declarations for requirements of the protocol that are not satisfied by
   /// the type's explicit members.
   ///
-  /// \param nominal The nominal type for which we are determining whether to
-  /// derive a witness.
-  ///
-  /// \param protocol The protocol whose requirements are being derived.
+  /// \param conformance The conformance.
   ///
   /// \return True if the type can implicitly derive a conformance for the
   /// given protocol.
-  static bool derivesProtocolConformance(DeclContext *DC,
-                                         NominalTypeDecl *nominal,
-                                         ProtocolDecl *protocol);
+  static bool derivesProtocolConformance(NormalProtocolConformance *conformance);
 
   /// Diagnose problems, if any, preventing automatic derivation of protocol
   /// requirements

lib/Sema/TypeCheckProtocol.cpp

@@ -4730,9 +4730,8 @@ ResolveWitnessResult ConformanceChecker::resolveWitnessViaDerivation(
 
   // Find the declaration that derives the protocol conformance.
   NominalTypeDecl *derivingTypeDecl = nullptr;
-  auto *nominal = DC->getSelfNominalTypeDecl();
-  if (DerivedConformance::derivesProtocolConformance(DC, nominal, Proto))
-    derivingTypeDecl = nominal;
+  if (DerivedConformance::derivesProtocolConformance(Conformance))
+    derivingTypeDecl = DC->getSelfNominalTypeDecl();
 
   if (!derivingTypeDecl) {
     return ResolveWitnessResult::Missing;
@@ -4815,16 +4814,35 @@ void ConformanceChecker::resolveSingleWitness(ValueDecl *requirement) {
   if (!requirement->isProtocolRequirement())
     return;
 
+  auto &evaluator = getASTContext().evaluator;
+
   // Resolve the type witnesses for all associated types referenced by
   // the requirement. If any are erroneous, don't bother resolving the
   // witness.
-  auto referenced = evaluateOrDefault(getASTContext().evaluator,
+  auto referenced = evaluateOrDefault(evaluator,
                                       ReferencedAssociatedTypesRequest{requirement},
                                       TinyPtrVector<AssociatedTypeDecl *>());
   for (auto assocType : referenced) {
+    // There's a weird cycle break here. If we're in the middle of resolving
+    // type witnesses, we return from here without recording a value witness.
+    // This is handled by not caching the result, and the conformance checker
+    // will then attempt to resolve the value witness later.
+    if (evaluator.hasActiveRequest(TypeWitnessRequest{Conformance, assocType})) {
+      return;
+    }
+
+    if (!Conformance->hasTypeWitness(assocType)) {
+      if (evaluator.hasActiveRequest(ResolveTypeWitnessesRequest{Conformance})) {
+        return;
+      }
+    }
+
     auto typeWitness = Conformance->getTypeWitness(assocType);
     if (!typeWitness)
       return;
+
+    // However, if the type witness was already resolved and it has an error
+    // type, mark the conformance invalid and give up.
     if (typeWitness->hasError()) {
       Conformance->setInvalid();
       return;
@@ -6871,16 +6889,22 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
     // is implied for enums which already declare a raw type.
     if (auto enumDecl = dyn_cast<EnumDecl>(existingDecl)) {
       if (diag.Protocol->isSpecificProtocol(
-              KnownProtocolKind::RawRepresentable) &&
-          DerivedConformance::derivesProtocolConformance(dc, enumDecl,
-                                                         diag.Protocol) &&
-          enumDecl->hasRawType() &&
-          enumDecl->getInherited().getStartLoc().isValid()) {
-        auto inheritedLoc = enumDecl->getInherited().getStartLoc();
-        Context.Diags.diagnose(
-            inheritedLoc, diag::enum_declares_rawrep_with_raw_type,
-            dc->getDeclaredInterfaceType(), enumDecl->getRawType());
-        continue;
+              KnownProtocolKind::RawRepresentable)) {
+        auto conformance = lookupConformance(
+            enumDecl->getDeclaredInterfaceType(), diag.Protocol);
+        if (!conformance.isConcrete())
+          continue;
+
+        if (DerivedConformance::derivesProtocolConformance(
+              conformance.getConcrete()->getRootNormalConformance()) &&
+            enumDecl->hasRawType() &&
+            enumDecl->getInherited().getStartLoc().isValid()) {
+          auto inheritedLoc = enumDecl->getInherited().getStartLoc();
+          Context.Diags.diagnose(
+              inheritedLoc, diag::enum_declares_rawrep_with_raw_type,
+              dc->getDeclaredInterfaceType(), enumDecl->getRawType());
+          continue;
+        }
       }
     }
 

lib/Sema/TypeOfReference.cpp

@@ -1652,13 +1652,6 @@ DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
     return { openedType, openedType, memberTy, memberTy, Type() };
   }
 
-  if (isa<AbstractFunctionDecl>(value) || isa<EnumElementDecl>(value)) {
-    if (value->getInterfaceType()->is<ErrorType>()) {
-      auto genericErrorTy = ErrorType::get(getASTContext());
-      return { genericErrorTy, genericErrorTy, genericErrorTy, genericErrorTy, Type() };
-    }
-  }
-
   // Figure out the declaration context to use when opening this type.
   DeclContext *innerDC = value->getInnermostDeclContext();
   DeclContext *outerDC = value->getDeclContext();
@@ -1677,9 +1670,15 @@ DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
   }
 
   Type thrownErrorType;
-  if (isa<AbstractFunctionDecl>(value) || isa<EnumElementDecl>(value)) {
+  if (isa<AbstractFunctionDecl>(value) ||
+      isa<EnumElementDecl>(value) ||
+      isa<MacroDecl>(value)) {
+    auto interfaceType = value->getInterfaceType();
+    if (interfaceType->is<ErrorType>() || isa<MacroDecl>(value))
+      return { interfaceType, interfaceType, interfaceType, interfaceType, Type() };
+
     // This is the easy case.
-    openedType = value->getInterfaceType()->castTo<AnyFunctionType>();
+    openedType = interfaceType->castTo<AnyFunctionType>();
 
     if (auto *genericFn = openedType->getAs<GenericFunctionType>()) {
       openedType = substGenericArgs(genericFn,

validation-test/compiler_crashers_2/2d564dafb1f91.swift renamed to validation-test/compiler_crashers_2_fixed/2d564dafb1f91.swift

@@ -1,5 +1,5 @@
 // {"kind":"typecheck","signature":"swift::constraints::ConstraintSystem::getTypeOfMemberReference(swift::Type, swift::ValueDecl*, swift::DeclContext*, bool, swift::FunctionRefInfo, swift::constraints::ConstraintLocator*, llvm::SmallVectorImpl<std::__1::pair<swift::GenericTypeParamType*, swift::TypeVariableType*>>*, swift::constraints::PreparedOverloadBuilder*)"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 class a {
   macro b()
   var c = b