---

yaml
---
r: 346833
b: refs/heads/master
c: c99da10
h: refs/heads/master
i:
  346831: c4d1dc0

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 452429d8d0a279423300d710375e6bb1304b6db5
+refs/heads/master: c99da10924b5c5f246808082dc41def5397578e2
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/Frontend/ParseableInterfaceSupport.cpp

@@ -452,7 +452,7 @@ bool ParseableInterfaceModuleLoader::buildSwiftModuleFromSwiftInterface(
       return;
     }
 
-    SubError = Diags.hadAnyError();
+    SubError = SubInstance.getDiags().hadAnyError();
   });
   return !RunSuccess || SubError;
 }

trunk/stdlib/public/Darwin/Foundation/NSValue.swift.gyb

@@ -23,3 +23,31 @@ ${ ObjectiveCBridgeableImplementationForNSValue("CGVector") }
 ${ ObjectiveCBridgeableImplementationForNSValue("CGSize") }
 ${ ObjectiveCBridgeableImplementationForNSValue("CGAffineTransform") }
 
+extension NSValue {
+    public func value<StoredType>(of type: StoredType.Type) -> StoredType? {
+        if StoredType.self is AnyObject.Type {
+            let encoding = String(cString: objCType)
+            // some subclasses of NSValue can return @ and the default initialized variant returns ^v for encoding
+            guard encoding == "^v" || encoding == "@" else {
+                return nil
+            }
+            return nonretainedObjectValue as? StoredType
+        } else if _isPOD(StoredType.self) {
+            var storedSize = 0
+            var storedAlignment = 0
+            NSGetSizeAndAlignment(objCType, &storedSize, &storedAlignment)
+            guard MemoryLayout<StoredType>.size == storedSize && MemoryLayout<StoredType>.alignment == storedAlignment else {
+                return nil
+            }
+            let allocated = UnsafeMutablePointer<StoredType>.allocate(capacity: 1)
+            defer { allocated.deallocate() }
+            if #available(OSX 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *) {
+            	getValue(allocated, size: storedSize)
+        	} else {
+        		getValue(allocated)
+        	}
+            return allocated.pointee
+        }
+        return nil
+    }
+}

trunk/test/ParseableInterface/ModuleCache/module-cache-errors-in-importing-file.swift

@@ -0,0 +1,23 @@
+// RUN: %empty-directory(%t)
+// RUN: %empty-directory(%t/modulecache)
+//
+// Setup builds a parseable interface for a module SomeModule (built from some-module.swift).
+// This test checks we still build and load its corresponding .swiftmodule when the file that imports it contains an error prior to the import statement.
+
+// Setup phase 1: Write the input file.
+//
+// RUN: echo 'public func SomeFunc() -> Int { return 42; }' >>%t/some-module.swift
+
+// Setup phase 2: build the module.
+//
+// RUN: %target-swift-frontend -I %t -emit-parseable-module-interface-path %t/SomeModule.swiftinterface -module-name SomeModule %t/some-module.swift -emit-module -o /dev/null
+
+// Actual test: compile and verify the import succeeds (i.e. we only report the error in this file)
+//
+// RUN: %target-swift-frontend -typecheck -verify -I %t -module-cache-path %t/modulecache -enable-parseable-module-interface %s
+
+unresolved // expected-error {{use of unresolved identifier 'unresolved'}}
+
+import SomeModule
+
+print(SomeFunc())

trunk/test/SourceKit/CodeComplete/Inputs/parseable-interface/MyPoint.swift

@@ -0,0 +1,13 @@
+public struct MyPoint {
+	public let x: Double
+	public let y: Double
+
+	public init(x: Double, y: Double) {
+		self.x = x
+		self.y = y
+	}
+
+	public var magnitudeSquared: Double {
+		return x*x + y*y
+	}
+}

trunk/test/SourceKit/CodeComplete/Inputs/parseable-interface/MyPointExtensions.swift

@@ -0,0 +1,7 @@
+import MyPoint
+
+public extension MyPoint {
+	var magnitude: Double {
+		return magnitudeSquared.squareRoot()
+	}
+}

trunk/test/SourceKit/CodeComplete/complete_swiftinterface.swift

