PR feedback + failed test adjustments

Author: ahoppen

lib/Sema/CSDiagnostics.cpp

@@ -4796,9 +4796,7 @@ bool MissingArgumentsFailure::diagnoseClosure(const ClosureExpr *closure) {
 
   auto *locator = getLocator();
   if (locator->isForContextualType()) {
-    if (auto type = getContextualType(locator->getAnchor())) {
-      funcType = type->getAs<FunctionType>();
-    }
+    funcType = getContextualType(locator->getAnchor())->getAs<FunctionType>();
   } else if (auto info = getFunctionArgApplyInfo(locator)) {
     auto paramType = info->getParamType();
     // Drop a single layer of optionality because argument could get injected

lib/Sema/CSFix.cpp

@@ -602,10 +602,6 @@ bool AllowTupleTypeMismatch::coalesceAndDiagnose(
     purpose = cs.getContextualTypePurpose(locator->getAnchor());
   }
 
-  if (!getFromType()->is<TupleType>() || !getToType()->is<TupleType>()) {
-    return false;
-  }
-
   TupleContextualFailure failure(solution, purpose, getFromType(), getToType(),
                                  indices, locator);
   return failure.diagnose(asNote);

lib/Sema/CSGen.cpp

@@ -890,7 +890,7 @@ namespace {
       // that member through the base returns a value convertible to the type
       // of this expression.
       auto baseTy = CS.getType(base);
-      if (auto error = dyn_cast<ErrorExpr>(base)) {
+      if (isa<ErrorExpr>(base)) {
         return CS.createTypeVariable(
             CS.getConstraintLocator(expr, ConstraintLocator::Member),
             TVO_CanBindToHole);
@@ -2327,8 +2327,9 @@ namespace {
         }
 
         if (!varType) {
-          varType = CS.createTypeVariable(CS.getConstraintLocator(locator),
-                                          TVO_CanBindToNoEscape);
+          varType =
+              CS.createTypeVariable(CS.getConstraintLocator(locator),
+                                    TVO_CanBindToNoEscape | TVO_CanBindToHole);
 
           // If this is either a `weak` declaration or capture e.g.
           // `weak var ...` or `[weak self]`. Let's wrap type variable

lib/Sema/CSSimplify.cpp

@@ -11201,18 +11201,32 @@ ConstraintSystem::simplifyApplicableFnConstraint(
   // following: $T1 -> $T2.
   auto func1 = type1->castTo<FunctionType>();
 
+  // Before stripping lvalue-ness and optional types, save the original second
+  // type for handling `func callAsFunction` and `@dynamicCallable`
+  // applications. This supports the following cases:
+  // - Generating constraints for `mutating func callAsFunction`. The nominal
+  //   type (`type2`) should be an lvalue type.
+  // - Extending `Optional` itself with `func callAsFunction` or
+  //   `@dynamicCallable` functionality. Optional types are stripped below if
+  //   `shouldAttemptFixes()` is true.
+  auto origLValueType2 =
+      getFixedTypeRecursive(type2, flags, /*wantRValue=*/false);
+  // Drill down to the concrete type on the right hand side.
+  type2 = getFixedTypeRecursive(type2, flags, /*wantRValue=*/true);
+  auto desugar2 = type2->getDesugaredType();
+
   // If a type variable representing "function type" is a hole
   // or it could be bound to some concrete type with a help of
   // a fix, let's propagate holes to the "input" type. Doing so
   // provides more information to upcoming argument and result matching.
   if (shouldAttemptFixes()) {
     if (auto *typeVar = type2->getAs<TypeVariableType>()) {
       auto *locator = typeVar->getImpl().getLocator();
-      if (typeVar->isPlaceholder() || hasFixFor(locator)) {
+      if (hasFixFor(locator)) {
         recordAnyTypeVarAsPotentialHole(func1);
       }
     }
-    Type underlyingType = simplifyType(type2);
+    Type underlyingType = simplifyType(desugar2);
     while (auto *MT = underlyingType->getAs<AnyMetatypeType>()) {
       underlyingType = MT->getInstanceType();
     }
@@ -11222,20 +11236,6 @@ ConstraintSystem::simplifyApplicableFnConstraint(
     }
   }
 
-  // Before stripping lvalue-ness and optional types, save the original second
-  // type for handling `func callAsFunction` and `@dynamicCallable`
-  // applications. This supports the following cases:
-  // - Generating constraints for `mutating func callAsFunction`. The nominal
-  //   type (`type2`) should be an lvalue type.
-  // - Extending `Optional` itself with `func callAsFunction` or
-  //   `@dynamicCallable` functionality. Optional types are stripped below if
-  //   `shouldAttemptFixes()` is true.
-  auto origLValueType2 =
-      getFixedTypeRecursive(type2, flags, /*wantRValue=*/false);
-  // Drill down to the concrete type on the right hand side.
-  type2 = getFixedTypeRecursive(type2, flags, /*wantRValue=*/true);
-  auto desugar2 = type2->getDesugaredType();
-
   TypeMatchOptions subflags = getDefaultDecompositionOptions(flags);
 
   SmallVector<LocatorPathElt, 2> parts;
@@ -12907,7 +12907,6 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::SpecifyLabelToAssociateTrailingClosure:
   case FixKind::AllowKeyPathWithoutComponents:
   case FixKind::IgnoreInvalidResultBuilderBody:
-  case FixKind::IgnoreInvalidASTNode:
   case FixKind::IgnoreResultBuilderWithReturnStmts:
   case FixKind::SpecifyContextualTypeForNil:
   case FixKind::AllowRefToInvalidDecl:
@@ -12927,6 +12926,9 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::RenameConflictingPatternVariables: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }
+  case FixKind::IgnoreInvalidASTNode: {
+    return recordFix(fix, 10) ? SolutionKind::Error : SolutionKind::Solved;
+  }
 
   case FixKind::ExplicitlyConstructRawRepresentable: {
     // Let's increase impact of this fix for binary operators because

test/Constraints/diagnostics.swift

@@ -1137,7 +1137,7 @@ func badTypes() {
 // rdar://34357545
 func unresolvedTypeExistential() -> Bool {
   return (Int.self==_{})
-  // expected-error@-1 {{type of expression is ambiguous without more context}}
+  // expected-error@-1 {{could not infer type for placeholder}}
   // expected-error@-2 {{type placeholder not allowed here}}
 }
 

test/Parse/switch.swift

@@ -336,8 +336,8 @@ func f1(x: String, y: Whichever) {
         break
     case Whichever.buzz: // expected-error {{type 'Whichever' has no member 'buzz'}}
         break
-    case Whichever.alias: // expected-error {{referencing operator function '~=' on 'RegexComponent' requires that 'Whichever' conform to 'RegexComponent'}}
-        break
+    case Whichever.alias: // expected-error {{expression pattern of type 'Whichever' cannot match values of type 'String'}}
+    // expected-note@-1 {{overloads for '~=' exist}}
     default:
       break
   }

test/StringProcessing/Parse/forward-slash-regex.swift

@@ -94,10 +94,11 @@ _ = /x/!.blah
 // expected-error@-2 {{value of type 'Regex<Substring>' has no member 'blah'}}
 
 do {
+  // expected-error@+2 {{cannot find operator '/?' in scope}}
+  // expected-error@+1 {{'/' is not a prefix unary operator}}
   _ = /x /?
     .blah
-  // expected-error@-2 {{cannot find operator '/?' in scope}}
-  // expected-error@-3 {{'/' is not a prefix unary operator}}
+  // expected-error@-1 {{cannot infer contextual base in reference to member 'blah'}}
 }
 _ = /x/? // expected-error {{cannot use optional chaining on non-optional value of type 'Regex<Substring>'}}
   .blah // expected-error {{value of type 'Regex<Substring>' has no member 'blah'}}
@@ -418,6 +419,7 @@ do {
   // expected-error@-1 {{'/' is not a prefix unary operator}}
   // expected-error@-2 {{consecutive statements on a line must be separated by ';'}}
   // expected-error@-3 {{expected expression}}
+  // expected-error@-4 {{cannot call value of non-function type '()'}}
 }
 do {
   _ = /[x])/

test/stmt/if_while_var.swift

@@ -51,9 +51,7 @@ guard let _ = nonOptionalEnum() else { fatalError() } // expected-error{{initial
 let optional: String? = nil
 if case let optional? { _ = optional } // expected-error{{variable binding in a condition requires an initializer}}
 if case let .some(optional) { _ = optional } // expected-error{{variable binding in a condition requires an initializer}}
-                                             // expected-error@-1 {{type of expression is ambiguous without more context}}
 if case .some(let optional) { _ = optional } // expected-error{{variable binding in a condition requires an initializer}}
-                                             // expected-error@-1 {{type of expression is ambiguous without more context}}
 
 if case let x? = nonOptionalStruct() { _ = x } // expected-error{{'?' pattern cannot match values of type 'NonOptionalStruct'}}
 if case let x? = nonOptionalEnum() { _ = x } // expected-error{{'?' pattern cannot match values of type 'NonOptionalEnum'}}

validation-test/compiler_crashers_2_fixed/0180-rdar45557325.swift

@@ -8,5 +8,6 @@ class MyClass: NSObject {
   func f() {
     let url = URL(url) // expected-error{{use of local variable 'url' before its declaration}}
     // expected-note@-1 {{'url' declared here}}
+    // expected-error@-2 {{missing argument label 'string:' in call}}
   }
 }