ASTScope: PatternEntryInitializerScope needs a custom lookup parent

Bindings are not visible from inside their own initializer, eg this
is invalid:

  var (x, y) = (y, x)

The PatternEntryDeclScope which starts after the 'var' introduces x
and y, and it contains the PatternEntryInitializerScope which starts
after the '='.

To model this properly in ASTScope, the PatternEntryInitializerScope
overrides getLookupParent() to skip the PatternEntryDeclScope that
contains it.

I believe this is simpler than having PatternEntryDeclScope begin
at the source location following the initializer, because it is hard
to compute this source location in a way that works with invalid
code, for example the 'var' might be nested inside of a BraceStmt
with the closing '}' missing.

Author: slavapestov

include/swift/AST/ASTScope.h

@@ -435,6 +435,7 @@ class ASTScopeImpl {
     return p->getParent().isNonNull() ? p : nullptr;
   }
 
+public:
   /// The tree is organized by source location and for most nodes this is also
   /// what obtaines for scoping. However, guards are different. The scope after
   /// the guard else must hop into the innermoset scope of the guard condition.
@@ -1094,6 +1095,7 @@ class PatternEntryInitializerScope final : public AbstractPatternEntryScope {
 
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;
+  NullablePtr<const ASTScopeImpl> getLookupParent() const override;
 
 private:
   void expandAScopeThatDoesNotCreateANewInsertionPoint(ScopeCreator &);

lib/AST/ASTScopeLookup.cpp

@@ -271,6 +271,24 @@ bool GenericTypeOrExtensionScope::areMembersVisibleFromWhereClause() const {
   return isa<ProtocolDecl>(decl) || isa<ExtensionDecl>(decl);
 }
 
+#pragma mark custom lookup parent behavior
+
+NullablePtr<const ASTScopeImpl>
+PatternEntryInitializerScope::getLookupParent() const {
+  auto parent = getParent().get();
+  assert(parent->getClassName() == "PatternEntryDeclScope");
+
+  // Lookups from inside a pattern binding initializer skip the parent
+  // scope that introduces bindings bound by the pattern, since we
+  // want this to work:
+  //
+  // func f(x: Int) {
+  //   let x = x
+  //   print(x)
+  // }
+  return parent->getLookupParent();
+}
+
 #pragma mark looking in locals or members - locals
 
 bool GenericParamScope::lookupLocalsOrMembers(DeclConsumer consumer) const {