---

yaml
---
r: 341407
b: refs/heads/rxwei-patch-1
c: f3655ed
h: refs/heads/master
i:
  341405: 96be4ac
  341403: aedd6ea
  341399: 8186b18
  341391: 50801cd
  341375: 2994580

Author: compnerd

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: ccc0a8980ee05ed9910dc048e0c9f43b34b1e8e9
+refs/heads/rxwei-patch-1: f3655ed5b482362759304d970f5e26e9050430de
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/include/swift/AST/DiagnosticsSIL.def

@@ -113,12 +113,6 @@ ERROR(unsupported_c_function_pointer_conversion,none,
       "C function pointer signature %0 is not compatible with expected type %1",
       (Type, Type))
 
-ERROR(c_function_pointer_from_function_with_context,none,
-      "a C function pointer cannot be formed from a "
-      "%select{local function|closure}0 that captures "
-      "%select{context|generic parameters|dynamic Self type|<<error>}1",
-      (bool, unsigned))
-
 ERROR(objc_selector_malformed,none,"the type ObjectiveC.Selector is malformed",
       ())
 

branches/rxwei-patch-1/include/swift/AST/DiagnosticsSema.def

@@ -1121,6 +1121,11 @@ ERROR(c_function_pointer_from_method,none,
 ERROR(c_function_pointer_from_generic_function,none,
       "a C function pointer cannot be formed from a reference to a generic "
       "function", ())
+ERROR(c_function_pointer_from_function_with_context,none,
+      "a C function pointer cannot be formed from a "
+      "%select{local function|closure}0 that captures "
+      "%select{context|generic parameters|dynamic Self type|<<error>}1",
+      (bool, unsigned))
 ERROR(invalid_autoclosure_forwarding,none,
       "add () to forward @autoclosure parameter", ())
 
@@ -3332,9 +3337,6 @@ ERROR(trailing_closure_requires_parens,none,
       "trailing closure requires parentheses for disambiguation in this"
       " context", ())
 
-ERROR(opaque_type_var_no_init,none,
-      "property declares an opaque return type, but has no initializer "
-      "expression from which to infer an underlying type", ())
 ERROR(opaque_type_no_underlying_type_candidates,none,
       "function declares an opaque return type, but has no return statements "
       "in its body from which to infer an underlying type", ())
@@ -3346,9 +3348,6 @@ NOTE(opaque_type_underlying_type_candidate_here,none,
 ERROR(opaque_type_self_referential_underlying_type,none,
       "function opaque return type was inferred as %0, which defines the "
       "opaque type in terms of itself", (Type))
-ERROR(opaque_type_var_no_underlying_type,none,
-      "property declares an opaque return type, but cannot infer the "
-      "underlying type from its initializer expression", ())
 
 //------------------------------------------------------------------------------
 // MARK: Type Check Patterns

branches/rxwei-patch-1/lib/Frontend/CompilerInvocation.cpp

@@ -89,6 +89,10 @@ static void updateRuntimeLibraryPaths(SearchPathOptions &SearchPathOpts,
   if (!SearchPathOpts.SDKPath.empty()) {
     LibPath = SearchPathOpts.SDKPath;
     llvm::sys::path::append(LibPath, "usr", "lib", "swift");
+    if (!Triple.isOSDarwin()) {
+      llvm::sys::path::append(LibPath, getPlatformNameForTriple(Triple));
+      llvm::sys::path::append(LibPath, swift::getMajorArchitectureName(Triple));
+    }
     SearchPathOpts.RuntimeLibraryImportPaths.push_back(LibPath.str());
   }
 }

branches/rxwei-patch-1/lib/IDE/Formatting.cpp

@@ -355,20 +355,6 @@ class FormatContext {
       }
     }
 
-    // func foo(a: Int,
-    //          b: Int
-    // ) {} <- Avoid adding indentation here
-    SourceLoc SignatureEnd;
-    if (auto *AFD = dyn_cast_or_null<AbstractFunctionDecl>(Cursor->getAsDecl())) {
-      SignatureEnd = AFD->getSignatureSourceRange().End;
-    } else if (auto *SD = dyn_cast_or_null<SubscriptDecl>(Cursor->getAsDecl())) {
-      SignatureEnd = SD->getSignatureSourceRange().End;
-    }
-    if (SignatureEnd.isValid() && TInfo &&
-        TInfo.StartOfLineTarget->getLoc() == SignatureEnd) {
-      return false;
-    }
-
     // If we're at the beginning of a brace on a separate line in the context
     // of anything other than BraceStmt, don't add an indent.
     // For example:

branches/rxwei-patch-1/lib/SIL/TypeLowering.cpp

@@ -436,7 +436,7 @@ namespace {
       }
       assert(props.isFixedABI() && "unsupported combination for now");
       if (props.isTrivial()) {
-        return asImpl().handleTrivial(type, props);
+        return asImpl().handleTrivial(type);
       }
       return asImpl().handleNonTrivialAggregate(type, props);
     }
