---

yaml
---
r: 349381
b: refs/heads/master-next
c: 8aa3c7a
h: refs/heads/master
i:
  349379: 9827d7e

Author: swift-ci

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: fb3d28c00d8716fd4588670decdc1afc36e62717
+refs/heads/master-next: 8aa3c7a5ad8f77761314184a1f6af0c5132777bf
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/lib/Sema/CodeSynthesis.cpp

@@ -648,20 +648,27 @@ createDesignatedInitOverride(ClassDecl *classDecl,
   // Determine the initializer parameters.
 
   // Create the initializer parameter patterns.
-  OptionSet<ParameterList::CloneFlags> options = ParameterList::Implicit;
-  options |= ParameterList::Inherited;
-  auto *bodyParams = superclassCtor->getParameters()->clone(ctx, options);
+  OptionSet<ParameterList::CloneFlags> options
+    = (ParameterList::Implicit |
+       ParameterList::Inherited |
+       ParameterList::WithoutTypes);
+  auto *superclassParams = superclassCtor->getParameters();
+  auto *bodyParams = superclassParams->clone(ctx, options);
 
   // If the superclass is generic, we need to map the superclass constructor's
   // parameter types into the generic context of our class.
   //
   // We might have to apply substitutions, if for example we have a declaration
   // like 'class A : B<Int>'.
-  for (auto *decl : *bodyParams) {
-    auto paramTy = decl->getInterfaceType();
+  for (unsigned idx : range(superclassParams->size())) {
+    auto *superclassParam = superclassParams->get(idx);
+    auto *bodyParam = bodyParams->get(idx);
+
+    auto paramTy = superclassParam->getInterfaceType();
     auto substTy = paramTy.subst(subMap, SubstFlags::UseErrorType);
-    decl->setInterfaceType(substTy);
-    decl->getTypeLoc() = TypeLoc::withoutLoc(substTy);
+
+    bodyParam->setInterfaceType(substTy);
+    bodyParam->getTypeLoc() = TypeLoc::withoutLoc(substTy);
   }
 
   // Create the initializer declaration, inheriting the name,

branches/master-next/lib/Sema/TypeCheckDecl.cpp

@@ -3916,6 +3916,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
         auto newValueParam = valueParams->get(0);
         newValueParam->setInterfaceType(valueIfaceTy);
         newValueParam->getTypeLoc().setType(valueIfaceTy);
+        accessor->getBodyResultTypeLoc().setType(TupleType::getEmpty(Context));
         break;
       }
 
@@ -3932,6 +3933,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
       // If we add yield types to the function type, we'll need to update this.
       case AccessorKind::Read:
       case AccessorKind::Modify:
+        accessor->getBodyResultTypeLoc().setType(TupleType::getEmpty(Context));
         break;
       }
     }

branches/master-next/lib/Sema/TypeCheckGeneric.cpp

@@ -145,19 +145,6 @@ TypeChecker::gatherGenericParamBindingsText(
   return result.str().str();
 }
 
-static void revertDependentTypeLoc(TypeLoc &tl) {
-  // If there's no type representation, there's nothing to revert.
-  if (!tl.getTypeRepr())
-    return;
-
-  // Don't revert an error type; we've already complained.
-  if (tl.wasValidated() && tl.isError())
-    return;
-
-  // Make sure we validate the type again.
-  tl.setType(Type());
-}
-
 //
 // Generic functions
 //
@@ -592,42 +579,50 @@ void TypeChecker::validateGenericFuncOrSubscriptSignature(
                               ->getGenericSignatureOfContext(),
                           resolution);
 
-    // Check parameter patterns.
-    typeCheckParameterList(params, resolution, func
-                             ? TypeResolverContext::AbstractFunctionDecl
-                             : TypeResolverContext::SubscriptDecl);
+    // Infer requirements from the parameter list.
+    auto *module = genCtx->getParentModule();
+    TypeResolutionOptions options =
+      (func
+       ? TypeResolverContext::AbstractFunctionDecl
+       : TypeResolverContext::SubscriptDecl);
 
