xxx

Author: hamishknight

include/swift/AST/Types.h

@@ -455,11 +455,11 @@ class alignas(1 << TypeAlignInBits) TypeBase
     NumProtocols : 16
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(TypeVariableType, TypeBase, 7+28,
+  SWIFT_INLINE_BITFIELD_FULL(TypeVariableType, TypeBase, 8+26,
     /// Type variable options.
-    Options : 7,
+    Options : 8,
     /// The unique number assigned to this type variable.
-    ID : 27
+    ID : 26
   );
 
   SWIFT_INLINE_BITFIELD_FULL(ErrorUnionType, TypeBase, 32,

include/swift/Sema/ConstraintLocator.h

@@ -238,6 +238,9 @@ class ConstraintLocator : public llvm::FoldingSetNode {
   /// e.g. `foo[0]` or `\Foo.[0]`
   bool isSubscriptMemberRef() const;
 
+  bool isClosureParameterType() const;
+  bool isClosureResultType() const;
+
   /// Determine whether give locator points to the type of the
   /// key path expression.
   bool isKeyPathType() const;

include/swift/Sema/ConstraintSystem.h

@@ -318,6 +318,10 @@ enum TypeVariableOptions {
 
   /// Whether the type variable can be bound only to a pack expansion type.
   TVO_PackExpansion = 0x40,
+
+  /// Whether the hole for this type variable origates from a different
+  /// type variable in the equivalence class.
+  TVO_NonRepresentativeHole = 0x80,
 };
 
 enum class KeyPathMutability : uint8_t {
@@ -397,6 +401,8 @@ class TypeVariableType::Implementation {
   /// Whether this type variable can bind only to PackExpansionType.
   bool isPackExpansion() const { return getRawOptions() & TVO_PackExpansion; }
 
+  bool isNonRepresentativeHole() const { return getRawOptions() & TVO_NonRepresentativeHole; }
+
   /// Whether this type variable prefers a subtype binding over a supertype
   /// binding.
   bool prefersSubtypeBinding() const {
@@ -588,6 +594,12 @@ class TypeVariableType::Implementation {
         recordBinding(*trail);
       getTypeVariable()->Bits.TypeVariableType.Options &= ~TVO_CanBindToPack;
     }
+
+    if (!canBindToHole() && otherRep->getImpl().canBindToHole()) {
+      if (trail)
+        recordBinding(*trail);
+      getTypeVariable()->Bits.TypeVariableType.Options |= (TVO_CanBindToHole | TVO_NonRepresentativeHole);
+    }
   }
 
   /// Retrieve the fixed type that corresponds to this type variable,
@@ -701,6 +713,7 @@ class TypeVariableType::Implementation {
     ENTRY(TVO_PrefersSubtypeBinding, "");
     ENTRY(TVO_CanBindToPack, "pack");
     ENTRY(TVO_PackExpansion, "pack expansion");
+    ENTRY(TVO_NonRepresentativeHole, "non-rep hole");
     }
   #undef ENTRY
   }
@@ -3485,6 +3498,8 @@ class ConstraintSystem {
   getImplicitValueConversionLocator(ConstraintLocatorBuilder root,
                                     ConversionRestrictionKind restriction);
 
+  ConstraintLocator *getHoleLocator(TypeVariableType *tv);
+
   /// Lookup and return parent associated with given expression.
   Expr *getParentExpr(Expr *expr) {
     if (auto result = getExprDepthAndParent(expr))

lib/Sema/CSBindings.cpp

@@ -170,7 +170,7 @@ bool BindingSet::isDelayed() const {
     return true;
 
   if (isHole()) {
-    auto *locator = TypeVar->getImpl().getLocator();
+    auto *locator = CS.getHoleLocator(TypeVar);
     assert(locator && "a hole without locator?");
 
     // Delay resolution of the code completion expression until
@@ -2735,7 +2735,7 @@ bool TypeVarBindingProducer::computeNext() {
 
 std::optional<std::pair<ConstraintFix *, unsigned>>
 TypeVariableBinding::fixForHole(ConstraintSystem &cs) const {
-  auto *dstLocator = TypeVar->getImpl().getLocator();
+  auto *dstLocator = cs.getHoleLocator(TypeVar);
   auto *srcLocator = Binding.getLocator();
 
   // FIXME: This check could be turned into an assert once
@@ -2756,7 +2756,7 @@ TypeVariableBinding::fixForHole(ConstraintSystem &cs) const {
 
   unsigned defaultImpact = 1;
 
-  if (auto *GP = TypeVar->getImpl().getGenericParameter()) {
+  if (auto *GP = dstLocator->getGenericParameter()) {
     // If it is representative for a key path root, let's emit a more
     // specific diagnostic.
     auto *keyPathRoot =
@@ -2776,12 +2776,12 @@ TypeVariableBinding::fixForHole(ConstraintSystem &cs) const {
     }
   }
 
-  if (TypeVar->getImpl().isClosureParameterType()) {
+  if (dstLocator->isClosureParameterType()) {
     ConstraintFix *fix = SpecifyClosureParameterType::create(cs, dstLocator);
     return std::make_pair(fix, defaultImpact);
   }
 
-  if (TypeVar->getImpl().isClosureResultType()) {
+  if (dstLocator->isClosureResultType()) {
     auto *closure = castToExpr<ClosureExpr>(dstLocator->getAnchor());
     // If the whole body is being ignored due to a pre-check failure,
     // let's not record a fix about result type since there is

lib/Sema/ConstraintLocator.cpp

@@ -561,6 +561,22 @@ bool ConstraintLocator::isSubscriptMemberRef() const {
   return path.back().getKind() == ConstraintLocator::SubscriptMember;
 }
 
+bool ConstraintLocator::isClosureParameterType() const {
+  if (!getAnchor())
+    return false;
+
+  return isExpr<ClosureExpr>(getAnchor()) &&
+         isLastElement<LocatorPathElt::TupleElement>();
+}
+
+bool ConstraintLocator::isClosureResultType() const {
+  if (!getAnchor())
+    return false;
+
+  return isExpr<ClosureExpr>(getAnchor()) &&
+         isLastElement<LocatorPathElt::ClosureResult>();
+}
+
 bool ConstraintLocator::isKeyPathType() const {
   auto anchor = getAnchor();
   auto path = getPath();

lib/Sema/ConstraintSystem.cpp

@@ -904,6 +904,26 @@ ConstraintLocator *ConstraintSystem::getOpenOpaqueLocator(
       { LocatorPathElt::OpenedOpaqueArchetype(opaqueDecl) }, 0);
 }
 
+ConstraintLocator *ConstraintSystem::getHoleLocator(TypeVariableType *tv) {
+  if (!tv->getImpl().isNonRepresentativeHole())
+    return tv->getImpl().getLocator();
+
+  // If we have a non-representative hole, the actual locator is given by
+  // a member of its equivalence class. Pick the the one with the lowest ID to
+  // ensure consistency.
+  TypeVariableType *candidate = nullptr;
+  for (auto equiv : CG[tv].getEquivalenceClass()) {
+    if (equiv == tv || !equiv->getImpl().canBindToHole())
+      continue;
+
+    if (!candidate || candidate->getID() > equiv->getID())
+      candidate = equiv;
+  }
+  ASSERT(candidate &&
+         "Non-representative hole ought to have hole in its equivalence class");
+  return candidate->getImpl().getLocator();
+}
+
 std::pair<Type, ExistentialArchetypeType *>
 ConstraintSystem::openAnyExistentialType(Type type,
                                          ConstraintLocator *locator) {
@@ -5284,7 +5304,7 @@ TypeVarBindingProducer::TypeVarBindingProducer(BindingSet &bindings)
                       bindings.getTypeVariable()->getImpl().getLocator()),
       TypeVar(bindings.getTypeVariable()), CanBeNil(bindings.canBeNil()) {
   if (bindings.isDirectHole()) {
-    auto *locator = getLocator();
+    auto *locator = CS.getHoleLocator(TypeVar);
     // If this type variable is associated with a code completion token
     // and it failed to infer any bindings let's adjust holes's locator
     // to point to a code completion token to avoid attempting to "fix"

lib/Sema/TypeCheckConstraints.cpp

@@ -119,19 +119,11 @@ bool TypeVariableType::Implementation::isTapType() const {
 }
 
 bool TypeVariableType::Implementation::isClosureParameterType() const {
-  if (!(locator && locator->getAnchor()))
-    return false;
-
-  return isExpr<ClosureExpr>(locator->getAnchor()) &&
-         locator->isLastElement<LocatorPathElt::TupleElement>();
+  return locator && locator->isClosureParameterType();
 }
 
 bool TypeVariableType::Implementation::isClosureResultType() const {
-  if (!(locator && locator->getAnchor()))
-    return false;
-
-  return isExpr<ClosureExpr>(locator->getAnchor()) &&
-         locator->isLastElement<LocatorPathElt::ClosureResult>();
+  return locator && locator->isClosureResultType();
 }
 
 bool TypeVariableType::Implementation::isKeyPathType() const {

test/Constraints/diagnostics.swift

@@ -1578,3 +1578,13 @@ func testAddMemberVsRemoveCall() {
   let b = Foo_74617()
   let c = (a + b).bar() // expected-error {{cannot call value of non-function type 'Float'}} {{22-24=}}
 }
+
+func testArrayLiteralMetatypeMismatch() {
+  // Make sure we can correctly turn 'T' into a hole here.
+  func foo<T>(_ xs: T.Type, _: Int) -> T {} // expected-note {{in call to function 'foo'}}
+  func foo(_ i: Int) {}
+  let x = foo([], i)
+  // expected-error@-1 {{generic parameter 'T' could not be inferred}}
+  // expected-error@-2 {{cannot convert value of type '[Any]' to expected argument type '_.Type'}}
+  // FIXME: The above should say `T.Type` not `_.Type` ^
+}

test/Constraints/rdar45511837.swift

@@ -18,8 +18,6 @@ class Foo<Bar: NSObject> {
 
   lazy var foo: () -> Void = {
     // TODO: improve diagnostic message
-    _ = self.foobar + nil // expected-error {{'Bar' is not convertible to 'String'}}
-    // expected-note@-1 {{did you mean to use 'as!' to force downcast?}}
-    // expected-error@-2 {{'nil' is not compatible with expected argument type 'String'}}
+    _ = self.foobar + nil // expected-error {{generic parameter 'Self' could not be inferred}}
   }
 }