Automatic conversion of mutable pointers to immutable pointers.

include/swift/AST/ASTContext.h

@@ -366,7 +366,20 @@ class ASTContext final {
   llvm::BumpPtrAllocator &
   getAllocator(AllocationArena arena = AllocationArena::Permanent) const;
 
+  /// init(implicit:) constructors declaring implicit conversions.
+  /// indexed by nominal of toType then nominal of fromType.
+  llvm::DenseMap<NominalTypeDecl *, llvm::DenseMap<NominalTypeDecl *,
+    SmallVector<ConstructorDecl *, 2>>> ImplicitConversionMap;
+
 public:
+  llvm::DenseMap<NominalTypeDecl *, SmallVector<ConstructorDecl *, 2>>
+    *implicitConversionsTo(NominalTypeDecl *toNominal, bool create) {
+    auto constructorsByFromType = ImplicitConversionMap.find(toNominal);
+    if (constructorsByFromType != ImplicitConversionMap.end())
+      return &constructorsByFromType->getSecond();
+    return create ? &ImplicitConversionMap[toNominal] : nullptr;
+  }
+
   /// Allocate - Allocate memory from the ASTContext bump pointer.
   void *Allocate(unsigned long bytes, unsigned alignment,
                  AllocationArena arena = AllocationArena::Permanent) const {

include/swift/AST/Decl.h

@@ -3155,11 +3155,19 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
     Bits.NominalTypeDecl.IsComputingSemanticMembers = false;
   }
 
+  bool implicitConversionsComputed = false;
+
   friend class ProtocolType;
 
 public:
   using GenericTypeDecl::getASTContext;
 
+  bool setConversionsComputed() {
+    bool wasComputed = implicitConversionsComputed;
+    implicitConversionsComputed = true;
+    return wasComputed;
+  }
+
   SourceRange getBraces() const { return Braces; }
 
   void setBraces(SourceRange braces) { Braces = braces; }

include/swift/AST/KnownIdentifiers.def

@@ -262,6 +262,7 @@ IDENTIFIER(identifier)
 IDENTIFIER(_distributedActorRemoteInitialize)
 IDENTIFIER(_distributedActorDestroy)
 IDENTIFIER(__isRemoteActor)
+IDENTIFIER(implicit)
 
 #undef IDENTIFIER
 #undef IDENTIFIER_

include/swift/Sema/Constraint.h

@@ -269,6 +269,8 @@ enum class ConversionRestrictionKind {
   /// Implicit conversion from a value of CGFloat type to a value of Double type
   /// via an implicit Double initializer call passing a CGFloat value.
   CGFloatToDouble,
+  /// Implicit conversion where an init(implicit:) initializer is available.
+  ImplicitConversion,
 };
 
 /// Specifies whether a given conversion requires the creation of a temporary

include/swift/Sema/ConstraintSystem.h

@@ -4243,6 +4243,9 @@ class ConstraintSystem {
                       SmallVectorImpl<RestrictionOrFix> &conversionsOrFixes,
                       ConstraintLocatorBuilder locator);
 
+  /// Is an implicit conversion available from fromType to toType.
+  ConstructorDecl *implicitConversionAvailable(Type fromType, Type toType);
+
   /// Subroutine of \c matchTypes(), which matches up two tuple types.
   ///
   /// \returns the result of performing the tuple-to-tuple conversion.

lib/AST/ASTVerifier.cpp

@@ -1136,6 +1136,10 @@ class Verifier : public ASTWalker {
     }
 
     void verifyChecked(TupleExpr *E) {
+      if (!E->getType()->is<TupleType>()) {
+          E->getType()->dump();
+          return;
+      }
       const TupleType *exprTy = E->getType()->castTo<TupleType>();
       for_each(exprTy->getElements().begin(), exprTy->getElements().end(),
                E->getElements().begin(),

lib/AST/Decl.cpp

@@ -3839,6 +3839,7 @@ void NominalTypeDecl::addExtension(ExtensionDecl *extension) {
   LastExtension->NextExtension.setPointer(extension);
   LastExtension = extension;
 
+  implicitConversionsComputed = false;
   addedExtension(extension);
 }
 

lib/AST/Type.cpp

@@ -818,7 +818,7 @@ bool TypeBase::isStdlibType() {
 
 bool TypeBase::isCGFloatType() {
   auto *NTD = getAnyNominal();
-  if (!NTD)
+  if (!NTD || !NTD->getName().is("CGFloat"))
     return false;
 
   auto *DC = NTD->getDeclContext();
@@ -828,9 +828,8 @@ bool TypeBase::isCGFloatType() {
   auto *module = DC->getParentModule();
   // On macOS `CGFloat` is part of a `CoreGraphics` module,
   // but on Linux it could be found in `Foundation`.
-  return (module->getName().is("CoreGraphics") ||
-          module->getName().is("Foundation")) &&
-         NTD->getName().is("CGFloat");
+  return module->getName().is("CoreGraphics") ||
+         module->getName().is("Foundation");
 }
 
 bool TypeBase::isKnownStdlibCollectionType() {

lib/Sema/CSApply.cpp

@@ -5606,6 +5606,9 @@ static unsigned getOptionalEvaluationDepth(Expr *expr, Expr *target) {
       expr = open->getExistentialValue();
 
     // Otherwise, look through implicit conversions.
+    } else if (auto call = dyn_cast<CallExpr>(expr)) {
+//      expr->dump();
+      return depth;
     } else {
       expr = cast<ImplicitConversionExpr>(expr)->getSubExpr();
     }
@@ -6633,6 +6636,10 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       if (toType->hasUnresolvedType())
         break;
 
+      if (cs.implicitConversionAvailable(fromType->lookThroughAllOptionalTypes(),
+                                         toType->lookThroughAllOptionalTypes()))
+        break;
+
       // HACK: Fix problem related to Swift 4 mode (with assertions),
       // since Swift 4 mode allows passing arguments with extra parens
       // to parameters which don't expect them, it should be supported
@@ -6853,8 +6860,16 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     }
 
     case ConversionRestrictionKind::CGFloatToDouble:
-    case ConversionRestrictionKind::DoubleToCGFloat: {
+    case ConversionRestrictionKind::DoubleToCGFloat:
+    case ConversionRestrictionKind::ImplicitConversion: {
       auto conversionKind = knownRestriction->second;
+      ConstructorDecl *implicitConstructor = nullptr;
+      Identifier label;
+      if (conversionKind == ConversionRestrictionKind::ImplicitConversion) {
+//        fromType->dump(); toType->dump();
+        implicitConstructor = cs.implicitConversionAvailable(fromType, toType);
+        label = cs.getASTContext().Id_implicit;
+      }
 
       auto *argExpr = locator.trySimplifyToExpr();
       assert(argExpr);
@@ -6865,7 +6880,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       auto *implicitInit =
           CallExpr::createImplicit(ctx, TypeExpr::createImplicit(toType, ctx),
                                    /*args=*/{argExpr},
-                                   /*argLabels=*/{Identifier()});
+                                   /*argLabels=*/{label});
 
       cs.cacheExprTypes(implicitInit->getFn());
       cs.setType(argExpr, fromType);
@@ -6894,7 +6909,15 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
                         ConstraintLocator::ApplyFunction,
                         ConstraintLocator::ConstructorMember}));
 
-        solution.overloadChoices.insert({memberLoc, overload});
+        if (implicitConstructor) { // Hack overload to constructor for implicits
+          SelectedOverload implicitOverload = {
+            OverloadChoice(toType, implicitConstructor,
+                           overload.choice.getFunctionRefKind()),
+            overload.openedFullType, overload.openedType, overload.boundType};
+          solution.overloadChoices.insert({memberLoc, implicitOverload});
+        }
+        else
+          solution.overloadChoices.insert({memberLoc, overload});
       }
 
       // Record the implicit call's parameter bindings and match direction.

lib/Sema/CSDiagnostics.cpp

@@ -6703,6 +6703,7 @@ void NonEphemeralConversionFailure::emitSuggestionNotes() const {
   case ConversionRestrictionKind::ObjCTollFreeBridgeToCF:
   case ConversionRestrictionKind::CGFloatToDouble:
   case ConversionRestrictionKind::DoubleToCGFloat:
+  case ConversionRestrictionKind::ImplicitConversion:
     llvm_unreachable("Expected an ephemeral conversion!");
   }
 }

lib/Sema/CSSimplify.cpp

@@ -3635,6 +3635,10 @@ static bool repairOutOfOrderArgumentsInBinaryFunction(
   return false;
 }
 
+/// Switch between restrictions mechanism and original PR using
+/// ConversionRestrictionKind::PointerToPointer in repairFailures().
+static bool useRestrictions = true;
+
 /// Attempt to repair typing failures and record fixes if needed.
 /// \return true if at least some of the failures has been repaired
 /// successfully, which allows type matcher to continue.
@@ -4971,9 +4975,90 @@ bool ConstraintSystem::repairFailures(
     break;
   }
 
+  // Accept mutable pointers in the place of immutables.
+  if (implicitConversionAvailable(lhs, rhs))
+    conversionsOrFixes.push_back(
+        ConversionRestrictionKind::ImplicitConversion);
+
   return !conversionsOrFixes.empty();
 }
 
