---

yaml
---
r: 274430
b: refs/heads/master-next
c: a19a623
h: refs/heads/master

Author: compnerd

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: cbef630f19f869ab5279731179bd731f12b3b9d5
-refs/heads/master-next: 75e31751ba62eb54892f7277dac02b3412bf964a
+refs/heads/master-next: a19a62351d9d928b7abda0d460a7b762f29bff98
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/benchmark/single-source/ArrayInClass.swift

@@ -17,11 +17,12 @@ public let ArrayInClass = [
     runFunction: run_ArrayInClass,
     tags: [.validation, .api, .Array],
     setUpFunction: { ac = ArrayContainer() },
-    tearDownFunction: { ac = nil }),
+    tearDownFunction: { ac = nil },
+    legacyFactor: 5),
   BenchmarkInfo(name: "DistinctClassFieldAccesses",
     runFunction: run_DistinctClassFieldAccesses,
-    tags: [.unstable, .api, .Array],
-    setUpFunction: { workload = ClassWithArrs(N: 100_000) },
+    tags: [.validation, .api, .Array],
+    setUpFunction: { workload = ClassWithArrs(N: 10_000) },
     tearDownFunction: { workload = nil }),
 ]
 
@@ -31,7 +32,7 @@ class ArrayContainer {
   final var arr : [Int]
 
   init() {
-    arr = [Int] (repeating: 0, count: 100_000)
+    arr = [Int] (repeating: 0, count: 20_000)
   }
 
   func runLoop(_ N: Int) {

branches/master-next/benchmark/single-source/DictionaryOfAnyHashableStrings.swift

@@ -21,18 +21,15 @@ public var DictionaryOfAnyHashableStrings = [
     name: "DictionaryOfAnyHashableStrings_insert",
     runFunction: run_DictionaryOfAnyHashableStrings_insert,
     tags: [.abstraction, .runtime, .cpubench],
-    setUpFunction: {
-      keys = buildKeys(500)
-    }
+    setUpFunction: { keys = buildKeys(50) },
+    legacyFactor: 14
   ),
   BenchmarkInfo(
     name: "DictionaryOfAnyHashableStrings_lookup",
     runFunction: run_DictionaryOfAnyHashableStrings_lookup,
     tags: [.abstraction, .runtime, .cpubench],
-    setUpFunction: {
-      keys = buildKeys(500)
-      workload = buildWorkload()
-    }
+    setUpFunction: { keys = buildKeys(50); workload = buildWorkload() },
+    legacyFactor: 24
   ),
 ]
 
@@ -65,7 +62,7 @@ func buildWorkload() -> [AnyHashable: Any] {
 @inline(never)
 public func run_DictionaryOfAnyHashableStrings_insert(_ n: Int) {
   precondition(keys.count > 0)
-  for _ in 0 ... n {
+  for _ in 1...n {
     blackHole(buildWorkload())
   }
 }
@@ -74,7 +71,7 @@ public func run_DictionaryOfAnyHashableStrings_insert(_ n: Int) {
 public func run_DictionaryOfAnyHashableStrings_lookup(_ n: Int) {
   precondition(workload.count > 0)
   precondition(keys.count > 0)
-  for _ in 0 ... n {
+  for _ in 1...n {
     for i in 0 ..< keys.count {
       let key = keys[i]
       CheckResults((workload[key] as! Int) == i)

branches/master-next/benchmark/single-source/Substring.swift

@@ -31,6 +31,8 @@ public let SubstringTest = [
 
 // A string that doesn't fit in small string storage and doesn't fit in Latin-1
 let longWide = "fὢasὢodὢijὢadὢolὢsjὢalὢsdὢjlὢasὢdfὢijὢliὢsdὢjøὢslὢdiὢalὢiὢ"
+let (s1, ss1) = equivalentWithDistinctBuffers()
+let (s2, ss2) = equivalentWithDistinctBuffers()
 
 @inline(never)
 public func run_SubstringFromLongString(_ N: Int) {
@@ -89,33 +91,33 @@ private func equivalentWithDistinctBuffers() -> (String, Substring) {
 
 @inline(never)
 public func run_EqualStringSubstring(_ N: Int) {
-  let (a, b) = equivalentWithDistinctBuffers()
+  let (a, b) = (s1, ss1)
   for _ in 1...N*500 {
     blackHole(a == b)
   }
 }
 
 @inline(never)
 public func run_EqualSubstringString(_ N: Int) {
-  let (a, b) = equivalentWithDistinctBuffers()
+  let (a, b) = (s1, ss1)
   for _ in 1...N*500 {
     blackHole(b == a)
   }
 }
 
 @inline(never)
 public func run_EqualSubstringSubstring(_ N: Int) {
-  let (_, a) = equivalentWithDistinctBuffers()
-  let (_, b) = equivalentWithDistinctBuffers()
+  let (_, a) = (s1, ss1)
+  let (_, b) = (s2, ss2)
   for _ in 1...N*500 {
     blackHole(a == b)
   }
 }
 
 @inline(never)
 public func run_EqualSubstringSubstringGenericEquatable(_ N: Int) {
-  let (_, a) = equivalentWithDistinctBuffers()
-  let (_, b) = equivalentWithDistinctBuffers()
+  let (_, a) = (s1, ss1)
+  let (_, b) = (s2, ss2)
   func check<T>(_ x: T, _ y: T) where T : Equatable {
     blackHole(x == y)
   }
@@ -132,24 +134,24 @@ where T : StringProtocol, U : StringProtocol {
 
 @inline(never)
 public func run _EqualStringSubstringGenericStringProtocol(_ N: Int) {
-  let (a, b) = equivalentWithDistinctBuffers()
+  let (a, b) = (s1, ss1)
   for _ in 1...N*500 {
     checkEqual(a, b)
   }
 }
 
 @inline(never)
 public func run _EqualSubstringStringGenericStringProtocol(_ N: Int) {
-  let (a, b) = equivalentWithDistinctBuffers()
+  let (a, b) = (s1, ss1)
   for _ in 1...N*500 {
     checkEqual(b, a)
   }
 }
 
 @inline(never)
 public func run _EqualSubstringSubstringGenericStringProtocol(_ N: Int) {
-  let (_, a) = equivalentWithDistinctBuffers()
-  let (_, b) = equivalentWithDistinctBuffers()
+  let (_, a) = (s1, ss1)
+  let (_, b) = (s2, ss2)
   for _ in 1...N*500 {
     checkEqual(a, b)
   }
@@ -161,15 +163,15 @@ public func run _EqualSubstringSubstringGenericStringProtocol(_ N: Int) {
 /*
 @inline(never)
 public func run _LessStringSubstring(_ N: Int) {
-  let (a, b) = equivalentWithDistinctBuffers()
+  let (a, b) = (s1, ss1)
   for _ in 1...N*500 {
     blackHole(a < b)
   }
 }
 
 @inline(never)
 public func run _LessSubstringString(_ N: Int) {
-  let (a, b) = equivalentWithDistinctBuffers()
+  let (a, b) = (s1, ss1)
   for _ in 1...N*500 {
     blackHole(b < a)
   }
@@ -178,17 +180,17 @@ public func run _LessSubstringString(_ N: Int) {
 
 @inline(never)
 public func run_LessSubstringSubstring(_ N: Int) {
-  let (_, a) = equivalentWithDistinctBuffers()
-  let (_, b) = equivalentWithDistinctBuffers()
+  let (_, a) = (s1, ss1)
+  let (_, b) = (s2, ss2)
   for _ in 1...N*500 {
     blackHole(a < b)
   }
 }
 
 @inline(never)
 public func run_LessSubstringSubstringGenericComparable(_ N: Int) {
-  let (_, a) = equivalentWithDistinctBuffers()
-  let (_, b) = equivalentWithDistinctBuffers()
+  let (_, a) = (s1, ss1)
+  let (_, b) = (s2, ss2)
   func check<T>(_ x: T, _ y: T) where T : Comparable {
     blackHole(x < y)
   }
@@ -251,24 +253,24 @@ where T : StringProtocol, U : StringProtocol {
 
 @inline(never)
 public func run _LessStringSubstringGenericStringProtocol(_ N: Int) {
-  let (a, b) = equivalentWithDistinctBuffers()
+  let (a, b) = (s1, ss1)
   for _ in 1...N*500 {
     checkLess(a, b)
   }
 }
 
 @inline(never)
 public func run _LessSubstringStringGenericStringProtocol(_ N: Int) {
-  let (a, b) = equivalentWithDistinctBuffers()
+  let (a, b) = (s1, ss1)
   for _ in 1...N*500 {
     checkLess(b, a)
   }
 }
 
 @inline(never)
 public func run _LessSubstringSubstringGenericStringProtocol(_ N: Int) {
-  let (_, a) = equivalentWithDistinctBuffers()
-  let (_, b) = equivalentWithDistinctBuffers()
+  let (_, a) = (s1, ss1)
+  let (_, b) = (s2, ss2)
   for _ in 1...N*500 {
     checkLess(a, b)
   }

branches/master-next/include/swift-c/SyntaxParser/SwiftSyntaxParser.h

@@ -232,6 +232,64 @@ swiftparse_parse_string(swiftparse_parser_t, const char *source);
 /// declarations, etc.
 SWIFTPARSE_PUBLIC const char* swiftparse_syntax_structure_versioning_identifier(void);
 
+typedef struct {
+  /// Represents the range for the fixit.
+  swiftparse_range_t range;
+  /// Represent the text for replacement.
+  const char* text;
+} swiftparse_diagnostic_fixit_t;
+
+typedef enum {
+  SWIFTPARSER_DIAGNOSTIC_SEVERITY_ERROR = 0,
+  SWIFTPARSER_DIAGNOSTIC_SEVERITY_WARNING = 1,
+  SWIFTPARSER_DIAGNOSTIC_SEVERITY_NOTE = 2,
+} swiftparser_diagnostic_severity_t;
+
+/// This is for the client to ask further information about a diagnostic that is
+/// associated with the pointer.
+/// This pointer is only valid to access from within the
+/// swiftparse_diagnostic_handler_t block
+typedef const void* swiftparser_diagnostic_t;
+
+/// Invoked by the parser when a diagnostic is emitted.
+typedef void(^swiftparse_diagnostic_handler_t)(swiftparser_diagnostic_t);
+
+/// Set the \c swiftparse_diagnostic_handler_t block to be used by the parser.
+///
+/// It isn't required to set a \c swiftparse_diagnostic_handler_t block.
+SWIFTPARSE_PUBLIC void
+swiftparse_parser_set_diagnostic_handler(swiftparse_parser_t,
+                                         swiftparse_diagnostic_handler_t);
+
+/// Get the message of a swiftparser_diagnostic_t
+SWIFTPARSE_PUBLIC const char*
+swiftparse_diagnostic_get_message(swiftparser_diagnostic_t);
+
+/// Get the source location in byte offset to where the diagnostic is issued
+/// in the source buffer.
+SWIFTPARSE_PUBLIC
+unsigned swiftparse_diagnostic_get_source_loc(swiftparser_diagnostic_t diag);
+
+/// Get the number of fixits of a swiftparser_diagnostic_t
+SWIFTPARSE_PUBLIC unsigned
+swiftparse_diagnostic_get_fixit_count(swiftparser_diagnostic_t);
+
+/// Get the fixit at the specified index of a swiftparser_diagnostic_t
+SWIFTPARSE_PUBLIC swiftparse_diagnostic_fixit_t
+swiftparse_diagnostic_get_fixit(swiftparser_diagnostic_t, unsigned);
+
+/// Get the number of highlight ranges of a swiftparser_diagnostic_t
+SWIFTPARSE_PUBLIC unsigned
+swiftparse_diagnostic_get_range_count(swiftparser_diagnostic_t);
+
+/// Get the highlight range at the specified index of a swiftparser_diagnostic_t
+SWIFTPARSE_PUBLIC swiftparse_range_t
+swiftparse_diagnostic_get_range(swiftparser_diagnostic_t, unsigned);
+
+/// Get the severity of a swiftparser_diagnostic_t
+SWIFTPARSE_PUBLIC swiftparser_diagnostic_severity_t
+swiftparse_diagnostic_get_severity(swiftparser_diagnostic_t diag);
+
 SWIFTPARSE_END_DECLS
 
 #endif

branches/master-next/include/swift/AST/Expr.h

@@ -823,11 +823,11 @@ class NumberLiteralExpr : public LiteralExpr {
   }
 };
 
-  
 /// Integer literal with a '+' or '-' sign, like '+4' or '- 2'.
 ///
-/// After semantic analysis assigns types, this is guaranteed to only have
-/// a BuiltinIntegerType.
+/// After semantic analysis assigns types, this is guaranteed to have
+/// a BuiltinIntegerType or be a normal type and implicitly be
+/// AnyBuiltinIntegerType.
 class IntegerLiteralExpr : public NumberLiteralExpr {
 public:
   IntegerLiteralExpr(StringRef Val, SourceLoc DigitsLoc, bool Implicit = false)
@@ -855,9 +855,12 @@ class IntegerLiteralExpr : public NumberLiteralExpr {
 };
 
 /// FloatLiteralExpr - Floating point literal, like '4.0'.  After semantic
-/// analysis assigns types, this is guaranteed to only have a
+/// analysis assigns types, BuiltinTy is guaranteed to only have a
 /// BuiltinFloatingPointType.
 class FloatLiteralExpr : public NumberLiteralExpr {
+  /// This is the type of the builtin literal.
+  Type BuiltinTy;
+
 public:
   FloatLiteralExpr(StringRef Val, SourceLoc Loc, bool Implicit = false)
     : NumberLiteralExpr(ExprKind::FloatLiteral, Val, Loc, Implicit)
@@ -870,6 +873,9 @@ class FloatLiteralExpr : public NumberLiteralExpr {
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::FloatLiteral;
   }
+
+  Type getBuiltinType() const { return BuiltinTy; }
+  void setBuiltinType(Type ty) { BuiltinTy = ty; }
 };
 
 /// A Boolean literal ('true' or 'false')

branches/master-next/include/swift/Demangling/Demangle.h

@@ -35,9 +35,9 @@ namespace Demangle {
 
 enum class SymbolicReferenceKind : uint8_t;
 
-/// A simple default implementation that assigns letters to archetypes in
+/// A simple default implementation that assigns letters to type parameters in
 /// alphabetic order.
-std::string archetypeName(uint64_t index, uint64_t depth);
+std::string genericParameterName(uint64_t depth, uint64_t index);
 
 /// Display style options for the demangler.
 struct DemangleOptions {
@@ -57,7 +57,8 @@ struct DemangleOptions {
   bool ShortenArchetype = false;
   bool ShowPrivateDiscriminators = true;
   bool ShowFunctionArgumentTypes = true;
-  std::function<std::string(uint64_t, uint64_t)> ArchetypeName = archetypeName;
+  std::function<std::string(uint64_t, uint64_t)> GenericParameterName =
+      genericParameterName;
 
   DemangleOptions() {}
 

branches/master-next/include/swift/Reflection/ReflectionContext.h

@@ -288,7 +288,7 @@ class ReflectionContext
   }
 
 #elif defined(_WIN32)
-  bool addImage(RemoteAddress ImageStart) {
+  bool readPECOFFSections(RemoteAddress ImageStart) {
     auto DOSHdrBuf = this->getReader().readBytes(
         ImageStart, sizeof(llvm::object::dos_header));
     auto DOSHdr =
@@ -380,6 +380,29 @@ class ReflectionContext
     return true;
   }
 
+  bool addImage(RemoteAddress ImageStart) {
+    auto Buf = this->getReader().readBytes(ImageStart,
+                                           sizeof(llvm::object::dos_header));
+    if (!Buf)
+      return false;
+
+    auto DOSHdr = reinterpret_cast<const llvm::object::dos_header *>(Buf.get());
+    if (!(DOSHdr->Magic[0] == 'M' && DOSHdr->Magic[1] == 'Z'))
+      return false;
+
+    auto PEHeaderAddress =
+        ImageStart.getAddressData() + DOSHdr->AddressOfNewExeHeader;
+
+    Buf = this->getReader().readBytes(RemoteAddress(PEHeaderAddress),
+                                      sizeof(llvm::COFF::PEMagic));
+    if (!Buf)
+      return false;
+
+    if (memcmp(Buf.get(), llvm::COFF::PEMagic, sizeof(llvm::COFF::PEMagic)))
+      return false;
+
+    return readPECOFFSections(ImageStart);
+  }
 #else // ELF platforms.
   template <typename T> bool readELFSections(RemoteAddress ImageStart) {
     auto Buf =