Resolving conflict with master

Author: LucianoPAlmeida

CMakeLists.txt

@@ -327,10 +327,6 @@ option(SWIFT_STDLIB_USE_NONATOMIC_RC
     "Build the standard libraries and overlays with nonatomic reference count operations enabled"
     FALSE)
 
-option(SWIFT_STDLIB_ENABLE_SIL_OWNERSHIP
-  "Build the standard libraries and overlays with sil ownership enabled."
-  FALSE)
-
 option(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS
   "Enable runtime function counters and expose the API."
   FALSE)

benchmark/CMakeLists.txt

@@ -134,6 +134,7 @@ set(SWIFT_BENCH_MODULES
     single-source/RandomValues
     single-source/RangeAssignment
     single-source/RangeIteration
+    single-source/RangeOverlaps
     single-source/RangeReplaceableCollectionPlusDefault
     single-source/RecursiveOwnedParameter
     single-source/ReduceInto

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -314,6 +314,7 @@ function (swift_benchmark_compile_archopts)
 
   set(common_options
       "-c"
+      "-Xfrontend" "-verify-sil-ownership"
       "-target" "${target}"
       "-${BENCH_COMPILE_ARCHOPTS_OPT}" ${PAGE_ALIGNMENT_OPTION})
 
@@ -343,6 +344,7 @@ function (swift_benchmark_compile_archopts)
 
   set(common_options_driver
       "-c"
+      "-Xfrontend" "-verify-sil-ownership"
       "-target" "${target}"
       "-${driver_opt}")
 

benchmark/single-source/RangeOverlaps.swift

@@ -0,0 +1,78 @@
+//===--- RangeOverlaps.swift ----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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 RangeOverlaps = [
+  BenchmarkInfo(
+    name: "RangeOverlapsRange",
+    runFunction: run_RangeOverlapsRange,
+    tags: [.validation, .api],
+    setUpFunction: buildRanges),
+  BenchmarkInfo(
+    name: "RangeOverlapsClosedRange",
+    runFunction: run_RangeOverlapsClosedRange,
+    tags: [.validation, .api],
+    setUpFunction: buildRanges),
+  BenchmarkInfo(
+    name: "ClosedRangeOverlapsClosedRange",
+    runFunction: run_ClosedRangeOverlapsClosedRange,
+    tags: [.validation, .api],
+    setUpFunction: buildRanges)
+]
+
+private func buildRanges() {
+  blackHole(ranges)
+  blackHole(closedRanges)
+}
+
+private let ranges: [Range<Int>] = (-8...8).flatMap { a in (0...16).map { l in a..<(a+l) } }
+private let closedRanges: [ClosedRange<Int>] = (-8...8).flatMap { a in (0...16).map { l in a...(a+l) } }
+
+@inline(never)
+public func run_RangeOverlapsRange(_ N: Int) {
+  var check: UInt64 = 0
+  for _ in 0..<N {
+    for lhs in ranges {
+      for rhs in ranges {
+        if lhs.overlaps(rhs) { check += 1 }
+      }
+    }
+  }
+  CheckResults(check == 47872 * UInt64(N))
+}
+
+@inline(never)
+public func run_RangeOverlapsClosedRange(_ N: Int) {
+  var check: UInt64 = 0
+  for _ in 0..<N {
+    for lhs in ranges {
+      for rhs in closedRanges {
+        if lhs.overlaps(rhs) { check += 1 }
+      }
+    }
+  }
+  CheckResults(check == 51680 * UInt64(N))
+}
+
+@inline(never)
+public func run_ClosedRangeOverlapsClosedRange(_ N: Int) {
+  var check: UInt64 = 0
+  for _ in 0..<N {
+    for lhs in closedRanges {
+      for rhs in closedRanges {
+        if lhs.overlaps(rhs) { check += 1 }
+      }
+    }
+  }
+  CheckResults(check == 55777 * UInt64(N))
+}

benchmark/utils/main.swift

@@ -127,6 +127,7 @@ import RandomShuffle
 import RandomValues
 import RangeAssignment
 import RangeIteration
+import RangeOverlaps
 import RangeReplaceableCollectionPlusDefault
 import RecursiveOwnedParameter
 import ReduceInto
