---

yaml
---
r: 344953
b: refs/heads/master
c: d75027f
h: refs/heads/master
i:
  344951: 4efa03f

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 953b5227939ca8e418aceb06255f916f07e81e33
+refs/heads/master: d75027f8e4151cc2ac75998959ec5aa1f2709194
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/DiagnosticsSema.def

@@ -1535,6 +1535,12 @@ ERROR(types_not_equal_decl,none,
 ERROR(types_not_equal_in_decl_ref,none,
       "referencing %0 %1 on %2 requires the types %3 and %4 be equivalent",
       (DescriptiveDeclKind, DeclName, Type, Type, Type))
+ERROR(types_not_inherited_decl,none,
+      "%0 %1 requires that %2 inherit from %3",
+      (DescriptiveDeclKind, DeclName, Type, Type))
+ERROR(types_not_inherited_in_decl_ref,none,
+      "referencing %0 %1 on %2 requires that %3 inherit from %4",
+      (DescriptiveDeclKind, DeclName, Type, Type, Type))
 NOTE(where_requirement_failure_one_subst,none,
      "where %0 = %1", (Type, Type))
 NOTE(where_requirement_failure_both_subst,none,

trunk/lib/Sema/CSDiagnostics.h

@@ -274,6 +274,40 @@ class SameTypeRequirementFailure final : public RequirementFailure {
   }
 };
 
+/// Diagnose failures related to superclass generic requirements, e.g.
+/// ```swift
+/// class A {
+/// }
+///
+/// class B {
+/// }
+///
+/// func foo<T>(_ t: [T]) where T: A {}
+/// foo([B()])
+/// ```
+///
+/// `A` is not the superclass of `B`, which is required by `foo<T>`.
+class SuperclassRequirementFailure final : public RequirementFailure {
+  Type LHS, RHS;
+
+public:
+  SuperclassRequirementFailure(Expr *expr, const Solution &solution, Type lhs,
+                               Type rhs, ConstraintLocator *locator)
+      : RequirementFailure(expr, solution, locator), LHS(lhs), RHS(rhs) {}
+
+  Type getLHS() const override { return LHS; }
+  Type getRHS() const override { return RHS; }
+
+protected:
+  DiagOnDecl getDiagnosticOnDecl() const override {
+    return diag::types_not_inherited_decl;
+  }
+
+  DiagInReference getDiagnosticInRereference() const override {
+    return diag::types_not_inherited_in_decl_ref;
+  }
+};
+
 /// Diagnose errors associated with missing, extraneous
 /// or incorrect labels supplied by arguments, e.g.
 /// ```swift

trunk/lib/Sema/CSFix.cpp

@@ -175,3 +175,15 @@ SkipSameTypeRequirement::create(ConstraintSystem &cs, Type lhs, Type rhs,
                                 ConstraintLocator *locator) {
   return new (cs.getAllocator()) SkipSameTypeRequirement(lhs, rhs, locator);
 }
+
+bool SkipSuperclassRequirement::diagnose(Expr *root,
+                                         const Solution &solution) const {
+  SuperclassRequirementFailure failure(root, solution, LHS, RHS, getLocator());
+  return failure.diagnose();
+}
+
+SkipSuperclassRequirement *
+SkipSuperclassRequirement::create(ConstraintSystem &cs, Type lhs, Type rhs,
+                                  ConstraintLocator *locator) {
+  return new (cs.getAllocator()) SkipSuperclassRequirement(lhs, rhs, locator);
+}

trunk/lib/Sema/CSFix.h

@@ -301,6 +301,26 @@ class SkipSameTypeRequirement final : public ConstraintFix {
                                          Type rhs, ConstraintLocator *locator);
 };
 
+/// Skip 'superclass' generic requirement constraint,
+/// and assume that types are equal.
+class SkipSuperclassRequirement final : public ConstraintFix {
+  Type LHS, RHS;
+
+  SkipSuperclassRequirement(Type lhs, Type rhs, ConstraintLocator *locator)
+      : ConstraintFix(FixKind::SkipSameTypeRequirement, locator), LHS(lhs),
+        RHS(rhs) {}
+
+public:
+  std::string getName() const override {
+    return "skip superclass generic requirement";
+  }
+
+  bool diagnose(Expr *root, const Solution &solution) const override;
+
+  static SkipSuperclassRequirement *
+  create(ConstraintSystem &cs, Type lhs, Type rhs, ConstraintLocator *locator);
+};
+
 } // end namespace constraints
 } // end namespace swift
 