+ConstructorDecl *ConstraintSystem::implicitConversionAvailable(Type fromType, Type toType) {
+#if 01 // Determine implicit conversions from init([_] implicit:) constructors
+  static int called = 0;
+  static const char *from = 0 ? "\nFROM" : nullptr;
+  auto trace = [](const char *prefix, Type ty) {
+    if (!from)
+      return;
+    if (prefix == from)
+      called++;
+    fprintf(stderr, prefix == from ? "%s %p #%d " :  "%s %p ",
+            prefix, ty.getPointer(), called);
+    ty->dump();
+  };
+  trace(from, fromType);
+  trace("TO", toType);
+  if (NominalTypeDecl *toNominal = toType->getAnyNominal()) {
+    auto &ctx = getASTContext();
+    if (!toNominal->setConversionsComputed())
+      for (ExtensionDecl *extension : toNominal->getExtensions()) {
+        Type extType = extension->getExtendedType()->getCanonicalType();
+        int arged = 0;
+        for (Decl *member : extension->getMembers())
+          if (ConstructorDecl *initDecl = dyn_cast<ConstructorDecl>(member)) {
+            ParameterList *parameters = initDecl->getParameters();
+            ParamDecl *param; // could be @implicit instead..
+            if (parameters->size() == 1 && (param = parameters->get(0)) &&
+                (param->getArgumentName() == ctx.Id_implicit ||
+                 param->getParameterName() == ctx.Id_implicit)) {
+              Type argType = param->getType()->getCanonicalType();
+              if (!arged++)
+                trace("\nEXT", extType);
+              trace(" ARG", argType);
+              (*ctx.implicitConversionsTo(extType->getAnyNominal(),
+                /*create*/true))[argType->getAnyNominal()].push_back(initDecl);
+            }
+          }
+      }
+
+    if (auto *exists = ctx.implicitConversionsTo(toNominal, /*create*/false))
+      for (ConstructorDecl *initDecl : (*exists)[fromType->getAnyNominal()])
+        if (ExtensionDecl *ext = dyn_cast<ExtensionDecl>(initDecl->getParent()))
+          if (Type argType = initDecl->getParameters()->get(0)->getType())
+            if (Type extType = initDecl->getResultInterfaceType()) {
+              extType = initDecl->getParent()->mapTypeIntoContext(extType);
+              // More rigourous check of conversion here...
+              trace("EXT2", extType);
+              trace("ARG2", argType);
+              if (argType->getCanonicalType() == fromType->getCanonicalType() ||
+                  (extType->isUnsafeRawPointer() &&
+                   (fromType->isUnsafeMutablePointer() || fromType->isUnsafePointer()))) {
+                trace("SELECTED", initDecl->getInterfaceType());
+                return initDecl;
+              }
+            }
+  }
+#else // Original hard coded rules for unsafe pointers.
+  if (toType->isUnsafeRawPointer() && (fromType->isUnsafeMutableRawPointer() ||
+         fromType->isUnsafeMutablePointer() || fromType->isUnsafePointer())) {
+    return true; // Unsafe[Mutable][Raw]Pointer -> UnsafeRawPointer
+  }
+
+  auto firstGenericArgument = [&](Type ty) -> CanType {
+    return dyn_cast<BoundGenericStructType>(ty->getCanonicalType())
+      ->getGenericArgs()[0]->getCanonicalType();
+  };
+
+  if (fromType->isUnsafeMutablePointer() && toType->isUnsafePointer() &&
+      firstGenericArgument(fromType) == firstGenericArgument(toType)) {
+    toType->dump();
+    fromType->dump();
+    return true; // UnsafeMutablePointer<Pointee> -> UnsafePointer<Pointee>
+  }
+#endif
+  return nullptr;
+}
+
 ConstraintSystem::TypeMatchResult
 ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
                              TypeMatchOptions flags,
