Merge remote-tracking branch 'apple/master'

Author: divadretlaw

docs/DebuggingTheCompiler.rst

@@ -37,7 +37,7 @@ Here is how to dump the IR after the main phases of the swift compiler
 #. **Performance SIL passes**. To print the SIL after the complete SIL
    optimization pipeline::
 
-    swiftc -emit-sil -O file-swift
+    swiftc -emit-sil -O file.swift
 
 #. **IRGen**. To print the LLVM IR after IR generation::
 

docs/Literals.rst

@@ -36,12 +36,16 @@ The StringLiteralConvertible Protocol
 -------------------------------------
 
 Here is the StringLiteralConvertible protocol as defined in the standard
-library's Policy.swift::
+library's CompilerProtocols.swift::
 
   // NOTE: the compiler has builtin knowledge of this protocol
-  protocol StringLiteralConvertible {
+  // Conforming types can be initialized with arbitrary string literals.
+  public protocol StringLiteralConvertible
+    : ExtendedGraphemeClusterLiteralConvertible {
+    
     typealias StringLiteralType : _BuiltinStringLiteralConvertible
-    class func convertFromStringLiteral(value : StringLiteralType) -> Self
+    // Create an instance initialized to `value`.
+    init(stringLiteral value: StringLiteralType)
   }
 
 Curiously, the protocol is not defined in terms of primitive types, but in
@@ -58,13 +62,16 @@ points could be constructed...which may be what's desired in some cases.)
 The _BuiltinStringLiteralConvertible Protocol
 ---------------------------------------------
 
-Policy.swift contains a second protocol::
+CompilerProtocols.swift contains a second protocol::
 
   // NOTE: the compiler has builtin knowledge of this protocol
-  protocol _BuiltinStringLiteralConvertible {
-    class func _convertFromBuiltinStringLiteral(value : Builtin.RawPointer,
-                                                byteSize : Builtin.Int64,
-                                                isASCII: Builtin.Int1) -> Self
+  public protocol _BuiltinStringLiteralConvertible
+    : _BuiltinExtendedGraphemeClusterLiteralConvertible {
+
+    init(
+        _builtinStringLiteral start: Builtin.RawPointer,
+        byteSize: Builtin.Word,
+        isASCII: Builtin.Int1)
   }
 
 The use of builtin types makes it clear that this is *only* for use in the

docs/SIL.rst

@@ -4316,7 +4316,7 @@ constant replacement but leave the function application to be serialized to
 sil).
 
 The compiler flag that influences the value of the ``assert_configuration``
-funtion application is the optimization flag: at ``-Onone` the application will
+function application is the optimization flag: at ``-Onone` the application will
 be replaced by ``Debug`` at higher optimization levels the instruction will be
 replaced by ``Release``. Optionally, the value to use for replacement can be
 specified with the ``-AssertConf`` flag which overwrites the value selected by

docs/archive/LangRef.html

@@ -1295,10 +1295,13 @@ <h3 id="type-optional">Optional Types</h3>
           <code>T?</code>.</li>
       </ul>
       To support these intrinsic use cases, the library is required to
-      provide four functions with these exact signatures:
+      provide functions with these exact signatures:
       <ul>
-        <li><code>func _preconditionOptionalHasValue<T>(inout v : T?)</code>
+        <li><code>func _doesOptionalHaveValueAsBool<T>(v : T?) -> Bool</code></li>
+        <li><code>func _diagnoseUnexpectedNilOptional()</code></li>
         <li><code>func _getOptionalValue<T>(v : T?) -> T</code></li>
+        <li><code>func _injectValueIntoOptional<T>(v : T) -> T?</code></li>
+        <li><code>func _injectNothingIntoOptional<T>() -> T?</code></li>
       </ul>
     </p>
 
@@ -1317,7 +1320,7 @@ <h3 id="type-optional">Optional Types</h3>
       var b : Int? = .None
 
       <i>// Declare an array of optionals:</i>
-      var c : Int?[] = new Int?[4]
+      var c : [Int?] = [10, nil, 42]
     </pre>
 
   <!-- _____________________________________________________________________ -->

docs/proposals/Accessors.rst

@@ -87,7 +87,7 @@ objects::
   point = point1
   point0.x = x
   point = point0
-  
+
 Note that ``point.y`` is left unchanged.
 
 Local analysis
@@ -157,7 +157,7 @@ through unexpected aliases::
 Note that, in either solution, you've introduced extra full-value
 loads.  This may be quite expensive, and it's not guaranteed to be
 semantically equivalent.
-  
+
 Performance
 ~~~~~~~~~~~
 
@@ -453,7 +453,7 @@ Nor can this be fixed with a purely local analysis; consider::
 
   class C { var array: [Int] }
   let global_C = C()
-  
+
   func assign(inout value: Int) {
     C.array = []
     value = 0
@@ -606,7 +606,7 @@ General solutions
 ~~~~~~~~~~~~~~~~~
 
 A language generally has six tools for dealing with code it considers
-undesireable.  Some of this terminology is taken from existing
+undesirable.  Some of this terminology is taken from existing
 standards, others not.
 
 * The language may nonetheless take steps to ensure that the code
@@ -916,7 +916,7 @@ I'm almost ready to state the core rule about formal accesses, but
 first I need to build up a few more definitions.
 
 An *abstract storage location* (ASL) is:
-  
+
 * a global variable declaration;
 
 * an ``inout`` parameter declaration, along with a reference
@@ -1106,7 +1106,7 @@ the other FA's DSN set and (2) not from a non-overlapping subobject.
 Are these conditions true?
 
 Recall that an addressor is invoked for an l-value of the form::
-  
+
   base.memory
 
 or::

include/swift/AST/Decl.h

@@ -573,8 +573,11 @@ class alignas(1 << DeclAlignInBits) Decl {
     unsigned : NumTypeDeclBits;
 
     unsigned Recursive : 1;
+
+    /// Whether or not this declaration is currently being type-checked.
+    unsigned BeingTypeChecked : 1;
   };
-  enum { NumAssociatedTypeDeclBits = NumTypeDeclBits + 1 };
+  enum { NumAssociatedTypeDeclBits = NumTypeDeclBits + 2 };
   static_assert(NumAssociatedTypeDeclBits <= 32, "fits in an unsigned");
 
   class ImportDeclBitfields {
@@ -2605,6 +2608,14 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
   void setIsRecursive() { AssociatedTypeDeclBits.Recursive = true; }
   bool isRecursive() { return AssociatedTypeDeclBits.Recursive; }
 
+  /// Whether the declaration is currently being validated.
+  bool isBeingTypeChecked() { return AssociatedTypeDeclBits.BeingTypeChecked; }
+
+  /// Toggle whether or not the declaration is being validated.
+  void setIsBeingTypeChecked(bool ibt = true) {
+    AssociatedTypeDeclBits.BeingTypeChecked = ibt;
+  }
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::AssociatedType;
   }

include/swift/AST/Types.h

@@ -732,7 +732,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// \code
   /// struct X<T, U> { }
   /// extension X {
-  ///   typealias SomeArray = [T];
+  ///   typealias SomeArray = [T]
   /// }
   /// \endcode
   ///

include/swift/Basic/ValueEnumerator.h

@@ -0,0 +1,58 @@
+//===--- ValueEnumerator.h --- Enumerates values ----------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_VALUEENUMERATOR_H
+#define SWIFT_BASIC_VALUEENUMERATOR_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace swift {
+
+/// / This class maps values to unique indices.
+template<class ValueTy, class IndexTy = size_t>
+class ValueEnumerator {
+  /// A running counter to enumerate values.
+  IndexTy counter;
+
+  /// Maps values to unique integers.
+  llvm::DenseMap<ValueTy, IndexTy> ValueToIndex;
+
+public:
+  /// Return the index of value \p v.
+  IndexTy getIndex(const ValueTy &v) {
+    // Return the index of this Key, if we've assigned one already.
+    auto It = ValueToIndex.find(v);
+    if (It != ValueToIndex.end()) {
+      return It->second;
+    }
+
+    // Generate a new counter for the key.
+    ValueToIndex[v] = ++counter;
+    return counter;
+  }
+
+  ValueEnumerator() = default;
+
+  /// Forget about key \p v.
+  void invalidateValue(const ValueTy &v) { ValueToIndex.erase(v); }
+
+  /// Clear the enumeration state of the
+  void clear() {
+    ValueToIndex.clear();
+    counter = 0;
+  }
+};
+
+} // end namespace swift
+
+#endif

include/swift/SIL/MemLocation.h

@@ -363,7 +363,7 @@ using TypeExpansionMap = llvm::DenseMap<SILType, ProjectionPathList>;
 /// the MemLocationVault, and this in turn reduces the # of bits each basic
 /// block keeps.
 ///
-/// Moreover, without canonicalization, its more difficult to implement the
+/// Moreover, without canonicalization, it's more difficult to implement the
 /// intersection operator in DSE/RLE?
 ///
 /// We basically need to compare every pair of MemLocation and find the ones

include/swift/SIL/SILFunction.h

@@ -165,7 +165,6 @@ class SILFunction
               const SILDebugScope *debugScope,
               DeclContext *DC);
 