trunk/lib/Sema/CSSimplify.cpp

@@ -161,6 +161,10 @@ matchCallArguments(ArrayRef<AnyFunctionType::Param> args,
   // requiring further checking at the end.
   bool potentiallyOutOfOrder = false;
 
+  auto hasDefault = [&defaultMap, &numParams](unsigned idx) -> bool {
+    return idx < numParams ? defaultMap.test(idx) : false;
+  };
+
   // Local function that claims the argument at \c argNumber, returning the
   // index of the claimed argument. This is primarily a helper for
   // \c claimNextNamed.
@@ -206,7 +210,7 @@ matchCallArguments(ArrayRef<AnyFunctionType::Param> args,
   // Local function that retrieves the next unclaimed argument with the given
   // name (which may be empty). This routine claims the argument.
   auto claimNextNamed
-    = [&](Identifier name, bool ignoreNameMismatch,
+    = [&](Identifier paramLabel, bool ignoreNameMismatch,
           bool forVariadic = false) -> Optional<unsigned> {
     // Skip over any claimed arguments.
     skipClaimedArgs();
@@ -218,8 +222,9 @@ matchCallArguments(ArrayRef<AnyFunctionType::Param> args,
     // Go hunting for an unclaimed argument whose name does match.
     Optional<unsigned> claimedWithSameName;
     for (unsigned i = nextArgIdx; i != numArgs; ++i) {
-      // Skip arguments where the name doesn't match.
-      if (args[i].getLabel() != name) {
+      auto argLabel = args[i].getLabel();
+
+      if (argLabel != paramLabel) {
         // If this is an attempt to claim additional unlabeled arguments
         // for variadic parameter, we have to stop at first labeled argument.
         if (forVariadic)
@@ -240,11 +245,23 @@ matchCallArguments(ArrayRef<AnyFunctionType::Param> args,
 
       // We found a match.  If the match wasn't the next one, we have
       // potentially out of order arguments.
-      if (i != nextArgIdx)
+      if (i != nextArgIdx) {
+        // Avoid claiming un-labeled defaulted parameters
+        // by out-of-order un-labeled arguments or parts
+        // of variadic argument sequence, because that might
+        // be incorrect:
+        // ```swift
+        // func foo(_ a: Int, _ b: Int = 0, c: Int = 0, _ d: Int) {}
+        // foo(1, c: 2, 3) // -> `3` will be claimed as '_ b:'.
+        // ```
+        if (argLabel.empty() && (hasDefault(i) || !forVariadic))
+          continue;
+
         potentiallyOutOfOrder = true;
+      }
 
       // Claim it.
-      return claim(name, i);
+      return claim(paramLabel, i);
     }
 
     // If we're not supposed to attempt any fixes, we're done.
@@ -268,8 +285,8 @@ matchCallArguments(ArrayRef<AnyFunctionType::Param> args,
       // Claim this argument if we are asked to ignore labeling failure,
       // only if argument doesn't have a label when parameter expected
       // it to, or vice versa.
-      if (name.empty() || argLabel.empty())
-        return claim(name, nextArgIdx);
+      if (paramLabel.empty() || argLabel.empty())
+        return claim(paramLabel, nextArgIdx);
     }
 
     // Redundant keyword arguments.
@@ -478,7 +495,7 @@ matchCallArguments(ArrayRef<AnyFunctionType::Param> args,
         continue;
 
       // Parameters with defaults can be unfulfilled.
-      if (defaultMap.test(paramIdx))
+      if (hasDefault(paramIdx))
         continue;
 
       listener.missingArgument(paramIdx);
@@ -1662,8 +1679,11 @@ static void attemptToFixRequirementFailure(
     return;
   }
 
-  case RequirementKind::Superclass:
-    break; // Not yet supported
+  case RequirementKind::Superclass: {
+    auto *fix = SkipSuperclassRequirement::create(cs, type1, type2, reqLoc);
+    conversionsOrFixes.push_back(fix);
+    return;
+  }
 
   case RequirementKind::Conformance:
   case RequirementKind::Layout:

trunk/test/Constraints/diagnostics.swift

@@ -1206,3 +1206,6 @@ func unresolvedTypeExistential() -> Bool {
   return (Int.self==_{})
   // expected-error@-1 {{ambiguous reference to member '=='}}
 }
+
+func rdar43525641(_ a: Int, _ b: Int = 0, c: Int = 0, _ d: Int) {}
+rdar43525641(1, c: 2, 3) // Ok

trunk/test/Constraints/diagnostics_swift4.swift

@@ -6,7 +6,7 @@ func sr_2505(_ a: Any) {} // expected-note {{}}
 sr_2505()          // expected-error {{missing argument for parameter #1 in call}}
 sr_2505(a: 1)      // expected-error {{extraneous argument label 'a:' in call}}
 sr_2505(1, 2)      // expected-error {{extra argument in call}}
-sr_2505(a: 1, 2)   // expected-error {{extra argument 'a' in call}}
+sr_2505(a: 1, 2)   // expected-error {{extra argument in call}}
 
 struct C_2505 {
   init(_ arg: Any) {

trunk/test/Constraints/keyword_arguments.swift

@@ -204,7 +204,7 @@ variadics4()
 variadics4(y: 0, x: 1, 2, 3) // expected-error{{argument 'x' must precede argument 'y'}} {{12-12=x: 1, 2, 3, }} {{16-28=}}
 variadics4(z: 1, x: 1) // expected-error{{argument 'x' must precede argument 'z'}} {{12-12=x: 1, }} {{16-22=}}
 
-func variadics5(_ x: Int, y: Int, _ z: Int...) { }
+func variadics5(_ x: Int, y: Int, _ z: Int...) { } // expected-note {{declared here}}
 
 // Using variadics (in-order, complete)
 variadics5(1, y: 2)
@@ -214,7 +214,7 @@ variadics5(1, y: 2, 1, 2, 3)
 
 // Using various (out-of-order)
 variadics5(1, 2, 3, 4, 5, 6, y: 7) // expected-error{{argument 'y' must precede unnamed argument #2}} {{15-15=y: 7, }} {{28-34=}}
-variadics5(y: 1, 2, 3, 4, 5, 6, 7) // expected-error{{unnamed argument #2 must precede argument 'y'}} {{12-12=2, }} {{16-19=}}
+variadics5(y: 1, 2, 3, 4, 5, 6, 7) // expected-error{{missing argument for parameter #1 in call}}
 
 func variadics6(x: Int..., y: Int = 2, z: Int) { } // expected-note 4 {{'variadics6(x:y:z:)' declared here}}
 

trunk/test/Generics/inheritance.swift

@@ -12,7 +12,7 @@ class Other { }
 
 func acceptA(_ a: A) { }
 
-func f0<T : A>(_ obji: T, _ ai: A, _ bi: B) {
+func f0<T : A>(_ obji: T, _ ai: A, _ bi: B) { // expected-note {{where 'T' = 'Other'}}
   var obj = obji, a = ai, b = bi
   // Method access
   obj.foo()
@@ -39,7 +39,7 @@ func f0<T : A>(_ obji: T, _ ai: A, _ bi: B) {
 func call_f0(_ a: A, b: B, other: Other) {
   f0(a, a, b)
   f0(b, a, b)
-  f0(other, a, b) // expected-error{{cannot convert value of type 'Other' to expected argument type 'A'}}
+  f0(other, a, b) // expected-error{{global function 'f0' requires that 'Other' inherit from 'A'}}
 }
 
 class X<T> {

trunk/test/type/subclass_composition.swift

@@ -300,9 +300,13 @@ func dependentMemberTypes<T : BaseIntAndP2>(
 func conformsToAnyObject<T : AnyObject>(_: T) {}
 func conformsToP1<T : P1>(_: T) {}
 func conformsToP2<T : P2>(_: T) {}
-func conformsToBaseIntAndP2<T : Base<Int> & P2>(_: T) {} // expected-note 3 {{where 'T' = 'Base<Int>'}}
+func conformsToBaseIntAndP2<T : Base<Int> & P2>(_: T) {}
+// expected-note@-1 2 {{where 'T' = 'Base<String>'}}
+// expected-note@-2   {{where 'T' = 'Base<Int>'}}
 
-func conformsToBaseIntAndP2WithWhereClause<T>(_: T) where T : Base<Int> & P2 {} // expected-note 2 {{where 'T' = 'Base<Int>'}}
+func conformsToBaseIntAndP2WithWhereClause<T>(_: T) where T : Base<Int> & P2 {}
+// expected-note@-1 {{where 'T' = 'Base<String>'}}
+// expected-note@-2 {{where 'T' = 'Base<Int>'}}
 
 class FakeDerived : Base<String>, P2 {
   required init(classInit: ()) {
@@ -417,13 +421,14 @@ func conformsTo<T1 : P2, T2 : Base<Int> & P2>(
   // expected-error@-1 {{argument type 'Base<Int>' does not conform to expected type 'P2'}}
 
   conformsToBaseIntAndP2(badBase)
-  // expected-error@-1 {{global function 'conformsToBaseIntAndP2' requires that 'Base<Int>' conform to 'P2'}}
+  // expected-error@-1 {{global function 'conformsToBaseIntAndP2' requires that 'Base<String>' inherit from 'Base<Int>'}}
+  // expected-error@-2 {{argument type 'Base<String>' does not conform to expected type 'P2'}}
 
   conformsToBaseIntAndP2(fakeDerived)
-  // expected-error@-1 {{global function 'conformsToBaseIntAndP2' requires that 'Base<Int>' conform to 'P2'}}
+  // expected-error@-1 {{global function 'conformsToBaseIntAndP2' requires that 'Base<String>' inherit from 'Base<Int>'}}
 
   conformsToBaseIntAndP2WithWhereClause(fakeDerived)
-  // expected-error@-1 {{global function 'conformsToBaseIntAndP2WithWhereClause' requires that 'Base<Int>' conform to 'P2'}}
+  // expected-error@-1 {{global function 'conformsToBaseIntAndP2WithWhereClause' requires that 'Base<String>' inherit from 'Base<Int>'}}
 
   conformsToBaseIntAndP2(p2Archetype)
   // expected-error@-1 {{global function 'conformsToBaseIntAndP2' requires that 'Base<Int>' conform to 'P2'}}

trunk/test/type/subclass_composition_objc.swift

@@ -24,13 +24,13 @@ class SomeMethods {
 
 // Test self-conformance
 
-func takesObjCClass<T : ObjCClass>(_: T) {}
+func takesObjCClass<T : ObjCClass>(_: T) {} // expected-note {{where 'T' = 'ObjCProtocol'}}
 func takesObjCProtocol<T : ObjCProtocol>(_: T) {}
-func takesObjCClassAndProtocol<T : ObjCClass & ObjCProtocol>(_: T) {} // expected-note {{where 'T' = 'ObjCClass'}}
+func takesObjCClassAndProtocol<T : ObjCClass & ObjCProtocol>(_: T) {} // expected-note {{where 'T' = 'ObjCProtocol'}}
 
 func testSelfConformance(c: ObjCClass, p: ObjCProtocol, cp: ObjCClass & ObjCProtocol) {
   takesObjCClass(c)
-  takesObjCClass(p) // expected-error {{cannot convert value of type 'ObjCProtocol' to expected argument type 'ObjCClass'}}
+  takesObjCClass(p) // expected-error {{global function 'takesObjCClass' requires that 'ObjCProtocol' inherit from 'ObjCClass'}}
   takesObjCClass(cp)
 
   takesObjCProtocol(c) // expected-error {{argument type 'ObjCClass' does not conform to expected type 'ObjCProtocol'}}
@@ -39,7 +39,7 @@ func testSelfConformance(c: ObjCClass, p: ObjCProtocol, cp: ObjCClass & ObjCProt
 
   // FIXME: Bad diagnostics
   takesObjCClassAndProtocol(c) // expected-error {{argument type 'ObjCClass' does not conform to expected type 'ObjCProtocol'}}
-  takesObjCClassAndProtocol(p) // expected-error {{global function 'takesObjCClassAndProtocol' requires that 'ObjCClass' conform to 'ObjCProtocol'}}
+  takesObjCClassAndProtocol(p) // expected-error {{global function 'takesObjCClassAndProtocol' requires that 'ObjCProtocol' inherit from 'ObjCClass'}}
   takesObjCClassAndProtocol(cp)
 }