[Type checker] Introduce "contextual patterns".

Contextual pattern describes a particular pattern with enough
contextual information to determine its type. Use this to simplify
TypeChecker::typeCheckPattern()'s interface in a manner that will
admit request'ification.

Author: DougGregor

include/swift/AST/Pattern.h

@@ -756,7 +756,93 @@ inline Pattern *Pattern::getSemanticsProvidingPattern() {
     return vp->getSubPattern()->getSemanticsProvidingPattern();
   return this;
 }
-  
+
+/// Describes a pattern and the context in which it occurs.
+class ContextualPattern {
+  /// The pattern and whether this is the top-level pattern.
+  llvm::PointerIntPair<Pattern *, 1, bool> patternAndTopLevel;
+
+  /// Either the declaration context or the enclosing pattern binding
+  /// declaration.
+  llvm::PointerUnion<PatternBindingDecl *, DeclContext *> declOrContext;
+
+  /// Index into the pattern binding declaration, when there is one.
+  unsigned index = 0;
+
+  ContextualPattern(
+      Pattern *pattern, bool topLevel,
+      llvm::PointerUnion<PatternBindingDecl *, DeclContext *> declOrContext,
+      unsigned index
+    ) : patternAndTopLevel(pattern, topLevel),
+        declOrContext(declOrContext),
+        index(index) { }
+
+public:
+  /// Produce a contextual pattern for a pattern binding declaration entry.
+  static ContextualPattern forPatternBindingDecl(
+     PatternBindingDecl *pbd, unsigned index);
+
+  /// Produce a contextual pattern for a raw pattern that always allows
+  /// inference.
+  static ContextualPattern forRawPattern(Pattern *pattern, DeclContext *dc) {
+    return ContextualPattern(pattern, /*topLevel=*/true, dc, /*index=*/0);
+  }
+
+  /// Retrieve a contextual pattern for the given subpattern.
+  ContextualPattern forSubPattern(
+      Pattern *subpattern, bool retainTopLevel) const {
+    return ContextualPattern(
+        subpattern, isTopLevel() && retainTopLevel, declOrContext, index);
+  }
+
+  /// Retrieve the pattern.
+  Pattern *getPattern() const {
+    return patternAndTopLevel.getPointer();
+  }
+
+  /// Whether this is the top-level pattern in this context.
+  bool isTopLevel() const {
+    return patternAndTopLevel.getInt();
+  }
+
+  /// Retrieve the declaration context of the pattern.
+  DeclContext *getDeclContext() const;
+
+  /// Retrieve the pattern binding declaration that owns this pattern, if
+  /// there is one.
+  PatternBindingDecl *getPatternBindingDecl() const;
+
+  /// Retrieve the index into the pattern binding declaration for the top-level
+  /// pattern.
+  unsigned getPatternBindingIndex() const {
+    assert(getPatternBindingDecl() != nullptr);
+    return index;
+  }
+
+  /// Whether this pattern allows type inference, e.g., from an initializer
+  /// expression.
+  bool allowsInference() const;
+
+  friend llvm::hash_code hash_value(const ContextualPattern &pattern) {
+    return llvm::hash_combine(pattern.getPattern(),
+                              pattern.isTopLevel(),
+                              pattern.declOrContext);
+  }
+
+  friend bool operator==(const ContextualPattern &lhs,
+                         const ContextualPattern &rhs) {
+    return lhs.patternAndTopLevel == rhs.patternAndTopLevel &&
+        lhs.declOrContext == rhs.declOrContext;
+  }
+
+  friend bool operator!=(const ContextualPattern &lhs,
+                         const ContextualPattern &rhs) {
+    return !(lhs == rhs);
+  }
+};
+
+void simple_display(llvm::raw_ostream &out, const ContextualPattern &pattern);
+
 } // end namespace swift
 
 #endif

lib/AST/Pattern.cpp

@@ -496,3 +496,33 @@ const UnifiedStatsReporter::TraceFormatter*
 FrontendStatsTracer::getTraceFormatter<const Pattern *>() {
   return &TF;
 }
