Hamish fuzzer fixes

include/swift/AST/DiagnosticsSema.def

@@ -7891,7 +7891,7 @@ ERROR(expected_macro_expansion_expr,PointsToFirstBadToken,
 ERROR(expected_macro_expansion_decls,PointsToFirstBadToken,
       "expected macro expansion to produce a declaration", ())
 ERROR(macro_undefined,PointsToFirstBadToken,
-      "no macro named %0", (Identifier))
+      "no macro named %0", (DeclName))
 ERROR(external_macro_not_found,none,
       "external macro implementation type '%0.%1' could not be found for "
       "macro %2; %3", (StringRef, StringRef, DeclName, StringRef))

include/swift/AST/ProtocolConformanceRef.h

@@ -140,6 +140,7 @@ class ProtocolConformanceRef {
   }
 
   AbstractConformance *getAbstract() const {
+    ASSERT(isAbstract());
     return Union.get<AbstractConformance *>();
   }
 

lib/AST/ASTContext.cpp

@@ -520,7 +520,7 @@ struct ASTContext::Implementation {
   llvm::DenseMap<const AbstractFunctionDecl *, SourceRange> OriginalBodySourceRanges;
 
   /// Macro discriminators per context.
-  llvm::DenseMap<std::pair<const void *, Identifier>, unsigned>
+  llvm::DenseMap<std::pair<const void *, DeclBaseName>, unsigned>
       NextMacroDiscriminator;
 
   /// Local and closure discriminators per context.
@@ -2286,8 +2286,8 @@ unsigned ASTContext::getNextMacroDiscriminator(
     MacroDiscriminatorContext context,
     DeclBaseName baseName
 ) {
-  std::pair<const void *, Identifier> key(
-      context.getOpaqueValue(), baseName.getIdentifier());
+  std::pair<const void *, DeclBaseName> key(
+      context.getOpaqueValue(), baseName);
   return getImpl().NextMacroDiscriminator[key]++;
 }
 

lib/AST/ASTDemangler.cpp

@@ -767,8 +767,8 @@ Type ASTBuilder::createExistentialMetatypeType(
 Type ASTBuilder::createConstrainedExistentialType(
     Type base, ArrayRef<BuiltRequirement> constraints,
     ArrayRef<BuiltInverseRequirement> inverseRequirements) {
-  llvm::SmallDenseMap<Identifier, Type> primaryAssociatedTypes;
-  llvm::SmallDenseSet<Identifier> claimed;
+  llvm::SmallDenseMap<AssociatedTypeDecl *, Type> primaryAssociatedTypes;
+  llvm::SmallDenseSet<AssociatedTypeDecl *> claimed;
 
   for (const auto &req : constraints) {
     switch (req.getKind()) {
@@ -782,7 +782,7 @@ Type ASTBuilder::createConstrainedExistentialType(
       if (auto *memberTy = req.getFirstType()->getAs<DependentMemberType>()) {
         if (memberTy->getBase()->is<GenericTypeParamType>()) {
           // This is the only case we understand so far.
-          primaryAssociatedTypes[memberTy->getName()] = req.getSecondType();
+          primaryAssociatedTypes[memberTy->getAssocType()] = req.getSecondType();
           continue;
         }
       }
@@ -799,7 +799,7 @@ Type ASTBuilder::createConstrainedExistentialType(
 
     llvm::SmallVector<Type, 4> args;
     for (auto *assocTy : proto->getPrimaryAssociatedTypes()) {
-      auto found = primaryAssociatedTypes.find(assocTy->getName());
+      auto found = primaryAssociatedTypes.find(assocTy);
       if (found == primaryAssociatedTypes.end())
         return protoTy;
       args.push_back(found->second);

lib/Parse/Lexer.cpp

@@ -660,8 +660,8 @@ static bool advanceIfValidContinuationOfOperator(char const *&ptr,
 
 /// Returns true if the given string is entirely whitespace (considering only
 /// those whitespace code points permitted in raw identifiers).
-static bool isEntirelyWhitespace(StringRef string) {
-  if (string.empty()) return false;
+static bool isEscapedIdentifierEntirelyWhitespace(StringRef string) {
+  if (string.empty()) return true;
   char const *p = string.data(), *end = string.end();
   if (!advanceIf(p, end, isPermittedRawIdentifierWhitespace))
     return false;
@@ -703,7 +703,7 @@ bool Lexer::isValidAsEscapedIdentifier(StringRef string) {
     ;
   if (p != end)
     return false;
-  return !isEntirelyWhitespace(string);
+  return !isEscapedIdentifierEntirelyWhitespace(string);
 }
 
 /// Determines if the given string is a valid operator identifier,
@@ -2315,7 +2315,8 @@ void Lexer::lexEscapedIdentifier() {
   // If we have the terminating "`", it's an escaped/raw identifier, unless it
   // contained only operator characters or was entirely whitespace.
   StringRef IdStr(IdentifierStart, CurPtr - IdentifierStart);
-  if (*CurPtr == '`' && !isOperator(IdStr) && !isEntirelyWhitespace(IdStr)) {
+  if (*CurPtr == '`' && !isOperator(IdStr) &&
+      !isEscapedIdentifierEntirelyWhitespace(IdStr)) {
     ++CurPtr;
     formEscapedIdentifierToken(Quote);
     return;

lib/Parse/ParseExpr.cpp

@@ -503,6 +503,9 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
        peekToken().isContextualPunctuator("~")) &&
       !peekToken().isAtStartOfLine()) {
     ParserResult<TypeRepr> ty = parseType();
+    if (ty.isNull())
+      return nullptr;
+
     auto *typeExpr = new (Context) TypeExpr(ty.get());
     return makeParserResult(typeExpr);
   }

lib/Sema/CSGen.cpp

@@ -4068,8 +4068,8 @@ namespace {
     }
 
     /// Lookup all macros with the given macro name.
-    SmallVector<OverloadChoice, 1> lookupMacros(Identifier moduleName,
-                                                Identifier macroName,
+    SmallVector<OverloadChoice, 1> lookupMacros(DeclName moduleName,
+                                                DeclName macroName,
                                                 FunctionRefInfo functionRefInfo,
                                                 MacroRoles roles) {
       SmallVector<OverloadChoice, 1> choices;
@@ -4100,8 +4100,8 @@ namespace {
       CS.associateArgumentList(locator, expr->getArgs());
 
       // Look up the macros with this name.
-      auto moduleIdent = expr->getModuleName().getBaseIdentifier();
-      auto macroIdent = expr->getMacroName().getBaseIdentifier();
+      auto moduleIdent = expr->getModuleName().getBaseName();
+      auto macroIdent = expr->getMacroName().getBaseName();
       FunctionRefInfo functionRefInfo = FunctionRefInfo::singleBaseNameApply();
       auto macros = lookupMacros(moduleIdent, macroIdent, functionRefInfo,
                                  expr->getMacroRoles());

lib/Sema/CSSimplify.cpp

@@ -7308,8 +7308,11 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
   // would be handled by existental promotion in cases where it's allowed.
   if (isTupleWithUnresolvedPackExpansion(origType1) ||
       isTupleWithUnresolvedPackExpansion(origType2)) {
-    if (desugar1->is<TupleType>() != desugar2->is<TupleType>() &&
-        (!desugar1->isAny() && !desugar2->isAny())) {
+    if (isa<TupleType>(desugar1) != isa<TupleType>(desugar2) &&
+        !isa<InOutType>(desugar1) &&
+        !isa<InOutType>(desugar2) &&
+        !desugar1->isAny() &&
+        !desugar2->isAny()) {
       return matchTypes(
           desugar1->is<TupleType>() ? type1
                                     : TupleType::get({type1}, getASTContext()),

lib/Sema/TypeCheckDecl.cpp

@@ -2248,13 +2248,20 @@ ParamSpecifierRequest::evaluate(Evaluator &evaluator,
 
   auto typeRepr = param->getTypeRepr();
 
-  if (!typeRepr && !param->isImplicit()) {
-    // Untyped closure parameter.
-    return ParamSpecifier::Default;
-  }
+  if (!typeRepr) {
+    if (!param->isImplicit()) {
+      // Untyped closure parameter.
+      return ParamSpecifier::Default;
+    }
 
-  assert(typeRepr != nullptr && "Should call setSpecifier() on "
-         "synthesized parameter declarations");
+    if (param->isInvalid()) {
+      // Invalid parse.
+      return ParamSpecifier::Default;
+    }
+
+    ASSERT(false && "Should call setSpecifier() on "
+           "synthesized parameter declarations");
+  }
 
   // Look through top-level pack expansions.  These specifiers are
   // part of what's repeated.

lib/Sema/TypeCheckEffects.cpp

@@ -1684,6 +1684,8 @@ class ApplyClassifier {
     const bool hasAnyConformances =
         llvm::any_of(substitutions.getConformances(),
                      [](const ProtocolConformanceRef conformance) {
+                       if (conformance.isInvalid())
+                         return false;
                        auto *requirement = conformance.getProtocol();
                        return !requirement->getInvertibleProtocolKind();
                      });

lib/Sema/TypeCheckNameLookup.cpp

@@ -266,7 +266,7 @@ convertToUnqualifiedLookupOptions(NameLookupOptions options) {
 static void synthesizeCodingKeysIfNeededForUnqualifiedLookup(ASTContext &ctx,
                                                              DeclContext *dc,
                                                              DeclNameRef name) {
-  if (name.getBaseIdentifier() != ctx.Id_CodingKeys)
+  if (!name.isSimpleName(ctx.Id_CodingKeys))
     return;
 
   for (auto typeCtx = dc->getInnermostTypeContext(); typeCtx != nullptr;

lib/Sema/TypeCheckPattern.cpp

@@ -221,6 +221,11 @@ static DeclRefTypeRepr *translateExprToDeclRefTypeRepr(Expr *E, ASTContext &C) {
     }
 
     DeclRefTypeRepr *visitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *udre) {
+      if (!udre->getName().isSimpleName() ||
+          udre->getName().isOperator() ||
+          udre->getName().isSpecial())
+        return nullptr;
+
       return UnqualifiedIdentTypeRepr::create(C, udre->getNameLoc(),
                                               udre->getName());
     }

test/DebugInfo/parameterized_existential_composition.swift

@@ -1,10 +1,17 @@
 // RUN: %target-swift-frontend -emit-ir %s -g -target %target-swift-5.9-abi-triple
 
+// Note: The goal of this test is to exercise the mangling/demangling via
+// the -g flag.
+
 public protocol P<A, B> {
   associatedtype A
   associatedtype B
 }
 
+public protocol P1<A> {
+  associatedtype A
+}
+
 public protocol Q<C> {
   associatedtype C
 }
@@ -31,6 +38,30 @@ public func foo(_ a: (any P<Int, Float> & Q<String> & R).Type) {}
 public func foo(_ a: (any P<Int, Float> & Q<String> & R & C<Bool>).Type) {}
 public func foo(_ a: (any P<Int, Float> & Q<String> & R & AnyObject).Type) {}
 
+public func foo(_ a: (any P & P1).Type) {}
+public func foo(_ a: (any P & P1<String>).Type) {}
+public func foo(_ a: (any P & P1<String> & R).Type) {}
+public func foo(_ a: (any P & P1<String> & R & C<Bool>).Type) {}
+public func foo(_ a: (any P & P1<String> & R & AnyObject).Type) {}
+
+public func foo(_ a: (any P<Int, Float> & P1).Type) {}
+public func foo(_ a: (any P<Int, Float> & P1 & R).Type) {}
+public func foo(_ a: (any P<Int, Float> & P1 & R & C<Bool>).Type) {}
+public func foo(_ a: (any P<Int, Float> & P1 & R & AnyObject).Type) {}
+
+public protocol Q2<C>: Q {}
+
+public protocol Q3<C>: Q {
+  associatedtype C
+}
+
+public func foo(_ a: (any Q2<Int> & R).Type) {}
+public func foo(_ a: (any Q3<Int> & R).Type) {}
+public func foo(_ a: (any Q2 & Q3).Type) {}
+public func foo(_ a: (any Q2 & Q3<Int>).Type) {}
+public func foo2(_ a: (any Q2<Int> & Q3).Type) {}
+public func foo3(_ a: (any Q2<Int> & Q3<Int>).Type) {}
+
 public struct Foo<each T, U> {
   public var a1: (repeat any P<each T, U> & R)
 }

test/decl/ext/specialize.swift

@@ -86,3 +86,9 @@ class State {
 extension Test.Key<State> {
   static let state = Self<State>()
 }
+
+protocol P {}
+struct S: P {}
+
+extension Sequence<any P> where Self == [S] {}
+// expected-error@-1 {{generic signature requires types 'S' and 'any P' to be the same}}

validation-test/compiler_crashers_2/1470917329979c9a.swift → validation-test/compiler_crashers_2_fixed/1470917329979c9a.swift

@@ -1,5 +1,5 @@
 // {"signature":"swift::PackExpansionType::PackExpansionType(swift::Type, swift::Type, swift::RecursiveTypeProperties, swift::ASTContext const*)"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 struct a < each b {
   struct c {
           d : (repeat(each b

validation-test/compiler_crashers_2/14b6ac8674b84f44.swift → validation-test/compiler_crashers_2_fixed/14b6ac8674b84f44.swift

@@ -1,4 +1,4 @@
 // {"signature":"(anonymous namespace)::ABIDependencyEvaluator::computeABIDependenciesForModule(swift::ModuleDecl*)"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 switch {
 case init

validation-test/compiler_crashers_2/43bf2cb496111e.swift → validation-test/compiler_crashers_2_fixed/43bf2cb496111e.swift

@@ -1,3 +1,3 @@
 // {"signature":"swift::Lexer::formEscapedIdentifierToken(char const*)"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 ``

validation-test/compiler_crashers_2/448bdb8b9df6dd2.swift → validation-test/compiler_crashers_2_fixed/448bdb8b9df6dd2.swift

@@ -1,3 +1,3 @@
 // {"signature":"swift::DeclRefTypeRepr::overwriteNameRef(swift::DeclNameRef)"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 switch {                         case    init(

validation-test/compiler_crashers_2/59b42964e169b6fa.swift → validation-test/compiler_crashers_2_fixed/59b42964e169b6fa.swift

@@ -1,5 +1,5 @@
 // {"signature":"swift::ProtocolConformanceRef::getProtocol() const"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
    func a<each b {
                    enum c {
                     case struct  var d: e      struct e {

validation-test/compiler_crashers_2/5ce9cd9830dc12a.swift → validation-test/compiler_crashers_2_fixed/5ce9cd9830dc12a.swift

@@ -1,3 +1,3 @@
 // {"signature":"swift::DeclAndTypePrinter::Implementation::visitVarDecl(swift::VarDecl*)"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 #init

validation-test/compiler_crashers_2/d03a7ba9ca6274b0.swift → validation-test/compiler_crashers_2_fixed/d03a7ba9ca6274b0.swift

@@ -1,3 +1,3 @@
 // {"signature":"swift::ParamSpecifierRequest::evaluate(swift::Evaluator&, swift::ParamDecl*) const"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 func a([0])

validation-test/compiler_crashers_2/fec3d092ae822aa6.swift → validation-test/compiler_crashers_2_fixed/fec3d092ae822aa6.swift

@@ -1,3 +1,3 @@
 // {"signature":"swift::Parser::parseExprSequenceElement(swift::Diag<>, bool)"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 any a <