---

yaml
---
r: 245759
b: refs/heads/marcrasi-static-assert
c: eac1524
h: refs/heads/master
i:
  245757: 5bda214
  245755: 0595368
  245751: 2ce295a
  245743: 9b5a5fd
  245727: 2e9a202
  245695: 1a03880
  245631: 024075c
  245503: 94d0b18
  245247: 5d17d4d
  244735: f43bb5c
  243711: 6072ae5
  241663: 2827929
  237567: 994e00e
  229375: 9ccee7d

Author: gottesmm

[refs]

@@ -1071,7 +1071,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-09-20-a: 37a08a7edae5cf9ebde7866dbc974
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-09-21-a: a47bb052988de099ac2562a50cd1ee60a411e182
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-09-22-a: 141f61f3c887a81aa5d7a66e843f5e5e9a31ca02
 refs/heads/anotherdayanothercommit: 983c399b25b26d80728c0bf11b12afac852768f6
-refs/heads/marcrasi-static-assert: dd8edef2d5644c9228e8b3f5381d97f5b772dc87
+refs/heads/marcrasi-static-assert: eac1524277364fc04a5e60d6eaf739b93251afcc
 refs/heads/revert-19500-updateValue-but-not-the-key: b4e27b110af0d7e3002b4f734a347f752d42b9a8
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-09-25-a: 2ed7952ddd7ef765b60efd13e169ea900ebb5e80
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-09-26-a: b7cbce34ef0921069091a65e5918640bb382a419

branches/marcrasi-static-assert/benchmark/CMakeLists.txt

