[swift-3.0-preview-1] stdlib: fix incorrect distance measurement between UTF-16 indices

CHANGELOG.md

@@ -2,6 +2,20 @@ Note: This is in reverse chronological order, so newer entries are added to the
 
 Swift 3.0
 ---------
+
+* [SE-103](https://github.com/apple/swift-evolution/blob/master/proposals/0103-make-noescape-default.md)
+
+  Closure parameters are non-escaping by default, rather than explicitly being
+  annotated `@noescape`. Use `@escaping` to say that a closure parameter may
+  escape. `@autoclosure(escaping)` is now spelled `@autoclosure @escaping`.
+  `@noescape` and `@autoclosure(escaping)` are deprecated.
+
+* [SE-0115](https://github.com/apple/swift-evolution/blob/master/proposals/0115-literal-syntax-protocols.md)
+
+  To clarify the role of `*LiteralConvertible` protocols, they have 
+  been renamed to `ExpressibleBy*Literal`.  No requirements of these 
+  protocols have changed.
+
 * [SE-0107](https://github.com/apple/swift-evolution/blob/master/proposals/0107-unsaferawpointer.md)
 
   An `Unsafe[Mutable]RawPointer` type has been introduced. It

apinotes/SceneKit.apinotes

@@ -15,3 +15,98 @@ Protocols:
     SwiftPrivate: true
     MethodKind: Instance
 
+#
+# New wrapper types will be made for these typedefs, and we want to nest them
+#
+Typedefs:
+- Name: SCNGeometrySourceSemantic
+  SwiftName: SCNGeometrySource.Semantic
+- Name: SCNLightType
+  SwiftName: SCNLight.LightType
+- Name: SCNLightingModel
+  SwiftName: SCNMaterial.LightingModel
+- Name: SCNParticleProperty
+  SwiftName: SCNParticleSystem.ParticleProperty
+- Name: SCNPhysicsShapeOption
+  SwiftName: SCNPhysicsShape.Option
+- Name: SCNPhysicsShapeType
+  SwiftName: SCNPhysicsShape.ShapeType
+- Name: SCNPhysicsTestOption
+  SwiftName: SCNPhysicsWorld.TestOption
+- Name: SCNPhysicsTestSearchMode
+  SwiftName: SCNPhysicsWorld.TestSearchMode
+- Name: SCNSceneAttribute
+  SwiftName: SCNScene.Attribute
+- Name: SCNSceneSourceAnimationImportPolicy
+  SwiftName: SCNSceneSource.AnimationImportPolicy
+- Name: SCNSceneSourceLoadingOption
+  SwiftName: SCNSceneSource.LoadingOption
+- Name: SCNViewOption
+  SwiftName: SCNView.Option
+
+#
+# Name overrides for globals that we will be nesting onto our new wrapper types
+#
+Globals:
+- Name: SCNHitTestFirstFoundOnlyKey
+  SwiftName: SCNHitTestOption.firstFoundOnly
+- Name: SCNHitTestSortResultsKey
+  SwiftName: SCNHitTestOption.sortResults
+- Name: SCNHitTestClipToZRangeKey
+  SwiftName: SCNHitTestOption.clipToZRange
+- Name: SCNHitTestBackFaceCullingKey
+  SwiftName: SCNHitTestOption.backFaceCulling
+- Name: SCNHitTestBoundingBoxOnlyKey
+  SwiftName: SCNHitTestOption.boundingBoxOnly
+- Name: SCNHitTestIgnoreChildNodesKey
+  SwiftName: SCNHitTestOption.ignoreChildNodes
+- Name: SCNHitTestRootNodeKey
+  SwiftName: SCNHitTestOption.rootNode
+- Name: SCNHitTestIgnoreHiddenNodesKey
+  SwiftName: SCNHitTestOption.ignoreHiddenNodes
+- Name: SCNPhysicsShapeTypeKey
+  SwiftName: SCNPhysicsShape.Option.type
+- Name: SCNPhysicsShapeKeepAsCompoundKey
+  SwiftName: SCNPhysicsShape.Option.keepAsCompound
+- Name: SCNPhysicsShapeScaleKey
+  SwiftName: SCNPhysicsShape.Option.scale
+- Name: SCNPhysicsTestCollisionBitMaskKey
+  SwiftName: SCNPhysicsWorld.TestOption.collisionBitMask
+- Name: SCNPhysicsTestSearchModeKey
+  SwiftName: SCNPhysicsWorld.TestOption.searchMode
+- Name: SCNPhysicsTestBackfaceCullingKey
+  SwiftName: SCNPhysicsWorld.TestOption.backfaceCulling
+- Name: SCNSceneStartTimeAttributeKey
+  SwiftName: SCNScene.Attribute.startTime
+- Name: SCNSceneEndTimeAttributeKey
+  SwiftName: SCNScene.Attribute.endTime
+- Name: SCNSceneFrameRateAttributeKey
+  SwiftName: SCNScene.Attribute.frameRate
+- Name: SCNSceneUpAxisAttributeKey
+  SwiftName: SCNScene.Attribute.upAxis
+- Name: SCNSceneSourceCreateNormalsIfAbsentKey
+  SwiftName: SCNSceneSource.LoadingOption.createNormalsIfAbsent
+- Name: SCNSceneSourceCheckConsistencyKey
+  SwiftName: SCNSceneSource.LoadingOption.checkConsistency
+- Name: SCNSceneSourceFlattenSceneKey
+  SwiftName: SCNSceneSource.LoadingOption.flattenScene
+- Name: SCNSceneSourceUseSafeModeKey
+  SwiftName: SCNSceneSource.LoadingOption.useSafeMode
+- Name: SCNSceneSourceAssetDirectoryURLsKey
+  SwiftName: SCNSceneSource.LoadingOption.assetDirectoryURLs
+- Name: SCNSceneSourceOverrideAssetURLsKey
+  SwiftName: SCNSceneSource.LoadingOption.overrideAssetURLs
+- Name: SCNSceneSourceStrictConformanceKey
+  SwiftName: SCNSceneSource.LoadingOption.strictConformance
+- Name: SCNSceneSourceConvertUnitsToMetersKey
+  SwiftName: SCNSceneSource.LoadingOption.convertUnitsToMeters
+- Name: SCNSceneSourceConvertToYUpKey
+  SwiftName: SCNSceneSource.LoadingOption.convertToYUp
+- Name: SCNSceneSourceAnimationImportPolicyKey
+  SwiftName: SCNSceneSource.LoadingOption.animationImportPolicy
+- Name: SCNPreferredRenderingAPIKey
+  SwiftName: SCNView.Option.preferredRenderingAPI
+- Name: SCNPreferredDeviceKey
+  SwiftName: SCNView.Option.preferredDevice
+- Name: SCNPreferLowPowerDeviceKey
+  SwiftName: SCNView.Option.preferLowPowerDevice

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -315,7 +315,6 @@ function (swift_benchmark_compile_archopts)
       DEPENDS
         ${bench_library_objects} ${SWIFT_BENCH_OBJFILES}
         "${objcfile}"
-        "adhoc-sign-swift-stdlib-${BENCH_COMPILE_ARCHOPTS_PLATFORM}"
       COMMAND
         "${CLANG_EXEC}"
         "-fno-stack-protector"
@@ -356,19 +355,6 @@ function(swift_benchmark_compile)
     endforeach()
   endif()
 
-  add_custom_target("copy-swift-stdlib-${SWIFT_BENCHMARK_COMPILE_PLATFORM}"
-      DEPENDS ${stdlib_dependencies}
-      COMMAND
-        "${CMAKE_COMMAND}" "-E" "copy_directory"
-        "${SWIFT_LIBRARY_PATH}/${SWIFT_BENCHMARK_COMPILE_PLATFORM}"
-        "${benchmark-lib-swift-dir}/${SWIFT_BENCHMARK_COMPILE_PLATFORM}")
-
-  add_custom_target("adhoc-sign-swift-stdlib-${SWIFT_BENCHMARK_COMPILE_PLATFORM}"
-      DEPENDS "copy-swift-stdlib-${SWIFT_BENCHMARK_COMPILE_PLATFORM}"
-      COMMAND
-        "codesign" "-f" "-s" "-"
-        "${benchmark-lib-swift-dir}/${SWIFT_BENCHMARK_COMPILE_PLATFORM}/*.dylib" "2>/dev/null")
-
   set(platform_executables)
   foreach(arch ${${SWIFT_BENCHMARK_COMPILE_PLATFORM}_arch})
     set(platform_executables)

include/swift/AST/ASTContext.h

@@ -364,7 +364,7 @@ class ASTContext {
                                         PrecedenceGroupDecl *right) const;
 
   /// Retrieve the declaration of Swift.Error.
-  NominalTypeDecl *getErrorDecl() const;
+  ProtocolDecl *getErrorDecl() const;
   CanType getExceptionType() const;
 
   /// Retrieve the declaration of Swift.Bool.

include/swift/AST/DiagnosticsParse.def

@@ -1215,6 +1215,12 @@ ERROR(attr_noescape_conflicts_escaping_autoclosure,none,
 ERROR(attr_noescape_implied_by_autoclosure,none,
       "@noescape is implied by @autoclosure and should not be "
       "redundantly specified", ())
+WARNING(attr_autoclosure_escaping_deprecated,none,
+        "@autoclosure(escaping) is deprecated; use @autoclosure @escaping instead",
+        ())
+WARNING(attr_noescape_deprecated,none,
+        "@noescape is the default and is deprecated",
+        ())
 
 // convention
 ERROR(convention_attribute_expected_lparen,none,

include/swift/AST/DiagnosticsSema.def

@@ -204,6 +204,8 @@ ERROR(cannot_call_with_params, none,
       "cannot invoke %select{|initializer for type }2'%0' with an argument list"
       " of type '%1'", (StringRef, StringRef, bool))
 
+NOTE(pointer_init_add_mutating,none,
+     "do you want to add 'mutating'", ())
 ERROR(expected_do_in_statement,none,
       "expected 'do' keyword to designate a block of statements", ())
 
@@ -2095,7 +2097,11 @@ ERROR(discard_expr_outside_of_assignment,none,
       ())
 ERROR(inout_expr_outside_of_call,none,
       "'&' can only appear immediately in a call argument list", ())
-
+ERROR(collection_literal_heterogenous,none,
+      "heterogenous collection literal could only be inferred to %0; add"
+      " explicit type annotation if this is intentional", (Type))
+ERROR(collection_literal_empty,none,
+      "empty collection literal requires an explicit type", ())
 
 ERROR(unresolved_member_no_inference,none,
       "reference to member %0 cannot be resolved without a contextual type",
@@ -2233,7 +2239,7 @@ ERROR(closure_implicit_capture_mutating_self,none,
       ())
 ERROR(nested_function_with_implicit_capture_argument,none,
       "nested function with %select{an |}0implicitly captured inout "
-      "parameter%select{|s}0 can only be used as a @noescape argument", (bool))
+      "parameter%select{|s}0 can only be used as a non-escaping argument", (bool))
 ERROR(nested_function_escaping_inout_capture,none,
       "nested function cannot capture inout parameter and escape", ())
 
@@ -2310,6 +2316,15 @@ ERROR(closure_noescape_use,none,
 ERROR(decl_closure_noescape_use,none,
       "declaration closing over non-escaping parameter %0 may allow it to escape",
       (Identifier))
+ERROR(passing_noescape_to_escaping,none,
+      "passing non-escaping parameter %0 to function expecting an @escaping closure",
+      (Identifier))
+ERROR(assigning_noescape_to_escaping,none,
+      "assigning non-escaping parameter %0 to an @escaping closure",
+      (Identifier))
+ERROR(general_noescape_to_escaping,none,
+      "using non-escaping parameter %0 in a context expecting an @escaping closure",
+      (Identifier))
 
 ERROR(capture_across_type_decl,none,
       "%0 declaration cannot close over value %1 defined in outer scope",

include/swift/AST/Expr.h

@@ -2140,6 +2140,10 @@ class CollectionExpr : public Expr {
 
   Expr *SemanticExpr = nullptr;
 
+  /// True if the type of this collection expr was inferred by the collection
+  /// fallback type, like [Any].
+  bool IsTypeDefaulted = false;
+
 protected:
   CollectionExpr(ExprKind Kind, SourceLoc LBracketLoc,
                  MutableArrayRef<Expr*> Elements,
@@ -2157,6 +2161,9 @@ class CollectionExpr : public Expr {
   void setElement(unsigned i, Expr *E) { Elements[i] = E; }
   unsigned getNumElements() const { return Elements.size(); }
 
+  bool isTypeDefaulted() const { return IsTypeDefaulted; }
+  void setIsTypeDefaulted(bool value = true) { IsTypeDefaulted = value; }
+
   SourceLoc getLBracketLoc() const { return LBracketLoc; }
   SourceLoc getRBracketLoc() const { return RBracketLoc; }
   SourceRange getSourceRange() const {
@@ -3010,12 +3017,36 @@ class ErasureExpr : public ImplicitConversionExpr {
   ArrayRef<ProtocolConformanceRef> getConformances() const {
     return Conformances;
   }
-  
+
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::Erasure;
   }
 };
 
+/// AnyHashableErasureExpr - Perform type erasure by converting a value
+/// to AnyHashable type.
+///
+/// The type of the sub-expression should always be a type that implements
+/// the Hashable protocol.
+class AnyHashableErasureExpr : public ImplicitConversionExpr {
+  ProtocolConformanceRef Conformance;
+
+public:
+  AnyHashableErasureExpr(Expr *subExpr, Type type,
+                         ProtocolConformanceRef conformance)
+    : ImplicitConversionExpr(ExprKind::AnyHashableErasure, subExpr, type),
+      Conformance(conformance) {}
+
+  /// \brief Retrieve the mapping specifying how the type of the
+  /// subexpression conforms to the Hashable protocol.
+  ProtocolConformanceRef getConformance() const {
+    return Conformance;
+  }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::AnyHashableErasure;
+  }
+};
 /// UnresolvedSpecializeExpr - Represents an explicit specialization using
 /// a type parameter list (e.g. "Vector<Int>") that has not been resolved.
 class UnresolvedSpecializeExpr : public Expr {

include/swift/AST/ExprNodes.def

@@ -127,6 +127,7 @@ ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(MetatypeConversion, ImplicitConversionExpr)
   EXPR(CollectionUpcastConversion, ImplicitConversionExpr)
   EXPR(Erasure, ImplicitConversionExpr)
+  EXPR(AnyHashableErasure, ImplicitConversionExpr)
   EXPR(DerivedToBase, ImplicitConversionExpr)
   EXPR(ArchetypeToSuper, ImplicitConversionExpr)
   EXPR(InjectIntoOptional, ImplicitConversionExpr)

include/swift/AST/IRGenOptions.h

@@ -197,6 +197,18 @@ class IRGenOptions {
     Hash = (Hash << 1) | DisableLLVMARCOpts;
     return Hash;
   }
+
+  /// Should LLVM IR value names be emitted and preserved?
+  bool shouldProvideValueNames() const {
+    // If the command line contains an explicit request about whether to add
+    // LLVM value names, honor it.  Otherwise, add value names only if the
+    // final result is textual LLVM assembly.
+    if (HasValueNamesSetting) {
+      return ValueNames;
+    } else {
+      return OutputKind == IRGenOutputKind::LLVMAssembly;
+    }
+  }
 };
 
 } // end namespace swift

include/swift/AST/KnownDecls.def

@@ -68,7 +68,11 @@ FUNC_DECL(ConditionallyBridgeFromObjectiveCBridgeable,
 FUNC_DECL(BridgeAnythingToObjectiveC,
           "_bridgeAnythingToObjectiveC")
 
+FUNC_DECL(ConvertToAnyHashable, "_convertToAnyHashable")
+
 FUNC_DECL(DidEnterMain, "_stdlib_didEnterMain")
 FUNC_DECL(DiagnoseUnexpectedNilOptional, "_diagnoseUnexpectedNilOptional")
 
+FUNC_DECL(GetErrorEmbeddedNSError, "_stdlib_getErrorEmbeddedNSError")
+
 #undef FUNC_DECL

include/swift/AST/Type.h

@@ -183,7 +183,30 @@ class Type {
 
   /// Get the canonical type, or return null if the type is null.
   CanType getCanonicalTypeOrNull() const; // in Types.h
-
+
+  /// Computes the meet between two types.
+  ///
+  /// The meet of two types is the most specific type that is a supertype of
+  /// both \c type1 and \c type2. For example, given a simple class hierarchy as
+  /// follows:
+  ///
+  /// \code
+  /// class A { }
+  /// class B : A { }
+  /// class C : A { }
+  /// class D { }
+  /// \endcode
+  ///
+  /// The meet of B and C is A, the meet of A and B is A. However, there is no
+  /// meet of D and A (or D and B, or D and C) because there is no common
+  /// superclass. One would have to jump to an existential (e.g., \c AnyObject)
+  /// to find a common type.
+  /// 
+  /// \returns the meet of the two types, if there is a concrete type that can
+  /// express the meet, or a null type if the only meet would be a more-general
+  /// existential type (e.g., \c Any).
+  static Type meet(Type type1, Type type2);
+
 private:
   // Direct comparison is disabled for types, because they may not be canonical.
   void operator==(Type T) const = delete;
@@ -432,6 +455,7 @@ class CanGenericSignature {
     return Signature;
   }
 };
+
 } // end namespace swift
 
 namespace llvm {

include/swift/Basic/LangOptions.h

@@ -131,7 +131,7 @@ namespace swift {
 
     /// \brief The upper bound, in bytes, of temporary data that can be
     /// allocated by the constraint solver.
-    unsigned SolverMemoryThreshold = 15000000;
+    unsigned SolverMemoryThreshold = 33554432; /* 32 * 1024 * 1024 */
 
     /// \brief Perform all dynamic allocations using malloc/free instead of
     /// optimized custom allocator, so that memory debugging tools can be used.

include/swift/Runtime/Metadata.h

@@ -1980,6 +1980,10 @@ struct TargetValueMetadata : public TargetMetadata<Runtime> {
     return (asWords + Description->GenericParams.Offset);
   }
 
+  const TargetNominalTypeDescriptor<Runtime> *getDescription() const {
+    return Description.get();
+  }
+
   StoredPointer offsetToDescriptorOffset() const {
     return offsetof(TargetValueMetadata<Runtime>, Description);
   }

include/swift/SIL/SILCloner.h

@@ -66,6 +66,14 @@ class SILCloner : protected SILVisitor<ImplClass> {
   SILBuilder &getBuilder() { return Builder; }
 
 protected:
+  void beforeVisit(ValueBase *V) {
+    if (auto I = dyn_cast<SILInstruction>(V)) {
+      // Update the set of available opened archetypes with the opened
+      // archetypes used by the current instruction.
+     doPreProcess(I);
+    }
+  }
+
 #define VALUE(CLASS, PARENT) \
   void visit##CLASS(CLASS *I) {                                       \
     llvm_unreachable("SILCloner visiting non-instruction?");          \
@@ -380,9 +388,6 @@ SILCloner<ImplClass>::visitSILBasicBlock(SILBasicBlock* BB) {
   SILFunction &F = getBuilder().getFunction();
   // Iterate over and visit all instructions other than the terminator to clone.
   for (auto I = BB->begin(), E = --BB->end(); I != E; ++I) {
-    // Update the set of available opened archetypes with the opened archetypes
-    // used by the current instruction.
-    doPreProcess(&*I);
     asImpl().visit(&*I);
   }
   // Iterate over successors to do the depth-first search.