Add back implementation of Parser.ParseInteractiveCode. (#1148)

Author: Hugues Valois

src/Parsing/Impl/Parser.cs

@@ -146,6 +146,56 @@ public static Parser CreateParser(Stream stream, PythonLanguageVersion version,
         //file_input: (Newline | stmt)* ENDMARKER
         public PythonAst ParseFile(Uri module = null) => ParseFileWorker(module);
 
+        //[stmt_list] Newline | compound_stmt Newline
+        //stmt_list ::= simple_stmt (";" simple_stmt)* [";"]
+        //compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef
+        //Returns a simple or coumpound_stmt or null if input is incomplete
+        /// <summary>
+        /// Parse one or more lines of interactive input
+        /// </summary>
+        /// <returns>null if input is not yet valid but could be with more lines</returns>
+        public PythonAst ParseInteractiveCode(Uri module, out ParseResult properties) {
+            bool parsingMultiLineCmpdStmt;
+
+            properties = ParseResult.Complete;
+
+            StartParsing();
+            Statement ret = InternalParseInteractiveInput(out parsingMultiLineCmpdStmt, out bool isEmptyStmt);
+
+            if (ErrorCode == 0) {
+                if (isEmptyStmt) {
+                    properties = ParseResult.Empty;
+                } else if (parsingMultiLineCmpdStmt) {
+                    properties = ParseResult.IncompleteStatement;
+                }
+
+                if (isEmptyStmt) {
+                    return null;
+                }
+
+                return CreateAst(module, ret);
+            } else {
+                if ((ErrorCode & ErrorCodes.IncompleteMask) != 0) {
+                    if ((ErrorCode & ErrorCodes.IncompleteToken) != 0) {
+                        properties = ParseResult.IncompleteToken;
+                        return null;
+                    }
+
+                    if ((ErrorCode & ErrorCodes.IncompleteStatement) != 0) {
+                        if (parsingMultiLineCmpdStmt) {
+                            properties = ParseResult.IncompleteStatement;
+                        } else {
+                            properties = ParseResult.IncompleteToken;
+                        }
+                        return null;
+                    }
+                }
+
+                properties = ParseResult.Invalid;
+                return null;
+            }
+        }
+
         public Expression ParseFStrSubExpr() {
             _alwaysAllowContextDependentSyntax = true;
             StartParsing();

src/Parsing/Test/ParserTests.cs

@@ -128,6 +128,26 @@ public void FStringErrors() {
             );
         }
 
+        [DataRow("True", ParseResult.Complete)]
+        [DataRow("if True:", ParseResult.IncompleteStatement)]
+        [DataRow("if True", ParseResult.Invalid)]
+        [DataRow("", ParseResult.Empty)]
+        [DataTestMethod, Priority(0)]
+        public void InteractiveCode(string code, ParseResult expectedResult) {
+            foreach (var version in AllVersions) {
+                var module = new Uri("file:///interactive");
+                var parser = Parser.CreateParser(new StringReader(code), version);
+                var ast = parser.ParseInteractiveCode(module, out var result);
+                result.Should().Be(expectedResult);
+                if (expectedResult == ParseResult.Complete) {
+                    ast.Should().NotBeNull();
+                    ast.Module.Should().BeEquivalentTo(module);
+                } else {
+                    ast.Should().BeNull();
+                }
+            }
+        }
+
         [TestMethod, Priority(0)]
         public void FStrings() {
             foreach (var version in V36AndUp) {