+
+
+ContextualPattern ContextualPattern::forPatternBindingDecl(
+    PatternBindingDecl *pbd, unsigned index) {
+  return ContextualPattern(
+      pbd->getPattern(index), /*isTopLevel=*/true, pbd, index);
+}
+
+DeclContext *ContextualPattern::getDeclContext() const {
+  if (auto pbd = getPatternBindingDecl())
+    return pbd->getDeclContext();
+
+  return declOrContext.get<DeclContext *>();
+}
+
+PatternBindingDecl *ContextualPattern::getPatternBindingDecl() const {
+  return declOrContext.dyn_cast<PatternBindingDecl *>();
+}
+
+bool ContextualPattern::allowsInference() const {
+  if (auto pbd = getPatternBindingDecl())
+    return pbd->isInitialized(index);
+
+  return true;
+}
+
+void swift::simple_display(llvm::raw_ostream &out,
+                           const ContextualPattern &pattern) {
+  out << "(pattern @ " << pattern.getPattern() << ")";
+}

lib/Sema/CSGen.cpp

@@ -2159,9 +2159,9 @@ namespace {
 
       case PatternKind::Typed: {
         // FIXME: Need a better locator for a pattern as a base.
-        TypeResolutionOptions options(TypeResolverContext::InExpression);
-        options |= TypeResolutionFlags::AllowUnboundGenerics;
-        Type type = TypeChecker::typeCheckPattern(pattern, CurDC, options);
+        auto contextualPattern =
+            ContextualPattern::forRawPattern(pattern, CurDC);
+        Type type = TypeChecker::typeCheckPattern(contextualPattern);
         Type openedType = CS.openUnboundGenericType(type, locator);
 
         // For a typed pattern, simply return the opened type of the pattern.

lib/Sema/TypeCheckConstraints.cpp

@@ -2864,10 +2864,8 @@ bool TypeChecker::typeCheckPatternBinding(PatternBindingDecl *PBD,
     if (pattern->hasType())
       patternType = pattern->getType();
     else {
-      TypeResolutionOptions options(TypeResolverContext::InExpression);
-      options |= TypeResolutionFlags::AllowUnspecifiedTypes;
-      options |= TypeResolutionFlags::AllowUnboundGenerics;
-      patternType = typeCheckPattern(pattern, DC, options);
+      auto contextualPattern = ContextualPattern::forRawPattern(pattern, DC);
+      patternType = typeCheckPattern(contextualPattern);
     }
 
     if (patternType->hasError()) {
@@ -2995,11 +2993,9 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
         return true;
       }
 
-      TypeResolutionOptions options(TypeResolverContext::InExpression);
-      options |= TypeResolutionFlags::AllowUnspecifiedTypes;
-      options |= TypeResolutionFlags::AllowUnboundGenerics;
-      Type patternType = TypeChecker::typeCheckPattern(
-          Stmt->getPattern(), DC, options);
+      auto contextualPattern =
+          ContextualPattern::forRawPattern(Stmt->getPattern(), DC);
+      Type patternType = TypeChecker::typeCheckPattern(contextualPattern);
       if (patternType->hasError()) {
         // FIXME: Handle errors better.
         Stmt->getPattern()->setType(ErrorType::get(ctx));
@@ -3221,10 +3217,8 @@ bool TypeChecker::typeCheckStmtCondition(StmtCondition &cond, DeclContext *dc,
 
     // Check the pattern, it allows unspecified types because the pattern can
     // provide type information.
-    TypeResolutionOptions options(TypeResolverContext::InExpression);
-    options |= TypeResolutionFlags::AllowUnspecifiedTypes;
-    options |= TypeResolutionFlags::AllowUnboundGenerics;
-    Type patternType = TypeChecker::typeCheckPattern(pattern, dc, options);
+    auto contextualPattern = ContextualPattern::forRawPattern(pattern, dc);
+    Type patternType = TypeChecker::typeCheckPattern(contextualPattern);
     if (patternType->hasError()) {
       typeCheckPatternFailed();
       continue;

lib/Sema/TypeCheckPattern.cpp

@@ -703,8 +703,20 @@ static Type validateTypedPattern(TypeResolution resolution,
   return TL.getType();
 }
 
-Type TypeChecker::typeCheckPattern(Pattern *P, DeclContext *dc,
-                                   TypeResolutionOptions options) {
+Type TypeChecker::typeCheckPattern(ContextualPattern pattern) {
+  Pattern *P = pattern.getPattern();
+  DeclContext *dc = pattern.getDeclContext();
+
+  TypeResolutionOptions options(pattern.getPatternBindingDecl()
+                                  ? TypeResolverContext::PatternBindingDecl
+                                  : TypeResolverContext::InExpression);
+  if (pattern.allowsInference()) {
+    options |= TypeResolutionFlags::AllowUnspecifiedTypes;
+    options |= TypeResolutionFlags::AllowUnboundGenerics;
+  }
+  if (!pattern.isTopLevel())
+    options = options.withoutContext();
+
   auto &Context = dc->getASTContext();
   switch (P->getKind()) {
   // Type-check paren patterns by checking the sub-pattern and
@@ -716,7 +728,8 @@ Type TypeChecker::typeCheckPattern(Pattern *P, DeclContext *dc,
       SP = PP->getSubPattern();
     else
       SP = cast<VarPattern>(P)->getSubPattern();
-    Type subType = TypeChecker::typeCheckPattern(SP, dc, options);
+    Type subType = TypeChecker::typeCheckPattern(
+        pattern.forSubPattern(SP, /*retainTopLevel=*/true));
     if (subType->hasError())
       return ErrorType::get(Context);
 
@@ -757,11 +770,10 @@ Type TypeChecker::typeCheckPattern(Pattern *P, DeclContext *dc,
     bool hadError = false;
     SmallVector<TupleTypeElt, 8> typeElts;
 
-    const auto elementOptions = options.withoutContext();
     for (unsigned i = 0, e = tuplePat->getNumElements(); i != e; ++i) {
       TuplePatternElt &elt = tuplePat->getElement(i);
-      Pattern *pattern = elt.getPattern();
-      Type subType = TypeChecker::typeCheckPattern(pattern, dc, elementOptions);
+      Type subType = TypeChecker::typeCheckPattern(
+          pattern.forSubPattern(elt.getPattern(), /*retainTopLevel=*/false));
       if (subType->hasError())
         hadError = true;
 

lib/Sema/TypeCheckStorage.cpp

@@ -206,6 +206,8 @@ PatternBindingEntryRequest::evaluate(Evaluator &eval,
   // In particular, it's /not/ correct to check the PBD's DeclContext because
   // top-level variables in a script file are accessible from other files,
   // even though the PBD is inside a TopLevelCodeDecl.
+  auto contextualPattern =
+      ContextualPattern::forPatternBindingDecl(binding, entryNumber);
   TypeResolutionOptions options(TypeResolverContext::PatternBindingDecl);
 
   if (binding->isInitialized(entryNumber)) {
@@ -214,8 +216,7 @@ PatternBindingEntryRequest::evaluate(Evaluator &eval,
     options |= TypeResolutionFlags::AllowUnboundGenerics;
   }
 
-  Type patternType = TypeChecker::typeCheckPattern(
-      pattern, binding->getDeclContext(), options);
+  Type patternType = TypeChecker::typeCheckPattern(contextualPattern);
   if (patternType->hasError()) {
     swift::setBoundVarsTypeError(pattern, Context);
     binding->setInvalid();

lib/Sema/TypeChecker.h

@@ -999,16 +999,11 @@ class TypeChecker final {
 
   /// Type check the given pattern.
   ///
-  /// \param P The pattern to type check.
-  /// \param dc The context in which type checking occurs.
-  /// \param options Options that control type resolution.
-  ///
   /// \returns the type of the pattern, which may be an error type if an
   /// unrecoverable error occurred. If the options permit it, the type may
   /// involve \c UnresolvedType (for patterns with no type information) and
   /// unbound generic types.
-  static Type typeCheckPattern(Pattern *P, DeclContext *dc,
-                               TypeResolutionOptions options);
+  static Type typeCheckPattern(ContextualPattern pattern);
 
   static bool typeCheckCatchPattern(CatchStmt *S, DeclContext *dc);