[stdlib] String internal API review changes

I had to XFAIL test/ClangModules/cf.swift, which is failing for reasons
I can't understand.  <rdar://problem/16911496>

Swift SVN r18071

stdlib/core/StringUnicodeScalarView.swift

@@ -10,158 +10,160 @@
 //
 //===----------------------------------------------------------------------===//
 
-func ==(lhs: UnicodeScalarView.IndexType, rhs: UnicodeScalarView.IndexType) -> Bool {
+func ==(lhs: String.UnicodeScalarView.IndexType, rhs: String.UnicodeScalarView.IndexType) -> Bool {
   return lhs._position == rhs._position
 }
 
-struct UnicodeScalarView : Sliceable, Sequence {
-  init(_ _base: _StringCore) {
-    self._base = _base
-  }
-
-  struct ScratchGenerator : Generator {
-    var base :_StringCore
-    var idx : Int
-    init(_ core : _StringCore, _ pos : Int) {
-      idx = pos
-      base = core
-    }
-    mutating func next() -> UTF16.CodeUnit? {
-      return self.base[idx++]
-    }
-  }
-
-  // FIXME: This index should probably become bidirectional, as UTF16
-  // is traversable in either direction.
-  struct IndexType : BidirectionalIndex {
-    init(_ _position: Int, _ _base: _StringCore) {
-      self._position = _position
+extension String {
+  struct UnicodeScalarView : Sliceable, Sequence {
+    init(_ _base: _StringCore) {
       self._base = _base
     }
 
-    func succ() -> IndexType {
-      var scratch = ScratchGenerator(_base, _position)
-      UTF16.decode(&scratch)
-      return IndexType(scratch.idx, _base)
+    struct ScratchGenerator : Generator {
+      var base :_StringCore
+      var idx : Int
+      init(_ core : _StringCore, _ pos : Int) {
+        idx = pos
+        base = core
+      }
+      mutating func next() -> UTF16.CodeUnit? {
+        return self.base[idx++]
+      }
     }
 
-    func pred() -> IndexType {
-      var i = _position
-      let codeUnit = self._base[--i]
-      if codeUnit >= 0xD800 && codeUnit <= 0xE000 {
-        --i
+    // FIXME: This index should probably become bidirectional, as UTF16
+    // is traversable in either direction.
+    struct IndexType : BidirectionalIndex {
+      init(_ _position: Int, _ _base: _StringCore) {
+        self._position = _position
+        self._base = _base
       }
-      return IndexType(i, _base)
+
+      func succ() -> IndexType {
+        var scratch = ScratchGenerator(_base, _position)
+        UTF16.decode(&scratch)
+        return IndexType(scratch.idx, _base)
+      }
+
+      func pred() -> IndexType {
+        var i = _position
+        let codeUnit = self._base[--i]
+        if codeUnit >= 0xD800 && codeUnit <= 0xE000 {
+          --i
+        }
+        return IndexType(i, _base)
+      }
+      
+      var _position: Int
+      var _base: _StringCore
+    }
+
+    var startIndex: IndexType {
+      return IndexType(_base.startIndex, _base)
     }
     
-    var _position: Int
+    var endIndex: IndexType {
+      return IndexType(_base.endIndex, _base)
+    }
+    
+    subscript(i: IndexType) -> UnicodeScalar {
+      var scratch = ScratchGenerator(_base, i._position)
+      return UTF16.decode(&scratch)!
+    }
+
+    func __slice__(start: IndexType, end: IndexType) -> UnicodeScalarView {
+      return UnicodeScalarView(_base[start._position..end._position])
+    }
+
+    subscript(r: Range<IndexType>) -> UnicodeScalarView {
+      return UnicodeScalarView(_base[r.startIndex._position..r.endIndex._position])
+    }
+
+    struct GeneratorType : Generator {
+      init(_ _base: _StringCore.GeneratorType) {
+        self._base = _base
+      }
+
+      mutating func next() -> UnicodeScalar? {
+        return UTF16.decode(&self._base)
+      }
+      var _base: _StringCore.GeneratorType
+    }
+    
+    func generate() -> GeneratorType {
+      return GeneratorType(_base.generate())
+    }
+
+    @conversion
+    func __conversion() -> String {
+      return String(_base)
+    }
+
+    func compare(other : UnicodeScalarView) -> Int {
+      // Try to compare the string without decoding
+      // the UTF16 string.
+      var AIdx = self._base.startIndex
+      var BIdx = other._base.startIndex
+      var AEnd = self._base.endIndex
+      var BEnd = other._base.endIndex
+      while true {
+        if AIdx < AEnd {
+          if BIdx < BEnd {
+            let e1 = self._base[AIdx]
+            let e2 = other._base[BIdx]
+            if (e1 >= 0x80 || e2 >= 0x80) {
+              // Use slow unicode comparator if
+              // we found multi-byte scalar.
+              return _compareUnicode(other)
+            }
+
+            if e1 < e2 {
+              return -1
+            }
+            if e2 < e1 {
+              return 1
+            }
+            AIdx++
+            BIdx++
+            continue // equivalent
+          }
+          return 1
+        }
+        if BIdx < BEnd {
+          return -1
+        }
+        return 0
+      }
+    }
+
+    func _compareUnicode(other : UnicodeScalarView) -> Int {
+      var g1 = self.generate()
+      var g2 = other.generate()
+      while true {
+        let e1_ = g1.next()
+        let e2_ = g2.next()
+        if let e1 = e1_ {
+          if let e2 = e2_ {
+            if e1 < e2 {
+              return -1
+            }
+            if e2 < e1 {
+              return 1
+            }
+            continue // equivalent
+          }
+          return 1
+        }
+        if e2_ {
+          return -1
+        }
+        return 0
+      }
+    }
+
     var _base: _StringCore
   }
-
-  var startIndex: IndexType {
-    return IndexType(_base.startIndex, _base)
-  }
-  
-  var endIndex: IndexType {
-    return IndexType(_base.endIndex, _base)
-  }
-  
-  subscript(i: IndexType) -> UnicodeScalar {
-    var scratch = ScratchGenerator(_base, i._position)
-    return UTF16.decode(&scratch)!
-  }
-
-  func __slice__(start: IndexType, end: IndexType) -> UnicodeScalarView {
-    return UnicodeScalarView(_base[start._position..end._position])
-  }
-
-  subscript(r: Range<IndexType>) -> UnicodeScalarView {
-    return UnicodeScalarView(_base[r.startIndex._position..r.endIndex._position])
-  }
-
-  struct GeneratorType : Generator {
-    init(_ _base: _StringCore.GeneratorType) {
-      self._base = _base
-    }
-
-    mutating func next() -> UnicodeScalar? {
-      return UTF16.decode(&self._base)
-    }
-    var _base: _StringCore.GeneratorType
-  }
-  
-  func generate() -> GeneratorType {
-    return GeneratorType(_base.generate())
-  }
-
-  @conversion
-  func __conversion() -> String {
-    return String(_base)
-  }
-
-  func compare(other : UnicodeScalarView) -> Int {
-    // Try to compare the string without decoding
-    // the UTF16 string.
-    var AIdx = self._base.startIndex
-    var BIdx = other._base.startIndex
-    var AEnd = self._base.endIndex
-    var BEnd = other._base.endIndex
-    while true {
-      if AIdx < AEnd {
-        if BIdx < BEnd {
-          let e1 = self._base[AIdx]
-          let e2 = other._base[BIdx]
-          if (e1 >= 0x80 || e2 >= 0x80) {
-            // Use slow unicode comparator if
-            // we found multi-byte scalar.
-            return _compareUnicode(other)
-          }
-
-          if e1 < e2 {
-            return -1
-          }
-          if e2 < e1 {
-            return 1
-          }
-          AIdx++
-          BIdx++
-          continue // equivalent
-        }
-        return 1
-      }
-      if BIdx < BEnd {
-        return -1
-      }
-      return 0
-    }
-  }
-
-  func _compareUnicode(other : UnicodeScalarView) -> Int {
-    var g1 = self.generate()
-    var g2 = other.generate()
-    while true {
-      let e1_ = g1.next()
-      let e2_ = g2.next()
-      if let e1 = e1_ {
-        if let e2 = e2_ {
-          if e1 < e2 {
-            return -1
-          }
-          if e2 < e1 {
-            return 1
-          }
-          continue // equivalent
-        }
-        return 1
-      }
-      if e2_ {
-        return -1
-      }
-      return 0
-    }
-  }
-
-  var _base: _StringCore
 }
 
 extension String {