Merge remote-tracking branch 'origin/master' into master-next

Author: swift-ci

benchmark/utils/ArgParse.swift

@@ -46,7 +46,7 @@ func checked<T>(
   if let t = try parse(value)  { return t }
   var type = "\(T.self)"
   if type.starts(with: "Optional<") {
-      let s = type.index(after: type.index(of:"<")!)
+      let s = type.index(after: type.firstIndex(of: "<")!)
       let e = type.index(before: type.endIndex) // ">"
       type = String(type[s ..< e]) // strip Optional< >
   }
@@ -66,7 +66,7 @@ class ArgumentParser<U> {
     private let programName: String = {
       // Strip full path from the program name.
       let r = CommandLine.arguments[0].reversed()
-      let ss = r[r.startIndex ..< (r.index(of:"/") ?? r.endIndex)]
+      let ss = r[r.startIndex ..< (r.firstIndex(of: "/") ?? r.endIndex)]
       return String(ss.reversed())
     }()
     private var positionalArgs = [String]()

include/swift/AST/DiagnosticsSema.def

@@ -1363,7 +1363,7 @@ WARNING(pattern_type_not_usable_from_inline_warn,none,
         "should be '@usableFromInline' or public",
         (bool, bool))
 ERROR(pattern_type_not_usable_from_inline_fixed_layout,none,
-      "type referenced from a stored property in a @_fixed_layout struct must "
+      "type referenced from a stored property in a '@_fixed_layout' struct must "
       "be '@usableFromInline' or public",
       (/*ignored*/bool, /*ignored*/bool))
 ERROR(pattern_type_not_usable_from_inline_inferred,none,
@@ -1380,7 +1380,7 @@ WARNING(pattern_type_not_usable_from_inline_inferred_warn,none,
         (bool, bool, Type))
 ERROR(pattern_type_not_usable_from_inline_inferred_fixed_layout,none,
       "type referenced from a stored property with inferred type %2 in a "
-      "@_fixed_layout struct must be '@usableFromInline' or public",
+      "'@_fixed_layout' struct must be '@usableFromInline' or public",
       (/*ignored*/bool, /*ignored*/bool, Type))
 
 ERROR(pattern_binds_no_variables,none,

lib/Sema/CSSimplify.cpp

@@ -1962,21 +1962,23 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
       auto meta1 = cast<AnyMetatypeType>(desugar1);
       auto meta2 = cast<AnyMetatypeType>(desugar2);
 
-      ConstraintKind subKind = ConstraintKind::Equal;
       // A.Type < B.Type if A < B and both A and B are classes.
-      if (isa<MetatypeType>(meta1) &&
-          meta1->getInstanceType()->mayHaveSuperclass() &&
-          meta2->getInstanceType()->getClassOrBoundGenericClass())
-        subKind = std::min(kind, ConstraintKind::Subtype);
       // P.Type < Q.Type if P < Q, both P and Q are protocols, and P.Type
-      // and Q.Type are both existential metatypes.
-      else if (isa<ExistentialMetatypeType>(meta1))
-        subKind = std::min(kind, ConstraintKind::Subtype);
-      
-      return matchTypes(meta1->getInstanceType(), meta2->getInstanceType(),
-                        subKind, subflags,
-                        locator.withPathElement(
-                          ConstraintLocator::InstanceType));
+      // and Q.Type are both existential metatypes
+      auto subKind = std::min(kind, ConstraintKind::Subtype);
+      // If instance types can't have a subtype relationship
+      // it means that such types can be simply equated.
+      auto instanceType1 = meta1->getInstanceType();
+      auto instanceType2 = meta2->getInstanceType();
+      if (isa<MetatypeType>(meta1) &&
+          !(instanceType1->mayHaveSuperclass() &&
+            instanceType2->getClassOrBoundGenericClass())) {
+        subKind = ConstraintKind::Equal;
+      }
+
+      return matchTypes(
+          instanceType1, instanceType2, subKind, subflags,
+          locator.withPathElement(ConstraintLocator::InstanceType));
     }
 
     case TypeKind::Function: {

test/Constraints/rdar44816848.swift

@@ -0,0 +1,16 @@
+// RUN: %target-typecheck-verify-swift
+
+class A {}
+class B: A {}
+class C: A {}
+
+struct S {
+  func foo<T: A>(types: [T.Type]) {}
+}
+
+func bar(_ s: S, _ forced_s: S!) {
+  s.foo(types: [A.self, B.self]) // ok
+  s.foo(types: [B.self, A.self]) // ok
+  forced_s.foo(types: [A.self, B.self]) // ok
+  forced_s.foo(types: [B.self, A.self]) // ok
+}

test/attr/attr_fixed_layout.swift

@@ -70,31 +70,31 @@ struct Rectangle {
 
 
 @_fixed_layout public struct BadFields1 {
-  private var field: PrivateStruct // expected-error {{type referenced from a stored property in a @_fixed_layout struct must be '@usableFromInline' or public}}
+  private var field: PrivateStruct // expected-error {{type referenced from a stored property in a '@_fixed_layout' struct must be '@usableFromInline' or public}}
 }
 
 @_fixed_layout public struct BadFields2 {
-  private var field: PrivateStruct? // expected-error {{type referenced from a stored property in a @_fixed_layout struct must be '@usableFromInline' or public}}
+  private var field: PrivateStruct? // expected-error {{type referenced from a stored property in a '@_fixed_layout' struct must be '@usableFromInline' or public}}
 }
 
 @_fixed_layout public struct BadFields3 {
-  internal var field: InternalStruct? // expected-error {{type referenced from a stored property in a @_fixed_layout struct must be '@usableFromInline' or public}}
+  internal var field: InternalStruct? // expected-error {{type referenced from a stored property in a '@_fixed_layout' struct must be '@usableFromInline' or public}}
 }
 
 @_fixed_layout @usableFromInline struct BadFields4 {
-  internal var field: InternalStruct? // expected-error {{type referenced from a stored property in a @_fixed_layout struct must be '@usableFromInline' or public}}
+  internal var field: InternalStruct? // expected-error {{type referenced from a stored property in a '@_fixed_layout' struct must be '@usableFromInline' or public}}
 }
 
 @_fixed_layout public struct BadFields5 {
-  private var field: PrivateStruct? { // expected-error {{type referenced from a stored property in a @_fixed_layout struct must be '@usableFromInline' or public}}
+  private var field: PrivateStruct? { // expected-error {{type referenced from a stored property in a '@_fixed_layout' struct must be '@usableFromInline' or public}}
     didSet {}
   }
 }
 
 // expected-warning@+1 {{the result of a '@usableFromInline' function should be '@usableFromInline' or public}}
 @usableFromInline func notReallyUsableFromInline() -> InternalStruct? { return nil }
 @_fixed_layout public struct BadFields6 {
-  private var field = notReallyUsableFromInline() // expected-error {{type referenced from a stored property with inferred type 'InternalStruct?' in a @_fixed_layout struct must be '@usableFromInline' or public}}
+  private var field = notReallyUsableFromInline() // expected-error {{type referenced from a stored property with inferred type 'InternalStruct?' in a '@_fixed_layout' struct must be '@usableFromInline' or public}}
 }
 
 @_fixed_layout public struct OKFields {

test/lit.cfg

@@ -1219,11 +1219,17 @@ config.target_sil_nm = (
     '%s -target %s %s'
     % (config.sil_nm, config.variant_triple, mcp_opt))
 
+rth_flags = ''
+if swift_execution_tests_extra_flags:
+    rth_flags = swift_execution_tests_extra_flags + ' -wmo'
+
 config.target_resilience_test = (
      '%s --target-build-swift "%s" --target-run "%s" --t %%t --S %%S --s %%s '
-     '--lib-prefix "%s" --lib-suffix ".%s" --target-codesign "%s"'
+     '--lib-prefix "%s" --lib-suffix ".%s" --target-codesign "%s" '
+     '--additional-compile-flags "%s"'
      % (config.rth, config.target_build_swift, config.target_run, 'lib',
-        config.target_dylib_extension, config.target_codesign))
+        config.target_dylib_extension, config.target_codesign,
+        rth_flags))
 
 # FIXME: Get symbol diffing working with binutils nm as well. The flags are slightly
 # different.

utils/rth

@@ -33,7 +33,7 @@ class ResilienceTest(object):
 
     def __init__(self, target_build_swift, target_run, target_codesign,
                  target_nm, tmp_dir, test_dir, test_src, lib_prefix,
-                 lib_suffix, additional_compile_flags_library,
+                 lib_suffix, additional_compile_flags,
                  no_backward_deployment, no_symbol_diff):
         self.target_build_swift = shlex.split(target_build_swift)
         self.target_run = shlex.split(target_run)
@@ -44,8 +44,7 @@ class ResilienceTest(object):
         self.test_src = test_src
         self.lib_prefix = lib_prefix
         self.lib_suffix = lib_suffix
-        self.additional_compile_flags_library = \
-            shlex.split(additional_compile_flags_library)
+        self.additional_compile_flags = shlex.split(additional_compile_flags)
 
         self.before_dir = os.path.join(self.tmp_dir, 'before')
         self.after_dir = os.path.join(self.tmp_dir, 'after')
@@ -95,7 +94,8 @@ class ResilienceTest(object):
                                    os.path.join('@rpath', lib_file)]
 
             command = self.target_build_swift + \
-                self.additional_compile_flags_library + compiler_flags
+                self.additional_compile_flags + \
+                compiler_flags
             verbose_print_command(command)
             returncode = subprocess.call(command)
             assert returncode == 0, str(command)
@@ -143,7 +143,9 @@ class ResilienceTest(object):
                               '-Xfrontend', '-enable-class-resilience',
                               '-I', self.config_dir_map[config],
                               '-o', output_obj]
-            command = self.target_build_swift + compiler_flags
+            command = self.target_build_swift + \
+                self.additional_compile_flags + \
+                compiler_flags
             verbose_print_command(command)
             returncode = subprocess.call(command)
             assert returncode == 0, str(command)
@@ -218,7 +220,7 @@ def main():
     parser.add_argument('--s', required=True)
     parser.add_argument('--lib-prefix', required=True)
     parser.add_argument('--lib-suffix', required=True)
-    parser.add_argument('--additional-compile-flags-library', default='')
+    parser.add_argument('--additional-compile-flags', default='')
     parser.add_argument('--no-backward-deployment', default=False,
                         action='store_true')
     parser.add_argument('--no-symbol-diff', default=False,
@@ -230,7 +232,7 @@ def main():
                                      args.target_codesign, args.target_nm,
                                      args.t, args.S, args.s, args.lib_prefix,
                                      args.lib_suffix,
-                                     args.additional_compile_flags_library,
+                                     args.additional_compile_flags,
                                      args.no_backward_deployment,
                                      args.no_symbol_diff)
 

validation-test/Evolution/Inputs/class_add_convenience_init.swift

@@ -0,0 +1,26 @@
+open class AddConvenienceInit {
+  public let age: Int
+
+  public init(x: Int) {
+    self.age = x
+  }
+
+#if BEFORE
+
+  public convenience init(z: Int) {
+    self.init(x: z * z + 2)
+  }
+
+#else
+
+  public convenience init(z: Int) {
+    self.init(y: z * z)
+  }
+
+  public convenience init(y: Int) {
+    self.init(x: y + 2)
+  }
+
+#endif
+
+}

validation-test/Evolution/Inputs/class_add_deinit.swift

@@ -0,0 +1,25 @@
+public var count = 0
+
+public func getVersion() -> Int {
+#if BEFORE
+  return 0
+#else
+  return 1
+#endif
+}
+
+open class Base {
+  public init() {}
+
+#if AFTER
+  deinit {
+    count += 1
+  }
+#endif
+}
+
+open class Derived : Base {
+  deinit {
+    count += 10
+  }
+}

validation-test/Evolution/Inputs/class_add_property_attribute.swift

@@ -0,0 +1,28 @@
+public var count = 0
+
+public func getVersion() -> Int {
+#if BEFORE
+  return 0
+#else
+  return 1
+#endif
+}
+
+public class MathClass {
+  public init() {}
+}
+
+public class Attributed {
+  public init(x: MathClass, y: MathClass) {
+    self.x = x
+    self.y = y
+  }
+
+#if BEFORE
+  public var x: MathClass?
+  public var y: MathClass
+#else
+  public weak var x: MathClass?
+  public unowned var y: MathClass
+#endif
+}

validation-test/Evolution/Inputs/class_change_lazy_to_computed.swift

@@ -0,0 +1,33 @@
+
+#if BEFORE
+
+public class ChangeLazyToComputed {
+  private var celsius: Int
+
+  public init(celsius: Int) {
+    self.celsius = celsius
+  }
+
+  public lazy var fahrenheit: Int = (celsius * 9) / 5 + 32
+}
+
+#else
+
+public class ChangeLazyToComputed {
+  private var celsius: Int
+
+  public init(celsius: Int) {
+    self.celsius = celsius
+  }
+
+  public var fahrenheit: Int {
+    get {
+      return (celsius * 9) / 5 + 32
+    }
+    set {
+      celsius = ((newValue - 32) * 5) / 9
+    }
+  }
+}
+
+#endif

validation-test/Evolution/Inputs/class_change_stored_to_observed.swift

@@ -0,0 +1,40 @@
+
+#if BEFORE
+
+public func getVersion() -> Int {
+  return 0
+}
+
+public class ChangeStoredToObserved {
+  public var friends: [String] = []
+  public var count: Int = 0
+
+  public var friend: String = "cat"
+
+  public init() {}
+}
+
+#else
+
+public func getVersion() -> Int {
+  return 1
+
+}
+
+public class ChangeStoredToObserved {
+  public var friends: [String] = []
+  public var count: Int = 0
+
+  public var friend: String = "cat" {
+    willSet {
+      friends.append(friend)
+    }
+    didSet {
+      count += 1
+    }
+  }
+
+  public init() {}
+}
+
+#endif

validation-test/Evolution/Inputs/class_add_override.swift renamed to validation-test/Evolution/Inputs/class_resilient_add_override.swift

@@ -0,0 +1,25 @@
+public struct Rain {
+  public init() {}
+
+#if BEFORE
+  public func doIt() {}
+#endif
+}
+
+public class Snow {
+  public init() {}
+
+#if BEFORE
+  public final func doIt() {}
+#endif
+}
+
+#if AFTER
+extension Rain {
+  public func doIt() {}
+}
+
+extension Snow {
+  public func doIt() {}
+}
+#endif