Merge pull request swiftlang#33907 from nathawes/make-hascodecompletion-flag-not-imply-haserror

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

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;
 }