@@ -1532,10 +1532,8 @@ TypeConverter::getTypeLowering(AbstractionPattern origType,
 
   if (prev == nullptr)
     insert(key, lowering);
-  else {
+  else
     prev->NextExpansion = lowering;
-    assert(prev->isResilient() == lowering->isResilient());
-  }
 
   return *lowering;
 }
@@ -1682,10 +1680,9 @@ TypeConverter::getTypeLoweringForLoweredType(TypeKey key,
                        forExpansion,
                        key.isDependent()).visit(key.SubstType);
 
-  if (prev) {
+  if (prev)
     prev->NextExpansion = lowering;
-    assert(prev->isResilient() == lowering->isResilient());
-  } else
+  else
     insert(key, lowering);
   return *lowering;
 }

branches/rxwei-patch-1/lib/SILGen/SILGenExpr.cpp

@@ -1514,57 +1514,17 @@ ManagedValue emitCFunctionPointer(SILGenFunction &SGF,
   } else if (auto memberRef = dyn_cast<MemberRefExpr>(semanticExpr)) {
     setLocFromConcreteDeclRef(memberRef->getMember());
   } else if (auto closure = dyn_cast<AbstractClosureExpr>(semanticExpr)) {
-    // Emit the closure body.
-    SGF.SGM.emitClosure(closure);
-
     loc = closure;
-  } else if (auto captureList = dyn_cast<CaptureListExpr>(semanticExpr)) {
-    // Ensure that weak captures are in a separate scope.
-    DebugScope scope(SGF, CleanupLocation(captureList));
-    // CaptureListExprs evaluate their bound variables.
-    for (auto capture : captureList->getCaptureList()) {
-      SGF.visit(capture.Var);
-      SGF.visit(capture.Init);
-    }
-
     // Emit the closure body.
-    auto *closure = captureList->getClosureBody();
     SGF.SGM.emitClosure(closure);
-
-    loc = closure;
   } else {
     llvm_unreachable("c function pointer converted from a non-concrete decl ref");
   }
 
   // Produce a reference to the C-compatible entry point for the function.
-  SILDeclRef constant(loc, /*curried*/ false, /*foreign*/ true);
+  SILDeclRef constant(loc, /*uncurryLevel*/ 0, /*foreign*/ true);
   SILConstantInfo constantInfo = SGF.getConstantInfo(constant);
 