@@ -5317,10 +5402,12 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
         }
       }
 
-      if (kind >= ConstraintKind::Subtype &&
+#if 0
+      if (0 && kind >= ConstraintKind::Subtype &&
           nominal1->getDecl() != nominal2->getDecl() &&
           ((nominal1->isCGFloatType() || nominal2->isCGFloatType()) &&
-           (nominal1->isDouble() || nominal2->isDouble()))) {
+           (nominal1->isDouble() || nominal2->isDouble())) ||
+          useRestrictions && implicitConversionAvailable(type1, type2)) {
         ConstraintLocatorBuilder location{locator};
         // Look through all value-to-optional promotions to allow
         // conversions like Double -> CGFloat?? and vice versa.
@@ -5388,16 +5475,20 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
                       rawElt.getAs<LocatorPathElt::ImplicitConversion>()) {
                 auto convKind = elt->getConversionKind();
                 return convKind == ConversionRestrictionKind::DoubleToCGFloat ||
-                       convKind == ConversionRestrictionKind::CGFloatToDouble;
+                       convKind == ConversionRestrictionKind::CGFloatToDouble ||
+                       convKind == ConversionRestrictionKind::ImplicitConversion;
               }
               return false;
             })) {
           conversionsOrFixes.push_back(
-              desugar1->isCGFloatType()
-                  ? ConversionRestrictionKind::CGFloatToDouble
-                  : ConversionRestrictionKind::DoubleToCGFloat);
+//              desugar1->isCGFloatType()
+//                  ? ConversionRestrictionKind::CGFloatToDouble :
+//              desugar2->isCGFloatType()
+//                  ? ConversionRestrictionKind::DoubleToCGFloat :
+                    ConversionRestrictionKind::ImplicitConversion);
         }
       }
