Support named opaque result types for properties.

Add lookup scopes for the generic parameters of a named opaque result
type and clean up the code that finds the opaque substitutions.

Author: DougGregor

include/swift/AST/Decl.h

@@ -106,6 +106,7 @@ namespace swift {
 
   namespace ast_scope {
   class AbstractPatternEntryScope;
+  class GenericParamScope;
   class PatternEntryDeclScope;
   class PatternEntryInitializerScope;
   } // namespace ast_scope
@@ -1565,6 +1566,7 @@ class PatternBindingEntry {
   friend class PatternBindingInitializer;
   friend class PatternBindingDecl;
   friend class ast_scope::AbstractPatternEntryScope;
+  friend class ast_scope::GenericParamScope;
   friend class ast_scope::PatternEntryDeclScope;
   friend class ast_scope::PatternEntryInitializerScope;
 

lib/AST/ASTScopeCreation.cpp

@@ -708,6 +708,26 @@ PatternEntryDeclScope::expandAScopeThatCreatesANewInsertionPoint(
   // Initializers come before VarDecls, e.g. PCMacro/didSet.swift 19
   auto patternEntry = getPatternEntry();
 
+  // If the pattern type is for a named opaque result type, introduce the
+  // generic type parameters based on the first variable we find.
+  ASTScopeImpl *leaf = this;
+  auto pattern = patternEntry.getPattern();
+  if (auto typedPattern = dyn_cast<TypedPattern>(pattern)) {
+    if (auto namedOpaque =
+            dyn_cast_or_null<NamedOpaqueReturnTypeRepr>(
+              typedPattern->getTypeRepr())) {
+      bool addedOpaqueResultTypeScope = false;
+      pattern->forEachVariable([&](VarDecl *var) {
+        if (addedOpaqueResultTypeScope)
+          return;
+
+        leaf = scopeCreator.addNestedGenericParamScopesToTree(
+            var, namedOpaque->getGenericParams(), leaf);
+        addedOpaqueResultTypeScope = true;
+      });
+    }
+  }
+
   // Create a child for the initializer, if present.
   // Cannot trust the source range given in the ASTScopeImpl for the end of the
   // initializer (because of InterpolatedLiteralStrings and EditorPlaceHolders),
@@ -724,7 +744,7 @@ PatternEntryDeclScope::expandAScopeThatCreatesANewInsertionPoint(
         "Original inits are always after the '='");
     scopeCreator
         .constructExpandAndInsert<PatternEntryInitializerScope>(
-            this, decl, patternEntryIndex);
+            leaf, decl, patternEntryIndex);
   }
 
   // If this pattern binding entry was created by the debugger, it will always
@@ -741,12 +761,12 @@ PatternEntryDeclScope::expandAScopeThatCreatesANewInsertionPoint(
         "inits are always after the '='");
     scopeCreator
         .constructExpandAndInsert<PatternEntryInitializerScope>(
-            this, decl, patternEntryIndex);
+            leaf, decl, patternEntryIndex);
   }
 
   // Add accessors for the variables in this pattern.
-  patternEntry.getPattern()->forEachVariable([&](VarDecl *var) {
-    scopeCreator.addChildrenForParsedAccessors(var, this);
+  pattern->forEachVariable([&](VarDecl *var) {
+    scopeCreator.addChildrenForParsedAccessors(var, leaf);
   });
 
   // In local context, the PatternEntryDeclScope becomes the insertion point, so

lib/AST/ASTScopeLookup.cpp

@@ -266,6 +266,14 @@ bool GenericTypeOrExtensionScope::areMembersVisibleFromWhereClause() const {
 NullablePtr<const ASTScopeImpl>
 PatternEntryInitializerScope::getLookupParent() const {
   auto parent = getParent().get();
+
+  // Skip generic parameter scopes, which occur here due to named opaque
+  // result types.
+  // FIXME: Proper isa/dyn_cast support would be better than a string
+  // comparison here.
+  while (parent->getClassName() == "GenericParamScope")
+    parent = parent->getLookupParent().get();
+
   ASTScopeAssert(parent->getClassName() == "PatternEntryDeclScope",
                  "PatternEntryInitializerScope in unexpected place");
 

lib/AST/ASTScopeSourceRange.cpp

@@ -161,6 +161,15 @@ SourceRange GenericParamScope::getSourceRangeOfThisASTNode(
     return SourceRange(getLocAfterExtendedNominal(ext), ext->getEndLoc());
   }
 
+  // For a variable, the generic parameter is visible throughout the pattern
+  // binding entry.
+  if (auto var = dyn_cast<VarDecl>(holder)) {
+    if (auto patternBinding = var->getParentPatternBinding()) {
+      unsigned index = patternBinding->getPatternEntryIndexForVarDecl(var);
+      return patternBinding->getPatternList()[index].getSourceRange();
+    }
+  }
+
   // For all other declarations, generic parameters are visible everywhere.
   return holder->getSourceRange();
 }

lib/Sema/TypeCheckConstraints.cpp

@@ -541,14 +541,23 @@ bool TypeChecker::typeCheckPatternBinding(PatternBindingDecl *PBD,
   // Bind a property with an opaque return type to the underlying type
   // given by the initializer.
   if (auto var = pattern->getSingleVar()) {
+    SubstitutionMap substitutions;
     if (auto opaque = var->getOpaqueResultTypeDecl()) {
       init->forEachChildExpr([&](Expr *expr) -> Expr * {
         if (auto coercionExpr = dyn_cast<UnderlyingToOpaqueExpr>(expr)) {
-          opaque->setUnderlyingTypeSubstitutions(
-              coercionExpr->substitutions.mapReplacementTypesOutOfContext());
+          auto newSubstitutions =
+              coercionExpr->substitutions.mapReplacementTypesOutOfContext();
+          if (substitutions.empty()) {
+            substitutions = newSubstitutions;
+          } else {
+            assert(substitutions.getCanonical() ==
+                       newSubstitutions.getCanonical());
+          }
         }
         return expr;
       });
+
+      opaque->setUnderlyingTypeSubstitutions(substitutions);
     }
   }
 

test/type/opaque_return_named.swift

@@ -100,7 +100,14 @@ func f4(cond: Bool) -> <T: P1, U where U: Q1> (T, U) {
 func f5(cond: Bool) -> <T: P1, U where U: Q1> (T, U) { }
 // expected-error@-1{{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
 
-struct Generic<T: P1 & Equatable> {
+protocol DefaultInitializable {
+  init()
+}
+
+extension String: DefaultInitializable { }
+extension Int: DefaultInitializable { }
+
+struct Generic<T: P1 & Equatable & DefaultInitializable> {
   var value: T
 
   func f() -> <U: Q1, V: P1 where U: Equatable, V: Equatable> (U, V) {
@@ -110,6 +117,20 @@ struct Generic<T: P1 & Equatable> {
   subscript(index: Int) -> <U: Q1, V: P1 where U: Equatable, V: Equatable> (U, V) {
     return ("hello", value)
   }
+
+  var property: <U: Q1, V: P1 where U: Equatable, V: Equatable> (U, V) {
+    return ("hello", value)
+  }
+
+  var property2: <U: Q1, V: P1 where U: Equatable, V: Equatable> (U, V) =
+    ("hello", T())
+
+  var property3: <U: Q1, V: P1 where U: Equatable, V: Equatable> (U, V) =
+    ("hello", T()) {
+    didSet {
+      print("here")
+    }
+  }
 }
 
 func testGeneric(i: Int, gs: Generic<String>, gi: Generic<Int>) {