A few more tests demonstrating usage.

Author: johnno1962

include/swift/Sema/Constraint.h

@@ -269,7 +269,7 @@ 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
+  /// Implicit conversion where an init(implicit:) initializer is available.
   ImplicitConversion,
 };
 

lib/Sema/CSSimplify.cpp

@@ -5000,7 +5000,6 @@ ConstructorDecl *ConstraintSystem::implicitConversionAvailable(Type fromType, Ty
   trace("TO", toType);
   if (NominalTypeDecl *toNominal = toType->getAnyNominal()) {
     auto &ctx = getASTContext();
-    auto implicitArgId = ctx.Id_implicit;
     if (!toNominal->setConversionsComputed())
       for (ExtensionDecl *extension : toNominal->getExtensions()) {
         Type extType = extension->getExtendedType()->getCanonicalType();
@@ -5010,8 +5009,8 @@ ConstructorDecl *ConstraintSystem::implicitConversionAvailable(Type fromType, Ty
             ParameterList *parameters = initDecl->getParameters();
             ParamDecl *param; // could be @implicit instead..
             if (parameters->size() == 1 && (param = parameters->get(0)) &&
-                (param->getArgumentName() == implicitArgId ||
-                 param->getParameterName() == implicitArgId)) {
+                (param->getArgumentName() == ctx.Id_implicit ||
+                 param->getParameterName() == ctx.Id_implicit)) {
               Type argType = param->getType()->getCanonicalType();
               if (!arged++)
                 trace("\nEXT", extType);

test/TypeCoercion/immutable_mutable.swift

@@ -5,14 +5,49 @@ import Foundation
 
 extension Double {
   init(implicit: CGFloat) {
+    print("Double.init(implicit: CGFloat)")
     self.init(implicit)
   }
 }
 extension CGFloat {
   init(implicit: Double) {
+    print("CGFloat.init(implicit: Double)")
     self.init(implicit)
   }
 }
+public struct III {
+  var i: Int
+}
+extension Int {
+  init(implicit: Int16) {
+    print("Int.init(implicit: Int16)")
+    self.init(implicit)
+  }
+  init(implicit: Int32) {
+    print("Int.init(implicit: Int32)")
+    self.init(implicit)
+  }
+  init(_ implicit: III) {
+    print("Int.init(implicit: I)")
+    self.init(implicit.i)
+  }
+}
+extension Int32 {
+  init(implicit: Int8) {
+    print("Int32.init(implicit: Int8)")
+    self.init(implicit)
+  }
+  init(implicit: Int16) {
+    print("Int32.init(implicit: Int16)")
+    self.init(implicit)
+  }
+}
+extension III {
+  public init(_ implicit: Int) {
+    print("III.init(implicit: Int)")
+    self.init(i: implicit)
+  }
+}
 
 extension UnsafeRawPointer {
   init(implicit: UnsafeMutableRawPointer) {
@@ -40,6 +75,15 @@ let x: Double = 99.1
 let y: CGFloat = x
 let z: Double? = y
 
+let a: Int32 = 997
+let b: Int = a
+let c: Int8 = 97
+let d: Int = c // expected-error {{cannot convert value of type 'Int8' to specified type 'Int'}}
+let e = III(i: 888)
+let f: Int = e
+let h: Int16 = 45
+let j: Int32 = h
+
 let optionalMutableRawPointer = UnsafeMutableRawPointer(bitPattern: -3)
 let mutableRawPointer = optionalMutableRawPointer!
 let immutable: UnsafeRawPointer = mutableRawPointer
@@ -91,28 +135,3 @@ array.withUnsafeMutableBufferPointer {
     _ = demutable(immutable: $0.baseAddress!)
     _ = demutable(optionalImmutable: $0.baseAddress)
 }
-
-extension Int {
-  init(implicit: Int8) {
-    self.init(implicit)
-  }
-  init(implicit: Int16) {
-    self.init(implicit)
-  }
-  init(implicit: Int32) {
-    self.init(implicit)
-  }
-}
-extension Int32 {
-  init(implicit: Int8) {
-    self.init(implicit)
-  }
-  init(implicit: Int16) {
-    self.init(implicit)
-  }
-}
-
-let a: Int32 = 997
-let b: Int = a
-let c: Int8 = 97
-let d: Int = c