---

yaml
---
r: 348956
b: refs/heads/master
c: 4bafc77
h: refs/heads/master

Author: CodaFi

[refs]

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

trunk/cmake/modules/SwiftSource.cmake

@@ -333,11 +333,6 @@ function(_compile_swift_files
            "-emit-module-interface-path" "${interface_file}")
     endif()
 
-    if (NOT SWIFTFILE_IS_STDLIB_CORE)
-      list(APPEND swift_module_flags
-           "-Xfrontend" "-experimental-skip-non-inlinable-function-bodies")
-    endif()
-
     # If we have extra regexp flags, check if we match any of the regexps. If so
     # add the relevant flags to our swift_flags.
     if (SWIFT_EXPERIMENTAL_EXTRA_REGEXP_FLAGS OR SWIFT_EXPERIMENTAL_EXTRA_NEGATIVE_REGEXP_FLAGS)

trunk/lib/ClangImporter/ImportDecl.cpp

@@ -2853,6 +2853,7 @@ namespace {
         auto enumDecl = Impl.createDeclWithClangNode<EnumDecl>(
             decl, AccessLevel::Public, loc, enumName,
             Impl.importSourceLoc(decl->getLocation()), None, nullptr, enumDC);
+        enumDecl->setHasFixedRawValues();
         enumDecl->computeType();
 
         // Annotate as 'frozen' if appropriate.

trunk/lib/IRGen/LoadableByAddress.cpp

@@ -1426,20 +1426,6 @@ static void convertBBArgType(SILBuilder &argBuilder, SILType newSILType,
   }
 }
 
