Sema: Plumb a GenericParamList through type resolution for SIL parsing

slavapestov · slavapestov · commit 8f7c59ee3846 · 2020-09-11T17:45:58.000-04:00
When parse-time lookup is disabled, we can't rely on the parser
binding IdentTypeReprs that name generic parameters, so we do it
in type resolution by having the SIL parser supply a GenericParamList.
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -2501,7 +2501,8 @@ class HasImplementationOnlyImportsRequest
 
 class ResolveTypeRequest
     : public SimpleRequest<ResolveTypeRequest,
-                           Type(const TypeResolution *, TypeRepr *),
+                           Type(const TypeResolution *, TypeRepr *,
+                                GenericParamList *),
                            RequestFlags::Uncached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -2515,7 +2516,7 @@ class ResolveTypeRequest
 
   // Evaluation.
   Type evaluate(Evaluator &evaluator, const TypeResolution *resolution,
-                TypeRepr *repr) const;
+                TypeRepr *repr, GenericParamList *silParams) const;
 };
 
 void simple_display(llvm::raw_ostream &out, const TypeResolution *resolution);
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -243,7 +243,7 @@ SWIFT_REQUEST(TypeChecker, ResolveTypeEraserTypeRequest,
               Type(ProtocolDecl *, TypeEraserAttr *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResolveTypeRequest,
-              Type (const TypeResolution *, TypeRepr *),
+              Type (const TypeResolution *, TypeRepr *, GenericParamList *),
               Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SPIGroupsRequest,
               llvm::ArrayRef<Identifier>(Decl *),
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -43,6 +43,7 @@
 #include "swift/Basic/StringExtras.h"
 #include "swift/ClangImporter/ClangImporter.h"
 #include "swift/Strings.h"
+#include "swift/Subsystems.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
@@ -670,6 +671,7 @@ static void diagnoseUnboundGenericType(Type ty, SourceLoc loc);
 ///
 /// \param type The generic type to which to apply arguments.
 /// \param resolution The type resolution to perform.
+/// \param silParams Used to look up generic parameters in SIL mode.
 /// \param comp The arguments to apply with the angle bracket range for
 /// diagnostics.
 ///
@@ -678,6 +680,7 @@ static void diagnoseUnboundGenericType(Type ty, SourceLoc loc);
 ///
 /// \see applyUnboundGenericArguments
 static Type applyGenericArguments(Type type, TypeResolution resolution,
+                                  GenericParamList *silParams,
                                   ComponentIdentTypeRepr *comp) {
   const auto options = resolution.getOptions();
   auto dc = resolution.getDeclContext();
@@ -775,7 +778,7 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
     if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
       if (nominal->isOptionalDecl()) {
         // Validate the generic argument.
-        Type objectType = resolution.resolveType(genericArgs[0]);
+        Type objectType = resolution.resolveType(genericArgs[0], silParams);
         if (objectType->hasError()) {
           return ErrorType::get(ctx);
         }
@@ -800,7 +803,7 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
   SmallVector<Type, 2> args;
   for (auto tyR : genericArgs) {
     // Propagate failure.
-    Type substTy = genericResolution.resolveType(tyR);
+    Type substTy = genericResolution.resolveType(tyR, silParams);
     if (!substTy || substTy->hasError())
       return ErrorType::get(ctx);
 
@@ -1010,6 +1013,7 @@ static void maybeDiagnoseBadConformanceRef(DeclContext *dc,
 /// Returns a valid type or ErrorType in case of an error.
 static Type resolveTypeDecl(TypeDecl *typeDecl, DeclContext *foundDC,
                             TypeResolution resolution,
+                            GenericParamList *silParams,
                             ComponentIdentTypeRepr *comp) {
   // Resolve the type declaration to a specific type. How this occurs
   // depends on the current context and where the type was found.
@@ -1025,7 +1029,7 @@ static Type resolveTypeDecl(TypeDecl *typeDecl, DeclContext *foundDC,
                                    typeDecl);
   }
 
-  return applyGenericArguments(type, resolution, comp);
+  return applyGenericArguments(type, resolution, silParams, comp);
 }
 
 static std::string getDeclNameFromContext(DeclContext *dc,
@@ -1287,6 +1291,7 @@ static SelfTypeKind getSelfTypeKind(DeclContext *dc,
 /// \returns Either the resolved type or a null type, the latter of
 /// which indicates that some dependencies were unsatisfied.
 static Type resolveTopLevelIdentTypeComponent(TypeResolution resolution,
+                                              GenericParamList *silParams,
                                               ComponentIdentTypeRepr *comp) {
   const auto options = resolution.getOptions();
   ASTContext &ctx = resolution.getASTContext();
@@ -1299,14 +1304,27 @@ static Type resolveTopLevelIdentTypeComponent(TypeResolution resolution,
   // that now.
   if (auto *typeDecl = comp->getBoundDecl()) {
     // Resolve the type declaration within this context.
-    return resolveTypeDecl(typeDecl, comp->getDeclContext(), resolution, comp);
+    return resolveTypeDecl(typeDecl, comp->getDeclContext(), resolution,
+                           silParams, comp);
   }
 
   // Resolve the first component, which is the only one that requires
   // unqualified name lookup.
   auto DC = resolution.getDeclContext();
   auto id = comp->getNameRef();
 
+  // In SIL mode, we bind generic parameters here, since name lookup
+  // won't find them.
+  if (silParams != nullptr) {
+    auto name = id.getBaseIdentifier();
+    if (auto *paramDecl = silParams->lookUpGenericParam(name)) {
+      comp->setValue(paramDecl, DC);
+
+      return resolveTypeDecl(paramDecl, DC, resolution,
+                             silParams, comp);
+    }
+  }
+
   NameLookupOptions lookupOptions = defaultUnqualifiedLookupOptions;
   if (options.contains(TypeResolutionFlags::KnownNonCascadingDependency))
     lookupOptions |= NameLookupFlags::KnownPrivate;
@@ -1322,7 +1340,7 @@ static Type resolveTopLevelIdentTypeComponent(TypeResolution resolution,
     auto *foundDC = entry.getDeclContext();
     auto *typeDecl = cast<TypeDecl>(entry.getValueDecl());
 
-    Type type = resolveTypeDecl(typeDecl, foundDC, resolution, comp);
+    Type type = resolveTypeDecl(typeDecl, foundDC, resolution, silParams, comp);
     if (type->is<ErrorType>())
       return type;
 
@@ -1417,7 +1435,9 @@ static void diagnoseAmbiguousMemberType(Type baseTy, SourceRange baseRange,
 /// Resolve the given identifier type representation as a qualified
 /// lookup within the given parent type, returning the type it
 /// references.
+/// \param silParams Used to look up generic parameters in SIL mode.
 static Type resolveNestedIdentTypeComponent(TypeResolution resolution,
+                                            GenericParamList *silParams,
                                             Type parentTy,
                                             SourceRange parentRange,
                                             ComponentIdentTypeRepr *comp) {
@@ -1473,7 +1493,8 @@ static Type resolveNestedIdentTypeComponent(TypeResolution resolution,
     }
 
     // If there are generic arguments, apply them now.
-    return applyGenericArguments(memberType, resolution, comp);
+    return applyGenericArguments(memberType, resolution,
+                                 silParams, comp);
   };
 
   // Short-circuiting.
@@ -1490,7 +1511,7 @@ static Type resolveNestedIdentTypeComponent(TypeResolution resolution,
       // type later on.
       if (!memberType->is<DependentMemberType>() ||
           memberType->castTo<DependentMemberType>()->getAssocType()) {
-        return applyGenericArguments(memberType, resolution, comp);
+        return applyGenericArguments(memberType, resolution, silParams, comp);
       }
 
       return memberType;
@@ -1558,28 +1579,33 @@ static Type resolveNestedIdentTypeComponent(TypeResolution resolution,
   return maybeDiagnoseBadMemberType(member, memberType, inferredAssocType);
 }
 
+/// \param silParams Used to look up generic parameters in SIL mode.
 static Type
 resolveIdentTypeComponent(TypeResolution resolution,
+                          GenericParamList *silParams,
                           ArrayRef<ComponentIdentTypeRepr *> components) {
   auto comp = components.back();
 
   // The first component uses unqualified lookup.
   const auto parentComps = components.drop_back();
   if (parentComps.empty()) {
-    return resolveTopLevelIdentTypeComponent(resolution, comp);
+    return resolveTopLevelIdentTypeComponent(resolution, silParams,
+                                             comp);
   }
 
   // All remaining components use qualified lookup.
 
   // Resolve the parent type.
-  Type parentTy = resolveIdentTypeComponent(resolution, parentComps);
+  Type parentTy = resolveIdentTypeComponent(resolution, silParams,
+                                            parentComps);
   if (!parentTy || parentTy->hasError()) return parentTy;
   
   SourceRange parentRange(parentComps.front()->getStartLoc(),
                           parentComps.back()->getEndLoc());
 
   // Resolve the nested type.
-  return resolveNestedIdentTypeComponent(resolution, parentTy, parentRange,
+  return resolveNestedIdentTypeComponent(resolution, silParams,
+                                         parentTy, parentRange,
                                          comp);
 }
 
@@ -1720,9 +1746,13 @@ namespace {
   class TypeResolver {
     const TypeResolution &resolution;
 
+    /// Used in SIL mode.
+    GenericParamList *genericParams;
+
   public:
-    explicit TypeResolver(const TypeResolution &resolution)
-        : resolution(resolution) {}
+    explicit TypeResolver(const TypeResolution &resolution,
+                          GenericParamList *genericParams = nullptr)
+        : resolution(resolution), genericParams(genericParams) {}
 
     NeverNullType resolveType(TypeRepr *repr, TypeResolutionOptions options);
 
@@ -1828,22 +1858,26 @@ namespace {
   };
 } // end anonymous namespace
 
-Type TypeResolution::resolveType(TypeRepr *TyR) const {
+Type TypeResolution::resolveType(TypeRepr *TyR,
+                                 GenericParamList *silParams) const {
   auto &ctx = getASTContext();
   auto Ty =
-      evaluateOrDefault(ctx.evaluator, ResolveTypeRequest{this, TyR}, Type());
+      evaluateOrDefault(ctx.evaluator,
+                        ResolveTypeRequest{this, TyR, silParams}, Type());
   if (!Ty)
     return ErrorType::get(ctx);
   return Ty;
 }
 
 Type ResolveTypeRequest::evaluate(Evaluator &evaluator,
                                   const TypeResolution *resolution,
-                                  TypeRepr *TyR) const {
+                                  TypeRepr *TyR,
+                                  GenericParamList *silParams) const {
   const auto options = resolution->getOptions();
   auto &ctx = resolution->getASTContext();
   auto result =
-      TypeResolver(*resolution).resolveType(TyR, resolution->getOptions());
+      TypeResolver(*resolution, silParams)
+          .resolveType(TyR, resolution->getOptions());
 
   // If we resolved down to an error, make sure to mark the typeRepr as invalid
   // so we don't produce a redundant diagnostic.
@@ -2677,6 +2711,23 @@ Type TypeResolver::resolveASTFunctionType(
     const clang::Type *parsedClangFunctionType,
     DifferentiabilityKind diffKind) {
 
+  Optional<llvm::SaveAndRestore<GenericParamList *>> saveGenericParams;
+
+  if (auto *genericParams = repr->getGenericParams())
+    saveGenericParams.emplace(this->genericParams, genericParams);
+
+  // Diagnose a couple of things that we can parse in SIL mode but we don't
+  // allow in formal types.
+  if (auto patternParams = repr->getPatternGenericParams()) {
+    diagnose(patternParams->getLAngleLoc(),
+             diag::ast_subst_function_type);
+    return ErrorType::get(getASTContext());
+  } else if (!repr->getInvocationSubstitutions().empty()) {
+    diagnose(repr->getInvocationSubstitutions()[0]->getStartLoc(),
+             diag::ast_subst_function_type);
+    return ErrorType::get(getASTContext());
+  }
+
   TypeResolutionOptions options = None;
   options |= parentOptions.withoutContext().getFlags();
   auto params = resolveASTFunctionTypeParams(
@@ -2724,16 +2775,6 @@ Type TypeResolver::resolveASTFunctionType(
                      .withClangFunctionType(clangFnType)
                      .build();
 
-  // Diagnose a couple of things that we can parse in SIL mode but we don't
-  // allow in formal types.
-  if (auto patternParams = repr->getPatternGenericParams()) {
-    diagnose(patternParams->getLAngleLoc(),
-             diag::ast_subst_function_type);
-  } else if (!repr->getInvocationSubstitutions().empty()) {
-    diagnose(repr->getInvocationSubstitutions()[0]->getStartLoc(),
-             diag::ast_subst_function_type);
-  }
-
   // SIL uses polymorphic function types to resolve overloaded member functions.
   if (auto genericEnv = repr->getGenericEnvironment()) {
     outputTy = outputTy->mapTypeOutOfContext();
@@ -2809,12 +2850,18 @@ Type TypeResolver::resolveSILBoxType(SILBoxTypeRepr *repr,
     // has one. (TODO: Field types should never refer to generic parameters
     // outside the box's own environment; we should really validate that...)
     TypeResolution fieldResolution{resolution};
-    if (auto env = repr->getGenericEnvironment()) {
+
+    auto *genericEnv = repr->getGenericEnvironment();
+    auto *genericParams = repr->getGenericParams();
+
+    if (genericParams) {
       fieldResolution = TypeResolution::forContextual(
-          getDeclContext(), env, options, resolution.getUnboundTypeOpener());
+          getDeclContext(), genericEnv, options,
+          resolution.getUnboundTypeOpener());
     }
 
-    TypeResolver fieldResolver{fieldResolution};
+    TypeResolver fieldResolver{fieldResolution,
+                               genericParams};
     for (auto &fieldRepr : repr->getFields()) {
       auto fieldTy = fieldResolver.resolveType(fieldRepr.getFieldType(), options);
       fields.push_back({fieldTy->getCanonicalType(), fieldRepr.isMutable()});
@@ -2878,6 +2925,13 @@ Type TypeResolver::resolveSILFunctionType(FunctionTypeRepr *repr,
 
   // Resolve generic params in the pattern environment, if present, or
   // else the function's generic environment, if it has one.
+  GenericParamList *genericParams = repr->getGenericParams();
+  if (genericParams == nullptr)
+    genericParams = this->genericParams;
+  GenericParamList *componentGenericParams = repr->getPatternGenericParams();
+  if (componentGenericParams == nullptr)
+    componentGenericParams = genericParams;
+
   GenericEnvironment *genericEnv = repr->getGenericEnvironment();
   GenericEnvironment *componentTypeEnv =
     repr->getPatternGenericEnvironment()
@@ -2903,7 +2957,7 @@ Type TypeResolver::resolveSILFunctionType(FunctionTypeRepr *repr,
         diagnose(element.UnderscoreLoc, diag::sil_function_input_label);
     }
 
-    TypeResolver silResolver{functionResolution};
+    TypeResolver silResolver{functionResolution, componentGenericParams};
     for (auto elt : argsTuple->getElements()) {
       auto elementOptions = options;
       elementOptions.setContext(TypeResolverContext::FunctionInput);
@@ -2915,7 +2969,6 @@ Type TypeResolver::resolveSILFunctionType(FunctionTypeRepr *repr,
     }
 
     {
-      // FIXME: Deal with unsatisfied dependencies.
       if (silResolver.resolveSILResults(repr->getResultTypeRepr(),
                                         options, yields,
                                         results, errorResult)) {
@@ -2957,11 +3010,13 @@ Type TypeResolver::resolveSILFunctionType(FunctionTypeRepr *repr,
                                         resolution.getUnboundTypeOpener());
       patternSubs = resolveSubstitutions(repr->getPatternGenericEnvironment(),
                                          repr->getPatternSubstitutions(),
-                                         TypeResolver{resolveSILParameters});
+                                         TypeResolver{resolveSILParameters,
+                                                      genericParams});
     } else {
       patternSubs = resolveSubstitutions(repr->getPatternGenericEnvironment(),
                                          repr->getPatternSubstitutions(),
-                                         TypeResolver{resolution});
+                                         TypeResolver{resolution,
+                                                      genericParams});
     }
   }
 
@@ -2970,7 +3025,8 @@ Type TypeResolver::resolveSILFunctionType(FunctionTypeRepr *repr,
   if (!repr->getInvocationSubstitutions().empty()) {
     invocationSubs = resolveSubstitutions(repr->getGenericEnvironment(),
                                           repr->getInvocationSubstitutions(),
-                                          TypeResolver{resolution});
+                                          TypeResolver{resolution,
+                                                       genericParams});
   }
 
   if (hasError) {
@@ -3261,7 +3317,7 @@ Type TypeResolver::resolveIdentifierType(IdentTypeRepr *IdType,
   auto Components = llvm::makeArrayRef(ComponentRange.begin(),
                                        ComponentRange.end());
   Type result = resolveIdentTypeComponent(resolution.withOptions(options),
-                                          Components);
+                                          genericParams, Components);
   if (!result || result->hasError()) {
     return ErrorType::get(getASTContext());
   }
diff --git a/lib/Sema/TypeCheckType.h b/lib/Sema/TypeCheckType.h
@@ -371,9 +371,11 @@ class TypeResolution {
   /// to create a well-formed type.
   ///
   /// \param TyR The type representation to check.
+  /// \param silParams Used to look up generic parameters in SIL mode.
   ///
   /// \returns A well-formed type that is never null, or an \c ErrorType in case of an error.
-  Type resolveType(TypeRepr *TyR) const;
+  Type resolveType(TypeRepr *TyR,
+                   GenericParamList *silParams=nullptr) const;
 
   /// Whether this type resolution uses archetypes (vs. generic parameters).
   bool usesArchetypes() const;
