Moving to restrictions mechanism

Author: johnno1962

include/swift/AST/ASTContext.h

@@ -366,16 +366,16 @@ class ASTContext final {
   llvm::BumpPtrAllocator &
   getAllocator(AllocationArena arena = AllocationArena::Permanent) const;
 
-  llvm::DenseMap<NominalTypeDecl *,
-    llvm::DenseMap<NominalTypeDecl *, ConstructorDecl *>> ConversionMap;
+  llvm::DenseMap<TypeBase *, llvm::DenseMap<TypeBase *,
+    SmallVector<ConstructorDecl *, 2>>> ImplicitConversionMap;
 
 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;
+  llvm::DenseMap<TypeBase *, SmallVector<ConstructorDecl *, 2>>
+    *implicitConversionsTo(TypeBase *toType, bool create) {
+    auto constructorsByFromType = ImplicitConversionMap.find(toType);
+    if (constructorsByFromType != ImplicitConversionMap.end())
+      return &constructorsByFromType->getSecond();
+    return create ? &ImplicitConversionMap[toType] : nullptr;
   }
 
   /// Allocate - Allocate memory from the ASTContext bump pointer.

include/swift/AST/Decl.h

@@ -3162,7 +3162,11 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
 public:
   using GenericTypeDecl::getASTContext;
 
-  ConstructorDecl *implicitConversionTo(Type type);
+  bool setConversionsComputed() {
+    bool wasComputed = implicitConversionsComputed;
+    implicitConversionsComputed = true;
+    return wasComputed;
+  }
 
   SourceRange getBraces() const { return 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/ConstraintSystem.h

@@ -4243,8 +4243,8 @@ class ConstraintSystem {
                       SmallVectorImpl<RestrictionOrFix> &conversionsOrFixes,
                       ConstraintLocatorBuilder locator);
 
-  /// Is a conversion from a Mutable to Immutable pointer possible.
-  bool toImmutablePossible(Type lhs, Type rhs);
+  /// Is an implicit conversion available from fromType to toType.
+  bool implicitConversionAvailable(Type fromType, Type toType);
 
   /// Subroutine of \c matchTypes(), which matches up two tuple types.
   ///

lib/Sema/CSApply.cpp

@@ -6633,7 +6633,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       if (toType->hasUnresolvedType())
         break;
 
-      if (cs.toImmutablePossible(fromType->lookThroughAllOptionalTypes(),
+      if (cs.implicitConversionAvailable(fromType->lookThroughAllOptionalTypes(),
                                  toType->lookThroughAllOptionalTypes()))
         break;
 
@@ -6857,56 +6857,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     }
 
     case ConversionRestrictionKind::CGFloatToDouble:
-    case ConversionRestrictionKind::DoubleToCGFloat: {
-      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=*/{Identifier()});
-
-      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.
-      {
-        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;
-    }
+    case ConversionRestrictionKind::DoubleToCGFloat:
     case ConversionRestrictionKind::ImplicitConversion: {
       auto conversionKind = knownRestriction->second;
 
@@ -6916,10 +6867,15 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       // Load the value for conversion.
       argExpr = cs.coerceToRValue(argExpr);
 
+      Identifier label;
+      if (knownRestriction->second ==
+          ConversionRestrictionKind::ImplicitConversion)
+        label = cs.getASTContext().Id_implicit;
+
       auto *implicitInit =
           CallExpr::createImplicit(ctx, TypeExpr::createImplicit(toType, ctx),
                                    /*args=*/{argExpr},
-                                   /*argLabels=*/{ctx.Id_implicit});
+                                   /*argLabels=*/{label});
 
       cs.cacheExprTypes(implicitInit->getFn());
       cs.setType(argExpr, fromType);
@@ -6938,7 +6894,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
 
       // 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});

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.
@@ -4972,21 +4976,56 @@ bool ConstraintSystem::repairFailures(
   }
 
   // Accept mutable pointers in the place of immutables.
-  if (toImmutablePossible(lhs, rhs))
+  if (implicitConversionAvailable(lhs, rhs))
     conversionsOrFixes.push_back(
         ConversionRestrictionKind::PointerToPointer);
 
   return !conversionsOrFixes.empty();
 }
 
-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())) {
+bool ConstraintSystem::implicitConversionAvailable(Type fromType, Type toType) {
+#if 01 // Determine implicit conversions from init(implicit:) constructors
+  fprintf(stderr, "\n\nFROM  %p ", fromType.getPointer());
+  fromType->dump();
+  fprintf(stderr, "TO %p ", toType.getPointer());
+  toType->dump();
+  if (NominalTypeDecl *toNominal = toType->getAnyNominal()) {
+    auto typeKey = ^TypeBase *(Type t) {
+        return t->getAnyNominal()->getInterfaceType()
+                ->getCanonicalType().getPointer();
+    };
+    TypeBase *toBase = typeKey(toType);
+    auto &ctx = getASTContext();
+    if (!toNominal->setConversionsComputed()) {
+      auto implicitArgId = ctx.Id_implicit;
+      for (ExtensionDecl *extension : toNominal->getExtensions()) {
+        Type extType = extension->getDeclaredInterfaceType()->getCanonicalType();
+        fprintf(stderr, "\nEXT %p ", extType.getPointer());
+        extType->dump();
+        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) {
+              Type argType = args->get(0)->getType()->getCanonicalType();
+              fprintf(stderr, "ARG %p ", argType.getPointer());
+              argType->dump();
+              (*ctx.implicitConversionsTo(typeKey(extType), /*create*/true))
+                [typeKey(argType)].push_back(initDecl);
+            }
+          }
+      }
+    }
+    if (auto *exists = ctx.implicitConversionsTo(toBase, /*create*/false)) {
+      for (ConstructorDecl *initFunc : (*exists)[typeKey(fromType)])
+        // More detailed check of conversion here...
+        if (initFunc != nullptr)
+          return true;
+    }
+  }
+#else // Original hard coded rules.
+  if (toType->isUnsafeRawPointer() && (fromType->isUnsafeMutableRawPointer() ||
+         fromType->isUnsafeMutablePointer() || fromType->isUnsafePointer())) {
     return true; // Unsafe[Mutable][Raw]Pointer -> UnsafeRawPointer
   }
 
