[TypeChecker] Inference of inout for closure parameters in generic contexts

This fixes SR-1976

Author: ahoppen

lib/Sema/CSGen.cpp

@@ -1889,7 +1889,7 @@ namespace {
 
         // Otherwise, create a fresh type variable.
         Type ty = CS.createTypeVariable(CS.getConstraintLocator(locator),
-                                        /*options=*/0);
+                                        TVO_CanBeInOut);
 
         param->overwriteType(ty);
       }

lib/Sema/CSSimplify.cpp

@@ -1410,6 +1410,22 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
     case ConstraintKind::ArgumentConversion:
     case ConstraintKind::OperatorArgumentTupleConversion:
     case ConstraintKind::OperatorArgumentConversion:
+      if (type1->is<InOutType>() && typeVar2 &&
+          typeVar2->getImpl().canBeInOut()) {
+        // Upgrade type2 to an InOutType
+        auto inOutType1 = type1->getAs<InOutType>();
+        
+        unsigned typeVar3Options = typeVar2->getImpl().getOptions();
+        typeVar3Options &= ~TVO_CanBeInOut;
+        auto typeVar3 = createTypeVariable(getConstraintLocator(locator),
+                                           typeVar3Options);
+        auto inOutType3 = InOutType::get(typeVar3);
+        
+        addConstraint(ConstraintKind::Equal, typeVar2, inOutType3, locator);
+        return matchTypes(inOutType1->getObjectType(), typeVar3, kind, flags,
+                          locator);
+      }
+        
       // We couldn't solve this constraint. If only one of the types is a type
       // variable, perhaps we can do something with it below.
       if (typeVar1 && typeVar2) {

lib/Sema/ConstraintSystem.h

@@ -64,8 +64,11 @@ namespace constraints {
 /// \brief A handle that holds the saved state of a type variable, which
 /// can be restored.
 class SavedTypeVariableBinding {
-  /// \brief The type variable and type variable options.
-  llvm::PointerIntPair<TypeVariableType *, 3> TypeVarAndOptions;
+  /// \brief The type variable.
+  TypeVariableType *TypeVar;
+  
+  /// \brief The type variable options.
+  unsigned TypeVarOptions : 4;
 
   /// \brief The parent or fixed type.
   llvm::PointerUnion<TypeVariableType *, TypeBase *> ParentOrFixed;
@@ -76,8 +79,8 @@ class SavedTypeVariableBinding {
   /// \brief Restore the state of the type variable to the saved state.
   void restore();
 
-  TypeVariableType *getTypeVariable() { return TypeVarAndOptions.getPointer(); }
-  unsigned getOptions() { return TypeVarAndOptions.getInt(); }
+  TypeVariableType *getTypeVariable() { return TypeVar; }
+  unsigned getOptions() { return TypeVarOptions; }
 };
 
 /// \brief A set of saved type variable bindings.
@@ -126,7 +129,10 @@ enum TypeVariableOptions {
   TVO_PrefersSubtypeBinding = 0x02,
 
   /// Whether the variable must be bound to a materializable type.
-  TVO_MustBeMaterializable = 0x04
+  TVO_MustBeMaterializable = 0x04,
+  
+  // Whether the variable can be of an inout type
+  TVO_CanBeInOut = 0x08,
 };
 
 /// \brief The implementation object for a type variable used within the
@@ -138,7 +144,7 @@ enum TypeVariableOptions {
 /// which it is assigned.
 class TypeVariableType::Implementation {
   /// Type variable options.
-  unsigned Options : 3;
+  unsigned Options : 4;
 
   /// \brief The locator that describes where this type variable was generated.
   constraints::ConstraintLocator *locator;
@@ -178,6 +184,14 @@ class TypeVariableType::Implementation {
   bool mustBeMaterializable() const {
     return Options & TVO_MustBeMaterializable;
   }
+  
+  bool canBeInOut() const {
+    return Options & TVO_CanBeInOut;
+  }
+  
+  unsigned getOptions() const {
+    return Options;
+  }
 
   /// \brief Retrieve the type variable associated with this implementation.
   TypeVariableType *getTypeVariable() {

lib/Sema/TypeCheckConstraints.cpp

@@ -56,7 +56,7 @@ void TypeVariableType::Implementation::print(llvm::raw_ostream &OS) {
 }
 
 SavedTypeVariableBinding::SavedTypeVariableBinding(TypeVariableType *typeVar)
-  : TypeVarAndOptions(typeVar, typeVar->getImpl().Options),
+  : TypeVar(typeVar), TypeVarOptions(typeVar->getImpl().Options),
     ParentOrFixed(typeVar->getImpl().ParentOrFixed) { }
 
 void SavedTypeVariableBinding::restore() {
@@ -2683,6 +2683,8 @@ void ConstraintSystem::print(raw_ostream &out) {
     tv->getImpl().print(out);
     if (tv->getImpl().canBindToLValue())
       out << " [lvalue allowed]";
+    if (tv->getImpl().canBeInOut())
+      out << " [inout allowed]";
     if (tv->getImpl().mustBeMaterializable())
       out << " [must be materializable]";
     auto rep = getRepresentative(tv);

test/expr/closure/inference.swift

@@ -38,3 +38,10 @@ var nestedClosuresWithBrokenInference = { f: Int in {} }
     // expected-error@-2 {{consecutive statements on a line must be separated by ';'}} {{44-44=;}}
     // expected-error@-3 {{expected expression}}
     // expected-error@-4 {{use of unresolved identifier 'f'}}
+
+// SR-1976/SR-3073: Inference of inout
+
+func sr1976<T>(_ closure: (inout T) -> Void) {
+}
+
+sr1976({ $0 += 2 })

test/stdlib/UnsafePointerDiagnostics.swift

@@ -137,3 +137,8 @@ func unsafeRawBufferPointerConversions(
   _ = UnsafeMutableRawBufferPointer(start: orp, count: 1) // expected-error {{cannot convert value of type 'UnsafeRawPointer?' to expected argument type 'UnsafeMutableRawPointer?'}}
   _ = UnsafeRawBufferPointer(start: orp, count: 1)
 }
+
+func pointerInoutEquality(i: Int, p: UnsafeMutablePointer<Int>?) {
+  var i = i
+  _ = (p == &i)
+}