Merge pull request #29005 from DougGregor/functional-pattern-checking

[Type checker] Make typeCheckPattern() a functional request

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

include/swift/AST/TypeCheckRequests.h

@@ -20,6 +20,7 @@
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/Evaluator.h"
+#include "swift/AST/Pattern.h"
 #include "swift/AST/SimpleRequest.h"
 #include "swift/AST/TypeResolutionStage.h"
 #include "swift/Basic/AnyValue.h"
@@ -33,6 +34,7 @@ namespace swift {
 class AbstractStorageDecl;
 class AccessorDecl;
 enum class AccessorKind;
+class ContextualPattern;
 class DefaultArgumentExpr;
 class GenericParamList;
 class PrecedenceGroupDecl;
@@ -1991,6 +1993,32 @@ class HasDynamicMemberLookupAttributeRequest
   }
 };
 
+/// Determines the type of a given pattern.
+///
+/// Note that this returns the "raw" pattern type, which can involve
+/// unresolved types and unbound generic types where type inference is
+/// allowed.
+class PatternTypeRequest
+    : public SimpleRequest<PatternTypeRequest, Type(ContextualPattern),
+                           CacheKind::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<Type> evaluate(
+      Evaluator &evaluator, ContextualPattern pattern) const;
+
+public:
+  bool isCached() const { return true; }
+
+  SourceLoc getNearestLoc() const {
+    return std::get<0>(getStorage()).getPattern()->getLoc();
+  }
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -216,3 +216,6 @@ SWIFT_REQUEST(TypeChecker, TypeWitnessRequest,
 SWIFT_REQUEST(TypeChecker, ValueWitnessRequest,
               Witness(NormalProtocolConformance *, ValueDecl *),
               SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, PatternTypeRequest,
+              Type(ContextualPattern),
+              Cached, HasNearestLocation)

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

@@ -2158,10 +2158,11 @@ namespace {
       }
 
       case PatternKind::Typed: {
-        auto typedPattern = cast<TypedPattern>(pattern);
         // FIXME: Need a better locator for a pattern as a base.
-        Type openedType = CS.openUnboundGenericType(typedPattern->getType(),
-                                                    locator);
+        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.
         // FIXME: Error recovery if the type is an error type?
@@ -2258,6 +2259,7 @@ namespace {
       // or exhaustive catches.
       class FindInnerThrows : public ASTWalker {
         ConstraintSystem &CS;
+        DeclContext *DC;
         bool FoundThrow = false;
 
         std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
@@ -2343,12 +2345,12 @@ namespace {
           Type exnType = CS.getASTContext().getErrorDecl()->getDeclaredType();
           if (!exnType)
             return false;
-          if (TypeChecker::coercePatternToType(pattern,
-                                        TypeResolution::forContextual(CS.DC),
-                                        exnType,
-                                        TypeResolverContext::InExpression)) {
+          auto contextualPattern =
+              ContextualPattern::forRawPattern(pattern, DC);
+          pattern = TypeChecker::coercePatternToType(
+            contextualPattern, exnType, TypeResolverContext::InExpression);
+          if (!pattern)
             return false;
-          }
 
           clause->setErrorPattern(pattern);
           return clause->isSyntacticallyExhaustive();
@@ -2384,7 +2386,8 @@ namespace {
         }
 
       public:
-        FindInnerThrows(ConstraintSystem &cs) : CS(cs) {}
+        FindInnerThrows(ConstraintSystem &cs, DeclContext *dc)
+            : CS(cs), DC(dc) {}
 
         bool foundThrow() { return FoundThrow; }
       };
@@ -2397,7 +2400,7 @@ namespace {
       if (!body)
         return false;
 
-      auto tryFinder = FindInnerThrows(CS);
+      auto tryFinder = FindInnerThrows(CS, expr);
       body->walk(tryFinder);
       return tryFinder.foundThrow();
     }