-  // C function pointers cannot capture anything from their context.
-  auto captures = SGF.SGM.Types.getLoweredLocalCaptures(
-    *constant.getAnyFunctionRef());
-
-  if (captures.hasGenericParamCaptures() ||
-      captures.hasDynamicSelfCapture() ||
-      captures.hasLocalCaptures() ||
-      captures.hasOpaqueValueCapture()) {
-    unsigned kind;
-    if (captures.hasLocalCaptures())
-      kind = 0;
-    else if (captures.hasGenericParamCaptures())
-      kind = 1;
-    else if (captures.hasLocalCaptures())
-      kind = 2;
-    else
-      kind = 3;
-    SGF.SGM.diagnose(expr->getLoc(),
-                     diag::c_function_pointer_from_function_with_context,
-                     /*closure*/ constant.hasClosureExpr(),
-                     kind);
-
-    return SGF.emitUndef(constantInfo.getSILType());
-  }
-
   return convertCFunctionSignature(
                     SGF, conversionExpr,
                     constantInfo.getSILType(),
@@ -2347,7 +2307,7 @@ RValue RValueEmitter::visitDynamicTypeExpr(DynamicTypeExpr *E, SGFContext C) {
 RValue RValueEmitter::visitCaptureListExpr(CaptureListExpr *E, SGFContext C) {
   // Ensure that weak captures are in a separate scope.
   DebugScope scope(SGF, CleanupLocation(E));
-  // CaptureListExprs evaluate their bound variables.
+  // ClosureExpr's evaluate their bound variables.
   for (auto capture : E->getCaptureList()) {
     SGF.visit(capture.Var);
     SGF.visit(capture.Init);

branches/rxwei-patch-1/lib/Sema/CSApply.cpp

@@ -5795,6 +5795,8 @@ maybeDiagnoseUnsupportedFunctionConversion(ConstraintSystem &cs, Expr *expr,
       } else if (fn->getGenericParams()) {
         tc.diagnose(expr->getLoc(),
                     diag::c_function_pointer_from_generic_function);
+      } else {
+        tc.maybeDiagnoseCaptures(expr, fn);
       }
     };
 
@@ -5815,8 +5817,10 @@ maybeDiagnoseUnsupportedFunctionConversion(ConstraintSystem &cs, Expr *expr,
       semanticExpr = capture->getClosureBody();
 
     // Can convert a literal closure that doesn't capture context.
-    if (auto closure = dyn_cast<ClosureExpr>(semanticExpr))
+    if (auto closure = dyn_cast<ClosureExpr>(semanticExpr)) {
+      tc.maybeDiagnoseCaptures(expr, closure);
       return;
+    }
 
     tc.diagnose(expr->getLoc(),
                 diag::invalid_c_function_pointer_conversion_expr);

branches/rxwei-patch-1/lib/Sema/CSDiag.cpp

@@ -6686,10 +6686,10 @@ bool FailureDiagnosis::diagnoseMemberFailures(
       }
 
       if (!optionalResult.ViableCandidates.empty()) {
-        MemberAccessOnOptionalBaseFailure failure(
-            expr, CS, CS.getConstraintLocator(baseExpr), memberName,
-            /*resultOptional=*/false);
-        return failure.diagnoseAsError();
+        if (diagnoseBaseUnwrapForMemberAccess(baseExpr, baseObjTy, memberName,
+                                              /* additionalOptional= */ false,
+                                              memberRange))
+          return true;
       }
     }
 
@@ -7329,3 +7329,31 @@ ValueDecl *ConstraintSystem::findResolvedMemberRef(ConstraintLocator *locator) {
 
   return nullptr;
 }
+
+bool swift::diagnoseBaseUnwrapForMemberAccess(Expr *baseExpr, Type baseType,
+                                              DeclName memberName,
+                                              bool resultOptional,
+                                              SourceRange memberRange) {
+  auto unwrappedBaseType = baseType->getOptionalObjectType();
+  if (!unwrappedBaseType)
+    return false;
+
+  ASTContext &ctx = baseType->getASTContext();
+  DiagnosticEngine &diags = ctx.Diags;
+  diags.diagnose(baseExpr->getLoc(), diag::optional_base_not_unwrapped,
+                 baseType, memberName, unwrappedBaseType);
+
+  // FIXME: It would be nice to immediately offer "base?.member ?? defaultValue"
+  // for non-optional results where that would be appropriate. For the moment
+  // always offering "?" means that if the user chooses chaining, we'll end up
+  // in MissingOptionalUnwrapFailure:diagnose() to offer a default value during
+  // the next compile.
+  diags.diagnose(baseExpr->getLoc(), diag::optional_base_chain, memberName)
+    .fixItInsertAfter(baseExpr->getEndLoc(), "?");
+
+  if (!resultOptional) {
+    diags.diagnose(baseExpr->getLoc(), diag::unwrap_with_force_value)
+        .fixItInsertAfter(baseExpr->getEndLoc(), "!");
+  }
+  return true;
+}

branches/rxwei-patch-1/lib/Sema/CSDiagnostics.cpp

@@ -886,7 +886,7 @@ bool MemberAccessOnOptionalBaseFailure::diagnoseAsError() {
     return false;
 
   auto *anchor = getAnchor();
-  auto baseType = getType(anchor)->getRValueType();
+  auto type = getType(anchor)->getRValueType();
   bool resultIsOptional = ResultTypeIsOptional;
 
   // If we've resolved the member overload to one that returns an optional
@@ -897,27 +897,8 @@ bool MemberAccessOnOptionalBaseFailure::diagnoseAsError() {
   if (overload && overload->ImpliedType->getOptionalObjectType())
     resultIsOptional = true;
 
-  auto unwrappedBaseType = baseType->getOptionalObjectType();
-  if (!unwrappedBaseType)
-    return false;
-
-  emitDiagnostic(anchor->getLoc(), diag::optional_base_not_unwrapped,
-                 baseType, Member, unwrappedBaseType);
-
-  // FIXME: It would be nice to immediately offer "base?.member ?? defaultValue"
-  // for non-optional results where that would be appropriate. For the moment
-  // always offering "?" means that if the user chooses chaining, we'll end up
-  // in MissingOptionalUnwrapFailure:diagnose() to offer a default value during
-  // the next compile.
-  emitDiagnostic(anchor->getLoc(), diag::optional_base_chain, Member)
-      .fixItInsertAfter(anchor->getEndLoc(), "?");
-
-  if (!resultIsOptional) {
-    emitDiagnostic(anchor->getLoc(), diag::unwrap_with_force_value)
-      .fixItInsertAfter(anchor->getEndLoc(), "!");
-  }
-
-  return true;
+  return diagnoseBaseUnwrapForMemberAccess(anchor, type, Member,
+                                           resultIsOptional, SourceRange());
 }
 
 void MissingOptionalUnwrapFailure::offerDefaultValueUnwrapFixIt(
@@ -2153,15 +2134,9 @@ bool MissingMemberFailure::diagnoseAsError() {
   };
 
   if (getName().getBaseName().getKind() == DeclBaseName::Kind::Subscript) {
-    auto loc = anchor->getLoc();
-    if (auto *metatype = baseType->getAs<MetatypeType>()) {
-      emitDiagnostic(loc, diag::could_not_find_type_member,
-                     metatype->getInstanceType(), getName())
+    emitDiagnostic(anchor->getLoc(), diag::could_not_find_value_subscript,
+                   baseType)
         .highlight(baseExpr->getSourceRange());
-    } else {
-      emitDiagnostic(loc, diag::could_not_find_value_subscript, baseType)
-        .highlight(baseExpr->getSourceRange());
-    }
   } else if (getName().getBaseName() == "deinit") {
     // Specialised diagnostic if trying to access deinitialisers
     emitDiagnostic(anchor->getLoc(), diag::destructor_not_accessible)

branches/rxwei-patch-1/lib/Sema/CSSolver.cpp

@@ -1208,8 +1208,7 @@ ConstraintSystem::solveImpl(Expr *&expr,
     auto constraintKind = ConstraintKind::Conversion;
 
     if ((getContextualTypePurpose() == CTP_ReturnStmt ||
-         getContextualTypePurpose() == CTP_ReturnSingleExpr ||
-         getContextualTypePurpose() == CTP_Initialization)
+         getContextualTypePurpose() == CTP_ReturnSingleExpr)
         && Options.contains(ConstraintSystemFlags::UnderlyingTypeForOpaqueReturnType))
       constraintKind = ConstraintKind::OpaqueUnderlyingType;
 

branches/rxwei-patch-1/lib/Sema/ConstraintSystem.h

@@ -4245,6 +4245,14 @@ class InputMatcher {
   size_t getNumSkippedParameters() const { return NumSkippedParameters; }
 };
 
+/// Diagnose an attempt to recover from a member access into a value of
+/// optional type which needed to be unwrapped for the member to be found.
+///
+/// \returns true if a diagnostic was produced.
+bool diagnoseBaseUnwrapForMemberAccess(Expr *baseExpr, Type baseType,
+                                       DeclName memberName, bool resultOptional,
+                                       SourceRange memberRange);
+
 // Return true if, when replacing "<expr>" with "<expr> ?? T", parentheses need
 // to be added around <expr> first in order to maintain the correct precedence.
 bool exprNeedsParensBeforeAddingNilCoalescing(TypeChecker &TC,

branches/rxwei-patch-1/lib/Sema/TypeCheckCaptures.cpp

@@ -590,6 +590,35 @@ class FindCapturedVars : public ASTWalker {
 
 } // end anonymous namespace
 
+void TypeChecker::maybeDiagnoseCaptures(Expr *E, AnyFunctionRef AFR) {
+  if (!AFR.getCaptureInfo().hasBeenComputed()) {
+    // The capture list is not always initialized by the point we reference
+    // it. Remember we formed a C function pointer so we can diagnose later
+    // if necessary.
+    LocalCFunctionPointers[AFR].push_back(E);
+    return;
+  }
+
+  if (AFR.getCaptureInfo().hasGenericParamCaptures() ||
+      AFR.getCaptureInfo().hasDynamicSelfCapture() ||
+      AFR.getCaptureInfo().hasLocalCaptures() ||
+      AFR.getCaptureInfo().hasOpaqueValueCapture()) {
+    unsigned kind;
+    if (AFR.getCaptureInfo().hasLocalCaptures())
+      kind = 0;
+    else if (AFR.getCaptureInfo().hasGenericParamCaptures())
+      kind = 1;
+    else if (AFR.getCaptureInfo().hasLocalCaptures())
+      kind = 2;
+    else
+      kind = 3;
+    diagnose(E->getLoc(),
+             diag::c_function_pointer_from_function_with_context,
+             /*closure*/ AFR.getAbstractClosureExpr() != nullptr,
+             kind);
+  }
+}
+
 void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
   if (AFR.getCaptureInfo().hasBeenComputed())
     return;
@@ -642,6 +671,13 @@ void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
       }
     }
   }
+
+  // Diagnose if we have local captures and there were C pointers formed to
+  // this function before we computed captures.
+  auto cFunctionPointers = LocalCFunctionPointers.find(AFR);
+  if (cFunctionPointers != LocalCFunctionPointers.end())
+    for (auto *expr : cFunctionPointers->second)
+      maybeDiagnoseCaptures(expr, AFR);
 }
 
 void TypeChecker::checkPatternBindingCaptures(NominalTypeDecl *typeDecl) {