@@ -298,6 +299,7 @@ registerBenchmark(RandomShuffle)
 registerBenchmark(RandomValues)
 registerBenchmark(RangeAssignment)
 registerBenchmark(RangeIteration)
+registerBenchmark(RangeOverlaps)
 registerBenchmark(RangeReplaceableCollectionPlusDefault)
 registerBenchmark(RecursiveOwnedParameter)
 registerBenchmark(ReduceInto)

cmake/modules/SwiftSharedCMakeConfig.cmake

@@ -63,8 +63,8 @@ macro(swift_common_standalone_build_config_llvm product)
   endif()
 
   if(CMAKE_CROSSCOMPILING)
-    set(LLVM_NATIVE_BUILD "${LLVM_BINARY_DIR}/NATIVE")
-    if(NOT EXISTS "${LLVM_NATIVE_BUILD}")
+    set(LLVM_NATIVE_BUILD_DIR "${LLVM_BINARY_DIR}/NATIVE")
+    if(NOT EXISTS "${LLVM_NATIVE_BUILD_DIR}")
       message(FATAL_ERROR
         "Attempting to cross-compile swift standalone but no native LLVM build
         found.  Please cross-compile LLVM as well.")

cmake/modules/SwiftSource.cmake

@@ -236,7 +236,7 @@ function(_compile_swift_files
   endif()
 
   if(SWIFTFILE_IS_STDLIB)
-    list(APPEND swift_flags "-Xfrontend" "-enable-sil-ownership")
+    list(APPEND swift_flags "-Xfrontend" "-verify-sil-ownership")
     list(APPEND swift_flags "-Xfrontend" "-enable-mandatory-semantic-arc-opts")
   endif()
 

docs/StandardLibraryProgrammersManual.md

@@ -53,15 +53,15 @@ Optionals can be unwrapped with `!`, which triggers a trap on nil. Alternatively
 
 ### Builtins
 
-#### `_fastPath` and `_slowPath` (also, `_branchHint`)
+#### `_fastPath` and `_slowPath`
 
 `_fastPath` returns its argument, wrapped in a Builtin.expect. This informs the optimizer that the vast majority of the time, the branch will be taken (i.e. the then branch is “hot”). The SIL optimizer may alter heuristics for anything dominated by the then branch. But the real performance impact comes from the fact that the SIL optimizer will consider anything dominated by the else branch to be infrequently executed (i.e. “cold”). This means that transformations that may increase code size have very conservative heuristics to keep the rarely executed code small.
 
 The probabilities are passed through to LLVM as branch weight metadata, to leverage LLVM’s use of GCC style builtin_expect knowledge (e.g. for code layout and low-level inlining).
 
 `_fastPath` probabilities are compounding, see the example below. For this reason, it can actually degrade performance in non-intuitive ways as it marks all other code (including subsequent `_fastPath`s) as being cold. Consider `_fastPath` as basically spraying the rest of the code with a Mr. Freeze-style ice gun.
 
-`_slowPath` is the same as `_fastPath`, just with the branches swapped. Both are just wrappers around `_branchHint`, which is otherwise never called directly.
+`_slowPath` is the same as `_fastPath`, just with the branches swapped.
 
 *Example:*
 
@@ -84,8 +84,6 @@ if _fastPath(...) {
 return
 ```
 
-*NOTE: these are due for a rename and possibly a redesign. They conflate multiple notions that don’t match the average standard library programmer’s intuition.*
-
 
 #### `_onFastPath`
 

include/swift/AST/Decl.h

@@ -4552,6 +4552,8 @@ class AbstractStorageDecl : public ValueDecl {
   /// True if any of the accessors to the storage is private or fileprivate.
   bool hasPrivateAccessor() const;
 
+  bool hasDidSetOrWillSetDynamicReplacement() const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_AbstractStorageDecl &&
@@ -4577,7 +4579,7 @@ class VarDecl : public AbstractStorageDecl {
   };
 
 protected:
-  llvm::PointerUnion<PatternBindingDecl*, Stmt*> ParentPattern;
+  PointerUnion3<PatternBindingDecl *, Stmt *, VarDecl *> Parent;
 
   VarDecl(DeclKind Kind, bool IsStatic, Specifier Sp, bool IsCaptureList,
           SourceLoc NameLoc, Identifier Name, DeclContext *DC)
@@ -4648,12 +4650,15 @@ class VarDecl : public AbstractStorageDecl {
   /// Return the parent pattern binding that may provide an initializer for this
   /// VarDecl.  This returns null if there is none associated with the VarDecl.
   PatternBindingDecl *getParentPatternBinding() const {
-    return ParentPattern.dyn_cast<PatternBindingDecl *>();
+    if (!Parent)
+      return nullptr;
+    return Parent.dyn_cast<PatternBindingDecl *>();
   }
   void setParentPatternBinding(PatternBindingDecl *PBD) {
-    ParentPattern = PBD;
+    assert(PBD);
+    Parent = PBD;
   }
-  
+
   /// Return the Pattern involved in initializing this VarDecl.  However, recall
   /// that the Pattern may be involved in initializing more than just this one
   /// vardecl.  For example, if this is a VarDecl for "x", the pattern may be
@@ -4664,16 +4669,53 @@ class VarDecl : public AbstractStorageDecl {
   /// returns null.
   ///
   Pattern *getParentPattern() const;
-  
+
   /// Return the statement that owns the pattern associated with this VarDecl,
   /// if one exists.
+  ///
+  /// NOTE: After parsing and before type checking, all VarDecls from
+  /// CaseLabelItem's Patterns return their CaseStmt. After type checking, we
+  /// will have constructed the CaseLabelItem VarDecl linked list implying this
+  /// will return nullptr. After type checking, if one wishes to find a parent
+  /// pattern of a VarDecl of a CaseStmt, \see getRecursiveParentPatternStmt
+  /// instead.
   Stmt *getParentPatternStmt() const {
-    return ParentPattern.dyn_cast<Stmt*>();
+    if (!Parent)
+      return nullptr;
+    return Parent.dyn_cast<Stmt *>();
   }
-  void setParentPatternStmt(Stmt *S) {
-    ParentPattern = S;
+
+  void setParentPatternStmt(Stmt *s) {
+    assert(s);
+    Parent = s;
+  }
+
+  /// Look for the parent pattern stmt of this var decl, recursively
+  /// looking through var decl pointers and then through any
+  /// fallthroughts.
+  Stmt *getRecursiveParentPatternStmt() const;
+
+  /// Returns the var decl that this var decl is an implicit reference to if
+  /// such a var decl exists.
+  VarDecl *getParentVarDecl() const {
+    if (!Parent)
+      return nullptr;
+    return Parent.dyn_cast<VarDecl *>();
+  }
+
+  /// Set \p v to be the pattern produced VarDecl that is the parent of this
+  /// var decl.
+  void setParentVarDecl(VarDecl *v) {
+    assert(v);
+    Parent = v;
   }
 
+  /// If this is a VarDecl that does not belong to a CaseLabelItem's pattern,
+  /// return this. Otherwise, this VarDecl must belong to a CaseStmt's
+  /// CaseLabelItem. In that case, return the first case label item of the first
+  /// case stmt in a sequence of case stmts that fallthrough into each other.
+  VarDecl *getCanonicalVarDecl() const;
+
   /// True if the global stored property requires lazy initialization.
   bool isLazilyInitializedGlobal() const;
 

include/swift/AST/SILOptions.h

@@ -112,7 +112,7 @@ class SILOptions {
   std::string SILOutputFileNameForDebugging;
 
   /// If set to true, compile with the SIL Ownership Model enabled.
-  bool EnableSILOwnership = false;
+  bool VerifySILOwnership = false;
 
   /// Assume that code will be executed in a single-threaded environment.
   bool AssumeSingleThreaded = false;

include/swift/Basic/LLVM.h

@@ -43,6 +43,7 @@ namespace llvm {
   template<typename T> class TinyPtrVector;
   template<typename T> class Optional;
   template <typename PT1, typename PT2> class PointerUnion;
+  template <typename PT1, typename PT2, typename PT3> class PointerUnion3;
   class SmallBitVector;
 
   // Other common classes.
@@ -62,22 +63,23 @@ namespace swift {
   using llvm::cast_or_null;
 
   // Containers.
+  using llvm::ArrayRef;
+  using llvm::MutableArrayRef;
   using llvm::None;
   using llvm::Optional;
-  using llvm::SmallPtrSetImpl;
+  using llvm::PointerUnion;
+  using llvm::PointerUnion3;
+  using llvm::SmallBitVector;
   using llvm::SmallPtrSet;
+  using llvm::SmallPtrSetImpl;
+  using llvm::SmallSetVector;
   using llvm::SmallString;
-  using llvm::StringRef;
-  using llvm::StringLiteral;
-  using llvm::Twine;
-  using llvm::SmallVectorImpl;
   using llvm::SmallVector;
-  using llvm::ArrayRef;
-  using llvm::MutableArrayRef;
+  using llvm::SmallVectorImpl;
+  using llvm::StringLiteral;
+  using llvm::StringRef;
   using llvm::TinyPtrVector;
-  using llvm::PointerUnion;
-  using llvm::SmallSetVector;
-  using llvm::SmallBitVector;
+  using llvm::Twine;
 
   // Other common classes.
   using llvm::APFloat;

include/swift/Frontend/FrontendOptions.h

@@ -220,9 +220,6 @@ class FrontendOptions {
   /// (if asked to emit SIL).
   bool EmitVerboseSIL = false;
 
-  /// If set, find and import parseable modules from .swiftinterface files.
-  bool EnableParseableModuleInterface = false;
-
   /// If set, this module is part of a mixed Objective-C/Swift framework, and
   /// the Objective-C half should implicitly be visible to the Swift sources.
   bool ImportUnderlyingModule = false;

include/swift/Option/FrontendOptions.td

@@ -299,8 +299,8 @@ def emit_pch : Flag<["-"], "emit-pch">,
 def pch_disable_validation : Flag<["-"], "pch-disable-validation">,
   HelpText<"Disable validating the persistent PCH">;
 
-def enable_sil_ownership : Flag<["-"], "enable-sil-ownership">,
-  HelpText<"Enable the SIL Ownership Model">;
+def verify_sil_ownership : Flag<["-"], "verify-sil-ownership">,
+  HelpText<"Verify ownership invariants during SIL Verification ">;
 
 def enable_mandatory_semantic_arc_opts : Flag<["-"], "enable-mandatory-semantic-arc-opts">,
   HelpText<"Enable the mandatory semantic arc optimizer">;

include/swift/Option/Options.td

@@ -346,11 +346,6 @@ def emit_parseable_module_interface_path :
   Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild,
          ArgumentIsPath]>,
   MetaVarName<"<path>">, HelpText<"Output parseable interface file to <path>">;
-def enable_parseable_module_interface :
-  Flag<["-"], "enable-parseable-module-interface">,
-  Flags<[FrontendOption, HelpHidden, NoInteractiveOption,
-         DoesNotAffectIncrementalBuild]>,
-  HelpText<"Accept parseable .swiftinterface form of modules">;
 
 def emit_objc_header : Flag<["-"], "emit-objc-header">,
   Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,

include/swift/Parse/Parser.h

@@ -230,7 +230,22 @@ class Parser {
     // Cut off parsing by acting as if we reached the end-of-file.
     Tok.setKind(tok::eof);
   }
-  
+
+  /// Use this to assert that the parser has advanced the lexing location, e.g.
+  /// before a specific parser function has returned.
+  class AssertParserMadeProgressBeforeLeavingScopeRAII {
+    Parser &P;
+    SourceLoc InitialLoc;
+  public:
+    AssertParserMadeProgressBeforeLeavingScopeRAII(Parser &parser) : P(parser) {
+      InitialLoc = P.Tok.getLoc();
+    }
+    ~AssertParserMadeProgressBeforeLeavingScopeRAII() {
+      assert(InitialLoc != P.Tok.getLoc() &&
+        "parser did not make progress, this can result in infinite loop");
+    }
+  };
+
   /// A RAII object for temporarily changing CurDeclContext.
   class ContextChange {
   protected: