[Constraint system] Generate constraints for EnumElement patterns.

Generate a complete set of constraints for EnumElement patterns, e.g.,

    case let .something(x, y)

Most of the complication here comes from the implicit injection of optionals,
e.g., this case can be matched to an optional of the enum type of which
`something` is a member. To effect this change, introduce a locator for
pattern matching and use it to permit implicit unwrapping during member
lookup without triggering an error.

Note also labels are dropped completely when performing the match,
because labels can be added or removed when pattern matching. Label
conflict are currently diagnosed as part of coercePatternToType, which
suffices so long as overloading cases based on argument labels is not
permitted.

The primary observable change from this commit is in diagnostics: rather
than diagnostics being triggered by `TypeChecker::coercePatternToType`,
diagnostics for matching failures here go through the diagnostics machinery
of the constraint solver. This is currently a regression, because
there are no custom diagnostics for pattern match failures within the
constraint system. This regression will be addressed in a subsequent
commit; for now, leave those tests failing.

Author: DougGregor

lib/Sema/CSGen.cpp

@@ -2310,10 +2310,81 @@ namespace {
       case PatternKind::Bool:
         return setType(CS.getASTContext().getBoolDecl()->getDeclaredType());
 
+      case PatternKind::EnumElement: {
+        auto enumPattern = cast<EnumElementPattern>(pattern);
+
+        // Create a type variable to represent the pattern.
+        Type patternType =
+            CS.createTypeVariable(CS.getConstraintLocator(locator),
+                                  TVO_CanBindToNoEscape);
+
+        // Form the member constraint for a reference to a member of this
+        // type.
+        Type baseType;
+        Type memberType = CS.createTypeVariable(
+            CS.getConstraintLocator(locator),
+            TVO_CanBindToLValue | TVO_CanBindToNoEscape);
+        FunctionRefKind functionRefKind = FunctionRefKind::Compound;
+        if (!enumPattern->getParentType().isNull()) {
+          // Resolve the parent type.
+          Type parentType =
+            resolveTypeReferenceInExpression(enumPattern->getParentType());
+          parentType = CS.openUnboundGenericType(parentType, locator);
+
+          // Perform member lookup into the parent's metatype.
+          Type parentMetaType = MetatypeType::get(parentType);
+          CS.addValueMemberConstraint(
+              parentMetaType, enumPattern->getName(), memberType, CurDC,
+              functionRefKind, { },
+              locator.withPathElement(ConstraintLocator::PatternMatch));
+
+          // Parent type needs to be convertible to the pattern type; this
+          // accounts for cases where the pattern type is existential.
+          CS.addConstraint(ConstraintKind::Conversion, parentType, patternType,
+                           locator);
+
+          baseType = parentType;
+        } else {
+          // Use the pattern type for member lookup.
+          CS.addUnresolvedValueMemberConstraint(
+              MetatypeType::get(patternType), enumPattern->getName(),
+              memberType, CurDC, functionRefKind,
+              locator.withPathElement(ConstraintLocator::PatternMatch));
+
+          baseType = patternType;
+        }
+
+        if (auto subPattern = enumPattern->getSubPattern()) {
+          // When there is a subpattern, the member will have function type,
+          // and we're matching the type of that subpattern to the parameter
+          // types.
+          Type subPatternType = getTypeForPattern(subPattern, locator);
+          SmallVector<AnyFunctionType::Param, 8> params;
+          AnyFunctionType::decomposeInput(subPatternType, params);
+
+          // Remove parameter labels; they aren't used when matching cases,
+          // but outright conflicts will be checked during coercion.
+          for (auto &param : params) {
+            param = param.getWithoutLabel();
+          }
+
+          Type outputType = CS.createTypeVariable(
+              CS.getConstraintLocator(locator),
+              TVO_CanBindToNoEscape);
+          Type functionType = FunctionType::get(params, outputType);
+          CS.addConstraint(ConstraintKind::Equal, functionType, memberType,
+                           locator);
+
+          CS.addConstraint(ConstraintKind::Conversion, outputType, baseType,
+                           locator);
+        }
+
+        return setType(patternType);
+      }
+
       // Refutable patterns occur when checking the PatternBindingDecls in an
       // if/let or while/let condition.  They always require an initial value,
       // so they always allow unspecified types.
-      case PatternKind::EnumElement:
       case PatternKind::Expr:
         // TODO: we could try harder here, e.g. for enum elements to provide the
         // enum type.

lib/Sema/CSSimplify.cpp

@@ -6039,6 +6039,24 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
     }
   }
 
+  // If we have candidates, and we're doing a member lookup for a pattern
+  // match, unwrap optionals and try again to allow implicit creation of
+  // optional "some" patterns (spelled "?").
+  if (result.ViableCandidates.empty() && result.UnviableCandidates.empty() &&
+      memberLocator->getLastElementAs<LocatorPathElt::PatternMatch>() &&
+      instanceTy->getOptionalObjectType() &&
+      baseObjTy->is<AnyMetatypeType>()) {
+    SmallVector<Type, 2> optionals;
+    Type instanceObjectTy = instanceTy->lookThroughAllOptionalTypes(optionals);
+    Type metaObjectType = MetatypeType::get(instanceObjectTy);
+    auto result = performMemberLookup(
+        constraintKind, memberName, metaObjectType,
+        functionRefKind, memberLocator, includeInaccessibleMembers);
+    result.numImplicitOptionalUnwraps = optionals.size();
+    result.actualBaseType = metaObjectType;
+    return result;
+  }
+
   // If we have no viable or unviable candidates, and we're generating,
   // diagnostics, rerun the query with inaccessible members included, so we can
   // include them in the unviable candidates list.
