Implicit conversions as initialisers.

Author: johnno1962

include/swift/AST/ASTContext.h

@@ -366,7 +366,18 @@ class ASTContext final {
   llvm::BumpPtrAllocator &
   getAllocator(AllocationArena arena = AllocationArena::Permanent) const;
 
+  llvm::DenseMap<NominalTypeDecl *,
+    llvm::DenseMap<NominalTypeDecl *, ConstructorDecl *>> ConversionMap;
+
 public:
+  llvm::DenseMap<NominalTypeDecl *, ConstructorDecl *> *implicitConversionsFor(
+                                  NominalTypeDecl *typeDecl, bool create) {
+    auto map = ConversionMap.find(typeDecl);
+    if (map != ConversionMap.end())
+      return &map->getSecond();
+    return create ? &ConversionMap[typeDecl] : 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,15 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
     Bits.NominalTypeDecl.IsComputingSemanticMembers = false;
   }
 
+  bool implicitConversionsComputed = false;
+
   friend class ProtocolType;
 
 public:
   using GenericTypeDecl::getASTContext;
 
+  ConstructorDecl *implicitConversionTo(Type type);
+
   SourceRange getBraces() const { return Braces; }
 
   void setBraces(SourceRange braces) { Braces = braces; }

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 vailable
+  ImplicitConversion,
 };
 
 /// Specifies whether a given conversion requires the creation of a temporary

lib/AST/Decl.cpp

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

lib/Sema/CSApply.cpp

@@ -6907,6 +6907,56 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       finishApply(implicitInit, toType, callLocator, callLocator);
       return implicitInit;
     }
+    case ConversionRestrictionKind::ImplicitConversion: {
+      auto conversionKind = knownRestriction->second;
+
+      auto *argExpr = locator.trySimplifyToExpr();
+      assert(argExpr);
+
+      // Load the value for conversion.
+      argExpr = cs.coerceToRValue(argExpr);
+
+      auto *implicitInit =
+          CallExpr::createImplicit(ctx, TypeExpr::createImplicit(toType, ctx),
+                                   /*args=*/{argExpr},
+                                   /*argLabels=*/{ctx.Id_implicit});
+
+      cs.cacheExprTypes(implicitInit->getFn());
+      cs.setType(argExpr, fromType);
+      cs.setType(implicitInit->getArg(),
+                 ParenType::get(cs.getASTContext(), fromType));
+
+      auto *callLocator = cs.getConstraintLocator(
+          implicitInit, LocatorPathElt::ImplicitConversion(conversionKind));
+
+      // HACK: Temporarily push the call expr onto the expr stack to make sure
+      // we don't try to prematurely close an existential when applying the
+      // curried member ref. This can be removed once existential opening is
+      // refactored not to rely on the shape of the AST prior to rewriting.
+      ExprStack.push_back(implicitInit);
+      SWIFT_DEFER { ExprStack.pop_back(); };
+
+      // We need to take information recorded for all conversions of this
+      // kind and move it to a specific location where restriction is applied.
+      if (01) {
+        auto *memberLoc = solution.getConstraintLocator(
+            callLocator, {ConstraintLocator::ApplyFunction,
+                          ConstraintLocator::ConstructorMember});
+
+        auto overload = solution.getOverloadChoice(cs.getConstraintLocator(
+            ASTNode(), {LocatorPathElt::ImplicitConversion(conversionKind),
+                        ConstraintLocator::ApplyFunction,
+                        ConstraintLocator::ConstructorMember}));
+
+        solution.overloadChoices.insert({memberLoc, overload});
+      }
+
+      // Record the implicit call's parameter bindings and match direction.
+      solution.recordSingleArgMatchingChoice(callLocator);
+
+      finishApply(implicitInit, toType, callLocator, callLocator);
+      return implicitInit;
+    }
     }
   }
 

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

@@ -4980,22 +4980,54 @@ bool ConstraintSystem::repairFailures(
 }
 
 bool ConstraintSystem::toImmutablePossible(Type lhs, Type rhs) {
+#if 1
+  if (auto nominal = lhs->getAnyNominal())
+    if (auto func = nominal->implicitConversionTo(rhs))
+      return true;
+#else
   if (rhs->isUnsafeRawPointer() && (lhs->isUnsafeMutableRawPointer() ||
-       lhs->isUnsafeMutablePointer() || lhs->isUnsafePointer()))
+      lhs->isUnsafeMutablePointer() || lhs->isUnsafePointer())) {
     return true; // Unsafe[Mutable][Raw]Pointer -> UnsafeRawPointer
+  }
 
   auto firstGenericArgument = [&](Type ty) -> CanType {
     return dyn_cast<BoundGenericStructType>(ty->getCanonicalType())
       ->getGenericArgs()[0]->getCanonicalType();
   };
 
   if (lhs->isUnsafeMutablePointer() && rhs->isUnsafePointer() &&
-      firstGenericArgument(lhs) == firstGenericArgument(rhs))
+      firstGenericArgument(lhs) == firstGenericArgument(rhs)) {
+    rhs->dump();
+    lhs->dump();
     return true; // UnsafeMutablePointer<Pointee> -> UnsafePointer<Pointee>
-
+  }
+#endif
   return false;
 }
 
+ConstructorDecl *NominalTypeDecl::implicitConversionTo(Type type) {
+  if (NominalTypeDecl *toNominal = type->getAnyNominal()) {
+    auto &ctx = getASTContext();
+    if (!toNominal->implicitConversionsComputed) {
+      auto implicitArgId = ctx.Id_implicit;
+      for (ExtensionDecl *extension : toNominal->getExtensions())
+        for (Decl *member : extension->getMembers())
+          if (ConstructorDecl *initDecl = dyn_cast<ConstructorDecl>(member)) {
+            ParameterList *args = initDecl->getParameters();
+            if (args->size() == 1 &&
+                args->get(0)->getBaseName().getIdentifier() == implicitArgId)
+              if (auto fromNominal = args->get(0)->getType()->getAnyNominal())
+                (*ctx.implicitConversionsFor(fromNominal, /*create*/true))
+                  [toNominal] = initDecl;
+          }
+      toNominal->implicitConversionsComputed = true;
+    }
+    if (auto *exists = ctx.implicitConversionsFor(this, /*create*/false))
+      return (*exists)[toNominal];
+  }
+  return nullptr;
+}
+
 ConstraintSystem::TypeMatchResult
 ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
                              TypeMatchOptions flags,
@@ -11200,6 +11232,8 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
         {getConstraintLocator(locator), restriction});
     return SolutionKind::Solved;
   }
+  case ConversionRestrictionKind::ImplicitConversion:
+    return SolutionKind::Solved;
   }
 
   llvm_unreachable("bad conversion restriction");

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

@@ -5130,6 +5130,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.

test/TypeCoercion/immutable_mutable.swift

@@ -2,6 +2,23 @@
 
 import Swift
 
+extension UnsafeRawPointer {
+  init(implicit: UnsafeMutableRawPointer) {
+    self.init(implicit)
+  }
+  init(implicit: UnsafeMutablePointer<Pointee>) {
+    self.init(implicit)
+  }
+  init(implicit: UnsafePointer<Pointee>) {
+    self.init(implicit)
+  }
+}
+extension UnsafePointer {
+  init(implicit: UnsafeMutablePointer<Pointee>) {
+    self.init(implicit)
+  }
+}
+
 let optionalMutableRawPointer = UnsafeMutableRawPointer(bitPattern: -3)
 let mutableRawPointer = optionalMutableRawPointer!
 let immutable: UnsafeRawPointer = mutableRawPointer