@@ -0,0 +1,28 @@
+// RUN: %empty-directory(%t)
+// RUN: %empty-directory(%t/modulecache)
+
+// 1) Build .swiftinterface files for MyPoint and MyExtensions, using a non-default module cache path
+// RUN: %target-swift-frontend -emit-parseable-module-interface-path %t/MyPoint.swiftinterface -module-name MyPoint -emit-module -o /dev/null %S/Inputs/parseable-interface/MyPoint.swift
+// RUN: %target-swift-frontend -emit-parseable-module-interface-path %t/MyPointExtensions.swiftinterface -module-name MyPointExtensions -emit-module -o /dev/null -enable-parseable-module-interface -module-cache-path %t/modulecache -I %t %S/Inputs/parseable-interface/MyPointExtensions.swift
+// RUN: %empty-directory(%t/modulecache)
+
+// 2) Check completion using the default (cold) module cache
+// RUN: %target-swift-ide-test -code-completion -code-completion-token=MEMBER -source-filename %s -I %t | %FileCheck %s
+
+// 3) Check completion again with a warm module cache
+// RUN: %target-swift-ide-test -code-completion -code-completion-token=MEMBER -source-filename %s -I %t | %FileCheck %s
+
+import MyPoint
+import MyPointExtensions
+
+let x = MyPoint(x: 1, y: 10.5)
+
+print(x.#^MEMBER^#)
+
+// CHECK: Begin completions, 5 items
+// CHECK: Keyword[self]/CurrNominal:          self[#MyPoint#]; name=self
+// CHECK: Decl[InstanceVar]/CurrNominal:      x[#Double#]; name=x
+// CHECK: Decl[InstanceVar]/CurrNominal:      y[#Double#]; name=y
+// CHECK: Decl[InstanceVar]/CurrNominal:      magnitudeSquared[#Double#]; name=magnitudeSquared
+// CHECK: Decl[InstanceVar]/CurrNominal:      magnitude[#Double#]; name=magnitude
+// CHECK: End completions

trunk/test/stdlib/NSValueBridging.swift.gyb

@@ -91,4 +91,31 @@ nsValueBridging.test("NSValue can only be cast back to its original type") {
   _ = rangeObject as! CGRect
 }
 
+nsValueBridging.test("NSValue fetching method should be able to convert constructed values safely") {
+  let range = NSRange(location: 17, length: 38)
+  let value = NSValue(range: range)
+  expectEqual(value.value(of: NSRange.self)?.location, range.location)
+  expectEqual(value.value(of: NSRange.self)?.length, range.length)
+  expectEqual(value.value(of: CGRect.self), .none)
+  expectEqual(value.value(of: String.self), .none)
+  expectTrue(value.value(of: AnyObject.self) == nil)
+
+
+  class GenericThingNotRootedInObjC<T> {
+    init() { }
+  }
+
+  let obj = GenericThingNotRootedInObjC<String>()
+  // extend the lifetime to ensure that the non retained pointer is valid for the test duration
+  withExtendedLifetime(obj) { () -> Void in
+    let value = NSValue(nonretainedObject: obj)
+    let resString = value.value(of: GenericThingNotRootedInObjC<String>.self)
+    expectEqual(resString === obj, true) // ensure the value is exactly the same
+    
+    let resInt = value.value(of: GenericThingNotRootedInObjC<Int>.self)
+    expectTrue(resInt == nil)
+  }
+
+}
+
 runAllTests()

trunk/tools/swift-ide-test/swift-ide-test.cpp

@@ -264,6 +264,12 @@ static llvm::cl::opt<std::string>
 ModuleCachePath("module-cache-path", llvm::cl::desc("Clang module cache path"),
                 llvm::cl::cat(Category));
 
+static llvm::cl::opt<bool>
+EnableParseableModuleInterface("enable-parseable-module-interface",
+           llvm::cl::desc("Enable loading .swiftinterface files when available"),
+           llvm::cl::cat(Category),
+           llvm::cl::init(true));
+
 static llvm::cl::opt<std::string>
 PCHOutputDir("pch-output-dir",
              llvm::cl::desc("place autogenerated PCH files in this directory"),
@@ -3201,6 +3207,8 @@ int main(int argc, char *argv[]) {
         InitInvok.getLangOptions().EffectiveLanguageVersion = actual.getValue();
     }
   }
+  InitInvok.getFrontendOptions().EnableParseableModuleInterface =
+    options::EnableParseableModuleInterface;
   InitInvok.getClangImporterOptions().ModuleCachePath =
     options::ModuleCachePath;
   InitInvok.getClangImporterOptions().PrecompiledHeaderOutputDir =

trunk/utils/gyb_foundation_support.py

@@ -12,7 +12,11 @@ def ObjectiveCBridgeableImplementationForNSValue(Type):
                         _getObjCTypeEncoding({Type}.self)) == 0,
                  "NSValue does not contain the right type to bridge to {Type}")
     result = {Type}()
-    source.getValue(&result!)
+    if #available(OSX 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *) {{
+      source.getValue(&result!, size: MemoryLayout<{Type}>.size)
+    }} else {{
+      source.getValue(&result!)
+    }}
   }}
 
   public static func _conditionallyBridgeFromObjectiveC(_ source: NSValue,
@@ -23,7 +27,11 @@ def ObjectiveCBridgeableImplementationForNSValue(Type):
       return false
     }}
     result = {Type}()
-    source.getValue(&result!)
+    if #available(OSX 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *) {{
+      source.getValue(&result!, size: MemoryLayout<{Type}>.size)
+    }} else {{
+      source.getValue(&result!)
+    }}
     return true
   }}
 
@@ -34,7 +42,11 @@ def ObjectiveCBridgeableImplementationForNSValue(Type):
                         _getObjCTypeEncoding({Type}.self)) == 0,
                  "NSValue does not contain the right type to bridge to {Type}")
     var result = {Type}()
-    unwrappedSource.getValue(&result)
+    if #available(OSX 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *) {{
+      unwrappedSource.getValue(&result, size: MemoryLayout<{Type}>.size)
+    }} else {{
+      unwrappedSource.getValue(&result)
+    }}
     return result
   }}
 }}