[Parse][CodeCompletion] Stop code completion within a closure causing parser recovery after the closure.

For example, the completion below would trigger error recovery within the
closure, which we recover from by skipping to the first inner closure's right
brace. The fact that we recovered though, was not recorded. The closure is
treated as still being an error, triggering another recovery after it that
skips over the 'Thing' token, giving a lone closure expression, rather than a
call.

CreateThings {
    Thing { point in
      print("hello")
      point.#^HERE^#
    }
    Thing { _ in }
}

This isn't an issue for code completion when the outer closure is a regular
closure, but when it's a function builder, invalid elements result in no types
being applied (no valid solutions) and we end up with no completion results.

The fix here is removing the error status from the parser result after the
initial parser recovery.

Author: Nathan Hawes

include/swift/Parse/ParserResult.h

@@ -39,7 +39,12 @@ template <typename T> class ParserResult {
     IsCodeCompletion = 0x2,
   };
 
-  template <typename U> friend class ParserResult;
+  template <typename U>
+  friend class ParserResult;
+
+  template <typename U>
+  friend inline ParserResult<U> makeParserResult(ParserStatus Status,
+                                                 U *Result);
 
 public:
   /// Construct a null result with error bit set.
@@ -78,21 +83,35 @@ template <typename T> class ParserResult {
   /// Return the AST node or a null pointer.
   T *getPtrOrNull() const { return PtrAndBits.getPointer(); }
 
-  /// Return true if there was a parse error.
+  /// Return true if there was a parse error that the parser has not yet
+  /// recovered from.
   ///
   /// Note that we can still have an AST node which was constructed during
   /// recovery.
   bool isParseError() const { return PtrAndBits.getInt() & IsError; }
 
+  /// Return true if there was a parse error that the parser has not yet
+  /// recovered from, or if we found a code completion token while parsing.
+  ///
+  /// Note that we can still have an AST node which was constructed during
+  /// recovery.
+  bool isParseErrorOrHasCompletion() const {
+    return PtrAndBits.getInt() & (IsError | IsCodeCompletion);
+  }
+
   /// Return true if we found a code completion token while parsing this.
   bool hasCodeCompletion() const {
     return PtrAndBits.getInt() & IsCodeCompletion;
   }
 
   void setIsParseError() { PtrAndBits.setInt(PtrAndBits.getInt() | IsError); }
+  void setHasCodeCompletionAndIsError() {
+    PtrAndBits.setInt(PtrAndBits.getInt() | IsError | IsCodeCompletion);
+  }
 
+private:
   void setHasCodeCompletion() {
-    PtrAndBits.setInt(PtrAndBits.getInt() | IsError | IsCodeCompletion);
+    PtrAndBits.setInt(PtrAndBits.getInt() | IsCodeCompletion);
   }
 };
 
@@ -119,7 +138,7 @@ static inline ParserResult<T> makeParserCodeCompletionResult(T *Result =
   ParserResult<T> PR;
   if (Result)
     PR = ParserResult<T>(Result);
-  PR.setHasCodeCompletion();
+  PR.setHasCodeCompletionAndIsError();
   return PR;
 }
 
@@ -145,27 +164,32 @@ class ParserStatus {
     if (Result.isParseError())
       setIsParseError();
     if (Result.hasCodeCompletion())
-      setHasCodeCompletion();
+      IsCodeCompletion = true;
   }
 
+  /// Return true if either 1) no errors were encountered while parsing this,
+  /// or 2) there were errors but the the parser already recovered from them.
   bool isSuccess() const { return !isError(); }
-  bool isError() const { return IsError; }
+  bool isErrorOrHasCompletion() const { return IsError || IsCodeCompletion; }
 
   /// Return true if we found a code completion token while parsing this.
   bool hasCodeCompletion() const { return IsCodeCompletion; }
 
+  /// Return true if we encountered any errors while parsing this that the
+  /// parser hasn't yet recovered from.
+  bool isError() const { return IsError; }
+
   void setIsParseError() {
     IsError = true;
   }
 
-  void setHasCodeCompletion() {
-    IsError = true;
-    IsCodeCompletion = true;
+  void clearIsError() {
+    IsError = false;
   }
 
-  /// True if we should stop parsing for any reason.
-  bool shouldStopParsing() const {
-    return IsError || IsCodeCompletion;
+  void setHasCodeCompletionAndIsError() {
+    IsError = true;
+    IsCodeCompletion = true;
   }
 
   ParserStatus &operator|=(ParserStatus RHS) {
@@ -196,19 +220,21 @@ static inline ParserStatus makeParserError() {
 /// Create a status with error and code completion bits set.
 static inline ParserStatus makeParserCodeCompletionStatus() {
   ParserStatus Status;
-  Status.setHasCodeCompletion();
+  Status.setHasCodeCompletionAndIsError();
   return Status;
 }
 
 /// Create a parser result with specified bits.
 template <typename T>
 static inline ParserResult<T> makeParserResult(ParserStatus Status,
                                                T *Result) {
-  if (Status.isSuccess())
-    return makeParserResult(Result);
+  ParserResult<T> PR = Status.isError()
+    ? makeParserErrorResult(Result)
+    : makeParserResult(Result);
+
   if (Status.hasCodeCompletion())
-    return makeParserCodeCompletionResult(Result);
-  return makeParserErrorResult(Result);
+    PR.setHasCodeCompletion();
+  return PR;
 }
 
 template <typename T> ParserResult<T>::ParserResult(ParserStatus Status) {

include/swift/Parse/SyntaxParserResult.h

@@ -44,11 +44,16 @@ template <typename Syntax, typename AST> class SyntaxParserResult {
 
   bool isNull() const { return ASTResult.isNull(); }
   bool isNonNull() const { return ASTResult.isNonNull(); }
-  bool isParseError() const { return ASTResult.isParseError(); }
+  bool isParseError() const {
+    return ASTResult.isParseError();
+  }
+  bool isParseErrorOrHasCompletion() const {
+    return ASTResult.isParseErrorOrHasCompletion();
+  }
   bool hasCodeCompletion() const { return ASTResult.hasCodeCompletion(); }
 
   void setIsParseError() { return ASTResult.setIsParserError(); }
-  void setHasCodeCompletion() { return ASTResult.setHasCodeCompletion(); }
+  void setHasCodeCompletionAndIsError() { return ASTResult.setHasCodeCompletionAndIsError(); }
 
   const ParserResult<AST> &getASTResult() { return ASTResult; }
 
@@ -92,7 +97,7 @@ makeSyntaxCodeCompletionResult(AST *Result = nullptr) {
   SyntaxParserResult<Syntax, AST> SR;
   if (Result)
     SR = SyntaxParserResult<Syntax, AST>(None, Result);
-  SR.setHasCodeCompletion();
+  SR.setHasCodeCompletionAndIsError();
   return SR;
 }