Merge remote-tracking branch 'origin/master' into swift-3-api-guidelines

Author: Max Moiseev

CMakeLists.txt

@@ -412,7 +412,12 @@ if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
   endif()
 
 elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "FreeBSD")
-  configure_sdk_unix(FREEBSD "FreeBSD" "freebsd" "freebsd" "x86_64" "x86_64-freebsd10")
+  # FIXME: Using the host OS version won't produce correct results for
+  # cross-compilation.
+  string(REPLACE "[-].*" "" FREEBSD_SYSTEM_VERSION ${CMAKE_SYSTEM_VERSION})
+  message(STATUS "FreeBSD Version: ${FREEBSD_SYSTEM_VERSION}")
+  configure_sdk_unix(FREEBSD "FreeBSD" "freebsd" "freebsd" "x86_64"
+    "x86_64-unknown-freebsd${FREEBSD_SYSTEM_VERSION}")
 
   set(CMAKE_EXECUTABLE_FORMAT "ELF")
 

docs/Failable Initializers.rst

@@ -173,7 +173,7 @@ a new hidden stored property to each class that directly defines failing
 initializers. The bit is set if this slice of the instance has been
 initialized.
 
-Note that unlike partailDeinit, if a class does not have failing initializers,
+Note that unlike partialDeinit, if a class does not have failing initializers,
 it does not need this bit, even if its initializer delegates to a failing
 initializer in a superclass.
 

include/swift/AST/ArchetypeBuilder.h

@@ -218,6 +218,12 @@ class ArchetypeBuilder {
   /// \returns true if an error occurred, false otherwise.
   bool addGenericParameter(GenericTypeParamDecl *GenericParam);
 
+  /// Add the requirements placed on the given abstract type parameter
+  /// to the given potential archetype.
+  ///
+  /// \returns true if an error occurred, false otherwise.
+  bool addGenericParameterRequirements(GenericTypeParamDecl *GenericParam);
+
   /// \brief Add a new generic parameter for which there may be requirements.
   ///
   /// \returns true if an error occurred, false otherwise.

include/swift/AST/Decl.h

@@ -2871,9 +2871,6 @@ class NominalTypeDecl : public TypeDecl, public DeclContext,
     return GenericSig;
   }
 
-  /// Mark generic type signature as invalid.
-  void markInvalidGenericSignature();
-
   /// getDeclaredType - Retrieve the type declared by this entity.
   Type getDeclaredType() const { return DeclaredTy; }
 
@@ -4371,6 +4368,7 @@ class AbstractFunctionDecl : public ValueDecl, public DeclContext {
   };
 
   GenericParamList *GenericParams;
+  GenericSignature *GenericSig;
 
   CaptureInfo Captures;
 
@@ -4379,7 +4377,7 @@ class AbstractFunctionDecl : public ValueDecl, public DeclContext {
                        GenericParamList *GenericParams)
       : ValueDecl(Kind, Parent, Name, NameLoc),
         DeclContext(DeclContextKind::AbstractFunctionDecl, Parent),
