Preliminary cleanups for creating fewer GenericSignatureBuilders

include/swift/SIL/TypeLowering.h

@@ -545,20 +545,15 @@ struct SILConstantInfo {
 
   /// The SIL function type of the constant.
   CanSILFunctionType SILFnType;
-
-  /// The generic environment used by the constant.
-  GenericEnvironment *GenericEnv;
 
   SILConstantInfo(CanAnyFunctionType formalType,
                   AbstractionPattern formalPattern,
                   CanAnyFunctionType loweredType,
-                  CanSILFunctionType silFnTy,
-                  GenericEnvironment *env)
+                  CanSILFunctionType silFnTy)
     : FormalType(formalType),
       FormalPattern(formalPattern),
       LoweredType(loweredType),
-      SILFnType(silFnTy),
-      GenericEnv(env) {}
+      SILFnType(silFnTy) {}
 
   SILType getSILType() const {
     return SILType::getPrimitiveObjectType(SILFnType);
@@ -567,8 +562,7 @@ struct SILConstantInfo {
   friend bool operator==(SILConstantInfo lhs, SILConstantInfo rhs) {
     return lhs.FormalType == rhs.FormalType &&
            lhs.LoweredType == rhs.LoweredType &&
-           lhs.SILFnType == rhs.SILFnType &&
-           lhs.GenericEnv == rhs.GenericEnv;
+           lhs.SILFnType == rhs.SILFnType;
   }
   friend bool operator!=(SILConstantInfo lhs, SILConstantInfo rhs) {
     return !(lhs == rhs);
@@ -707,9 +701,6 @@ class TypeConverter {
 
   CanAnyFunctionType makeConstantInterfaceType(SILDeclRef constant);
 
-  /// Get the generic environment for a constant.
-  GenericEnvironment *getConstantGenericEnvironment(SILDeclRef constant);
-
   // Types converted during foreign bridging.
 #define BRIDGING_KNOWN_TYPE(BridgedModule,BridgedType) \
   Optional<CanType> BridgedType##Ty;
@@ -830,6 +821,9 @@ class TypeConverter {
   /// for a constant reference.
   const SILConstantInfo &getConstantInfo(SILDeclRef constant);
 
+  /// Get the generic environment for a constant.
+  GenericEnvironment *getConstantGenericEnvironment(SILDeclRef constant);
+
   /// Returns the SIL type of a constant reference.
   SILType getConstantType(SILDeclRef constant) {
     return getConstantInfo(constant).getSILType();

lib/AST/ASTVerifier.cpp

@@ -592,6 +592,9 @@ class Verifier : public ASTWalker {
         abort();
       }
 
+      if (!type->hasArchetype())
+        return;
+
       bool foundError = type->getCanonicalType().findIf([&](Type type) -> bool {
         if (auto archetype = type->getAs<ArchetypeType>()) {
           // Only visit each archetype once.

lib/AST/GenericSignatureBuilder.cpp

@@ -5440,8 +5440,7 @@ class GenericSignatureBuilder::InferRequirementsWalker : public TypeWalker {
       return Action::Continue;
 
     /// Retrieve the substitution.
-    auto subMap = ty->getContextSubstitutionMap(&module, decl,
-                                                decl->getGenericEnvironment());
+    auto subMap = ty->getContextSubstitutionMap(&module, decl);
 
     // Handle the requirements.
     // FIXME: Inaccurate TypeReprs.

lib/SIL/SILFunctionType.cpp

@@ -2159,7 +2159,6 @@ const SILConstantInfo &TypeConverter::getConstantInfo(SILDeclRef constant) {
   // First, get a function type for the constant.  This creates the
   // right type for a getter or setter.
   auto formalInterfaceType = makeConstantInterfaceType(constant);
-  auto *genericEnv = getConstantGenericEnvironment(constant);
 
   // The formal type is just that with the right representation.
   auto rep = getDeclRefRepresentation(constant);
@@ -2192,8 +2191,7 @@ const SILConstantInfo &TypeConverter::getConstantInfo(SILDeclRef constant) {
   auto result = ::new (resultBuf) SILConstantInfo{formalInterfaceType,
                                                   bridgedTypes.Pattern,
                                                   loweredInterfaceType,
-                                                  silFnType,
-                                                  genericEnv};
+                                                  silFnType};
   if (DisableConstantInfoCache)
     return *result;
 
@@ -2380,8 +2378,7 @@ TypeConverter::getConstantOverrideInfo(SILDeclRef derived, SILDeclRef base) {
     derivedInterfaceTy,
     bridgedTypes.Pattern,
     overrideLoweredInterfaceTy,
-    fnTy,
-    derivedInfo.GenericEnv};
+    fnTy};
 
   auto inserted = ConstantOverrideTypes.insert({{derived, base}, result});
   assert(inserted.second);

lib/SIL/SILVerifier.cpp

@@ -2527,7 +2527,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     assert(!methodTy->isCoroutine());
 
     // Map interface types to archetypes.
-    if (auto *env = constantInfo.GenericEnv) {
+    if (auto *env = F.getModule().Types.getConstantGenericEnvironment(method)) {
       auto subs = env->getForwardingSubstitutionMap();
       methodTy = methodTy->substGenericArgs(F.getModule(), subs);
     }

lib/SILGen/SILGen.cpp

@@ -646,7 +646,7 @@ void SILGenModule::preEmitFunction(SILDeclRef constant,
   assert(F->empty() && "already emitted function?!");
 
   if (F->getLoweredFunctionType()->isPolymorphic())
-    F->setGenericEnvironment(Types.getConstantInfo(constant).GenericEnv);
+    F->setGenericEnvironment(Types.getConstantGenericEnvironment(constant));
 
   // Create a debug scope for the function using astNode as source location.
   F->setDebugScope(new (M) SILDebugScope(Loc, F));

lib/SILGen/SILGenBridging.cpp

@@ -1268,9 +1268,6 @@ static SILFunctionType *emitObjCThunkArguments(SILGenFunction &SGF,
   auto swiftFormalFnTy = substGenericArgs(swiftInfo.LoweredType, subs);
   SILFunctionConventions swiftConv(swiftFnTy, SGF.SGM.M);
 
-  // We must have the same context archetypes as the unthunked function.
-  assert(objcInfo.GenericEnv == swiftInfo.GenericEnv);
-
   SmallVector<ManagedValue, 8> bridgedArgs;
   bridgedArgs.reserve(objcFnTy->getParameters().size());
 
@@ -1399,7 +1396,7 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
   SILFunctionConventions substConv(substTy, SGM.M);
 
   // Use the same generic environment as the native entry point.
-  F.setGenericEnvironment(nativeInfo.GenericEnv);
+  F.setGenericEnvironment(SGM.Types.getConstantGenericEnvironment(native));
 
   auto loc = thunk.getAsRegularLocation();
   loc.markAutoGenerated();
@@ -1607,7 +1604,7 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
   assert(nativeFnTy == nativeCI.SILFnType);
 
   // Use the same generic environment as the native entry point.
-  F.setGenericEnvironment(nativeCI.GenericEnv);
+  F.setGenericEnvironment(SGM.Types.getConstantGenericEnvironment(thunk));
 
   SILDeclRef foreignDeclRef = thunk.asForeign(true);
   SILConstantInfo foreignCI = getConstantInfo(foreignDeclRef);

lib/SILGen/SILGenExpr.cpp

@@ -2858,7 +2858,7 @@ static SILFunction *getOrCreateKeyPathGetter(SILGenModule &SGM,
   // If the storage declaration is from a protocol, chase the override chain
   // back to the declaration whose getter introduced the witness table
   // entry.
-  if (auto origProto = dyn_cast<ProtocolDecl>(property->getDeclContext())) {
+  if (isa<ProtocolDecl>(property->getDeclContext())) {
     auto getter = property->getGetter();
     if (!SILDeclRef::requiresNewWitnessTableEntry(getter)) {
       // Find the getter that does have a witness table entry.
@@ -2989,7 +2989,7 @@ static SILFunction *getOrCreateKeyPathSetter(SILGenModule &SGM,
   // If the storage declaration is from a protocol, chase the override chain
   // back to the declaration whose setter introduced the witness table
   // entry.
-  if (auto origProto = dyn_cast<ProtocolDecl>(property->getDeclContext())) {
+  if (isa<ProtocolDecl>(property->getDeclContext())) {
     auto setter = property->getSetter();
     if (!SILDeclRef::requiresNewWitnessTableEntry(setter)) {
       // Find the setter that does have a witness table entry.

lib/Sema/ConstraintLocator.cpp

@@ -45,10 +45,6 @@ void ConstraintLocator::Profile(llvm::FoldingSetNodeID &id, Expr *anchor,
       id.AddPointer(elt.getWitness());
       break;
 
-    case AssociatedType:
-      id.AddPointer(elt.getAssociatedType());
-      break;
-
     case ApplyArgument:
     case ApplyFunction:
     case FunctionArgument:
@@ -117,11 +113,6 @@ void ConstraintLocator::dump(SourceManager *sm, raw_ostream &out) {
       out << "archetype '" << elt.getArchetype()->getString() << "'";
       break;
 
-    case AssociatedType:
-      out << "associated type '"
-          << elt.getAssociatedType()->getNameStr() << "'";
-      break;
-
     case ApplyArgument:
       out << "apply argument";
       break;

lib/Sema/ConstraintLocator.h

@@ -63,10 +63,6 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     ///
     /// Also contains the archetype itself.
     Archetype,
-    /// An associated type reference.
-    ///
-    /// Contains the associated type itself.
-    AssociatedType,
     /// \brief The argument type of a function.
     FunctionArgument,
     /// \brief The result type of a function.
@@ -138,7 +134,6 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     case ApplyArgument:
     case ApplyFunction:
     case Archetype:
-    case AssociatedType:
     case FunctionArgument:
     case FunctionResult:
     case OptionalPayload:
@@ -211,7 +206,6 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     case SubscriptMember:
     case OpenedGeneric:
     case Archetype:
-    case AssociatedType:
     case GenericArgument:
     case NamedTupleElement:
     case TupleElement:
@@ -316,13 +310,6 @@ class ConstraintLocator : public llvm::FoldingSetNode {
               (kind == Witness && getWitness() == decl)));
     }
 
-    PathElement(AssociatedTypeDecl *decl)
-      : storage((reinterpret_cast<uintptr_t>(decl) >> 2)),
-        storedKind(StoredRequirement)
-    {
-      assert(getAssociatedType() == decl);
-    }
-
     /// \brief Retrieve a path element for a tuple element referred to by
     /// its position.
     static PathElement getTupleElement(unsigned position) {
@@ -370,8 +357,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
         return Archetype;
 
       case StoredRequirement:
-        return isa<AssociatedTypeDecl>(getRequirement()) ? AssociatedType
-                                                         : Requirement;
+        return Requirement;
 
       case StoredWitness:
         return Witness;
@@ -427,12 +413,6 @@ class ConstraintLocator : public llvm::FoldingSetNode {
       return reinterpret_cast<ValueDecl *>(storage << 2);
     }
 
-    /// Retrieve the declaration for an associated type path element.
-    AssociatedTypeDecl *getAssociatedType() const {
-      assert(getKind() == AssociatedType && "Is not an associated type");
-      return reinterpret_cast<AssociatedTypeDecl *>(storage << 2);
-    }
-
     /// \brief Return the summary flags for this particular element.
     unsigned getNewSummaryFlags() const {
       return getSummaryFlagsForPathElement(getKind());

lib/Sema/ConstraintSystem.cpp

@@ -801,8 +801,7 @@ void ConstraintSystem::recordOpenedTypes(
   SmallVector<LocatorPathElt, 2> pathElts;
   Expr *anchor = locator.getLocatorParts(pathElts);
   if (!pathElts.empty() &&
-      (pathElts.back().getKind() == ConstraintLocator::Archetype ||
-       pathElts.back().getKind() == ConstraintLocator::AssociatedType))
+      pathElts.back().getKind() == ConstraintLocator::Archetype)
     return;
 
   // If the locator is empty, ignore it.
@@ -1017,8 +1016,6 @@ static void bindArchetypesFromContext(
     ConstraintLocator *locatorPtr,
     const OpenedTypeMap &replacements) {
 
-  auto *genericEnv = cs.DC->getGenericEnvironmentOfContext();
-
   auto bindContextArchetype = [&](Type paramTy, Type contextTy) {
     auto found = replacements.find(cast<GenericTypeParamType>(
                                      paramTy->getCanonicalType()));
@@ -1054,7 +1051,7 @@ static void bindArchetypesFromContext(
       break;
 
     for (auto *paramTy : genericSig->getGenericParams()) {
-      Type contextTy = genericEnv->mapTypeIntoContext(paramTy);
+      Type contextTy = cs.DC->mapTypeIntoContext(paramTy);
       bindContextArchetype(paramTy, contextTy);
     }
 

lib/Sema/TypeCheckConstraints.cpp

@@ -27,6 +27,7 @@
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/NameLookup.h"
+#include "swift/AST/ParameterList.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/AST/TypeCheckerDebugConsumer.h"
@@ -215,29 +216,12 @@ Expr *ConstraintLocatorBuilder::trySimplifyToExpr() const {
 //===----------------------------------------------------------------------===//
 
 static unsigned getNumArgs(ValueDecl *value) {
-  if (!isa<FuncDecl>(value)) return ~0U;
-
-  AnyFunctionType *fnTy = value->getInterfaceType()->castTo<AnyFunctionType>();
-  if (value->getDeclContext()->isTypeContext())
-    fnTy = fnTy->getResult()->castTo<AnyFunctionType>();
-
-  auto params = fnTy->getParams();
-  if (params.size() == 1) {
-    const auto &param = params.front();
-    if (param.hasLabel() || param.isVariadic())
-      return 1;
-
-    if (auto *tuple = param.getOldType()->getAs<TupleType>())
-      return tuple->getNumElements();
-  }
-
-  return params.size();
+  if (auto *func = dyn_cast<FuncDecl>(value))
+    return func->getParameters()->size();
+  return ~0U;
 }
 
 static bool matchesDeclRefKind(ValueDecl *value, DeclRefKind refKind) {
-  if (value->getInterfaceType()->hasError())
-    return true;
-
   switch (refKind) {
   // An ordinary reference doesn't ignore anything.
   case DeclRefKind::Ordinary:

lib/Sema/TypeCheckDecl.cpp

@@ -3934,8 +3934,6 @@ void TypeChecker::validateDecl(ValueDecl *D) {
           aliasDecl->getUnderlyingTypeLoc().setType(Type());
           aliasDecl->setInterfaceType(Type());
 
-          (void) aliasDecl->getFormalAccess();
-
           // Check generic parameters, if needed.
           if (aliasDecl->hasValidationStarted()) {
             validateTypealiasType(*this, aliasDecl);
@@ -4444,8 +4442,6 @@ void TypeChecker::validateDeclForNameLookup(ValueDecl *D) {
     for (auto paramDecl : *gp)
       paramDecl->setDepth(depth);
 
-    (void) proto->getFormalAccess();
-
     for (auto ATD : proto->getAssociatedTypeMembers()) {
       validateDeclForNameLookup(ATD);
     }
@@ -4468,7 +4464,6 @@ void TypeChecker::validateDeclForNameLookup(ValueDecl *D) {
     if (assocType->hasInterfaceType())
       return;
     assocType->computeType();
-    (void) assocType->getFormalAccess();
     break;
   }
   case DeclKind::TypeAlias: {
@@ -4482,8 +4477,6 @@ void TypeChecker::validateDeclForNameLookup(ValueDecl *D) {
         if (typealias->isBeingValidated()) return;
 
         auto helper = [&] {
-          (void) typealias->getFormalAccess();
-
           TypeResolutionOptions options(TypeResolverContext::TypeAliasDecl);
           if (validateType(typealias->getUnderlyingTypeLoc(),
                            TypeResolution::forStructural(typealias), options)) {

lib/Serialization/ModuleFile.cpp

@@ -561,6 +561,8 @@ class ModuleFile::DeclMemberNamesTableInfo {
       return {DeclBaseName::Kind::Subscript, StringRef()};
     case static_cast<uint8_t>(DeclNameKind::Destructor):
       return {DeclBaseName::Kind::Destructor, StringRef()};
+    case static_cast<uint8_t>(DeclNameKind::Constructor):
+      return {DeclBaseName::Kind::Constructor, StringRef()};
     default:
       llvm_unreachable("Unknown DeclNameKind");
     }

test/Parse/matching_patterns.swift

@@ -280,7 +280,8 @@ case (1, 2, 3):
 
 // patterns in expression-only positions are errors.
 case +++(_, var d, 3):
-// expected-error@-1{{'+++' is not a prefix unary operator}}
+// expected-error@-1{{'_' can only appear in a pattern or on the left side of an assignment}}
+// expected-error@-2{{'var' binding pattern cannot appear in an expression}}
   ()
 case (_, var e, 3) +++ (1, 2, 3):
 // expected-error@-1{{'_' can only appear in a pattern}}