-    // Infer requirements from the pattern.
-    builder.inferRequirements(*genCtx->getParentModule(), params);
+    for (auto param : *params) {
+      auto *typeRepr = param->getTypeLoc().getTypeRepr();
+      if (typeRepr == nullptr)
+        continue;
 
-    // Check the result type, but leave opaque return types alone
-    // for structural checking.
-    if (!resultTyLoc.isNull() &&
-        !(resultTyLoc.getTypeRepr() &&
-          isa<OpaqueReturnTypeRepr>(resultTyLoc.getTypeRepr())))
-      validateType(resultTyLoc, resolution,
-                   TypeResolverContext::FunctionResult);
+      auto paramOptions = options;
+      paramOptions.setContext(param->isVariadic() ?
+                              TypeResolverContext::VariadicFunctionInput :
+                              TypeResolverContext::FunctionInput);
+      paramOptions |= TypeResolutionFlags::Direct;
+
+      auto type = resolution.resolveType(typeRepr, paramOptions);
+
+      if (auto *specifier = dyn_cast_or_null<SpecifierTypeRepr>(typeRepr))
+        typeRepr = specifier->getBase();
+
+      auto source = GenericSignatureBuilder::FloatingRequirementSource::
+          forInferred(typeRepr);
+      builder.inferRequirements(*module, type, typeRepr, source);
+    }
+
+    // Infer requirements from the result type.
+    auto *resultTypeRepr = resultTyLoc.getTypeRepr();
+    if (resultTypeRepr && !isa<OpaqueReturnTypeRepr>(resultTypeRepr)) {
+      TypeResolutionOptions resultOptions = TypeResolverContext::FunctionResult;
+
+      auto resultType = resolution.resolveType(resultTypeRepr, resultOptions);
 
-    // Infer requirements from it.
-    if (resultTyLoc.getTypeRepr()) {
       auto source = GenericSignatureBuilder::FloatingRequirementSource::
-          forInferred(resultTyLoc.getTypeRepr());
-      builder.inferRequirements(*genCtx->getParentModule(),
-                                resultTyLoc.getType(),
-                                resultTyLoc.getTypeRepr(), source);
+          forInferred(resultTypeRepr);
+      builder.inferRequirements(*module, resultType, resultTypeRepr, source);
     }
 
     // The signature is complete and well-formed. Determine
     // the type of the generic function or subscript.
     sig = std::move(builder).computeGenericSignature(decl->getLoc());
 
-    // The generic signature builder now has all of the requirements, although
-    // there might still be errors that have not yet been diagnosed. Revert the
-    // signature and type-check it again, completely.
-    revertDependentTypeLoc(resultTyLoc);
-    for (auto &param : *params)
-      revertDependentTypeLoc(param->getTypeLoc());
-
     // Debugging of the generic signature.
     if (Context.LangOpts.DebugGenericSignatures) {
       decl->dumpRef(llvm::errs());

branches/master-next/lib/Sema/TypeCheckStorage.cpp

@@ -426,21 +426,6 @@ static VarDecl *getFirstParamDecl(FuncDecl *fn) {
   return getParamDeclAtIndex(fn, 0);
 };
 
-
-static ParamDecl *buildArgument(SourceLoc loc, DeclContext *DC,
-                                StringRef name,
-                                Type interfaceType,
-                                ParamDecl::Specifier specifier,
-                                ASTContext &context) {
-  auto *param = new (context) ParamDecl(specifier, SourceLoc(), SourceLoc(),
-                                        Identifier(), loc,
-                                        context.getIdentifier(name),
-                                        DC);
-  param->setImplicit();
-  param->setInterfaceType(interfaceType);
-  return param;
-}
-
 /// Build a parameter list which can forward the formal index parameters of a
 /// declaration.
 ///
@@ -1648,8 +1633,6 @@ static AccessorDecl *createGetterPrototype(AbstractStorageDecl *storage,
                                            ASTContext &ctx) {
   SourceLoc loc = storage->getLoc();
 
-  GenericEnvironment *genericEnvironmentOfLazyAccessor = nullptr;
-
   ParamDecl *selfDecl = nullptr;
   if (storage->getDeclContext()->isTypeContext()) {
     if (storage->getAttrs().hasAttribute<LazyAttr>()) {
@@ -1660,8 +1643,6 @@ static AccessorDecl *createGetterPrototype(AbstractStorageDecl *storage,
         bindingDecl->getPatternEntryForVarDecl(varDecl).getInitContext());
 
       selfDecl = bindingInit->getImplicitSelfDecl();
-      genericEnvironmentOfLazyAccessor =
-        bindingInit->getGenericEnvironmentOfContext();
     }
   }
 
@@ -1674,16 +1655,14 @@ static AccessorDecl *createGetterPrototype(AbstractStorageDecl *storage,
   if (storage->isStatic())
     staticLoc = storage->getLoc();
 
-  auto storageInterfaceType = storage->getValueInterfaceType();
-
   auto getter = AccessorDecl::create(
       ctx, loc, /*AccessorKeywordLoc*/ loc,
       AccessorKind::Get, storage,
       staticLoc, StaticSpellingKind::None,
       /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
       genericParams,
       getterParams,
-      TypeLoc::withoutLoc(storageInterfaceType),
+      TypeLoc(),
       storage->getDeclContext());
 
   // If we're stealing the 'self' from a lazy initializer, set it now.
@@ -1692,18 +1671,6 @@ static AccessorDecl *createGetterPrototype(AbstractStorageDecl *storage,
   if (selfDecl)
     *getter->getImplicitSelfDeclStorage() = selfDecl;
 
-  // We need to install the generic environment here because:
-  // 1) validating the getter will change the implicit self decl's DC to it,
-  // 2) it's likely that the initializer will be type-checked before the
-  //    accessor (and therefore before the normal installation happens), and
-  // 3) type-checking a reference to the self decl will map its type into
-  //    its context, which requires an environment to be installed on that
-  //    context.
-  // We can safely use the enclosing environment because properties are never
-  // differently generic.
-  if (genericEnvironmentOfLazyAccessor)
-    getter->setGenericEnvironment(genericEnvironmentOfLazyAccessor);
-
   if (storage->isGetterMutating())
     getter->setSelfAccessKind(SelfAccessKind::Mutating);
   else
@@ -1733,20 +1700,22 @@ static AccessorDecl *createSetterPrototype(AbstractStorageDecl *storage,
   GenericParamList *genericParams = createAccessorGenericParams(storage);
 
   // Add a "(value : T, indices...)" argument list.
-  auto storageInterfaceType = storage->getValueInterfaceType();
-  auto valueDecl = buildArgument(storage->getLoc(), storage->getDeclContext(),
-                                 "value", storageInterfaceType,
-                                 ParamDecl::Specifier::Default, ctx);
-  auto *params = buildIndexForwardingParamList(storage, valueDecl, ctx);
+  auto *param = new (ctx) ParamDecl(ParamDecl::Specifier::Default,
+                                    SourceLoc(), SourceLoc(),
+                                    Identifier(), loc,
+                                    ctx.getIdentifier("value"),
+                                    storage->getDeclContext());
+  param->setImplicit();
+
+  auto *params = buildIndexForwardingParamList(storage, param, ctx);
 
-  Type setterRetTy = TupleType::getEmpty(ctx);
   auto setter = AccessorDecl::create(
       ctx, loc, /*AccessorKeywordLoc*/ SourceLoc(),
       AccessorKind::Set, storage,
       /*StaticLoc=*/SourceLoc(), StaticSpellingKind::None,
       /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
       genericParams, params,
-      TypeLoc::withoutLoc(setterRetTy),
+      TypeLoc(),
       storage->getDeclContext());
 
   if (isMutating)
@@ -1849,9 +1818,6 @@ SynthesizeAccessorRequest::evaluate(Evaluator &evaluator,
                                     AccessorKind kind) const {
   auto &ctx = storage->getASTContext();
 
-  if (!storage->hasInterfaceType())
-    ctx.getLazyResolver()->resolveDeclSignature(storage);
-
   switch (kind) {
   case AccessorKind::Get:
     return createGetterPrototype(storage, ctx);

branches/master-next/lib/Sema/TypeChecker.cpp

@@ -241,7 +241,7 @@ static void bindExtensionToNominal(ExtensionDecl *ext,
   nominal->addExtension(ext);
 }
 
-static void bindExtensions(SourceFile &SF, TypeChecker &TC) {
+static void bindExtensions(SourceFile &SF) {
   // Utility function to try and resolve the extended type without diagnosing.
   // If we succeed, we go ahead and bind the extension. Otherwise, return false.
   auto tryBindExtension = [&](ExtensionDecl *ext) -> bool {
@@ -413,7 +413,7 @@ void swift::performTypeChecking(SourceFile &SF, TopLevelContext &TLC,
     // Resolve extensions. This has to occur first during type checking,
     // because the extensions need to be wired into the AST for name lookup
     // to work.
-    bindExtensions(SF, TC);
+    bindExtensions(SF);
 
     // Look for bridging functions. This only matters when
     // -enable-source-import is provided.