---

yaml
---
r: 293759
b: refs/heads/tensorflow
c: 6ca706e
h: refs/heads/master
i:
  293757: c79a1cb
  293755: 4d55a65
  293751: 8222d67
  293743: e33d3c1
  293727: a484558
  293695: ab579fd
  293631: d0f8079

Author: palimondo

[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: d2a47db71aa57c33feb29001a3428ba8812b9078
+refs/heads/tensorflow: 6ca706eb1d9053f57e059bc1f5922e5fdf5df7bc
 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

@@ -3058,14 +3058,22 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
     return cast<ProtocolDecl>(getDeclContext());
   }
 
+  /// Check if we have a default definition type.
+  bool hasDefaultDefinitionType() const {
+    // If we have a TypeRepr, return true immediately without kicking off
+    // a request.
+    return !DefaultDefinition.isNull() || getDefaultDefinitionType();
+  }
+
   /// Retrieve the default definition type.
-  Type getDefaultDefinitionType() const {
-    return getDefaultDefinitionLoc().getType();
+  Type getDefaultDefinitionType() const;
+
+  TypeLoc &getDefaultDefinitionLoc() {
+    return DefaultDefinition;
   }
 
-  TypeLoc &getDefaultDefinitionLoc();
   const TypeLoc &getDefaultDefinitionLoc() const {
-    return const_cast<AssociatedTypeDecl *>(this)->getDefaultDefinitionLoc();
+    return DefaultDefinition;
   }
 
   /// Retrieve the trailing where clause for this associated type, if any.
@@ -3076,7 +3084,7 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
     TrailingWhere = trailingWhereClause;
   }
 
-  /// Set the interface type of this associated type declaration to a dependen
+  /// Set the interface type of this associated type declaration to a dependent
   /// member type of 'Self'.
   void computeType();
 

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/LazyResolver.h

@@ -159,8 +159,8 @@ class alignas(void*) LazyMemberLoader {
                       SmallVectorImpl<ProtocolConformance *> &Conformances) = 0;
 
   /// Returns the default definition type for \p ATD.
-  virtual TypeLoc loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,
-                                            uint64_t contextData) = 0;
+  virtual Type loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,
+                                         uint64_t contextData) = 0;
 
   /// Returns the generic environment.
   virtual GenericEnvironment *loadGenericEnvironment(const DeclContext *decl,

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/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

@@ -198,9 +198,13 @@ class SILBuilder {
   SILModule &getModule() const { return C.Module; }
   ASTContext &getASTContext() const { return getModule().getASTContext(); }
   const Lowering::TypeLowering &getTypeLowering(SILType T) const {
-    // FIXME: Expansion
-    return getModule().Types.getTypeLowering(T,
-                                             ResilienceExpansion::Minimal);
+    auto expansion = ResilienceExpansion::Maximal;
+    // If there's no current SILFunction, we're inserting into a global
+    // variable initializer.
+    if (F)
+      expansion = F->getResilienceExpansion();
+
+    return getModule().Types.getTypeLowering(T, expansion);
   }
 
   void setOpenedArchetypesTracker(SILOpenedArchetypesTracker *Tracker) {
@@ -452,22 +456,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 +485,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,
@@ -2167,15 +2162,7 @@ class SILBuilder {
     if (!SILModuleConventions(M).useLoweredAddresses())
       return true;
 
-    // FIXME: Just call getTypeLowering() here, and move this code there
-
-    auto expansion = ResilienceExpansion::Maximal;
-    // If there's no current SILFunction, we're inserting into a global
-    // variable initializer.
-    if (F)
-      expansion = F->getResilienceExpansion();
-
-    return M.Types.getTypeLowering(Ty, expansion).isLoadable();
+    return getTypeLowering(Ty).isLoadable();
   }
 
   void appendOperandTypeName(SILType OpdTy, llvm::SmallString<16> &Name) {