---

yaml
---
r: 341415
b: refs/heads/rxwei-patch-1
c: 5430aa0
h: refs/heads/master
i:
  341413: 7d70261
  341411: 718f538
  341407: 860a5b7

Author: ravikandhadai

[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: 6bf46b9350edf9022cf12f1dfe46609fd813ce00
+refs/heads/rxwei-patch-1: 5430aa0b178bcff77e4fa3f619e030784b780a2f
 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/Builtins.def

@@ -551,6 +551,20 @@ BUILTIN_MISC_OPERATION(WillThrow, "willThrow", "", Special)
 /// poundAssert has type (Builtin.Int1, Builtin.RawPointer) -> ().
 BUILTIN_MISC_OPERATION(PoundAssert, "poundAssert", "", Special)
 
+// BUILTIN_MISC_OPERATION_WITH_SILGEN - Miscellaneous operations that are
+// specially emitted during SIL generation.
+#ifndef BUILTIN_MISC_OPERATION_WITH_SILGEN
+#define BUILTIN_MISC_OPERATION_WITH_SILGEN(Id, Name, Attrs, Overload) \
+  BUILTIN_MISC_OPERATION(Id, Name, Attrs, Overload)
+#endif
+
+/// globalStringTablePointer has type String -> Builtin.RawPointer.
+/// It returns an immortal, global string table pointer for strings constructed
+/// from string literals.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(GlobalStringTablePointer, "globalStringTablePointer", "", Special)
+
+#undef BUILTIN_MISC_OPERATION_WITH_SILGEN
+
 #undef BUILTIN_MISC_OPERATION
 
 /// Builtins for instrumentation added by sanitizers during SILGen.

branches/rxwei-patch-1/include/swift/AST/Identifier.h

@@ -264,8 +264,6 @@ class DeclBaseName {
 
   bool isSpecial() const { return getKind() != Kind::Normal; }
 
-  bool isSubscript() const { return getKind() == Kind::Subscript; }
-
   /// Return the identifier backing the name. Assumes that the name is not
   /// special.
   Identifier getIdentifier() const {

branches/rxwei-patch-1/lib/AST/Builtins.cpp

@@ -951,6 +951,13 @@ static ValueDecl *getGetObjCTypeEncodingOperation(ASTContext &Context,
   return builder.build(Id);
 }
 
+static ValueDecl *getGlobalStringTablePointer(ASTContext &Context,
+                                              Identifier Id) {
+  // String -> Builtin.RawPointer
+  auto stringType = NominalType::get(Context.getStringDecl(), Type(), Context);
+  return getBuiltinFunction(Id, {stringType}, Context.TheRawPointerType);
+}
+
 static ValueDecl *getPoundAssert(ASTContext &Context, Identifier Id) {
   auto int1Type = BuiltinIntegerType::get(1, Context);
   auto optionalRawPointerType = BoundGenericEnumType::get(
@@ -1960,6 +1967,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::GetObjCTypeEncoding:
     return getGetObjCTypeEncodingOperation(Context, Id);
 
+  case BuiltinValueKind::GlobalStringTablePointer:
+    return getGlobalStringTablePointer(Context, Id);
+
   case BuiltinValueKind::PoundAssert:
     return getPoundAssert(Context, Id);
 

branches/rxwei-patch-1/lib/IRGen/GenBuiltin.cpp

@@ -354,6 +354,18 @@ if (Builtin.ID == BuiltinValueKind::id) { \
 #define BUILTIN(ID, Name, Attrs)  // Ignore the rest.
 #include "swift/AST/Builtins.def"
 
+  if (Builtin.ID == BuiltinValueKind::GlobalStringTablePointer) {
+    // This builtin should be used only on strings constructed from a
+    // string literal. If we ever get to the point of executing this builtin
+    // at run time, it implies an incorrect use of the builtin and must result
+    // in a trap.
+    IGF.emitTrap(/*Unreachable=*/false);
+    auto returnValue = llvm::UndefValue::get(IGF.IGM.Int8PtrTy);
+    // Consume the arguments of the builtin.
+    (void)args.claimAll();
+    return out.add(returnValue);
+  }
+
   if (Builtin.ID == BuiltinValueKind::WillThrow) {
     // willThrow is emitted like a Swift function call with the error in
     // the error return register. We also have to pass a fake context

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

@@ -1057,6 +1057,16 @@ CONSTANT_OWNERSHIP_BUILTIN(Any, MustBeLive, Swift3ImplicitObjCEntrypoint)
 CONSTANT_OWNERSHIP_BUILTIN(Any, MustBeLive, PoundAssert)
 #undef CONSTANT_OWNERSHIP_BUILTIN
 
+// CONSTANT_OWNERSHIP_BUILTIN(Owned, MustBeLive, GlobalStringTablePointer)
+
+OperandOwnershipKindMap
+OperandOwnershipKindBuiltinClassifier::visitGlobalStringTablePointer(
+    BuiltinInst *bi, StringRef attr) {
+  return Map::compatibilityMap(
+      {{ValueOwnershipKind::Guaranteed, UseLifetimeConstraint::MustBeLive},
+       {ValueOwnershipKind::Owned, UseLifetimeConstraint::MustBeLive}});
+}
+
 // Builtins that should be lowered to SIL instructions so we should never see
 // them.
 #define BUILTIN_SIL_OPERATION(ID, NAME, CATEGORY)                              \

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

@@ -491,6 +491,7 @@ CONSTANT_OWNERSHIP_BUILTIN(Any, OnceWithContext)
 CONSTANT_OWNERSHIP_BUILTIN(Any, TSanInoutAccess)
 CONSTANT_OWNERSHIP_BUILTIN(Any, Swift3ImplicitObjCEntrypoint)
 CONSTANT_OWNERSHIP_BUILTIN(Any, PoundAssert)
+CONSTANT_OWNERSHIP_BUILTIN(Any, GlobalStringTablePointer)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 

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

@@ -4057,12 +4057,14 @@ CallEmission::applySpecializedEmitter(SpecializedEmitter &specializedEmitter,
     return firstLevelResult;
   }
 
-  // Builtins.
+  // Named Builtins.
   assert(specializedEmitter.isNamedBuiltin());
   auto builtinName = specializedEmitter.getBuiltinName();
   SmallVector<SILValue, 4> consumedArgs;
   for (auto arg : uncurriedArgs) {
-    // Builtins have a special convention that takes everything at +1.
+    // Named builtins are by default assumed to take all arguments at +1 i.e.,
+    // as Owned or Trivial. Named builtins that don't follow this convention
+    // must use a specialized emitter.
     auto maybePlusOne = arg.ensurePlusOne(SGF, uncurriedLoc.getValue());
     consumedArgs.push_back(maybePlusOne.forward(SGF));
   }

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

@@ -1028,6 +1028,28 @@ static ManagedValue emitBuiltinTypeTrait(SILGenFunction &SGF,
   return ManagedValue::forUnmanaged(val);
 }
 
+/// Emit SIL for the named builtin: globalStringTablePointer. Unlike the default
+/// ownership convention for named builtins, which is to take (non-trivial)
+/// arguments as Owned, this builtin accepts owned as well as guaranteed
+/// arguments, and hence doesn't require the arguments to be at +1. Therefore,
+/// this builtin is emitted specially.
+static ManagedValue
+emitBuiltinGlobalStringTablePointer(SILGenFunction &SGF, SILLocation loc,
+                                    SubstitutionMap subs,
+                                    ArrayRef<ManagedValue> args, SGFContext C) {
+  assert(args.size() == 1);
+
+  SILValue argValue = args[0].getValue();
+  auto &astContext = SGF.getASTContext();
+  Identifier builtinId = astContext.getIdentifier(
+      getBuiltinName(BuiltinValueKind::GlobalStringTablePointer));
+
+  auto resultVal = SGF.B.createBuiltin(loc, builtinId,
+                                       SILType::getRawPointerType(astContext),
+                                       subs, ArrayRef<SILValue>(argValue));
+  return SGF.emitManagedRValueWithCleanup(resultVal);
+}
+
 Optional<SpecializedEmitter>
 SpecializedEmitter::forDecl(SILGenModule &SGM, SILDeclRef function) {
   // Only consider standalone declarations in the Builtin module.
@@ -1052,6 +1074,7 @@ SpecializedEmitter::forDecl(SILGenModule &SGM, SILDeclRef function) {
 #define BUILTIN(Id, Name, Attrs)                                            \
   case BuiltinValueKind::Id:
 #define BUILTIN_SIL_OPERATION(Id, Name, Overload)
+#define BUILTIN_MISC_OPERATION_WITH_SILGEN(Id, Name, Attrs, Overload)
 #define BUILTIN_SANITIZER_OPERATION(Id, Name, Attrs)
 #define BUILTIN_TYPE_CHECKER_OPERATION(Id, Name)
 #define BUILTIN_TYPE_TRAIT_OPERATION(Id, Name)
@@ -1068,8 +1091,12 @@ SpecializedEmitter::forDecl(SILGenModule &SGM, SILDeclRef function) {
   case BuiltinValueKind::Id:                                                \
     return SpecializedEmitter(&emitBuiltin##Id);
 
-  // Sanitizer builtins should never directly be called; they should only
-  // be inserted as instrumentation by SILGen.
+#define BUILTIN_MISC_OPERATION_WITH_SILGEN(Id, Name, Attrs, Overload)          \
+  case BuiltinValueKind::Id:                                                   \
+    return SpecializedEmitter(&emitBuiltin##Id);
+
+    // Sanitizer builtins should never directly be called; they should only
+    // be inserted as instrumentation by SILGen.
 #define BUILTIN_SANITIZER_OPERATION(Id, Name, Attrs)                        \
   case BuiltinValueKind::Id:                                                \
     llvm_unreachable("Sanitizer builtin called directly?");

branches/rxwei-patch-1/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -130,6 +130,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::Swift3ImplicitObjCEntrypoint:
     case BuiltinValueKind::WillThrow:
     case BuiltinValueKind::PoundAssert:
+    case BuiltinValueKind::GlobalStringTablePointer:
       return false;
 
     // Handle some rare builtins that may be sensitive to object lifetime

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

@@ -3973,19 +3973,6 @@ bool swift::hasDynamicMemberLookupAttribute(Type type) {
   return ::hasDynamicMemberLookupAttribute(type, DynamicMemberLookupCache);
 }
 
-static bool isForKeyPathSubscript(ConstraintSystem &cs,
-                                  ConstraintLocator *locator) {
-  if (!locator || !locator->getAnchor())
-    return false;
-
-  if (auto *SE = dyn_cast<SubscriptExpr>(locator->getAnchor())) {
-    auto *indexExpr = dyn_cast<TupleExpr>(SE->getIndex());
-    return indexExpr && indexExpr->getNumElements() == 1 &&
-           indexExpr->getElementName(0) == cs.getASTContext().Id_keyPath;
-  }
-  return false;
-}
-
 /// Given a ValueMember, UnresolvedValueMember, or TypeMember constraint,
 /// perform a lookup into the specified base type to find a candidate list.
 /// The list returned includes the viable candidates as well as the unviable
@@ -4017,7 +4004,14 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
   MemberLookupResult result;
   result.OverallResult = MemberLookupResult::HasResults;
 
-  if (isForKeyPathSubscript(*this, memberLocator)) {
+  // If we're looking for a subscript, consider key path operations.
+  //
+  // TODO: This logic needs to be refactored to make sure that implicit
+  // keypath result is only introduced when it makes sense e.g. if there
+  // is a single argument with `keypath:` label or `\.` syntax is used.
+  if (memberName.isSimpleName() &&
+      memberName.getBaseName().getKind() == DeclBaseName::Kind::Subscript &&
+      !(memberLocator && memberLocator->isForKeyPathDynamicMemberLookup())) {
     if (baseTy->isAnyObject()) {
       result.addUnviable(
           OverloadChoice(baseTy, OverloadChoiceKind::KeyPathApplication),
@@ -4762,21 +4756,17 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
       performMemberLookup(kind, member, baseTy, functionRefKind, locator,
                           /*includeInaccessibleMembers*/ shouldAttemptFixes());
 
-  auto formUnsolved = [&] {
+  switch (result.OverallResult) {
+  case MemberLookupResult::Unsolved:
     // If requested, generate a constraint.
     if (flags.contains(TMF_GenerateConstraints)) {
-      addUnsolvedConstraint(Constraint::createMemberOrOuterDisjunction(
-          *this, kind, baseTy, memberTy, member, useDC, functionRefKind,
-          outerAlternatives, locator));
+      addUnsolvedConstraint(
+        Constraint::createMemberOrOuterDisjunction(*this, kind, baseTy, memberTy, member, useDC,
+                                                   functionRefKind, outerAlternatives, locator));
       return SolutionKind::Solved;
     }
 
     return SolutionKind::Unsolved;
-  };
-
-  switch (result.OverallResult) {
-  case MemberLookupResult::Unsolved:
-    return formUnsolved();
 
   case MemberLookupResult::ErrorAlreadyDiagnosed:
     return SolutionKind::Error;
@@ -4789,18 +4779,6 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
   SmallVector<Constraint *, 4> candidates;
   // If we found viable candidates, then we're done!
   if (!result.ViableCandidates.empty()) {
-    // If only possible choice to refer to member is via keypath
-    // dynamic member dispatch, let's delay solving this constraint
-    // until constraint generation phase is complete, because
-    // subscript dispatch relies on presence of function application.
-    if (result.ViableCandidates.size() == 1) {
-      auto &choice = result.ViableCandidates.front();
-      if (!solverState && choice.isKeyPathDynamicMemberLookup() &&
-          member.getBaseName().isSubscript()) {
-        return formUnsolved();
-      }
-    }
-
     generateConstraints(
         candidates, memberTy, result.ViableCandidates, useDC, locator,
         result.getFavoredIndex(), /*requiresFix=*/false,
@@ -5877,11 +5855,7 @@ Type ConstraintSystem::simplifyAppliedOverloads(
     }
 
     // FIXME: Could also rewrite fnType to include this result type.
-    // Introduction of `Bind` constraint here could result in the disconnect
-    // in the constraint system with unintended consequences because e.g.
-    // in case of key path application it could disconnect one of the
-    // components like subscript from the rest of the context.
-    addConstraint(ConstraintKind::Equal, argFnType->getResult(),
+    addConstraint(ConstraintKind::Bind, argFnType->getResult(),
                   commonResultType, locator);
   }
 

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

@@ -256,10 +256,6 @@ class OverloadChoice {
   /// unwrapped.
   bool isImplicitlyUnwrappedValueOrReturnValue() const;
 
-  bool isKeyPathDynamicMemberLookup() const {
-    return getKind() == OverloadChoiceKind::KeyPathDynamicMemberLookup;
-  }
-
   /// Get the name of the overload choice.
   DeclName getName() const;
 

branches/rxwei-patch-1/test/Constraints/overload_filtering.swift

@@ -26,7 +26,8 @@ struct X {
 }
 
 func testSubscript(x: X, i: Int) {
-  // CHECK: disabled disjunction term {{.*}}X.subscript(_:)
+  // CHECK: disabled disjunction term {{.*}} bound to key path application
+  // CHECK-NEXT: disabled disjunction term {{.*}}X.subscript(_:)
   // CHECK-NEXT: disabled disjunction term {{.*}}X.subscript(_:_:_:)
   // CHECK-NEXT: introducing single enabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.subscript(_:_:)
   _ = x[i, i]

branches/rxwei-patch-1/test/IRGen/builtins.swift

@@ -804,7 +804,15 @@ enum MyError : Error {
 
 throw MyError.A
 
+/// Builtin.globalStringTablePointer must be reduced to a string_literal instruction before IRGen. IRGen
+/// should make this a trap.
+// CHECK-LABEL: define {{.*}}globalStringTablePointer
+// CHECK: call void @llvm.trap()
+// CHECK: ret i8* undef
+func globalStringTablePointerUse(_ str: String) -> Builtin.RawPointer {
+  return Builtin.globalStringTablePointer(str);
+}
 
 
-// CHECK: ![[R]] = !{i64 0, i64 9223372036854775807}
 
+// CHECK: ![[R]] = !{i64 0, i64 9223372036854775807}

branches/rxwei-patch-1/test/expr/unary/keypath/keypath.swift

@@ -128,6 +128,8 @@ func testKeyPath(sub: Sub, optSub: OptSub,
   let _: ReferenceWritableKeyPath<A, Prop> = \.property
   //expected-error@-1 {{cannot convert value of type 'WritableKeyPath<A, Prop>' to specified type 'ReferenceWritableKeyPath<A, Prop>'}}
 
+  // FIXME: shouldn't be ambiguous
+  // expected-error@+1{{ambiguous}}
   let _: PartialKeyPath<A> = \.[sub]
   let _: KeyPath<A, A> = \.[sub]
   let _: WritableKeyPath<A, A> = \.[sub]