---

yaml
---
r: 348869
b: refs/heads/master
c: fac36f9
h: refs/heads/master
i:
  348867: 333aaf5

Author: slavapestov

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5669b9ec6a3f719dcf2b5058c086181b8e21473b
+refs/heads/master: fac36f95b0469766c0c0ce05b7d6543d8dc31c35
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/AST/Decl.cpp

@@ -2744,13 +2744,7 @@ void ValueDecl::setInterfaceType(Type type) {
   if (type) {
     assert(!type->hasTypeVariable() && "Type variable in interface type");
     assert(!type->is<InOutType>() && "Interface type must be materializable");
-
-    // ParamDecls in closure contexts can have type variables
-    // archetype in them during constraint generation.
-    if (!(isa<ParamDecl>(this) && isa<AbstractClosureExpr>(getDeclContext()))) {
-      assert(!type->hasArchetype() &&
-             "Archetype in interface type");
-    }
+    assert(!type->hasArchetype() && "Archetype in interface type");
 
     if (type->hasError())
       setInvalid();

trunk/lib/Sema/CSGen.cpp

@@ -2028,8 +2028,9 @@ namespace {
 
         // If a type was explicitly specified, use its opened type.
         if (auto type = param->getTypeLoc().getType()) {
+          paramType = closureExpr->mapTypeIntoContext(type);
           // FIXME: Need a better locator for a pattern as a base.
-          paramType = CS.openUnboundGenericType(type, locator);
+          paramType = CS.openUnboundGenericType(paramType, locator);
           internalType = paramType;
         } else {
           // Otherwise, create fresh type variables.

trunk/lib/Sema/TypeCheckConstraints.cpp

@@ -1350,8 +1350,7 @@ bool PreCheckExpression::walkToClosureExprPre(ClosureExpr *closure) {
   options |= TypeResolutionFlags::AllowUnboundGenerics;
   bool hadParameterError = false;
 
-  auto resolution = TypeResolution::forContextual(closure);
-  if (TC.typeCheckParameterList(PL, resolution, options)) {
+  if (TC.typeCheckParameterList(PL, closure, options)) {
     // If we encounter an error validating the parameter list, don't bail.
     // Instead, go on to validate any potential result type, and bail
     // afterwards.  This allows for better diagnostics, and keeps the
@@ -1361,8 +1360,9 @@ bool PreCheckExpression::walkToClosureExprPre(ClosureExpr *closure) {
 
   // Validate the result type, if present.
   if (closure->hasExplicitResultType() &&
-      TypeChecker::validateType(TC.Context, closure->getExplicitResultTypeLoc(),
-                                resolution,
+      TypeChecker::validateType(TC.Context,
+                                closure->getExplicitResultTypeLoc(),
+                                TypeResolution::forContextual(closure),
                                 TypeResolverContext::InExpression)) {
     return false;
   }

trunk/lib/Sema/TypeCheckDecl.cpp

@@ -4045,8 +4045,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
 
     // We want the function to be available for name lookup as soon
     // as it has a valid interface type.
-    auto resolution = TypeResolution::forInterface(FD);
-    typeCheckParameterList(FD->getParameters(), resolution,
+    typeCheckParameterList(FD->getParameters(), FD,
                            TypeResolverContext::AbstractFunctionDecl);
     validateResultType(FD, FD->getBodyResultTypeLoc());
     // FIXME: Roll all of this interface type computation into a request.
@@ -4072,8 +4071,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
 
     DeclValidationRAII IBV(CD);
 
-    auto res = TypeResolution::forInterface(CD);
-    typeCheckParameterList(CD->getParameters(), res,
+    typeCheckParameterList(CD->getParameters(), CD,
                            TypeResolverContext::AbstractFunctionDecl);
     CD->computeType();
     break;
@@ -4084,8 +4082,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
 
     DeclValidationRAII IBV(DD);
 
-    auto res = TypeResolution::forInterface(DD);
-    typeCheckParameterList(DD->getParameters(), res,
+    typeCheckParameterList(DD->getParameters(), DD,
                            TypeResolverContext::AbstractFunctionDecl);
     DD->computeType();
     break;
@@ -4096,8 +4093,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
 
     DeclValidationRAII IBV(SD);
 
-    auto res = TypeResolution::forInterface(SD);
-    typeCheckParameterList(SD->getIndices(), res,
+    typeCheckParameterList(SD->getIndices(), SD,
                            TypeResolverContext::SubscriptDecl);
     validateResultType(SD, SD->getElementTypeLoc());
     SD->computeType();
@@ -4112,8 +4108,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
     DeclValidationRAII IBV(EED);
 
     if (auto *PL = EED->getParameterList()) {
-      auto res = TypeResolution::forInterface(ED);
-      typeCheckParameterList(PL, res,
+      typeCheckParameterList(PL, ED,
                              TypeResolverContext::EnumElementDecl);
     }
 

trunk/lib/Sema/TypeCheckPattern.cpp

@@ -794,8 +794,10 @@ static bool validateParameterType(ParamDecl *decl, TypeResolution resolution,
 
 /// Type check a parameter list.
 bool TypeChecker::typeCheckParameterList(ParameterList *PL,
-                                         TypeResolution resolution,
+                                         DeclContext *dc,
                                          TypeResolutionOptions options) {
+  auto resolution = TypeResolution::forInterface(dc);
+
   bool hadError = false;
 
   for (auto param : *PL) {

trunk/lib/Sema/TypeChecker.h

@@ -1354,7 +1354,7 @@ class TypeChecker final : public LazyResolver {
   bool typeCheckCatchPattern(CatchStmt *S, DeclContext *dc);
 
   /// Type check a parameter list.
-  bool typeCheckParameterList(ParameterList *PL, TypeResolution resolution,
+  bool typeCheckParameterList(ParameterList *PL, DeclContext *dc,
                               TypeResolutionOptions options);
 
   /// Coerce a pattern to the given type.