Merge pull request #3181 from slavapestov/generic-typealias-fixes

Author: swift-ci

include/swift/Serialization/ModuleFormat.h

@@ -760,6 +760,7 @@ namespace decls_block {
     TypeIDField, // interface type
     BCFixed<1>,  // implicit flag
     AccessibilityKindField // accessibility
+    // Trailed by generic parameters (if any).
   >;
 
   using GenericTypeParamDeclLayout = BCRecordLayout<

lib/Sema/ConstraintSystem.cpp

@@ -593,8 +593,8 @@ namespace {
         // pointing at a generic TypeAliasDecl here. If we find a way to
         // handle generic TypeAliases elsewhere, this can just become a
         // call to BoundGenericType::get().
-        return cs.TC.applyUnboundGenericArguments(unbound, SourceLoc(), cs.DC,
-                                                  arguments,
+        return cs.TC.applyUnboundGenericArguments(unbound, unboundDecl,
+                                                  SourceLoc(), cs.DC, arguments,
                                                   /*isGenericSignature*/false,
                                                   /*resolver*/nullptr);
       }

lib/Sema/TypeCheckStmt.cpp

@@ -1017,13 +1017,17 @@ void TypeChecker::checkIgnoredExpr(Expr *E) {
     return;
   }
 
-  // Drill through noop expressions we don't care about, like ParanExprs.
+  // Drill through noop expressions we don't care about.
   auto valueE = E;
   while (1) {
     valueE = valueE->getValueProvidingExpr();
 
     if (auto *OEE = dyn_cast<OpenExistentialExpr>(valueE))
       valueE = OEE->getSubExpr();
+    else if (auto *CRCE = dyn_cast<CovariantReturnConversionExpr>(valueE))
+      valueE = CRCE->getSubExpr();
+    else if (auto *EE = dyn_cast<ErasureExpr>(valueE))
+      valueE = EE->getSubExpr();
     else
       break;
   }

lib/Sema/TypeCheckType.cpp

@@ -209,7 +209,7 @@ Type TypeChecker::resolveTypeInContext(
   // If we have a callback to report dependencies, do so.
   if (unsatisfiedDependency &&
       (*unsatisfiedDependency)(requestResolveTypeDecl(typeDecl)))
-    return nullptr;
+    return Type();
 
   // If we found a generic parameter, map to the archetype if there is one.
   if (auto genericParam = dyn_cast<GenericTypeParamDecl>(typeDecl)) {
@@ -233,7 +233,7 @@ Type TypeChecker::resolveTypeInContext(
   // We might have an invalid extension that didn't resolve.
   if (ownerNominal == nullptr && ownerDC->isExtensionContext()) {
     assert(cast<ExtensionDecl>(ownerDC)->isInvalid());
-    return ErrorType::get(ownerDC->getASTContext());
+    return ErrorType::get(Context);
   }
 
   auto assocType = dyn_cast<AssociatedTypeDecl>(typeDecl);
@@ -372,7 +372,7 @@ Type TypeChecker::resolveTypeInContext(
 
           auto protoSelf = parentDC->getProtocolSelf();
           if (protoSelf == nullptr)
-            return ErrorType::get(parentDC->getASTContext());
+            return ErrorType::get(Context);
 
           auto selfType = protoSelf
               ->getDeclaredType()
@@ -402,61 +402,85 @@ Type TypeChecker::resolveTypeInContext(
   }
 
   assert(incomplete && "Should have found type by now");
-  return ErrorType::get(ownerDC->getASTContext());
+  return ErrorType::get(Context);
 }
 
-Type TypeChecker::applyGenericArguments(Type type, SourceLoc loc,
-                                        DeclContext *dc,
+Type TypeChecker::applyGenericArguments(Type type, TypeDecl *decl,
+                                        SourceLoc loc, DeclContext *dc,
                                         GenericIdentTypeRepr *generic,
                                         bool isGenericSignature,
                                         GenericTypeResolver *resolver) {
 
-  auto unbound = type->getAs<UnboundGenericType>();
-  if (!unbound) {
-    if (!type->is<ErrorType>()) {
-      auto diag = diagnose(loc, diag::not_a_generic_type, type);
+  if (type->is<ErrorType>()) {
+    generic->setInvalid();
+    return type;
+  }
+
+  // We must either have an unbound generic type, or a generic type alias.
+  if (!type->is<UnboundGenericType>() &&
+      !(isa<TypeAliasDecl>(decl) &&
+        cast<TypeAliasDecl>(decl)->getGenericParams())) {
+
+    auto diag = diagnose(loc, diag::not_a_generic_type, type);
+
+    // Don't add fixit on module type; that isn't the right type regardless
+    // of whether it had generic arguments.
+    if (!type->is<ModuleType>())
+      diag.fixItRemove(generic->getAngleBrackets());
 
-      // Don't add fixit on module type; that isn't the right type regardless
-      // of whether it had generic arguments.
-      if (!type->is<ModuleType>())
-        diag.fixItRemove(generic->getAngleBrackets());
-    }
     generic->setInvalid();
     return type;
   }
 
+  // If we have a non-generic type alias, we have an unbound generic type.
+  // Grab the decl from the unbound generic type.
+  //
+  // The idea is if you write:
+  //
+  // typealias Foo = Bar.Baz
+  //
+  // Then 'Foo<Int>' applies arguments to Bar.Baz, whereas if you write:
+  //
+  // typealias Foo<T> = Bar.Baz<T>
+  //
+  // Then 'Foo<Int>' applies arguments to Foo itself.
+  //
+  if (isa<TypeAliasDecl>(decl) &&
+      !cast<TypeAliasDecl>(decl)->getGenericParams()) {
+    decl = type->castTo<UnboundGenericType>()->getDecl();
+  }
+
   // Make sure we have the right number of generic arguments.
   // FIXME: If we have fewer arguments than we need, that might be okay, if
   // we're allowed to deduce the remaining arguments from context.
-  auto unboundDecl = unbound->getDecl();
+  auto genericDecl = cast<GenericTypeDecl>(decl);
   auto genericArgs = generic->getGenericArgs();
-  auto genericParams = unboundDecl->getGenericParams();
+  auto genericParams = genericDecl->getGenericParams();
   if (genericParams->size() != genericArgs.size()) {
-    diagnose(loc, diag::type_parameter_count_mismatch, unboundDecl->getName(),
+    diagnose(loc, diag::type_parameter_count_mismatch, decl->getName(),
              genericParams->size(), genericArgs.size(),
              genericArgs.size() < genericParams->size())
         .highlight(generic->getAngleBrackets());
-    diagnose(unboundDecl, diag::generic_type_declared_here,
-             unboundDecl->getName());
+    diagnose(decl, diag::generic_type_declared_here,
+             decl->getName());
     return nullptr;
   }
 
   SmallVector<TypeLoc, 8> args;
   for (auto tyR : genericArgs)
     args.push_back(tyR);
 
-  return applyUnboundGenericArguments(unbound, loc, dc, args,
+  return applyUnboundGenericArguments(type, genericDecl, loc, dc, args,
                                       isGenericSignature, resolver);
 }
 
 /// Apply generic arguments to the given type.
 Type TypeChecker::applyUnboundGenericArguments(
-    UnboundGenericType *unbound, SourceLoc loc, DeclContext *dc,
+    Type type, GenericTypeDecl *decl, SourceLoc loc, DeclContext *dc,
     MutableArrayRef<TypeLoc> genericArgs, bool isGenericSignature,
     GenericTypeResolver *resolver) {
 
-  assert(unbound &&
-         genericArgs.size() == unbound->getDecl()->getGenericParams()->size() &&
+  assert(genericArgs.size() == decl->getGenericParams()->size() &&
          "invalid arguments, use applyGenericArguments for diagnostic emitting");
 
   // Make sure we always have a resolver to use.
@@ -477,50 +501,48 @@ Type TypeChecker::applyUnboundGenericArguments(
 
     genericArgTypes.push_back(genericArg.getType());
   }
-  
+
   // If we're completing a generic TypeAlias, then we map the types provided
   // onto the underlying type.
-  if (auto *TAD = dyn_cast<TypeAliasDecl>(unbound->getDecl())) {
+  if (auto *TAD = dyn_cast<TypeAliasDecl>(decl)) {
     auto signature = TAD->getGenericSignature();
-    assert(TAD->getGenericParams()->getAllArchetypes().size()
-             == genericArgs.size() &&
-           signature->getInnermostGenericParams().size() == genericArgs.size()&&
-           "argument arity mismatch");
 
-    SmallVector<Substitution, 4> subs;
-    subs.reserve(genericArgs.size());
-    
-    // If we have any nested archetypes from an outer type, include them
-    // verbatim.
-    auto outerParams = signature->getGenericParams();
-    outerParams = outerParams.drop_back(genericArgs.size());
-    for (auto param : outerParams) {
-      Type type = resolver->resolveGenericTypeParamType(param);
+    TypeSubstitutionMap subs;
+    for (unsigned i = 0, e = genericArgs.size(); i < e; i++) {
+      auto t = signature->getInnermostGenericParams()[i];
+      subs[t->getCanonicalType().getPointer()] = genericArgs[i].getType();
+    }
 
-      subs.push_back(Substitution(type, {}));
+    if (auto outerSig = TAD->getDeclContext()->getGenericSignatureOfContext()) {
+      for (auto outerParam : outerSig->getGenericParams()) {
+        subs[outerParam->getCanonicalType().getPointer()] =
+            ArchetypeBuilder::mapTypeIntoContext(TAD->getDeclContext(),
+                                                 outerParam);
+      }
     }
-    
-    for (auto t : genericArgs)
-      subs.push_back(Substitution(t.getType(), {}));
-  
-    auto subst = TAD->getGenericParams()->getSubstitutionMap(subs);
+
+    // FIXME: Change callers to pass the right type in for generic typealiases
+    if (type->is<UnboundGenericType>() || isa<NameAliasType>(type.getPointer())) {
+      type = ArchetypeBuilder::mapTypeOutOfContext(TAD, TAD->getUnderlyingType());
+    }
+
+    type = type.subst(dc->getParentModule(), subs, None);
 
     // FIXME: return a SubstitutedType to preserve the fact that
     // we resolved a generic TypeAlias, for availability diagnostics.
     // A better fix might be to introduce a BoundGenericAliasType
     // which desugars as appropriate.
-    return SubstitutedType::get(
-        TAD->getDeclaredType(),
-        TAD->getUnderlyingType().subst(TAD->getParentModule(), subst, None),
-        Context);
+    return SubstitutedType::get(TAD->getDeclaredType(), type, Context);
   }
 
   // Form the bound generic type.
-  auto *BGT = BoundGenericType::get(cast<NominalTypeDecl>(unbound->getDecl()),
-                                    unbound->getParent(), genericArgTypes);
+  auto *UGT = type->castTo<UnboundGenericType>();
+  auto *BGT = BoundGenericType::get(cast<NominalTypeDecl>(decl),
+                                    UGT->getParent(), genericArgTypes);
+
   // Check protocol conformance.
   if (!BGT->hasTypeParameter() && !BGT->hasTypeVariable()) {
-    SourceLoc noteLoc = unbound->getDecl()->getLoc();
+    SourceLoc noteLoc = decl->getLoc();
     if (noteLoc.isInvalid())
       noteLoc = loc;
 
@@ -532,14 +554,13 @@ Type TypeChecker::applyUnboundGenericArguments(
     ArrayRef<Type> allGenericArgs = BGT->getAllGenericArgs(scratch);
 
     // Check the generic arguments against the generic signature.
-    auto genericSig = unbound->getDecl()->getGenericSignature();
-    if (!unbound->getDecl()->hasType() ||
-        unbound->getDecl()->isValidatingGenericSignature()) {
+    auto genericSig = decl->getGenericSignature();
+    if (!decl->hasType() || decl->isValidatingGenericSignature()) {
       diagnose(loc, diag::recursive_requirement_reference);
       return nullptr;
     }
     assert(genericSig != nullptr);
-    if (checkGenericArguments(dc, loc, noteLoc, unbound, genericSig,
+    if (checkGenericArguments(dc, loc, noteLoc, UGT, genericSig,
                               allGenericArgs))
       return nullptr;
 
@@ -549,14 +570,16 @@ Type TypeChecker::applyUnboundGenericArguments(
   return BGT;
 }
 
-static Type applyGenericTypeReprArgs(TypeChecker &TC, Type type, SourceLoc loc,
+static Type applyGenericTypeReprArgs(TypeChecker &TC, Type type,
+                                     TypeDecl *decl,
+                                     SourceLoc loc,
                                      DeclContext *dc,
                                      GenericIdentTypeRepr *generic,
                                      bool isGenericSignature,
                                      GenericTypeResolver *resolver) {
 
-  Type ty = TC.applyGenericArguments(type, loc, dc, generic, isGenericSignature,
-                                     resolver);
+  Type ty = TC.applyGenericArguments(type, decl, loc, dc, generic,
+                                     isGenericSignature, resolver);
   if (!ty)
     return ErrorType::get(TC.Context);
   return ty;
@@ -660,7 +683,7 @@ static Type resolveTypeDecl(TypeChecker &TC, TypeDecl *typeDecl, SourceLoc loc,
 
   if (generic && !options.contains(TR_ResolveStructure)) {
     // Apply the generic arguments to the type.
-    type = applyGenericTypeReprArgs(TC, type, loc, dc, generic,
+    type = applyGenericTypeReprArgs(TC, type, typeDecl, loc, dc, generic,
                                     options.contains(TR_GenericSignature),
                                     resolver);
   }
@@ -1035,7 +1058,7 @@ static Type resolveNestedIdentTypeComponent(
     // If there are generic arguments, apply them now.
     if (auto genComp = dyn_cast<GenericIdentTypeRepr>(comp)) {
       memberType = applyGenericTypeReprArgs(
-          TC, memberType, comp->getIdLoc(), DC, genComp,
+          TC, memberType, typeDecl, comp->getIdLoc(), DC, genComp,
           options.contains(TR_GenericSignature), resolver);
 
       // Propagate failure.
@@ -1154,7 +1177,7 @@ static Type resolveNestedIdentTypeComponent(
   // If there are generic arguments, apply them now.
   if (auto genComp = dyn_cast<GenericIdentTypeRepr>(comp))
     memberType = applyGenericTypeReprArgs(
-        TC, memberType, comp->getIdLoc(), DC, genComp,
+        TC, memberType, member, comp->getIdLoc(), DC, genComp,
         options.contains(TR_GenericSignature), resolver);
 
   // If we found a reference to an associated type or other member type that
@@ -2235,16 +2258,17 @@ Type TypeResolver::resolveDictionaryType(DictionaryTypeRepr *repr,
 
   Type valueTy = resolveType(repr->getValue(), withoutContext(options));
   if (!valueTy || valueTy->is<ErrorType>()) return valueTy;
-  
+
+  auto dictDecl = TC.Context.getDictionaryDecl();
+
   if (auto dictTy = TC.getDictionaryType(repr->getBrackets().Start, keyTy, 
                                          valueTy)) {
     // Check the requirements on the generic arguments.
-    auto unboundTy = UnboundGenericType::get(TC.Context.getDictionaryDecl(),
-                                             nullptr, TC.Context);
+    auto unboundTy = dictDecl->getDeclaredType();
     TypeLoc args[2] = { TypeLoc(repr->getKey()), TypeLoc(repr->getValue()) };
 
     if (!TC.applyUnboundGenericArguments(
-            unboundTy, repr->getStartLoc(), DC, args,
+            unboundTy, dictDecl, repr->getStartLoc(), DC, args,
             options.contains(TR_GenericSignature), Resolver)) {
       return ErrorType::get(TC.Context);
     }

lib/Sema/TypeChecker.h

@@ -774,6 +774,7 @@ class TypeChecker final : public LazyResolver {
   /// to be in a correct and valid form.
   ///
   /// \param type The generic type to which to apply arguments.
+  /// \param decl The declaration of the type.
   /// \param loc The source location for diagnostic reporting.
   /// \param dc The context where the arguments are applied.
   /// \param generic The arguments to apply with the angle bracket range for
@@ -786,8 +787,8 @@ class TypeChecker final : public LazyResolver {
   /// error.
   ///
   /// \see applyUnboundGenericArguments
-  Type applyGenericArguments(Type type, SourceLoc loc, DeclContext *dc,
-                             GenericIdentTypeRepr *generic,
+  Type applyGenericArguments(Type type, TypeDecl *decl, SourceLoc loc,
+                             DeclContext *dc, GenericIdentTypeRepr *generic,
                              bool isGenericSignature,
                              GenericTypeResolver *resolver);
 
@@ -797,7 +798,8 @@ class TypeChecker final : public LazyResolver {
   /// number of generic arguments given, whereas applyGenericArguments emits
   /// diagnostics in those cases.
   ///
-  /// \param unbound The unbound generic type to which to apply arguments.
+  /// \param type The unbound generic type to which to apply arguments.
+  /// \param decl The declaration of the type.
   /// \param loc The source location for diagnostic reporting.
   /// \param dc The context where the arguments are applied.
   /// \param genericArgs The list of generic arguments to apply to the type.
@@ -809,8 +811,8 @@ class TypeChecker final : public LazyResolver {
   /// error.
   ///
   /// \see applyGenericArguments
-  Type applyUnboundGenericArguments(UnboundGenericType *unbound, SourceLoc loc,
-                                    DeclContext *dc,
+  Type applyUnboundGenericArguments(Type type, GenericTypeDecl *decl,
+                                    SourceLoc loc, DeclContext *dc,
                                     MutableArrayRef<TypeLoc> genericArgs,
                                     bool isGenericSignature,
                                     GenericTypeResolver *resolver);