-static bool containsFunctionType(CanType ty) {
-  if (auto tuple = dyn_cast<TupleType>(ty)) {
-    for (auto elt : tuple.getElementTypes()) {
-      if (containsFunctionType(elt))
-        return true;
-    }
-    return false;
-  }
-  if (auto optionalType = ty.getOptionalObjectType()) {
-    return containsFunctionType(optionalType);
-  }
-  return isa<SILFunctionType>(ty);
-}
-
 void LoadableStorageAllocation::convertApplyResults() {
   for (auto &BB : *pass.F) {
     for (auto &II : BB) {
@@ -1464,7 +1450,16 @@ void LoadableStorageAllocation::convertApplyResults() {
         auto numFuncTy = llvm::count_if(origSILFunctionType->getResults(),
             [](const SILResultInfo &origResult) {
               auto resultStorageTy = origResult.getSILStorageType();
-              return containsFunctionType(resultStorageTy.getASTType());
+              // Check if it is a function type
+              if (resultStorageTy.is<SILFunctionType>()) {
+                return true;
+              }
+              // Check if it is an optional function type
+              auto optionalType = resultStorageTy.getOptionalObjectType();
+              if (optionalType && optionalType.is<SILFunctionType>()) {
+                return true;
+              }
+              return false;
             });
         assert(numFuncTy != 0 &&
                "Expected a SILFunctionType inside the result Type");

trunk/lib/Sema/TypeCheckDecl.cpp

@@ -1654,6 +1654,13 @@ EnumRawValuesRequest::evaluate(Evaluator &eval, EnumDecl *ED,
       continue;
     }
 
+    // If the raw values of the enum case are fixed, then we trust our callers
+    // to have set things up correctly.  This comes up with imported enums
+    // and deserialized @objc enums which always have their raw values setup
+    // beforehand.
+    if (ED->LazySemanticInfo.hasFixedRawValues())
+      continue;
+
     // Check that the raw value is unique.
     RawValueKey key{prevValue};
     RawValueSource source{elt, lastExplicitValueElt};

trunk/stdlib/public/runtime/HeapObject.cpp

@@ -72,19 +72,6 @@ static inline bool isValidPointerForNativeRetain(const void *p) {
 #endif
 }
 
-// Call the appropriate implementation of the `name` function, passing `args`
-// to the call. This checks for an override in the function pointer. If an
-// override is present, it calls that override. Otherwise it directly calls
-// the default implementation. This allows the compiler to inline the default
-// implementation and avoid the performance penalty of indirecting through
-// the function pointer in the common case.
-#define CALL_IMPL(name, args) do { \
-    if (SWIFT_UNLIKELY(_ ## name != _ ## name ## _)) \
-      return _ ## name args; \
-    return _ ## name ## _ args; \
-} while(0)
-
-
 static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
                                        size_t requiredSize,
                                        size_t requiredAlignmentMask) {
@@ -108,7 +95,9 @@ static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
 HeapObject *swift::swift_allocObject(HeapMetadata const *metadata,
                                      size_t requiredSize,
                                      size_t requiredAlignmentMask) {
-  CALL_IMPL(swift_allocObject, (metadata, requiredSize, requiredAlignmentMask));
+  if (SWIFT_UNLIKELY(_swift_allocObject != _swift_allocObject_))
+    return _swift_allocObject(metadata, requiredSize, requiredAlignmentMask);
+  return _swift_allocObject_(metadata, requiredSize, requiredAlignmentMask);
 }
 
 HeapObject *(*swift::_swift_allocObject)(HeapMetadata const *metadata,
@@ -316,7 +305,9 @@ static HeapObject *_swift_retain_(HeapObject *object) {
 }
 
 HeapObject *swift::swift_retain(HeapObject *object) {
-  CALL_IMPL(swift_retain, (object));
+  if (SWIFT_UNLIKELY(_swift_retain != _swift_retain_))
+    return _swift_retain(object);
+  return _swift_retain_(object);
 }
 
 HeapObject *(*swift::_swift_retain)(HeapObject *object) = _swift_retain_;
@@ -336,7 +327,9 @@ static HeapObject *_swift_retain_n_(HeapObject *object, uint32_t n) {
 }
 
 HeapObject *swift::swift_retain_n(HeapObject *object, uint32_t n) {
-  CALL_IMPL(swift_retain_n, (object, n));
+  if (SWIFT_UNLIKELY(_swift_retain_n != _swift_retain_n_))
+    return _swift_retain_n(object, n);
+  return _swift_retain_n_(object, n);
 }
 
 HeapObject *(*swift::_swift_retain_n)(HeapObject *object, uint32_t n) =
@@ -356,7 +349,9 @@ static void _swift_release_(HeapObject *object) {
 }
 
 void swift::swift_release(HeapObject *object) {
-  CALL_IMPL(swift_release, (object));
+  if (SWIFT_UNLIKELY(_swift_release != _swift_release_))
+    _swift_release(object);
+  _swift_release_(object);
 }
 
 void (*swift::_swift_release)(HeapObject *object) = _swift_release_;
@@ -374,7 +369,9 @@ static void _swift_release_n_(HeapObject *object, uint32_t n) {
 }
 
 void swift::swift_release_n(HeapObject *object, uint32_t n) {
-  CALL_IMPL(swift_release_n, (object, n));
+  if (SWIFT_UNLIKELY(_swift_release_n != _swift_release_n_))
+    return _swift_release_n(object, n);
+  return _swift_release_n_(object, n);
 }
 
 void (*swift::_swift_release_n)(HeapObject *object, uint32_t n) =
@@ -512,7 +509,9 @@ static HeapObject *_swift_tryRetain_(HeapObject *object) {
 }
 
 HeapObject *swift::swift_tryRetain(HeapObject *object) {
-  CALL_IMPL(swift_tryRetain, (object));
+  if (SWIFT_UNLIKELY(_swift_tryRetain != _swift_tryRetain_))
+    return _swift_tryRetain(object);
+  return _swift_tryRetain_(object);
 }
 
 HeapObject *(*swift::_swift_tryRetain)(HeapObject *object) = _swift_tryRetain_;

trunk/stdlib/toolchain/Compatibility50/ProtocolConformance.cpp

@@ -20,7 +20,6 @@
 #include "Overrides.h"
 #include "../../public/runtime/Private.h"
 #include "swift/Basic/Lazy.h"
-#include <dlfcn.h>
 #include <mach-o/dyld.h>
 #include <mach-o/getsect.h>
 #include <objc/runtime.h>
@@ -90,25 +89,13 @@ static void registerAddImageCallback(void *) {
   _dyld_register_func_for_add_image(addImageCallback);
 }
 
-static const Metadata *getObjCClassMetadata(const ClassMetadata *c) {
-  // Look up swift_getObjCClassMetadata dynamically. This handles the case
-  // where the main executable can't link against libswiftCore.dylib because
-  // it will be loaded dynamically from a location that isn't known at build
-  // time.
-  using FPtr = const Metadata *(*)(const ClassMetadata *);
-  FPtr func = SWIFT_LAZY_CONSTANT(
-    reinterpret_cast<FPtr>(dlsym(RTLD_DEFAULT, "swift_getObjCClassMetadata")));
-
-  return func(c);
-}
-
 // Clone of private helper swift::_swiftoverride_class_getSuperclass
 // for use in the override implementation.
 static const Metadata *_swift50override_class_getSuperclass(
                                                     const Metadata *theClass) {
   if (const ClassMetadata *classType = theClass->getClassObject()) {
     if (classHasSuperclass(classType))
-      return getObjCClassMetadata(classType->Superclass);
+      return getMetadataForClass(classType->Superclass);
   }
 
   if (const ForeignClassMetadata *foreignClassType

trunk/test/CMakeLists.txt

@@ -205,7 +205,7 @@ foreach(SDK ${SWIFT_SDKS})
 
     # NOTE create a stub BlocksRuntime library that can be used for the
     # reflection tests
-    file(WRITE ${test_bin_dir}/Inputs/BlocksRuntime.c
+    file(WRITE ${test_bin_dir}/BlocksRuntime.c
       "void
 #if defined(_WIN32)
 __declspec(dllexport)
@@ -220,7 +220,7 @@ _Block_release(void) { }\n")
       ARCHITECTURE ${ARCH}
       SDK ${SDK}
       INSTALL_IN_COMPONENT dev
-      ${test_bin_dir}/Inputs/BlocksRuntime.c)
+      ${test_bin_dir}/BlocksRuntime.c)
     set_target_properties(BlocksRuntimeStub${VARIANT_SUFFIX} PROPERTIES
       ARCHIVE_OUTPUT_DIRECTORY ${test_bin_dir}
       LIBRARY_OUTPUT_DIRECTORY ${test_bin_dir}

trunk/test/IRGen/big_types_corner_cases.swift

@@ -346,11 +346,3 @@ public extension sr8076_QueryHandler {
         return try body(query)
     }
 }
-
-public func foo() -> Optional<(a: Int?, b: Bool, c: (Int?)->BigStruct?)> {
-  return nil
-}
-
-public func dontAssert() {
-  let _ = foo()
-}

trunk/test/lit.cfg

@@ -178,8 +178,8 @@ config.test_format = swift_test.SwiftTest(coverage_mode=config.coverage_mode,
                                           execute_external=not use_lit_shell)
 
 # suffixes: A list of file extensions to treat as test files.
-config.suffixes = ['.swift', '.ll', '.sil', '.gyb', '.m', '.c',
-                   '.swiftinterface', '.test-sh']
+config.suffixes = ['.swift', '.ll', '.sil', '.gyb', '.m', '.swiftinterface',
+                   '.test-sh']
 
 # excludes: A list of directories to exclude from the testsuite. The 'Inputs'
 # subdirectories contain auxiliary inputs for various tests in their parent