@@ -4995,39 +5034,16 @@ bool ConstraintSystem::toImmutablePossible(Type lhs, Type rhs) {
       ->getGenericArgs()[0]->getCanonicalType();
   };
 
-  if (lhs->isUnsafeMutablePointer() && rhs->isUnsafePointer() &&
-      firstGenericArgument(lhs) == firstGenericArgument(rhs)) {
-    rhs->dump();
-    lhs->dump();
+  if (fromType->isUnsafeMutablePointer() && toType->isUnsafePointer() &&
+      firstGenericArgument(fromType) == firstGenericArgument(toType)) {
+    toType->dump();
+    fromType->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,
@@ -5374,7 +5390,8 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
       if (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.
@@ -5442,14 +5459,17 @@ 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);
+                  ? ConversionRestrictionKind::CGFloatToDouble :
+              desugar2->isCGFloatType()
+                  ? ConversionRestrictionKind::DoubleToCGFloat :
+                    ConversionRestrictionKind::ImplicitConversion);
         }
       }
 
@@ -11177,7 +11197,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;
@@ -11224,16 +11245,17 @@ 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(
         {getConstraintLocator(locator), restriction});
     return SolutionKind::Solved;
   }
-  case ConversionRestrictionKind::ImplicitConversion:
-    return SolutionKind::Solved;
   }
 
   llvm_unreachable("bad conversion restriction");

lib/Sema/ConstraintSystem.cpp

@@ -452,7 +452,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});

test/TypeCoercion/immutable_mutable.swift

@@ -22,7 +22,7 @@ extension UnsafePointer {
 let optionalMutableRawPointer = UnsafeMutableRawPointer(bitPattern: -3)
 let mutableRawPointer = optionalMutableRawPointer!
 let immutable: UnsafeRawPointer = mutableRawPointer
-let immutable2: UnsafeRawPointer? = optionalMutableRawPointer
+//let immutable2: UnsafeRawPointer? = optionalMutableRawPointer
 let optionalImmutable: UnsafeRawPointer? = mutableRawPointer
 let mutable: UnsafeMutableRawPointer = immutable // expected-error {{cannot convert value of type 'UnsafeRawPointer' to specified type 'UnsafeMutableRawPointer'}}
 
@@ -34,7 +34,7 @@ func unmutable(immutable: UnsafeRawPointer) -> UnsafeRawPointer {
     return mutableRawPointer
 }
 func unmutable(optionalImmutable: UnsafeRawPointer?) -> UnsafeRawPointer? {
-    return optionalMutableRawPointer
+    return optionalImmutable//optionalMutableRawPointer
 }
 
 _ = unmutable(immutable: mutableRawPointer)
@@ -56,7 +56,7 @@ func demutable(immutable: UnsafePointer<Int>) -> UnsafeRawPointer {
     return mutableRawPointer
 }
 func demutable(optionalImmutable: UnsafePointer<Int>?) -> UnsafeRawPointer? {
-    return optionalMutableRawPointer
+    return optionalImmutable//optionalMutableRawPointer
 }
 
 _ = demutable(immutable: mutable3)