---

yaml
---
r: 293723
b: refs/heads/tensorflow
c: f3bda1c
h: refs/heads/master
i:
  293721: c107881
  293719: 2a8a618

Author: gottesmm

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: ade2df1253dcc43d0af497c8ad93ba23f64a4942
+refs/heads/tensorflow: f3bda1c59ca6d30c4707ffa67c0b955d53632d15
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/benchmark/CMakeLists.txt

@@ -43,6 +43,7 @@ set(SWIFT_BENCH_MODULES
     single-source/BinaryFloatingPointProperties
     single-source/BitCount
     single-source/Breadcrumbs
+    single-source/BucketSort
     single-source/ByteSwap
     single-source/COWTree
     single-source/COWArrayGuaranteedParameterOverhead

branches/tensorflow/benchmark/single-source/BucketSort.swift

@@ -0,0 +1,139 @@
+//===--- BucketSort.swift ----------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+// Adapted from the original implementation: 
+// https://github.com/raywenderlich/swift-algorithm-club/tree/master/Bucket%20Sort
+// Issue: https://github.com/raywenderlich/swift-algorithm-club/issues/863
+
+// This benchmark implements the classical BucketSort algorithm described at
+// https://en.wikipedia.org/wiki/Bucket_sort. The implementation allows for an
+// array of generic type of "SortableItem" to be sorted. Unfortunately,  if
+// ``sortingAlgo'' type is not known for the callsite in line 84, then the 
+// ``sort'' method can not be specialized to integer array sorting, which will 
+// lead to a huge performance loss. Since SortingAlgorithm and InsertionSort are 
+// declared to be ``public'' and that lines 83-85 can not be inlined in
+// BucketSortImpl (due to inlining heuristic limitations), today swift 
+// compiler (without ExistentialSpecializer) can not achieve this feat.  With 
+// ExistentialSpecializer which enables generic specialization recursively in a
+// call chain, we are able to specialize line 84 for InsertionSort on integers.
+
+import TestsUtils
+import Foundation
+
+public let BucketSort = BenchmarkInfo(
+  name: "BucketSort",
+  runFunction: run_BucketSort,
+  tags: [.validation, .algorithm],
+  setUpFunction: { buildWorkload() },
+  legacyFactor: 10)
+
+public protocol IntegerConvertible {
+    func convertToInt() -> Int
+}
+extension Int: IntegerConvertible, SortableItem {
+    public func convertToInt() -> Int {
+        return self
+    }
+}
+public protocol SortableItem: IntegerConvertible, Comparable { }
+public protocol SortingAlgorithm {
+    func sort<T: SortableItem>(_ items: [T]) -> [T]
+}
+public struct InsertionSort: SortingAlgorithm {
+    public func sort<T: SortableItem>(_ items: [T]) -> [T] {
+        var sortedItems = items
+        for i in 0 ..< sortedItems.count {
+            var j = i
+            while j > 0 && sortedItems[j-1] > sortedItems[j] {
+                let temp = sortedItems[j-1]
+                sortedItems[j-1] = sortedItems[j]
+                sortedItems[j] = temp
+                j -= 1
+            }
+        }
+        return sortedItems
+    }
+}
+func distribute<T>(_ item: T, bucketArray: inout [Bucket<T>]) {
+  let val = item.convertToInt()
+  let capacity = bucketArray.first!.capacity
+  let index = val / capacity
+  bucketArray[index].add(item)
+}
+struct Bucket<T: SortableItem> {
+  var items: [T]
+  let capacity: Int
+  init(capacity: Int) {
+    self.capacity = capacity
+    items = [T]()
+  }
+  mutating func add(_ item: T) {
+    if items.count < capacity {
+      items.append(item)
+    }
+  }
+  func sort(_ sortingAlgo: SortingAlgorithm) -> [T] {
+    return sortingAlgo.sort(items)
+  }
+}
+func BucketSortImpl<T>(_ items: [T], sortingAlgorithm: SortingAlgorithm, bucketArray: [Bucket<T>]) -> [T] {
+  var copyBucketArray = bucketArray
+  for item in items {
+    distribute(item, bucketArray: &copyBucketArray)
+  }
+  var sortedArray = [T]()
+  for bucket in copyBucketArray {
+    sortedArray += bucket.sort(sortingAlgorithm)
+  }
+  return sortedArray
+}
+func isArraySorted(_ arr: [Int]) -> Bool {
+  var idx = 0
+  while idx < (arr.count - 1) {
+    if arr[idx] > arr[idx+1] {
+       return false
+    }
+    idx += 1
+  }
+  return true
+}
+let NUMITEMS = 2500
+let MAXBUCKETSIZE = 1000
+let NUMBUCKETS: Int = 10
+let items: [Int] = {
+  var array: [Int]? = [Int]()
+  for _ in 0..<NUMITEMS {
+    array!.append(Int.random(in: 0..<MAXBUCKETSIZE))
+  }
+  return array!
+}()
+
+let buckets: [Bucket<Int>] = {
+  let val = (items.max()?.convertToInt())! + 1
+  let maxCapacity = Int( ceil( Double(val) / Double(NUMBUCKETS)))
+  var bucketArray = [Bucket<Int>]()
+  for _ in 0..<NUMBUCKETS {
+    bucketArray.append(Bucket<Int>(capacity: maxCapacity))
+  }
+  return bucketArray
+}()
+@inline(never)
+func run_BucketSort(_ N : Int) {
+  for _ in 0..<N {
+    let sortedArray = BucketSortImpl(items, sortingAlgorithm: InsertionSort(), bucketArray: buckets)
+    CheckResults(isArraySorted(sortedArray))
+  }
+}
+@inline(never)
+func buildWorkload() {
+  blackHole(items)
+  blackHole(buckets)
+}

branches/tensorflow/benchmark/utils/main.swift

@@ -31,6 +31,7 @@ import BinaryFloatingPointConversionFromBinaryInteger
 import BinaryFloatingPointProperties
 import BitCount
 import Breadcrumbs
+import BucketSort
 import ByteSwap
 import COWTree
 import COWArrayGuaranteedParameterOverhead
@@ -199,6 +200,7 @@ registerBenchmark(BinaryFloatingPointPropertiesNextUp)
 registerBenchmark(BinaryFloatingPointPropertiesUlp)
 registerBenchmark(BitCount)
 registerBenchmark(Breadcrumbs)
+registerBenchmark(BucketSort)
 registerBenchmark(ByteSwap)
 registerBenchmark(COWTree)
 registerBenchmark(COWArrayGuaranteedParameterOverhead)

branches/tensorflow/include/swift/AST/Decl.h

@@ -234,11 +234,14 @@ struct OverloadSignature {
   /// Whether this signature is of a member defined in an extension of a generic
   /// type.
   unsigned InExtensionOfGenericType : 1;
+  
+  /// Whether this declaration has an opaque return type.
+  unsigned HasOpaqueReturnType : 1;
 
   OverloadSignature()
       : UnaryOperator(UnaryOperatorKind::None), IsInstanceMember(false),
         IsVariable(false), IsFunction(false), InProtocolExtension(false),
-        InExtensionOfGenericType(false) {}
+        InExtensionOfGenericType(false), HasOpaqueReturnType(false) {}
 };
 
 /// Determine whether two overload signatures conflict.

branches/tensorflow/include/swift/AST/DiagnosticsParse.def

@@ -852,10 +852,9 @@ ERROR(parameter_specifier_as_attr_disallowed,none,
       "'%0' before a parameter name is not allowed, place it before the parameter type instead",
       (StringRef))
 ERROR(parameter_specifier_repeated,none,
-      "parameter must not have multiple '__owned', 'inout', '__shared',"
-      " 'var', or 'let' specifiers", ())
-ERROR(parameter_let_var_as_attr,none,
-      "'%0' as a parameter attribute is not allowed",
+      "parameter must not have multiple '__owned', 'inout', or '__shared' specifiers", ())
+WARNING(parameter_let_var_as_attr,none,
+      "'%0' in this position is interpreted as an argument label",
       (StringRef))
 
 

branches/tensorflow/include/swift/AST/KnownIdentifiers.def

@@ -110,6 +110,7 @@ IDENTIFIER(type)
 IDENTIFIER(Value)
 IDENTIFIER(value)
 IDENTIFIER_WITH_NAME(value_, "_value")
+IDENTIFIER(WinSDK)
 IDENTIFIER(with)
 IDENTIFIER(withArguments)
 IDENTIFIER(withKeywordArguments)

branches/tensorflow/include/swift/AST/Module.h

@@ -983,10 +983,6 @@ class SourceFile final : public FileUnit {
   /// If not, we can fast-path module checks.
   bool HasImplementationOnlyImports = false;
 
-  /// The list of protocol conformances that were "used" within this
-  /// source file.
-  llvm::SetVector<NormalProtocolConformance *> UsedConformances;
-
   /// The scope map that describes this source file.
   ASTScope *Scope = nullptr;
 
@@ -1146,17 +1142,6 @@ class SourceFile final : public FileUnit {
 
   virtual bool walk(ASTWalker &walker) override;
 
-  /// Note that the given conformance was used by this source file.
-  void addUsedConformance(NormalProtocolConformance *conformance) {
-    UsedConformances.insert(conformance);
-  }
-
-  /// Retrieve the set of conformances that were used in this source
-  /// file.
-  ArrayRef<NormalProtocolConformance *> getUsedConformances() const {
-    return UsedConformances.getArrayRef();
-  }
-
   /// @{
 
   /// Look up the given operator in this file.

branches/tensorflow/include/swift/AST/TypeCheckRequests.h

@@ -550,7 +550,11 @@ class PropertyDelegateBackingPropertyInfoRequest :
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>
-bool AnyValue::Holder<Type>::equals(const HolderBase &other) const;
+inline bool AnyValue::Holder<Type>::equals(const HolderBase &other) const {
+  assert(typeID == other.typeID && "Caller should match type IDs");
+  return value.getPointer() ==
+      static_cast<const Holder<Type> &>(other).value.getPointer();
+}
 
 void simple_display(llvm::raw_ostream &out, const Type &type);
 

branches/tensorflow/include/swift/AST/Types.h

@@ -4689,6 +4689,14 @@ class ArchetypeType : public SubstitutableType,
 
   /// Get the generic environment this archetype lives in.
   GenericEnvironment *getGenericEnvironment() const;
+  
+  /// Get the protocol/class existential type that most closely represents the
+  /// set of constraints on this archetype.
+  ///
+  /// Right now, this only considers constraints on the archetype itself, not
+  /// any of its associated types, since those are the only kind of existential
+  /// type we can represent.
+  Type getExistentialType() const;
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {

branches/tensorflow/include/swift/Basic/Statistics.def

@@ -141,9 +141,6 @@ FRONTEND_STATISTIC(AST, NumPrefixOperators)
 /// Number of precedence groups in the AST context.
 FRONTEND_STATISTIC(AST, NumPrecedenceGroups)
 
-/// Number of conformances used by code processed by this frontend job.
-FRONTEND_STATISTIC(AST, NumUsedConformances)
-
 /// Number of full function bodies parsed.
 FRONTEND_STATISTIC(Parse, NumFunctionsParsed)
 

branches/tensorflow/include/swift/Parse/Parser.h

@@ -609,6 +609,8 @@ class Parser {
 
   void skipUntilDeclRBrace(tok T1, tok T2);
 
+  void skipListUntilDeclRBrace(SourceLoc startLoc, tok T1, tok T2);
+  
   /// Skip a single token, but match parentheses, braces, and square brackets.
   ///
   /// Note: this does \em not match angle brackets ("<" and ">")! These are

branches/tensorflow/include/swift/Parse/Token.h

@@ -173,8 +173,8 @@ class Token {
       return true;
     }
 
-    // 'let', 'var', and 'inout' cannot be argument labels.
-    if (isAny(tok::kw_let, tok::kw_var, tok::kw_inout))
+    // inout cannot be used as an argument label.
+    if (is(tok::kw_inout))
       return false;
 
     // All other keywords can be argument labels.

branches/tensorflow/include/swift/SIL/BridgedTypes.def

@@ -53,6 +53,9 @@ BRIDGING_KNOWN_TYPE(Swift, Error)
 BRIDGE_TYPE(ObjectiveC, ObjCBool, Swift, Bool, false)
 BRIDGE_TYPE(Darwin, DarwinBoolean, Swift, Bool, false)
 
+BRIDGING_KNOWN_TYPE(WinSDK, WindowsBool)
+BRIDGE_TYPE(WinSDK, WindowsBool, Swift, Bool, false)
+
 #undef BRIDGING_KNOWN_TYPE
 #undef BRIDGE_TYPE
 

branches/tensorflow/include/swift/SIL/SILBuilder.h

@@ -452,22 +452,13 @@ class SILBuilder {
 
   ApplyInst *createApply(
       SILLocation Loc, SILValue Fn, SubstitutionMap Subs,
-      ArrayRef<SILValue> Args, bool isNonThrowing,
+      ArrayRef<SILValue> Args, bool isNonThrowing = false,
       const GenericSpecializationInformation *SpecializationInfo = nullptr) {
     return insert(ApplyInst::create(getSILDebugLocation(Loc), Fn, Subs, Args,
                                     isNonThrowing, C.silConv, *F,
                                     C.OpenedArchetypes, SpecializationInfo));
   }
 
-  ApplyInst *createApply(
-      SILLocation Loc, SILValue Fn, ArrayRef<SILValue> Args, bool isNonThrowing,
-      const GenericSpecializationInformation *SpecializationInfo = nullptr) {
-    SILFunctionConventions conventions(Fn->getType().castTo<SILFunctionType>(),
-                                       getModule());
-    return createApply(Loc, Fn, SubstitutionMap(), Args, isNonThrowing,
-                       SpecializationInfo);
-  }
-
   TryApplyInst *createTryApply(
       SILLocation Loc, SILValue fn, SubstitutionMap subs,
       ArrayRef<SILValue> args, SILBasicBlock *normalBB, SILBasicBlock *errorBB,
@@ -490,7 +481,7 @@ class SILBuilder {
 
   BeginApplyInst *createBeginApply(
       SILLocation Loc, SILValue Fn, SubstitutionMap Subs,
-      ArrayRef<SILValue> Args, bool isNonThrowing,
+      ArrayRef<SILValue> Args, bool isNonThrowing = false,
       const GenericSpecializationInformation *SpecializationInfo = nullptr) {
     return insert(BeginApplyInst::create(
         getSILDebugLocation(Loc), Fn, Subs, Args, isNonThrowing, C.silConv, *F,

branches/tensorflow/lib/AST/ASTContext.cpp

@@ -3946,6 +3946,12 @@ ASTContext::getForeignRepresentationInfo(NominalTypeDecl *nominal,
       addTrivial(getIdentifier("DarwinBoolean"), darwin);
     }
 
+    if (auto winsdk = getLoadedModule(Id_WinSDK)) {
+      // NOTE: WindowsBool is odd because it is bridged to Bool in APIs, but can
+      // also be trivially bridged.
+      addTrivial(getIdentifier("WindowsBool"), winsdk);
+    }
+
     if (auto objectiveC = getLoadedModule(Id_ObjectiveC)) {
       addTrivial(Id_Selector, objectiveC, true);
 
@@ -4003,6 +4009,7 @@ ASTContext::getForeignRepresentationInfo(NominalTypeDecl *nominal,
     }
   };
   conditionallyAddTrivial(nominal, getIdentifier("DarwinBoolean") , Id_Darwin);
+  conditionallyAddTrivial(nominal, getIdentifier("WindowsBool"), Id_WinSDK);
   conditionallyAddTrivial(nominal, Id_Selector, Id_ObjectiveC, true);
   conditionallyAddTrivial(nominal, getIdentifier("ObjCBool"), Id_ObjectiveC);
   conditionallyAddTrivial(nominal, getSwiftId(KnownFoundationEntity::NSZone), Id_ObjectiveC, true);