-        Body(nullptr), GenericParams(nullptr) {
+        Body(nullptr), GenericParams(nullptr), GenericSig(nullptr) {
     setBodyKind(BodyKind::None);
     setGenericParams(GenericParams);
     AbstractFunctionDeclBits.NumParamPatterns = NumParamPatterns;
@@ -4396,6 +4394,17 @@ class AbstractFunctionDecl : public ValueDecl, public DeclContext {
   }
 
   void setGenericParams(GenericParamList *GenericParams);
+  
+public:
+  void setGenericSignature(GenericSignature *GenericSig) {
+    assert(!this->GenericSig && "already have signature?");
+    this->GenericSig = GenericSig;
+  }
+  
+  GenericSignature *getGenericSignature() const {
+    return GenericSig;
+  }
+
 public:
   // FIXME: Hack that provides names with keyword arguments for accessors.
   DeclName getEffectiveFullName() const;

include/swift/AST/DeclContext.h

@@ -359,6 +359,10 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
 
   /// Determine whether the innermost context is generic.
   bool isInnermostContextGeneric() const;
+  
+  /// Determine whether the innermost context is either a generic type context,
+  /// or a concrete type nested inside a generic type context.
+  bool isGenericTypeContext() const;
 
   /// Returns true if lookups within this context could affect downstream files.
   ///

include/swift/AST/Expr.h

@@ -931,9 +931,6 @@ class DeclRefExpr : public Expr {
     return DOrSpecialized.get<ConcreteDeclRef>();
   }
 
-  /// Set the declaration.
-  void setDeclRef(ConcreteDeclRef ref);
-
   void setSpecialized();
 
   /// \brief Determine whether this declaration reference was immediately

include/swift/AST/IRGenOptions.h

@@ -126,6 +126,9 @@ class IRGenOptions {
   /// Whether we should embed the bitcode file.
   IRGenEmbedMode EmbedMode : 2;
 
+  /// For resilient access to super's members for testing.
+  unsigned ForceResilientSuperDispatch: 1;
+
   /// List of backend command-line options for -embed-bitcode.
   std::vector<uint8_t> CmdArgs;
 
@@ -135,7 +138,9 @@ class IRGenOptions {
                    DisableLLVMARCOpts(false), DisableLLVMSLPVectorizer(false),
                    DisableFPElim(true), Playground(false),
                    EmitStackPromotionChecks(false), GenerateProfile(false),
-                   EmbedMode(IRGenEmbedMode::None) {}
+                   EmbedMode(IRGenEmbedMode::None),
+                   ForceResilientSuperDispatch(false)
+                   {}
 
   /// Gets the name of the specified output filename.
   /// If multiple files are specified, the last one is returned.

include/swift/Basic/STLExtras.h

@@ -558,6 +558,21 @@ void sortUnique(
   C.erase(std::unique(C.begin(), C.end()), C.end());
 }
 
+/// Sorts and then uniques a container with random access iterators and an erase
+/// method that removes a range specified by random access iterators.
+template <typename Container, typename Comparator>
+void sortUnique(
+    Container &C,
+    Comparator Cmp,
+    typename std::enable_if<
+        std::is_same<typename std::iterator_traits<
+                         typename Container::iterator>::iterator_category,
+                     std::random_access_iterator_tag>::value,
+        void>::type * = nullptr) {
+  std::sort(C.begin(), C.end(), Cmp);
+  C.erase(std::unique(C.begin(), C.end()), C.end());
+}
+
 } // end namespace swift
 
 #endif

include/swift/ClangImporter/ClangImporterOptions.h

@@ -53,10 +53,6 @@ class ClangImporterOptions {
   /// generation.
   bool DetailedPreprocessingRecord = false;
 
-  /// If true, matched getter-like and setter-like methods will be imported as
-  /// properties.
-  bool InferImplicitProperties = false;
-
   /// If true, Clang diagnostics will be dumped to stderr using Clang's
   /// diagnostic printer as well as being passed to Swift's diagnostic engine.
   bool DumpClangDiagnostics = false;

include/swift/Option/FrontendOptions.td

@@ -190,6 +190,9 @@ def emit_verbose_sil : Flag<["-"], "emit-verbose-sil">,
 def use_native_super_method : Flag<["-"], "use-native-super-method">,
   HelpText<"Use super_method for super calls in native classes">;
 
+def force_resilient_super_dispatch: Flag<["-"], "force-resilient-super-dispatch">,
+  HelpText<"Assume all super member accesses are resilient">;
+
 def disable_self_type_mangling : Flag<["-"], "disable-self-type-mangling">,
   HelpText<"Disable including Self type in method type manglings">;
 
@@ -200,10 +203,6 @@ def disable_availability_checking : Flag<["-"],
   "disable-availability-checking">,
   HelpText<"Disable checking for potentially unavailable APIs">;
 
-def enable_objc_implicit_properties :
-  Flag<["-"], "enable-objc-implicit-properties">,
-  HelpText<"Import Objective-C \"implicit properties\" as properties">;
-
 def enable_omit_needless_words :
   Flag<["-"], "enable-omit-needless-words">,
   HelpText<"Omit needless words when importing Objective-C names">;
@@ -212,6 +211,10 @@ def enable_infer_default_arguments :
   Flag<["-"], "enable-infer-default-arguments">,
   HelpText<"Infer default arguments for imported parameters">;
 
+def enable_swift_name_lookup_tables :
+  Flag<["-"], "enable-swift-name-lookup-tables">,
+  HelpText<"Enable Swift name lookup tables in the Clang importer">;
+
 def warn_omit_needless_words :
   Flag<["-"], "Womit-needless-words">,
   HelpText<"Warn about needless words in names">;

include/swift/SIL/DebugUtils.h

@@ -164,6 +164,8 @@ inline SILInstruction *getSingleNonDebugUser(const V &value) {
   auto Range = getNonDebugUses(value);
   auto I = Range.begin(), E = Range.end();
   if (I == E) return nullptr;
+  if (std::next(I) != E)
+    return nullptr;
   return I->getUser();
 }
 

include/swift/SIL/LoopInfo.h

@@ -46,6 +46,10 @@ class SILLoop : public llvm::LoopBase<SILBasicBlock, SILLoop> {
     return make_range(begin(), end());
   }
 
+  /// Check whether it is safe to duplicate this instruction when duplicating
+  /// this loop by unrolling or versioning.
+  bool canDuplicate(SILInstruction *Inst) const;
+
 private:
   friend class llvm::LoopInfoBase<SILBasicBlock, SILLoop>;
 

include/swift/SIL/SILBasicBlock.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_SIL_BASICBLOCK_H
 #define SWIFT_SIL_BASICBLOCK_H
 
+#include "swift/Basic/Range.h"
 #include "swift/SIL/SILInstruction.h"
 
 namespace llvm {
@@ -234,10 +235,31 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
 
   /// \brief Returns true if \p BB is a successor of this block.
   bool isSuccessor(SILBasicBlock *BB) const {
-    for (auto &Succ : getSuccessors())
-      if (Succ.getBB() == BB)
-        return true;
-    return false;
+    auto Range = getSuccessorBlocks();
+    return any_of(Range, [&BB](const SILBasicBlock *SuccBB) -> bool {
+      return BB == SuccBB;
+    });
+  }
+
+  using SuccessorBlockListTy =
+    TransformRange<SuccessorListTy,
+                   std::function<SILBasicBlock *(const SILSuccessor &)>>;
+  using ConstSuccessorBlockListTy =
+    TransformRange<ConstSuccessorListTy,
+                   std::function<const SILBasicBlock *(const SILSuccessor &)>>;
+
+  /// Return the range of SILBasicBlocks that are successors of this block.
+  SuccessorBlockListTy getSuccessorBlocks() {
+    using FuncTy = std::function<SILBasicBlock *(const SILSuccessor &)>;
+    FuncTy F(&SILSuccessor::getBB);
+    return makeTransformRange(getSuccessors(), F);
+  }
+
+  /// Return the range of SILBasicBlocks that are successors of this block.
+  ConstSuccessorBlockListTy getSuccessorBlocks() const {
+    using FuncTy = std::function<const SILBasicBlock *(const SILSuccessor &)>;
+    FuncTy F(&SILSuccessor::getBB);
+    return makeTransformRange(getSuccessors(), F);
   }
 
   using pred_iterator = SILSuccessorIterator;
@@ -250,6 +272,12 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
     return {pred_begin(), pred_end() };
   }
 
+  bool isPredecessor(SILBasicBlock *BB) const {
+    return any_of(getPreds(), [&BB](const SILBasicBlock *PredBB) -> bool {
+      return BB == PredBB;
+    });
+  }
+
   SILBasicBlock *getSinglePredecessor() {
     if (pred_empty() || std::next(pred_begin()) != pred_end())
       return nullptr;

include/swift/SIL/SILCloner.h

@@ -366,7 +366,7 @@ SILCloner<ImplClass>::visitSILBasicBlock(SILBasicBlock* BB) {
   // Iterate over successors to do the depth-first search.
   for (auto &Succ : BB->getSuccessors()) {
     auto BBI = BBMap.find(Succ);
-    // Only visit a successor that has not already been visisted.
+    // Only visit a successor that has not already been visited.
     if (BBI == BBMap.end()) {
       // Map the successor to a new BB.
       auto MappedBB = new (F.getModule()) SILBasicBlock(&F);

include/swift/SIL/SILFunction.h

@@ -108,7 +108,7 @@ class SILFunction
   /// functions into the thunk.
   unsigned Thunk : 2;
 
-  /// The visiblity of the parent class, if this is a method which is contained
+  /// The visibility of the parent class, if this is a method which is contained
   /// in the vtable of that class.
   unsigned ClassVisibility : 2;
 
@@ -300,7 +300,7 @@ class SILFunction
 
   /// Get's the effective linkage which is used to derive the llvm linkage.
   /// Usually this is the same as getLinkage(), except in one case: if this
-  /// function is a method in a class which has higher visiblity than the
+  /// function is a method in a class which has higher visibility than the
   /// method itself, the function can be referenced from vtables of derived
   /// classes in other compilation units.
   SILLinkage getEffectiveSymbolLinkage() const {

include/swift/SILOptimizer/Analysis/ClassHierarchyAnalysis.h

@@ -21,8 +21,6 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Debug.h"
 
-using namespace llvm;
-
 namespace swift {
 
 class SILModule;
@@ -32,7 +30,8 @@ class ClassHierarchyAnalysis : public SILAnalysis {
   typedef SmallVector<ClassDecl *, 8> ClassList;
   typedef SmallPtrSet<ClassDecl *, 32> ClassSet;
   typedef SmallVector<NominalTypeDecl *, 8> NominalTypeList;
-  typedef DenseMap<ProtocolDecl *, NominalTypeList> ProtocolImplementations;
+  typedef llvm::DenseMap<ProtocolDecl *, NominalTypeList>
+      ProtocolImplementations;
 
   ClassHierarchyAnalysis(SILModule *Mod)
       : SILAnalysis(AnalysisKind::ClassHierarchy), M(Mod) {
@@ -101,10 +100,10 @@ class ClassHierarchyAnalysis : public SILAnalysis {
   SILModule *M;
 
   /// A cache that maps a class to all of its known direct subclasses.
-  DenseMap<ClassDecl*, ClassList> DirectSubclassesCache;
+  llvm::DenseMap<ClassDecl*, ClassList> DirectSubclassesCache;
 
   /// A cache that maps a class to all of its known indirect subclasses.
-  DenseMap<ClassDecl*, ClassList> IndirectSubclassesCache;
+  llvm::DenseMap<ClassDecl*, ClassList> IndirectSubclassesCache;
 
   /// A cache that maps a protocol to all of its known implementations.
   ProtocolImplementations ProtocolImplementationsCache;

include/swift/SILOptimizer/Analysis/LoopRegionAnalysis.h

@@ -399,6 +399,10 @@ class LoopRegion {
     /// Subregions array by the RPO number of its header.
     llvm::SmallVector<std::pair<unsigned, unsigned>, 2> Subloops;
 
+    /// A list of subregions with non-local successors. This is the actual ID
+    /// of the subregion since we do not care about any ordering.
+    llvm::SmallVector<unsigned, 2> ExitingSubregions;
+
     subregion_iterator begin() const {
       return subregion_iterator(Subregions.begin(), &Subloops);
     }
@@ -498,6 +502,14 @@ class LoopRegion {
     return std::find(subregion_begin(), End, R->getID()) != End;
   }
 
+  /// Returns an ArrayRef containing IDs of the exiting subregions of this
+  /// region. The exit regions associated with the exiting subregions are the
+  /// end points of the non-local edges. This asserts if this is a region
+  /// representing a block.
+  ArrayRef<unsigned> getExitingSubregions() const {
+    return getSubregionData().ExitingSubregions;
+  }
+
   using pred_const_iterator = decltype(Preds)::const_iterator;
   pred_const_iterator pred_begin() const { return Preds.begin(); }
   pred_const_iterator pred_end() const { return Preds.end(); }

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -26,6 +26,7 @@ namespace swift {
 class SILFunction;
 class SILFunctionTransform;
 class SILModule;
+class SILModuleTransform;
 class SILOptions;
 class SILTransform;
 
@@ -156,6 +157,10 @@ class SILPassManager {
 
   typedef llvm::ArrayRef<SILFunctionTransform *> PassList;
 private:
+  /// Run the SIL module transform \p SMT over all the functions in
+  /// the module.
+  void runModulePass(SILModuleTransform *SMT);
+
   /// Run the passes in \p FuncTransforms. Return true
   /// if the pass manager requested to stop the execution
   /// of the optimization cycle (this is a debug feature).

include/swift/SILOptimizer/PassManager/Passes.def

@@ -38,6 +38,8 @@ PASS(AllocBoxToStack, "allocbox-to-stack",
      "Promote heap allocations to stack allocations")
 PASS(ArrayCountPropagation, "array-count-propagation",
      "Propagate the count of arrays")
+PASS(ArrayElementPropagation, "array-element-propagation",
+     "Propagate the value of array elements")
 PASS(BasicCalleePrinter, "basic-callee-printer",
      "Construct basic callee analysis and use it to print callees "
      "for testing purposes")
@@ -130,6 +132,8 @@ PASS(LoopRegionViewCFG, "loop-region-view-cfg",
      "Construct the loop region data structure and dump its contents as a pdf cfg")
 PASS(LoopRotate, "loop-rotate",
      "Rotate loops")
+PASS(LoopUnroll, "loop-unroll",
+     "Unroll loops")
 PASS(LowerAggregateInstrs, "lower-aggregate-instrs",
      "Lower aggregate instructions to scalar instructions")
 PASS(MandatoryInlining, "mandatory-inlining",