+#endif
 
       break;
     }
@@ -11123,7 +11214,8 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
   }
 
   case ConversionRestrictionKind::DoubleToCGFloat:
-  case ConversionRestrictionKind::CGFloatToDouble: {
+  case ConversionRestrictionKind::CGFloatToDouble:
+  case ConversionRestrictionKind::ImplicitConversion: {
     // Prefer CGFloat -> Double over other way araund.
     auto impact =
         restriction == ConversionRestrictionKind::CGFloatToDouble ? 1 : 10;
@@ -11170,8 +11262,11 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
                              memberTy, DC, FunctionRefKind::DoubleApply,
                              /*outerAlternatives=*/{}, memberLoc);
 
+    Identifier label;
+    if (restriction == ConversionRestrictionKind::ImplicitConversion)
+      label = getASTContext().Id_implicit;
     addConstraint(ConstraintKind::ApplicableFunction,
-                  FunctionType::get({FunctionType::Param(type1)}, type2),
+                  FunctionType::get({FunctionType::Param(type1, label)}, type2),
                   memberTy, applicationLoc);
 
     ImplicitValueConversions.push_back(

lib/Sema/Constraint.cpp

@@ -562,6 +562,8 @@ StringRef swift::constraints::getName(ConversionRestrictionKind kind) {
     return "[CGFloat-to-Double]";
   case ConversionRestrictionKind::DoubleToCGFloat:
     return "[Double-to-CGFloat]";
+  case ConversionRestrictionKind::ImplicitConversion:
+    return "[Implicit-Conversion]";
   }
   llvm_unreachable("bad conversion restriction kind");
 }

lib/Sema/ConstraintSystem.cpp

@@ -183,6 +183,9 @@ void ConstraintSystem::assignFixedType(TypeVariableType *typeVar, Type type,
           getASTContext(), castToExpr(locator->getAnchor()));
       if (!literalProtocol)
         continue;
+//      fprintf(stderr, "HERE ");
+//      (locator->getAnchor()).dump();
+//      fprintf(stderr, "\n");
 
       // If the protocol has a default type, check it.
       if (auto defaultType = TypeChecker::getDefaultType(literalProtocol, DC)) {
@@ -452,7 +455,8 @@ ConstraintLocator *ConstraintSystem::getCalleeLocator(
   if (auto conversion =
           locator->findLast<LocatorPathElt::ImplicitConversion>()) {
     if (conversion->is(ConversionRestrictionKind::DoubleToCGFloat) ||
-        conversion->is(ConversionRestrictionKind::CGFloatToDouble)) {
+        conversion->is(ConversionRestrictionKind::CGFloatToDouble) ||
+        conversion->is(ConversionRestrictionKind::ImplicitConversion)) {
       return getConstraintLocator(
           ASTNode(), {*conversion, ConstraintLocator::ApplyFunction,
                       ConstraintLocator::ConstructorMember});
@@ -5130,6 +5134,7 @@ ConstraintSystem::isConversionEphemeral(ConversionRestrictionKind conversion,
   case ConversionRestrictionKind::ObjCTollFreeBridgeToCF:
   case ConversionRestrictionKind::CGFloatToDouble:
   case ConversionRestrictionKind::DoubleToCGFloat:
+  case ConversionRestrictionKind::ImplicitConversion:
     // @_nonEphemeral has no effect on these conversions, so treat them as all
     // being non-ephemeral in order to allow their passing to an @_nonEphemeral
     // parameter.

lib/Sema/TypeCheckCaptures.cpp

@@ -465,6 +465,10 @@ class FindCapturedVars : public ASTWalker {
     // Approximate this for the purposes of being able to invoke @objc methods
     // by considering tuples of ObjC-representable types to not use metadata.
     if (auto tuple = dyn_cast<TupleExpr>(E)) {
+      if (!tuple->getType()->is<TupleType>()) {
+        tuple->getType()->dump();
+        return false;
+      }
       for (auto elt : tuple->getType()->castTo<TupleType>()->getElements()) {
         if (!elt.getType()->isRepresentableIn(ForeignLanguage::ObjectiveC,
                                               CurDC))