diff --git a/benchmark/single-source/Join.swift b/benchmark/single-source/Join.swift
index 96097b927f2..023729354b7 100644
--- a/benchmark/single-source/Join.swift
+++ b/benchmark/single-source/Join.swift
@@ -19,6 +19,6 @@ public func run_Join(N: Int) {
   for x in 0..<1000 * N {
     array.append(String(x))
   }
-  _ = array.join(separator: "")
-  _ = array.join(separator: " ")
+  _ = array.joined(separator: "")
+  _ = array.joined(separator: " ")
 }
diff --git a/stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift b/stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift
index af7664761f2..4116cce49d7 100644
--- a/stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift
+++ b/stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift
@@ -1699,7 +1699,7 @@ self.test("\(testNamePrefix).split/separator/semantics") {
     )
     let separator = wrapValueIntoEquatable(MinimalEquatableValue(test.separator))
     let result = s.split(
-      by: separator,
+      separator: separator,
       maxSplits: test.maxSplits,
       omittingEmptySubsequences: test.omittingEmptySubsequences)
     expectEqualSequence(
@@ -1726,7 +1726,7 @@ self.test("\(testNamePrefix).split/semantics/separator/negativeMaxSplit") {
   let s = makeWrappedSequenceWithEquatableElement([MinimalEquatableValue(1)])
   let separator = wrapValueIntoEquatable(MinimalEquatableValue(1))
   expectCrashLater()
-  _ = s.split(by: separator, maxSplits: -1, omittingEmptySubsequences: false)
+  _ = s.split(separator: separator, maxSplits: -1, omittingEmptySubsequences: false)
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/stdlib/private/SwiftPrivate/SwiftPrivate.swift b/stdlib/private/SwiftPrivate/SwiftPrivate.swift
index 0784147f0f8..cd7259a993a 100644
--- a/stdlib/private/SwiftPrivate/SwiftPrivate.swift
+++ b/stdlib/private/SwiftPrivate/SwiftPrivate.swift
@@ -24,7 +24,7 @@ public func asHex<
 where
   S.Iterator.Element : Integer
 >(x: S) -> String {
-  return "[ " + x.lazy.map { asHex($0) }.join(separator: ", ") + " ]"
+  return "[ " + x.lazy.map { asHex($0) }.joined(separator: ", ") + " ]"
 }
 
 /// Compute the prefix sum of `seq`.
diff --git a/stdlib/public/core/Collection.swift b/stdlib/public/core/Collection.swift
index fc556b50c1c..6cef3efb318 100644
--- a/stdlib/public/core/Collection.swift
+++ b/stdlib/public/core/Collection.swift
@@ -489,7 +489,7 @@ extension Collection where Iterator.Element : Equatable {
   /// - Precondition: `maxSplits >= 0`
   @warn_unused_result
   public func split(
-    by separator: Iterator.Element,
+    separator separator: Iterator.Element,
     maxSplits: Int = Int.max,
     omittingEmptySubsequences: Bool = true
   ) -> [SubSequence] {
@@ -764,9 +764,9 @@ extension Collection {
 }
 
 extension Collection where Iterator.Element : Equatable {
-  @available(*, unavailable, message="Please use split(_:maxSplits:omittingEmptySubsequences:) instead")
+  @available(*, unavailable, message="Please use split(separator:maxSplits:omittingEmptySubsequences:) instead")
   public func split(
-    by separator: Iterator.Element,
+    separator: Iterator.Element,
     maxSplit: Int = Int.max,
     allowEmptySlices: Bool = false
   ) -> [SubSequence] {
diff --git a/stdlib/public/core/Join.swift b/stdlib/public/core/Join.swift
index 65c787bb1ff..55c2d67bccc 100644
--- a/stdlib/public/core/Join.swift
+++ b/stdlib/public/core/Join.swift
@@ -19,7 +19,7 @@ internal enum _JoinIteratorState {
 
 /// An iterator that presents the elements of the sequences traversed
 /// by `Base`, concatenated using a given separator.
-public struct JoinIterator<
+public struct JoinedIterator<
   Base : IteratorProtocol where Base.Element : Sequence
 > : IteratorProtocol {
 
@@ -90,7 +90,7 @@ public struct JoinIterator<
 
 /// A sequence that presents the elements of the `Base` sequences
 /// concatenated using a given separator.
-public struct JoinSequence<
+public struct JoinedSequence<
   Base : Sequence where Base.Iterator.Element : Sequence
 > : Sequence {
 
@@ -110,8 +110,8 @@ public struct JoinSequence<
   /// Return an iterator over the elements of this sequence.
   ///
   /// - Complexity: O(1).
-  public func iterator() -> JoinIterator<Base.Iterator> {
-    return JoinIterator(
+  public func iterator() -> JoinedIterator<Base.Iterator> {
+    return JoinedIterator(
       base: _base.iterator(),
       separator: _separator)
   }
@@ -163,37 +163,37 @@ extension Sequence where Iterator.Element : Sequence {
   /// `separator` between the elements of the sequence `self`.
   ///
   /// For example,
-  /// `[[1, 2, 3], [4, 5, 6], [7, 8, 9]].join(separator: [-1, -2])`
+  /// `[[1, 2, 3], [4, 5, 6], [7, 8, 9]].joined(separator: [-1, -2])`
   /// yields `[1, 2, 3, -1, -2, 4, 5, 6, -1, -2, 7, 8, 9]`.
   @warn_unused_result
-  public func join<
+  public func joined<
     Separator : Sequence
     where
     Separator.Iterator.Element == Iterator.Element.Iterator.Element
-  >(separator separator: Separator) -> JoinSequence<Self> {
-    return JoinSequence(base: self, separator: separator)
+  >(separator separator: Separator) -> JoinedSequence<Self> {
+    return JoinedSequence(base: self, separator: separator)
   }
 }
 
-@available(*, unavailable, renamed="JoinIterator")
+@available(*, unavailable, renamed="JoinedIterator")
 public struct JoinGenerator<
   Base : IteratorProtocol where Base.Element : Sequence
 > {}
 
-extension JoinSequence {
+extension JoinedSequence {
   @available(*, unavailable, renamed="iterator")
-  public func generate() -> JoinIterator<Base.Iterator> {
+  public func generate() -> JoinedIterator<Base.Iterator> {
     fatalError("unavailable function can't be called")
   }
 }
 
 extension Sequence where Iterator.Element : Sequence {
-  @available(*, unavailable, renamed="join")
+  @available(*, unavailable, renamed="joined")
   public func joinWithSeparator<
     Separator : Sequence
     where
     Separator.Iterator.Element == Iterator.Element.Iterator.Element
-  >(separator: Separator) -> JoinSequence<Self> {
+  >(separator: Separator) -> JoinedSequence<Self> {
     fatalError("unavailable function can't be called")
   }
 }
diff --git a/stdlib/public/core/Sequence.swift b/stdlib/public/core/Sequence.swift
index 6a0df10dd96..c09541435a9 100644
--- a/stdlib/public/core/Sequence.swift
+++ b/stdlib/public/core/Sequence.swift
@@ -519,7 +519,7 @@ extension Sequence where Iterator.Element : Equatable {
   /// - Precondition: `maxSplits >= 0`
   @warn_unused_result
   public func split(
-    by separator: Iterator.Element,
+    separator separator: Iterator.Element,
     maxSplits: Int = Int.max,
     omittingEmptySubsequences: Bool = true
   ) -> [AnySequence<Iterator.Element>] {
@@ -671,9 +671,9 @@ extension Sequence {
 }
 
 extension Sequence where Iterator.Element : Equatable {
-  @available(*, unavailable, message="call 'split(_:omittingEmptySubsequences:isSeparator:)' and invert the 'allowEmptySlices' argument")
+  @available(*, unavailable, message="call 'split(separator:omittingEmptySubsequences:isSeparator:)' and invert the 'allowEmptySlices' argument")
   public func split(
-    by separator: Iterator.Element,
+    separator: Iterator.Element,
     maxSplit: Int = Int.max,
     allowEmptySlices: Bool = false
   ) -> [AnySequence<Iterator.Element>] {
diff --git a/stdlib/public/core/String.swift b/stdlib/public/core/String.swift
index 284e3b0f7b6..f34bfc4145b 100644
--- a/stdlib/public/core/String.swift
+++ b/stdlib/public/core/String.swift
@@ -610,9 +610,9 @@ extension Sequence where Iterator.Element == String {
   /// Interpose the `separator` between elements of `self`, then concatenate
   /// the result.  For example:
   ///
-  ///     ["foo", "bar", "baz"].join(separator: "-|-") // "foo-|-bar-|-baz"
+  ///     ["foo", "bar", "baz"].joined(separator: "-|-") // "foo-|-bar-|-baz"
   @warn_unused_result
-  public func join(separator separator: String) -> String {
+  public func joined(separator separator: String) -> String {
     var result = ""
 
     // FIXME(performance): this code assumes UTF-16 in-memory representation.
diff --git a/test/1_stdlib/Mirror.swift b/test/1_stdlib/Mirror.swift
index 9cb1844ee01..80292bbde11 100644
--- a/test/1_stdlib/Mirror.swift
+++ b/test/1_stdlib/Mirror.swift
@@ -37,7 +37,7 @@ extension Mirror {
     return "[" +
       children.lazy
         .map { "\($0.0 ?? nil_): \(String(reflecting: $0.1))" }
-        .join(separator: ", ")
+        .joined(separator: ", ")
       + "]"
   }
 }
diff --git a/test/SILOptimizer/devirt_type_subst_bug.swift b/test/SILOptimizer/devirt_type_subst_bug.swift
index 323ba99e9b2..cf6960fb771 100644
--- a/test/SILOptimizer/devirt_type_subst_bug.swift
+++ b/test/SILOptimizer/devirt_type_subst_bug.swift
@@ -16,5 +16,5 @@
 // from ApplyInst to match what GenericSignature expects.
 
 func asHex(a: [UInt8]) -> String {
-  return a.map { "0x" + String($0, radix: 16) }.join(separator: "")
+  return a.map { "0x" + String($0, radix: 16) }.joined(separator: "")
 }
diff --git a/test/expr/expressions.swift b/test/expr/expressions.swift
index 0bdddc80e56..c9079b204e1 100644
--- a/test/expr/expressions.swift
+++ b/test/expr/expressions.swift
@@ -674,8 +674,8 @@ func invalidDictionaryLiteral() {
 
     
 // FIXME: The issue here is a type compatibility problem, there is no ambiguity.
-[4].join(separator: [1]) // expected-error {{type of expression is ambiguous without more context}}
-[4].join(separator: [[[1]]]) // expected-error {{type of expression is ambiguous without more context}}
+[4].joined(separator: [1]) // expected-error {{type of expression is ambiguous without more context}}
+[4].joined(separator: [[[1]]]) // expected-error {{type of expression is ambiguous without more context}}
 
 //===----------------------------------------------------------------------===//
 // nil/metatype comparisons
diff --git a/validation-test/compiler_crashers_fixed/00039-string-join.script.swift b/validation-test/compiler_crashers_fixed/00039-string-join.script.swift
index 59829f0c7ca..1073c14d181 100644
--- a/validation-test/compiler_crashers_fixed/00039-string-join.script.swift
+++ b/validation-test/compiler_crashers_fixed/00039-string-join.script.swift
@@ -3,5 +3,5 @@
 // Test case submitted to project by https://github.com/tmu (Teemu Kurppa)
 // rdar://18174611
 
-["ab", "cd"].join(separator: "")
+["ab", "cd"].joined(separator: "")
 
diff --git a/validation-test/stdlib/Join.swift.gyb b/validation-test/stdlib/Join.swift.gyb
index ac14fc73e52..103b0a3b63b 100644
--- a/validation-test/stdlib/Join.swift.gyb
+++ b/validation-test/stdlib/Join.swift.gyb
@@ -282,7 +282,7 @@ JoinTestSuite.test("${Base}.join()") {
       ${Base}(${label} $0)
     })
     let separator = ${Base}(${label} test.separator)
-    let r = Array(elements.join(separator: separator))
+    let r = Array(elements.joined(separator: separator))
     checkSequence(test.expected, r)
   }
 }
@@ -293,7 +293,7 @@ JoinTestSuite.test("${Base}.join()/_copyToNativeArrayBuffer()") {
       ${Base}(${label} $0)
     })
     let separator = ${Base}(${label} test.separator)
-    let r = Array(elements.join(separator: separator))
+    let r = Array(elements.joined(separator: separator))
     checkSequence(test.expected, r)
   }
 }
@@ -301,10 +301,10 @@ JoinTestSuite.test("${Base}.join()/_copyToNativeArrayBuffer()") {
 % end
 
 func join(separator: String, _ elements: [String]) -> String {
-  return elements.join(separator: separator)
+  return elements.joined(separator: separator)
 }
 
-JoinTestSuite.test("String.join(separator:)") {
+JoinTestSuite.test("String.joined(separator:)") {
   //
   // Test the free function.
   //
@@ -341,7 +341,7 @@ JoinTestSuite.test("String.join(separator:)") {
   // Test forwarding instance function.
   //
 
-  expectEqual("abxycdxyef", ["ab", "cd", "ef"].join(separator: "xy"))
+  expectEqual("abxycdxyef", ["ab", "cd", "ef"].joined(separator: "xy"))
 }
 
 runAllTests()