-public:
   static SILFunction *create(SILModule &M, SILLinkage linkage, StringRef name,
                              CanSILFunctionType loweredType,
                              GenericParamList *contextGenericParams,
@@ -180,6 +179,8 @@ class SILFunction
                              SILFunction *InsertBefore = nullptr,
                              const SILDebugScope *DebugScope = nullptr,
                              DeclContext *DC = nullptr);
+
+public:
   ~SILFunction();
 
   SILModule &getModule() const { return Module; }

include/swift/SIL/SILModule.h

@@ -443,6 +443,23 @@ class SILModule {
                                    SILDeclRef constant,
                                    ForDefinition_t forDefinition);
 
+  /// \brief Return the declaration of a function, or create it if it does not
+  /// exist.
+  ///
+  /// This signature is a direct copy of the signature of SILFunction::create()
+  /// in order to simplify refactoring all SILFunction creation use-sites to use
+  /// SILModule. Eventually the uses should probably be refactored.
+  SILFunction *getOrCreateFunction(
+      SILLinkage linkage, StringRef name, CanSILFunctionType loweredType,
+      GenericParamList *contextGenericParams, Optional<SILLocation> loc,
+      IsBare_t isBareSILFunction, IsTransparent_t isTrans,
+      IsFragile_t isFragile, IsThunk_t isThunk = IsNotThunk,
+      SILFunction::ClassVisibility_t classVisibility = SILFunction::NotRelevant,
+      Inline_t inlineStrategy = InlineDefault,
+      EffectsKind EK = EffectsKind::Unspecified,
+      SILFunction *InsertBefore = nullptr,
+      const SILDebugScope *DebugScope = nullptr, DeclContext *DC = nullptr);
+
   /// Look up the SILWitnessTable representing the lowering of a protocol
   /// conformance, and collect the substitutions to apply to the referenced
   /// witnesses, if any.

include/swift/SILAnalysis/ARCAnalysis.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_SILANALYSIS_ARCANALYSIS_H
 #define SWIFT_SILANALYSIS_ARCANALYSIS_H
 
+#include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILValue.h"
 #include "swift/SIL/SILBasicBlock.h"
 #include "llvm/ADT/SmallPtrSet.h"
@@ -102,9 +103,6 @@ valueHasARCDecrementOrCheckInInstructionRange(SILValue Op,
                                               SILBasicBlock::iterator End,
                                               AliasAnalysis *AA);
 
-/// Match a call to a trap BB with no ARC relevant side effects.
-bool isARCInertTrapBB(SILBasicBlock *BB);
-
 /// A class that attempts to match owned arguments and corresponding epilogue
 /// releases for a specific function.
 ///