@@ -88,6 +88,7 @@ set(SWIFT_BENCH_MODULES
     single-source/Hash
     single-source/HashQuadratic
     single-source/Histogram
+    single-source/InsertCharacter  
     single-source/Integrate
     single-source/IterateData
     single-source/Join

branches/marcrasi-static-assert/benchmark/single-source/InsertCharacter.swift

@@ -0,0 +1,98 @@
+//===--- InsertCharacter.swift ------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 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
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+public let InsertCharacter = [
+  BenchmarkInfo(name: "InsertCharacterEndIndex", runFunction: run_InsertCharacterEndIndex, tags: [.validation, .api], setUpFunction: buildWorkload),
+  BenchmarkInfo(name: "InsertCharacterTowardsEndIndex", runFunction: run_InsertCharacterTowardsEndIndex, tags: [.validation, .api], setUpFunction: buildWorkload),
+  BenchmarkInfo(name: "InsertCharacterStartIndex", runFunction: run_InsertCharacterStartIndex, tags: [.validation, .api], setUpFunction: buildWorkload),
+  BenchmarkInfo(name: "InsertCharacterEndIndexNonASCII", runFunction: run_InsertCharacterEndIndexNonASCII, tags: [.validation, .api], setUpFunction: buildWorkload),
+  BenchmarkInfo(name: "InsertCharacterTowardsEndIndexNonASCII", runFunction: run_InsertCharacterTowardsEndIndexNonASCII, tags: [.validation, .api], setUpFunction: buildWorkload),
+  BenchmarkInfo(name: "InsertCharacterStartIndexNonASCII", runFunction: run_InsertCharacterStartIndexNonASCII, tags: [.validation, .api], setUpFunction: buildWorkload)
+]
+
+let str = String(repeating: "A very long ASCII string.", count: 200)
+
+func buildWorkload() {
+  blackHole(str)
+}
+
+// Insert towards end index
+
+@inline(__always)
+func insertTowardsEndIndex(_ c: Character, in string: String, count: Int) {
+  var workload = string
+  var index = workload.endIndex
+  for i in 0..<count {
+    workload.insert(identity(c), at: index)
+    if i % 1000 == 0 {
+      index = workload.endIndex
+    }
+  }
+  blackHole(workload)
+}
+
+@inline(never)
+func run_InsertCharacterTowardsEndIndex(_ N: Int) {
+  insertTowardsEndIndex("s", in: str, count: N * 3000)
+}
+
+@inline(never)
+func run_InsertCharacterTowardsEndIndexNonASCII(_ N: Int) {
+  insertTowardsEndIndex("👩🏼‍💻", in: str, count: N * 1000)
+}
+
+// Insert at end index
+
+@inline(__always)
+func insertAtEndIndex(_ c: Character, in string: String, count: Int) {
+  var workload = string
+  for _ in 0..<count {
+    workload.insert(identity(c), at: workload.endIndex)
+  }
+  blackHole(workload)
+}
+
+@inline(never)
+func run_InsertCharacterEndIndex(_ N: Int) {
+  insertAtEndIndex("s", in: str, count: N * 3000)
+}
+
+@inline(never)
+func run_InsertCharacterEndIndexNonASCII(_ N: Int) {
+  insertAtEndIndex("👩🏾‍🏫", in: str, count: N * 1000)
+}
+
+// Insert at start index
+
+@inline(__always)
+func insertAtStartIndex(_ c: Character, in string: String, count: Int, insertions: Int) {
+  var workload = str
+  for _ in 0..<count {
+    for _ in 0..<insertions {
+      workload.insert(identity(c), at: workload.startIndex)
+    }
+    workload = str
+  }
+  blackHole(workload)
+}
+
+@inline(never)
+func run_InsertCharacterStartIndex(_ N: Int) {
+  insertAtStartIndex("w", in: str, count: N * 75, insertions: 50)
+}
+
+@inline(never)
+func run_InsertCharacterStartIndexNonASCII(_ N: Int) {
+  insertAtStartIndex("👩🏾‍🏫", in: str, count: N * 75, insertions: 25)
+}

branches/marcrasi-static-assert/benchmark/utils/main.swift

@@ -76,6 +76,7 @@ import Hanoi
 import Hash
 import HashQuadratic
 import Histogram
+import InsertCharacter
 import Integrate
 import IterateData
 import Join
@@ -241,6 +242,7 @@ registerBenchmark(Hanoi)
 registerBenchmark(HashTest)
 registerBenchmark(HashQuadratic)
 registerBenchmark(Histogram)
+registerBenchmark(InsertCharacter)
 registerBenchmark(IntegrateTest)
 registerBenchmark(IterateData)
 registerBenchmark(Join)

branches/marcrasi-static-assert/docs/ABI/Mangling.rst

@@ -128,7 +128,7 @@ Globals
 
   global ::= protocol-conformance 'Mc'   // protocol conformance descriptor
   global ::= protocol-conformance 'WP'   // protocol witness table
-  global ::= protocol-conformance 'Wa'   // protocol witness table accessor
+  global ::= protocol-conformance 'Wa'   // protocol witness table accessor (HISTORICAL)
 
   global ::= protocol-conformance 'WG'   // generic protocol witness table (HISTORICAL)
   global ::= protocol-conformance 'Wp'   // protocol witness table pattern

branches/marcrasi-static-assert/docs/GenericsManifesto.md

@@ -346,7 +346,7 @@ public struct ZipIterator<... Iterators : IteratorProtocol> : Iterator {  // zer
   public mutating func next() -> Element? {
     if reachedEnd { return nil }
 
-    guard let values = (iterators.next()...) {   // call "next" on each of the iterators, put the results into a tuple named "values"
+    guard let values = (iterators.next()...) else {   // call "next" on each of the iterators, put the results into a tuple named "values"
       reachedEnd = true
       return nil
     }

branches/marcrasi-static-assert/include/swift/ABI/Metadata.h

@@ -2013,13 +2013,10 @@ struct TargetGenericWitnessTable {
   /// to require instantiation.
   uint16_t WitnessTablePrivateSizeInWordsAndRequiresInstantiation;
 
-  /// The pattern.
-  RelativeDirectPointer<const TargetWitnessTable<Runtime>> Pattern;
-
   /// The instantiation function, which is called after the template is copied.
   RelativeDirectPointer<void(TargetWitnessTable<Runtime> *instantiatedTable,
                              const TargetMetadata<Runtime> *type,
-                             void ** const *instantiationArgs),
+                             const void * const *instantiationArgs),
                         /*nullable*/ true> Instantiator;
 
   using PrivateDataType = void *[swift::NumGenericMetadataPrivateDataWords];
@@ -2036,18 +2033,6 @@ struct TargetGenericWitnessTable {
   uint16_t requiresInstantiation() const {
     return WitnessTablePrivateSizeInWordsAndRequiresInstantiation & 0x01;
   }
-
-  /// Retrieve the protocol conformance descriptor.
-  ConstTargetPointer<Runtime, TargetProtocolConformanceDescriptor<Runtime>>
-  getConformance() const {
-    return Pattern->Description;
-  }
-
-  /// Retrieve the protocol.
-  ConstTargetPointer<Runtime, TargetProtocolDescriptor<Runtime>>
-  getProtocol() const {
-    return Pattern->Description->getProtocol();
-  }
 };
 using GenericWitnessTable = TargetGenericWitnessTable<InProcess>;
 
@@ -2279,15 +2264,8 @@ struct TargetProtocolConformanceDescriptor final
   // Some description of the type that conforms to the protocol.
   TargetTypeReference<Runtime> TypeRef;
 
-  // The conformance, or a generator function for the conformance.
-  union {
-    /// A direct reference to the witness table for the conformance.
-    RelativeDirectPointer<const TargetWitnessTable<Runtime>> WitnessTable;
-    
-    /// A function that produces the witness table given an instance of the
-    /// type.
-    RelativeDirectPointer<WitnessTableAccessorFn> WitnessTableAccessor;
-  };
+  /// The witness table pattern, which may also serve as the witness table.
+  RelativeDirectPointer<const TargetWitnessTable<Runtime>> WitnessTablePattern;
 
   /// Various flags, including the kind of conformance.
   ConformanceFlags Flags;
@@ -2302,10 +2280,6 @@ struct TargetProtocolConformanceDescriptor final
     return Flags.getTypeReferenceKind();
   }
 
-  typename ConformanceFlags::ConformanceKind getConformanceKind() const {
-    return Flags.getConformanceKind();
-  }
-
   const char *getDirectObjCClassName() const {
     return TypeRef.getDirectObjCClassName(getTypeKind());
   }
@@ -2325,6 +2299,18 @@ struct TargetProtocolConformanceDescriptor final
     return this->template getTrailingObjects<RelativeContextPointer<Runtime>>();
   }
 
+  /// Whether this conformance is non-unique because it has been synthesized
+  /// for a foreign type.
+  bool isSynthesizedNonUnique() const {
+    return Flags.isSynthesizedNonUnique();
+  }
+
+  /// Whether this conformance has any conditional requirements that need to
+  /// be evaluated.
+  bool hasConditionalRequirements() const {
+    return Flags.getNumConditionalRequirements() > 0;
+  }
+
   /// Retrieve the conditional requirements that must also be
   /// satisfied
   llvm::ArrayRef<GenericRequirementDescriptor>
@@ -2333,31 +2319,12 @@ struct TargetProtocolConformanceDescriptor final
             Flags.getNumConditionalRequirements()};
   }
 