@@ -6369,8 +6387,13 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
   }
 
   SmallVector<Constraint *, 4> candidates;
+
   // If we found viable candidates, then we're done!
   if (!result.ViableCandidates.empty()) {
+    // If we had to look in a different type, use that.
+    if (result.actualBaseType)
+      baseTy = result.actualBaseType;
+
     // If only possible choice to refer to member is via keypath
     // dynamic member dispatch, let's delay solving this constraint
     // until constraint generation phase is complete, because

lib/Sema/ConstraintLocator.cpp

@@ -117,6 +117,7 @@ unsigned LocatorPathElt::getNewSummaryFlags() const {
   case ConstraintLocator::DynamicCallable:
   case ConstraintLocator::ImplicitCallAsFunction:
   case ConstraintLocator::TernaryBranch:
+  case ConstraintLocator::PatternMatch:
     return 0;
 
   case ConstraintLocator::FunctionArgument:
@@ -476,12 +477,17 @@ void ConstraintLocator::dump(SourceManager *sm, raw_ostream &out) const {
       out << "implicit reference to callAsFunction";
       break;
 
-    case TernaryBranch:
+    case TernaryBranch: {
       auto branchElt = elt.castTo<LocatorPathElt::TernaryBranch>();
       out << (branchElt.forThen() ? "'then'" : "'else'")
           << " branch of a ternary operator";
       break;
     }
+
+    case PatternMatch:
+      out << "pattern match";
+      break;
+    }
   }
   out << ']';
 }

lib/Sema/ConstraintLocatorPathElts.def

@@ -175,6 +175,9 @@ SIMPLE_LOCATOR_PATH_ELT(DynamicCallable)
 /// The 'true' or 'false' branch of a ternary operator.
 CUSTOM_LOCATOR_PATH_ELT(TernaryBranch)
 
+/// Performing a pattern patch.
+SIMPLE_LOCATOR_PATH_ELT(PatternMatch)
+
 #undef LOCATOR_PATH_ELT
 #undef CUSTOM_LOCATOR_PATH_ELT
 #undef SIMPLE_LOCATOR_PATH_ELT

lib/Sema/ConstraintSystem.h

@@ -1051,8 +1051,15 @@ struct MemberLookupResult {
   /// If there is a favored candidate in the viable list, this indicates its
   /// index.
   unsigned FavoredChoice = ~0U;
-  
-  
+
+  /// The number of optional unwraps that were applied implicitly in the
+  /// lookup, for contexts where that is permitted.
+  unsigned numImplicitOptionalUnwraps = 0;
+
+  /// The base lookup type used to find the results, which will be non-null
+  /// only when it differs from the provided base type.
+  Type actualBaseType;
+
   /// This enum tracks reasons why a candidate is not viable.
   enum UnviableReason {
     /// This uses a type like Self in its signature that cannot be used on an

test/Constraints/patterns.swift

@@ -344,7 +344,7 @@ func rdar32241441() {
 
 
 // SR-6100
-struct One<Two> {
+struct One<Two> { // expected-note{{'Two' declared as parameter to type 'One'}}
     public enum E: Error {
         // if you remove associated value, everything works
         case SomeError(String)
@@ -354,7 +354,7 @@ struct One<Two> {
 func testOne() {
   do {
   } catch let error { // expected-warning{{'catch' block is unreachable because no errors are thrown in 'do' block}}
-    if case One.E.SomeError = error {} // expected-error{{generic enum type 'One.E' is ambiguous without explicit generic parameters when matching value of type 'Error'}}
+    if case One.E.SomeError = error {} // expected-error{{generic parameter 'Two' could not be inferred}}
   }
 }
 

test/stmt/if_while_var.swift

@@ -144,3 +144,58 @@ func testWhileScoping(_ a: Int?) {// expected-note {{did you mean 'a'?}}
   useInt(x) // expected-error{{use of unresolved identifier 'x'}}
 }
 
+// Matching a case with a single, labeled associated value.
+public enum SomeParseResult<T> {
+  case error(length: Int)
+  case repeated(value: String, repetitions: Int)
+
+  var _error: Int? {
+    if case .error(let result) = self { return result }
+    return nil
+  }
+
+  var _error2: Int? {
+    if case .error(length: let result) = self { return result }
+    return nil
+  }
+
+  var _error3: Int? {
+    if case .error(wrong: let result) = self { return result } // expected-error{{tuple pattern element label 'wrong' must be 'length'}}
+    return nil
+  }
+
+  var _repeated: (String, Int)? {
+    if case .repeated(let value, let repetitions) = self {
+      return (value, repetitions)
+    }
+    return nil
+  }
+
+  var _repeated2: (String, Int)? {
+    if case .repeated(value: let value, let repetitions) = self {
+      return (value, repetitions)
+    }
+    return nil
+  }
+
+  var _repeated3: (String, Int)? {
+    if case .repeated(let value, repetitions: let repetitions) = self {
+      return (value, repetitions)
+    }
+    return nil
+  }
+
+  var _repeated4: (String, Int)? {
+    if case .repeated(value: let value, repetitions: let repetitions) = self {
+      return (value, repetitions)
+    }
+    return nil
+  }
+
+  var _repeated5: (String, Int)? {
+    if case .repeated(value: let value, wrong: let repetitions) = self { // expected-error{{tuple pattern element label 'wrong' must be 'repetitions'}}
+      return (value, repetitions)
+    }
+    return nil
+  }
+}