---

yaml
---
r: 349228
b: refs/heads/master-next
c: 777d557
h: refs/heads/master

Author: jckarter

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: e2b6a3d98287176606b8a9b3a43c6c4d399c4d62
+refs/heads/master-next: 777d557d392d8c0842098e81046924db071c5bac
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/CMakeLists.txt

@@ -996,6 +996,7 @@ if(SWIFT_NEED_EXPLICIT_LIBDISPATCH)
                         -DCMAKE_CXX_COMPILER=${SWIFT_LIBDISPATCH_CXX_COMPILER}
                         -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
                         -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
+                        -DCMAKE_INSTALL_LIBDIR=lib
                         -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
                         -DCMAKE_LINKER=${CMAKE_LINKER}
                         -DCMAKE_RANLIB=${CMAKE_RANLIB}

branches/master-next/lib/Sema/TypeCheckDecl.cpp

@@ -1431,55 +1431,57 @@ static LiteralExpr *getAutomaticRawValueExpr(TypeChecker &TC,
   llvm_unreachable("Unhandled AutomaticEnumValueKind in switch.");
 }
 
-static void checkEnumRawValues(TypeChecker &TC, EnumDecl *ED) {
+static Optional<AutomaticEnumValueKind>
+computeAutomaticEnumValueKind(TypeChecker &TC, EnumDecl *ED) {
   Type rawTy = ED->getRawType();
-  if (!rawTy) {
-    return;
-  }
-
+  assert(rawTy && "Cannot compute value kind without raw type!");
+  
   if (ED->getGenericEnvironmentOfContext() != nullptr)
     rawTy = ED->mapTypeIntoContext(rawTy);
-  if (rawTy->hasError())
-    return;
-
-  AutomaticEnumValueKind valueKind;
+  
   // Swift enums require that the raw type is convertible from one of the
   // primitive literal protocols.
   auto conformsToProtocol = [&](KnownProtocolKind protoKind) {
-      ProtocolDecl *proto = TC.getProtocol(ED->getLoc(), protoKind);
-      return TypeChecker::conformsToProtocol(rawTy, proto,
-                                             ED->getDeclContext(), None);
+    ProtocolDecl *proto = TC.getProtocol(ED->getLoc(), protoKind);
+    return TypeChecker::conformsToProtocol(rawTy, proto,
+                                           ED->getDeclContext(), None);
   };
-
+  
   static auto otherLiteralProtocolKinds = {
     KnownProtocolKind::ExpressibleByFloatLiteral,
     KnownProtocolKind::ExpressibleByUnicodeScalarLiteral,
     KnownProtocolKind::ExpressibleByExtendedGraphemeClusterLiteral,
   };
-
+  
   if (conformsToProtocol(KnownProtocolKind::ExpressibleByIntegerLiteral)) {
-    valueKind = AutomaticEnumValueKind::Integer;
+    return AutomaticEnumValueKind::Integer;
   } else if (conformsToProtocol(KnownProtocolKind::ExpressibleByStringLiteral)){
-    valueKind = AutomaticEnumValueKind::String;
+    return AutomaticEnumValueKind::String;
   } else if (std::any_of(otherLiteralProtocolKinds.begin(),
                          otherLiteralProtocolKinds.end(),
                          conformsToProtocol)) {
-    valueKind = AutomaticEnumValueKind::None;
+    return AutomaticEnumValueKind::None;
   } else {
-    TC.diagnose(ED->getInherited().front().getSourceRange().Start,
-                diag::raw_type_not_literal_convertible,
-                rawTy);
-    ED->getInherited().front().setInvalidType(TC.Context);
-    return;
+    return None;
   }
+}
 
-  // We need at least one case to have a raw value.
-  if (ED->getAllElements().empty()) {
-    TC.diagnose(ED->getInherited().front().getSourceRange().Start,
-                diag::empty_enum_raw_type);
+static void checkEnumRawValues(TypeChecker &TC, EnumDecl *ED) {
+  Type rawTy = ED->getRawType();
+  if (!rawTy) {
     return;
   }
 
+  if (ED->getGenericEnvironmentOfContext() != nullptr)
+    rawTy = ED->mapTypeIntoContext(rawTy);
+  if (rawTy->hasError())
+    return;
+
+  // If we don't have a value kind, the decl checker will provide a diagnostic.
+  auto valueKind = computeAutomaticEnumValueKind(TC, ED);
+  if (!valueKind.hasValue())
+    return;
+  
   // Check the raw values of the cases.
   LiteralExpr *prevValue = nullptr;
   EnumElementDecl *lastExplicitValueElt = nullptr;
@@ -1499,24 +1501,14 @@ static void checkEnumRawValues(TypeChecker &TC, EnumDecl *ED) {
     (void)elt->getInterfaceType();
     if (elt->isInvalid())
       continue;
-
-    // We don't yet support raw values on payload cases.
-    if (elt->hasAssociatedValues()) {
-      TC.diagnose(elt->getLoc(),
-                  diag::enum_with_raw_type_case_with_argument);
-      TC.diagnose(ED->getInherited().front().getSourceRange().Start,
-                  diag::enum_raw_type_here, rawTy);
-      elt->setInvalid();
-      continue;
-    }
 
     if (elt->hasRawValueExpr()) {
       lastExplicitValueElt = elt;
     } else {
       // If the enum element has no explicit raw value, try to
       // autoincrement from the previous value, or start from zero if this
       // is the first element.
-      auto nextValue = getAutomaticRawValueExpr(TC, valueKind, elt, prevValue);
+      auto nextValue = getAutomaticRawValueExpr(TC, *valueKind, elt, prevValue);
       if (!nextValue) {
         elt->setInvalid();
         break;
@@ -2611,11 +2603,26 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     checkAccessControl(TC, ED);
 
     TC.checkPatternBindingCaptures(ED);
-
-    if (ED->hasRawType() && !ED->isObjC()) {
+    
+    if (auto rawTy = ED->getRawType()) {
+      // The raw type must be one of the blessed literal convertible types.
+      if (!computeAutomaticEnumValueKind(TC, ED)) {
+        TC.diagnose(ED->getInherited().front().getSourceRange().Start,
+                    diag::raw_type_not_literal_convertible,
+                    rawTy);
+        ED->getInherited().front().setInvalidType(TC.Context);
+      }
+      
+      // We need at least one case to have a raw value.
+      if (ED->getAllElements().empty()) {
+        TC.diagnose(ED->getInherited().front().getSourceRange().Start,
+                    diag::empty_enum_raw_type);
+      }
+      
       // ObjC enums have already had their raw values checked, but pure Swift
       // enums haven't.
-      checkEnumRawValues(TC, ED);
+      if (!ED->isObjC())
+        checkEnumRawValues(TC, ED);
     }
 
     checkExplicitAvailability(ED);
@@ -3089,6 +3096,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
   void visitEnumElementDecl(EnumElementDecl *EED) {
     (void)EED->getInterfaceType();
+    auto *ED = EED->getParentEnum();
 
     TC.checkDeclAttributes(EED);
 
@@ -3097,8 +3105,19 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       checkDefaultArguments(TC, PL, EED);
     }
 
+    // We don't yet support raw values on payload cases.
+    if (EED->hasAssociatedValues()) {
+      if (auto rawTy = ED->getRawType()) {
+        TC.diagnose(EED->getLoc(),
+                    diag::enum_with_raw_type_case_with_argument);
+        TC.diagnose(ED->getInherited().front().getSourceRange().Start,
+                    diag::enum_raw_type_here, rawTy);
+        EED->setInvalid();
+      }
+    }
+
     // Yell if our parent doesn't have a raw type but we have a raw value.
-    if (!EED->getParentEnum()->hasRawType() && EED->hasRawValueExpr()) {
+    if (EED->hasRawValueExpr() && !ED->hasRawType()) {
       TC.diagnose(EED->getRawValueExpr()->getLoc(),
                   diag::enum_raw_value_without_raw_type);
       EED->setInvalid();

branches/master-next/lib/Sema/TypeCheckDeclObjC.cpp

@@ -1372,6 +1372,11 @@ static bool isEnumObjC(EnumDecl *enumDecl) {
     return false;
   }
 
+  // We need at least one case to have a raw value.
+  if (enumDecl->getAllElements().empty()) {
+    enumDecl->diagnose(diag::empty_enum_raw_type);
+  }
+  
   return true;
 }
 

branches/master-next/stdlib/public/core/BridgeObjectiveC.swift

@@ -85,10 +85,7 @@ public protocol _ObjectiveCBridgeable {
 
 #if _runtime(_ObjC)
 
-@available(macOS, introduced: 9999, deprecated)
-@available(iOS, introduced: 9999, deprecated)
-@available(watchOS, introduced: 9999, deprecated)
-@available(tvOS, introduced: 9999, deprecated)
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 @available(*, deprecated)
 @_cdecl("_SwiftCreateBridgedArray")
 @usableFromInline
@@ -101,6 +98,19 @@ internal func _SwiftCreateBridgedArray(
   return Unmanaged<AnyObject>.passRetained(bridged)
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+@available(*, deprecated)
+@_cdecl("_SwiftCreateBridgedMutableArray")
+@usableFromInline
+internal func _SwiftCreateBridgedMutableArray(
+  values: UnsafePointer<AnyObject>,
+  numValues: Int
+) -> Unmanaged<AnyObject> {
+  let bufPtr = UnsafeBufferPointer(start: values, count: numValues)
+  let bridged = _SwiftNSMutableArray(Array(bufPtr))
+  return Unmanaged<AnyObject>.passRetained(bridged)
+}
+
 @_silgen_name("swift_stdlib_connectNSBaseClasses")
 internal func _connectNSBaseClasses() -> Bool
 

branches/master-next/stdlib/public/core/Runtime.swift.gyb

@@ -276,6 +276,18 @@ internal class __SwiftNativeNSArray {
   deinit {}
 }
 
+@_fixed_layout
+@usableFromInline
+@objc @_swift_native_objc_runtime_base(__SwiftNativeNSMutableArrayBase)
+internal class _SwiftNativeNSMutableArray {
+  @inlinable
+  @nonobjc
+  internal init() {}
+//  @objc public init(coder: AnyObject) {}
+  @inlinable
+  deinit {}
+}
+
 @_fixed_layout
 @usableFromInline
 @objc @_swift_native_objc_runtime_base(__SwiftNativeNSDictionaryBase)