-  /// Get the directly-referenced static witness table.
-  const swift::TargetWitnessTable<Runtime> *getStaticWitnessTable() const {
-    switch (getConformanceKind()) {
-    case ConformanceFlags::ConformanceKind::WitnessTable:
-      break;
-        
-    case ConformanceFlags::ConformanceKind::WitnessTableAccessor:
-    case ConformanceFlags::ConformanceKind::ConditionalWitnessTableAccessor:
-      assert(false && "not witness table");
-    }
-    return WitnessTable;
+  /// Get the directly-referenced witness table pattern, which may also
+  /// serve as the witness table.
+  const swift::TargetWitnessTable<Runtime> *getWitnessTablePattern() const {
+    return WitnessTablePattern;
   }
-  
-  WitnessTableAccessorFn *getWitnessTableAccessor() const {
-    switch (getConformanceKind()) {
-    case ConformanceFlags::ConformanceKind::WitnessTableAccessor:
-    case ConformanceFlags::ConformanceKind::ConditionalWitnessTableAccessor:
-      break;
-        
-    case ConformanceFlags::ConformanceKind::WitnessTable:
-      assert(false && "not witness table accessor");
-    }
-    return WitnessTableAccessor;
-  }
-  
+
   /// Get the canonical metadata for the type referenced by this record, or
   /// return null if the record references a generic or universal type.
   const TargetMetadata<Runtime> *getCanonicalTypeMetadata() const;

branches/marcrasi-static-assert/include/swift/ABI/MetadataValues.h

@@ -600,24 +600,9 @@ class ConformanceFlags {
 public:
   typedef uint32_t int_type;
 
-  enum class ConformanceKind {
-    /// A direct reference to a protocol witness table.
-    WitnessTable,
-    /// A function pointer that can be called to access the protocol witness
-    /// table.
-    WitnessTableAccessor,
-    /// A function pointer that can be called to access the protocol witness
-    /// table whose conformance is conditional on additional requirements that
-    /// must first be evaluated and then provided to the accessor function.
-    ConditionalWitnessTableAccessor,
-
-    First_Kind = WitnessTable,
-    Last_Kind = ConditionalWitnessTableAccessor,
-  };
-
 private:
   enum : int_type {
-    ConformanceKindMask = 0x07,      // 8 conformance kinds
+    UnusedLowBits = 0x07,      // historical conformance kind
 
     TypeMetadataKindMask = 0x7 << 3, // 8 type reference kinds
     TypeMetadataKindShift = 3,
@@ -637,10 +622,6 @@ class ConformanceFlags {
 public:
   ConformanceFlags(int_type value = 0) : Value(value) {}
 
-  ConformanceFlags withConformanceKind(ConformanceKind kind) const {
-    return ConformanceFlags((Value & ~ConformanceKindMask) | int_type(kind));
-  }
-
   ConformanceFlags withTypeReferenceKind(TypeReferenceKind kind) const {
     return ConformanceFlags((Value & ~TypeMetadataKindMask)
                             | (int_type(kind) << TypeMetadataKindShift));
@@ -677,11 +658,6 @@ class ConformanceFlags {
                                  : 0));
   }
 
-  /// Retrieve the conformance kind.
-  ConformanceKind getConformanceKind() const {
-    return ConformanceKind(Value & ConformanceKindMask);
-  }
-
   /// Retrieve the type reference kind kind.
   TypeReferenceKind getTypeReferenceKind() const {
     return TypeReferenceKind(
@@ -880,7 +856,11 @@ using FunctionTypeFlags = TargetFunctionTypeFlags<size_t>;
 
 template <typename int_type>
 class TargetParameterTypeFlags {
-  enum : int_type { ValueOwnershipMask = 0x7F, VariadicMask = 0x80 };
+  enum : int_type {
+    ValueOwnershipMask = 0x7F,
+    VariadicMask       = 0x80,
+    AutoClosureMask    = 0x100,
+  };
   int_type Data;
 
   constexpr TargetParameterTypeFlags(int_type Data) : Data(Data) {}
@@ -900,8 +880,15 @@ class TargetParameterTypeFlags {
                                               (isVariadic ? VariadicMask : 0));
   }
 
+  constexpr TargetParameterTypeFlags<int_type>
+  withAutoClosure(bool isAutoClosure) const {
+    return TargetParameterTypeFlags<int_type>(
+        (Data & ~AutoClosureMask) | (isAutoClosure ? AutoClosureMask : 0));
+  }
+
   bool isNone() const { return Data == 0; }
   bool isVariadic() const { return Data & VariadicMask; }
+  bool isAutoClosure() const { return Data & AutoClosureMask; }
 
   ValueOwnership getValueOwnership() const {
     return (ValueOwnership)(Data & ValueOwnershipMask);

branches/marcrasi-static-assert/include/swift/AST/Decl.h

@@ -463,7 +463,8 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasStubImplementation : 1
   );
 
-  SWIFT_INLINE_BITFIELD_EMPTY(AbstractTypeParamDecl, ValueDecl);
+  SWIFT_INLINE_BITFIELD_EMPTY(TypeDecl, ValueDecl);
+  SWIFT_INLINE_BITFIELD_EMPTY(AbstractTypeParamDecl, TypeDecl);
 
   SWIFT_INLINE_BITFIELD_FULL(GenericTypeParamDecl, AbstractTypeParamDecl, 16+16,
     : NumPadBits,
@@ -472,7 +473,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     Index : 16
   );
 
-  SWIFT_INLINE_BITFIELD_EMPTY(GenericTypeDecl, ValueDecl);
+  SWIFT_INLINE_BITFIELD_EMPTY(GenericTypeDecl, TypeDecl);
 
   SWIFT_INLINE_BITFIELD(TypeAliasDecl, GenericTypeDecl, 1+1,
     /// Whether the typealias forwards perfectly to its underlying type.
@@ -572,6 +573,22 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasAnyUnavailableValues : 1
   );
 
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1,
+    /// If the module was or is being compiled with `-enable-testing`.
+    TestingEnabled : 1,
+
+    /// If the module failed to load
+    FailedToLoad : 1,
+
+    /// Whether the module is resilient.
+    ///
+    /// \sa ResilienceStrategy
+    RawResilienceStrategy : 1,
+
+    /// Whether all imports have been resolved. Used to detect circular imports.
+    HasResolvedImports : 1
+  );
+
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,
     /// Is this an assignment operator?
     IsAssignment : 1,