[clang-repl] Support multiline function definition.

[sunho]

Summary

Supports multiline function definition. It pre-lex the entire source code and count brace level to see if additional lines are needed. It counts braces after preprocessing is done, thus it correctly handles tricky #ifdef directive cases such as this one reported in cling. (https://sft.its.cern.ch/jira/si/jira.issueviews:issue-html/ROOT-4812/ROOT-4812.html)

Currently, ReceiveCompleteSourceInput runs in O(n^2) where n is the number of lines within a function. Extension of Lexer class is required to make this more efficient up to O(n). Specifically, we need to teach Lexer to receive variable buffer and ask for additional bytes when it consumed all the buffer.

[sunho]

This comment was removed by sunho.

[sunho]

We don't need this now.

clang/include/clang/Interpreter/Interpreter.h

 class Interpreter {
   std::unique_ptr<llvm::orc::ThreadSafeContext> TSCtx;
   std::unique_ptr<IncrementalParser> IncrParser;
   std::unique_ptr<IncrementalExecutor> IncrExecutor;
 
   Interpreter(std::unique_ptr<CompilerInstance> CI, llvm::Error &Err);
 
 public:
+  using ReceiveAdditionalLine = std::function<llvm::Optional<std::string>()>;
   ~Interpreter();
   static llvm::Expected<std::unique_ptr<Interpreter>>
   create(std::unique_ptr<CompilerInstance> CI);
   const CompilerInstance *getCompilerInstance() const;
   const llvm::orc::LLJIT *getExecutionEngine() const;
-  llvm::Expected<PartialTranslationUnit &> Parse(llvm::StringRef Code);
+  ///\param RecvLine a callback that will be called to get additional lines
+  ///required to finish parsing.
+  llvm::Expected<PartialTranslationUnit &>
+  Parse(llvm::StringRef Code, ReceiveAdditionalLine RecvLine = nullptr);
   llvm::Error Execute(PartialTranslationUnit &T);
-  llvm::Error ParseAndExecute(llvm::StringRef Code) {
-    auto PTU = Parse(Code);
+  ///\param RecvLine a callback that will be called to get additional lines
+  ///required to finish parsing.
+  llvm::Error ParseAndExecute(llvm::StringRef Code,
+                              ReceiveAdditionalLine RecvLine = nullptr) {
+    auto PTU = Parse(Code, RecvLine);
     if (!PTU)
       return PTU.takeError();
     if (PTU->TheModule)
       return Execute(*PTU);
     return llvm::Error::success();
   }
 
   /// Undo N previous incremental inputs.

clang/lib/Interpreter/IncrementalDiagnosticBuffer.h

+//===-- IncrementalDiagnosticBuffer.h - Incremental Diagnostics --*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the class which collects diagnostics messages.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_INTERPRETER_INCREMENTALDIAGNOSTICBUFFER_H
+#define LLVM_CLANG_LIB_INTERPRETER_INCREMENTALDIAGNOSTICBUFFER_H
+
+#include "clang/Basic/DiagnosticLex.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
+
+#include "llvm/Support/Error.h"
+
+namespace clang {
+
+/// Collect diagnostics messages to buffer that can be flushed or
+/// cleared based on the circumstances.
+/// While collecting diagnostics messages, this looks whether
+/// certain interesting diagnostic kinds have happend.
+class IncrementalDiagnosticBuffer : public DiagnosticConsumer {
+public:
+  IncrementalDiagnosticBuffer(DiagnosticOptions &DiagOpts)
+      : TextStream(TextBuffer),
+        TextPrinter(
+            std::make_unique<TextDiagnosticPrinter>(TextStream, &DiagOpts)) {}
+  ~IncrementalDiagnosticBuffer() = default;
+
+  /// Whether err_pp_unterminated_conditional has happend since the last
+  /// flush/clear. If true, it indicates that #ifdef or #if directive was not
+  /// finished off by #endif.
+  bool HasTruncatedConditionalDirective() const {
+    return TruncatedConditionalDirective;
+  }
+
+  /// Clear the collected diagnostic messages.
+  void ClearDiagnostics() {
+    TruncatedConditionalDirective = false;
+    TextBuffer.clear();
+  }
+
+  /// Get the collected diagnostic messages as a string buffer.
+  /// This also clears the collected diagnostic message buffer.
+  std::string FlushDiagnostics() {
+    std::string Result = std::move(TextBuffer);
+    ClearDiagnostics();
+    return Result;
+  }
+
+  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
+                        const Diagnostic &Info) override {
+    switch (Info.getID()) {
+    case diag::err_pp_unterminated_conditional: {
+      TruncatedConditionalDirective = true;
+      break;
+    }
+    default:
+      break;
+    }
+    TextPrinter->HandleDiagnostic(DiagLevel, Info);
+  }
+
+  void BeginSourceFile(const clang::LangOptions &LO,
+                       const clang::Preprocessor *PP) override {
+    TextPrinter->BeginSourceFile(LO, PP);
+  }
+
+  void EndSourceFile() override { TextPrinter->EndSourceFile(); }
+
+private:
+  bool TruncatedConditionalDirective = false;
+  std::string TextBuffer;
+  llvm::raw_string_ostream TextStream;
+  std::unique_ptr<TextDiagnosticPrinter> TextPrinter;
+};
+
+} // namespace clang
+
+#endif
 No newline at end of file

clang/lib/Interpreter/IncrementalParser.h

 #include "clang/Interpreter/PartialTranslationUnit.h"
 
 #include "clang/AST/GlobalDecl.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
+#include "IncrementalDiagnosticBuffer.h"
+
 #include <list>
 #include <memory>
 namespace llvm {
 class LLVMContext;
 }
 
 namespace clang {
 class ASTConsumer;
class IncrementalParser {
   /// Counts the number of direct user input lines that have been parsed.
   unsigned InputCount = 0;
 
   /// List containing every information about every incrementally parsed piece
   /// of code.
   std::list<PartialTranslationUnit> PTUs;
 
 public:
+  using ReceiveAdditionalLine = std::function<llvm::Optional<std::string>()>;
   IncrementalParser(std::unique_ptr<CompilerInstance> Instance,
+                    IncrementalDiagnosticBuffer &DiagsBuffer,
                     llvm::LLVMContext &LLVMCtx, llvm::Error &Err);
   ~IncrementalParser();
 
   const CompilerInstance *getCI() const { return CI.get(); }
 
   /// Parses incremental input by creating an in-memory file.
-  ///\returns a \c PartialTranslationUnit which holds information about the
+  ///\param RecvLine a callback that will be called to get additional lines
+  ///required to finish parsing. \returns a \c PartialTranslationUnit which
+  ///holds information about the
   /// \c TranslationUnitDecl and \c llvm::Module corresponding to the input.
-  llvm::Expected<PartialTranslationUnit &> Parse(llvm::StringRef Input);
+  llvm::Expected<PartialTranslationUnit &>
+  Parse(llvm::StringRef Input, ReceiveAdditionalLine RecvLine = nullptr);
 
   /// Uses the CodeGenModule mangled name cache and avoids recomputing.
   ///\returns the mangled name of a \c GD.
   llvm::StringRef GetMangledName(GlobalDecl GD) const;
 
   void CleanUpPTU(PartialTranslationUnit &PTU);
 
   std::list<PartialTranslationUnit> &getPTUs() { return PTUs; }
 
 private:
   llvm::Expected<PartialTranslationUnit &> ParseOrWrapTopLevelDecl();
+  llvm::Expected<FileID>
+  ReceiveCompleteSourceInput(ReceiveAdditionalLine RecvLine,
+                             StringRef InitialCode, StringRef SourceName);
+  IncrementalDiagnosticBuffer &DiagsBuffer;
 };
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_INTERPRETER_INCREMENTALPARSER_H

clang/lib/Interpreter/IncrementalParser.cpp

public:
   void FinalizeAction() {
     assert(!IsTerminating && "Already finalized!");
     IsTerminating = true;
     EndSourceFile();
   }
 };
 
 IncrementalParser::IncrementalParser(std::unique_ptr<CompilerInstance> Instance,
+                                     IncrementalDiagnosticBuffer &DiagsBuffer,
                                      llvm::LLVMContext &LLVMCtx,
                                      llvm::Error &Err)
-    : CI(std::move(Instance)) {
+    : CI(std::move(Instance)), DiagsBuffer(DiagsBuffer) {
   llvm::ErrorAsOutParameter EAO(&Err);
   Act = std::make_unique<IncrementalAction>(*CI, LLVMCtx, Err);
   if (Err)
     return;
   CI->ExecuteAction(*Act);
   Consumer = &CI->getASTConsumer();
   P.reset(
       new Parser(CI->getPreprocessor(), CI->getSema(), /*SkipBodies=*/false));
IncrementalParser::ParseOrWrapTopLevelDecl() {
   Parser::DeclGroupPtrTy ADecl;
   Sema::ModuleImportState ImportState;
   for (bool AtEOF = P->ParseFirstTopLevelDecl(ADecl, ImportState); !AtEOF;
        AtEOF = P->ParseTopLevelDecl(ADecl, ImportState)) {
     // If we got a null return and something *was* parsed, ignore it.  This
     // is due to a top-level semicolon, an action override, or a parse error
     // skipping something.
     if (ADecl && !Consumer->HandleTopLevelDecl(ADecl.get()))
-      return llvm::make_error<llvm::StringError>("Parsing failed. "
-                                                 "The consumer rejected a decl",
-                                                 std::error_code());
+      return llvm::make_error<llvm::StringError>(
+          (llvm::Twine("Parsing failed. "
+                       "The consumer rejected a decl\n") +
+           DiagsBuffer.FlushDiagnostics())
+              .str(),
   }
 
   DiagnosticsEngine &Diags = getCI()->getDiagnostics();
   if (Diags.hasErrorOccurred()) {
     PartialTranslationUnit MostRecentPTU = {C.getTranslationUnitDecl(),
                                             nullptr};
     CleanUpPTU(MostRecentPTU);
 
     Diags.Reset(/*soft=*/true);
     Diags.getClient()->clear();
-    return llvm::make_error<llvm::StringError>("Parsing failed.",
-                                               std::error_code());
+    return llvm::make_error<llvm::StringError>(
+        (llvm::Twine("Parsing failed. \n") + DiagsBuffer.FlushDiagnostics())
+            .str(),
   }
 
   // Process any TopLevelDecls generated by #pragma weak.
   for (Decl *D : S.WeakTopLevelDecls()) {
     DeclGroupRef DGR(D);
     Consumer->HandleTopLevelDecl(DGR);
   }
 
   LocalInstantiations.perform();
   GlobalInstantiations.perform();
 
   Consumer->HandleTranslationUnit(C);
 
   return LastPTU;
 }
 
 static CodeGenerator *getCodeGen(FrontendAction *Act) {
   IncrementalAction *IncrAct = static_cast<IncrementalAction *>(Act);
   FrontendAction *WrappedAct = IncrAct->getWrapped();
   if (!WrappedAct->hasIRSupport())
     return nullptr;
   return static_cast<CodeGenAction *>(WrappedAct)->getCodeGenerator();
 }
 
-llvm::Expected<PartialTranslationUnit &>
-IncrementalParser::Parse(llvm::StringRef input) {
-  Preprocessor &PP = CI->getPreprocessor();
-  assert(PP.isIncrementalProcessingEnabled() && "Not in incremental mode!?");
-
-  std::ostringstream SourceName;
-  SourceName << "input_line_" << InputCount++;
-
+static std::unique_ptr<llvm::MemoryBuffer>
+CreateMemoryBuffer(llvm::StringRef SourceName, llvm::StringRef Str) {
   // Create an uninitialized memory buffer, copy code in and append "\n"
-  size_t InputSize = input.size(); // don't include trailing 0
+  size_t StrSize = Str.size(); // don't include trailing 0
   // MemBuffer size should *not* include terminating zero
   std::unique_ptr<llvm::MemoryBuffer> MB(
-      llvm::WritableMemoryBuffer::getNewUninitMemBuffer(InputSize + 1,
-                                                        SourceName.str()));
+      llvm::WritableMemoryBuffer::getNewUninitMemBuffer(StrSize + 1,
+                                                        SourceName));
   char *MBStart = const_cast<char *>(MB->getBufferStart());
-  memcpy(MBStart, input.data(), InputSize);
-  MBStart[InputSize] = '\n';
+  memcpy(MBStart, Str.data(), StrSize);
+  MBStart[StrSize] = '\n';
+  return MB;
+}
 
+// If RecvLine is not null, this will repeatedly call RecvLine function to fetch
+// the additional lines required to finish a cut-off multiline function
+// definition.
+llvm::Expected<FileID>
+IncrementalParser::ReceiveCompleteSourceInput(ReceiveAdditionalLine RecvLine,
+                                              StringRef InitialCode,
+                                              StringRef SourceName) {
+  // FIXME: Optimize this to O(n) by teaching Lexer to ask for additional bytes.
+  // FIXME: Support string literal cutoff.
+  Preprocessor &PP = CI->getPreprocessor();
   SourceManager &SM = CI->getSourceManager();
-
-  // FIXME: Create SourceLocation, which will allow clang to order the overload
-  // candidates for example
+  DiagnosticsEngine &Diags = getCI()->getDiagnostics();
   SourceLocation NewLoc = SM.getLocForStartOfFile(SM.getMainFileID());
 
+  // Buffer holding collected source code
+  auto CodeBuffer = InitialCode.str();
+  CodeBuffer += '\n';
+
+  while (true) {
     // Create FileID for the current buffer.
-  FileID FID = SM.createFileID(std::move(MB), SrcMgr::C_User, /*LoadedID=*/0,
+    FileID FID = SM.createFileID(llvm::MemoryBufferRef(CodeBuffer, ""),
+                                 SrcMgr::C_User, /*LoadedID=*/0,
                                  /*LoadedOffset=*/0, NewLoc);
-
-  // NewLoc only used for diags.
     if (PP.EnterSourceFile(FID, /*DirLookup=*/nullptr, NewLoc))
       return llvm::make_error<llvm::StringError>("Parsing failed. "
                                                  "Cannot enter source file.",
                                                  std::error_code());
 
+    // Count brace level to determine if additional lines are needed.
+    Token Tok;
+    unsigned BraceLevel = 0;
+    do {
+      PP.Lex(Tok);
+      if (Tok.getKind() == tok::l_brace)
+        ++BraceLevel;
+      else if (Tok.getKind() == tok::r_brace) {
+        if (BraceLevel == 0)
+          return llvm::make_error<llvm::StringError>("Parsing failed. "
+                                                     "Unmathced braces.",
+                                                     std::error_code());
+        --BraceLevel;
+      }
+    } while (Tok.isNot(tok::eof));
+    PP.EndSourceFile();
+
+    if (BraceLevel != 0 || DiagsBuffer.HasTruncatedConditionalDirective()) {
+      // We can't finish off the function definition either because of
+      // truncated #ifdef/if directive or lacking closing braces.
+      // Try to get additional lines.
+
+      // If we can't fetch additional lines, this is just an error.
+      if (!RecvLine)
+        return llvm::make_error<llvm::StringError>("Parsing failed. "
+                                                   "Unmathced braces.",
+                                                   std::error_code());
+
+      // Clear the diagnostic messages that might contain incorrect
+      // diagnostics.
+      Diags.Reset(/*soft=*/true);
+      Diags.getClient()->clear();
+      DiagsBuffer.ClearDiagnostics();
+
+      // Fetch additional lines.
+      if (auto Line = RecvLine()) {
+        CodeBuffer += *Line;
+        CodeBuffer += '\n';
+      } else
+        return llvm::make_error<llvm::StringError>("Parsing failed. "
+                                                   "Truncated code.",
+                                                   std::error_code());
+    } else {
+      // Brace count is sane and it has no truncated #ifdef/if directive.
+      // We're good to go.
+      break;
+    }
+  }
+  return SM.createFileID(CreateMemoryBuffer(SourceName, CodeBuffer),
+                         SrcMgr::C_User, /*LoadedID=*/0,
+                         /*LoadedOffset=*/0, NewLoc);
+}
+
+llvm::Expected<PartialTranslationUnit &>
+IncrementalParser::Parse(llvm::StringRef Input,
+                         ReceiveAdditionalLine RecvLine) {
+  Preprocessor &PP = CI->getPreprocessor();
+  assert(PP.isIncrementalProcessingEnabled() && "Not in incremental mode!?");
+
+  auto SourceName = ("input_line_" + llvm::Twine(InputCount++)).str();
+
+  SourceManager &SM = CI->getSourceManager();
+  auto FID = ReceiveCompleteSourceInput(RecvLine, Input, SourceName);
+  if (!FID)
+    return FID.takeError();
+
+  SourceLocation NewLoc = SM.getLocForStartOfFile(SM.getMainFileID());
+  if (PP.EnterSourceFile(*FID, /*DirLookup=*/nullptr, NewLoc))
+    return llvm::make_error<llvm::StringError>("Parsing failed. "
+                                               "Cannot enter source file.",
+                                               std::error_code());
   auto PTU = ParseOrWrapTopLevelDecl();
   if (!PTU)
     return PTU.takeError();
 
   if (PP.getLangOpts().DelayedTemplateParsing) {
     // Microsoft-specific:
     // Late parsed templates can leave unswallowed "macro"-like tokens.
     // They will seriously confuse the Parser when entering the next

clang/lib/Interpreter/Interpreter.cpp

CreateCI(const llvm::opt::ArgStringList &Argv) {
   // FIXME: Clang should register these container operations automatically.
   auto PCHOps = Clang->getPCHContainerOperations();
   PCHOps->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
   PCHOps->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
 
   // Buffer diagnostics from argument parsing so that we can output them using
   // a well formed diagnostic object.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-  TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
-  DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
+  TextDiagnosticBuffer *TextDiagsBuffer = new TextDiagnosticBuffer;
+  DiagnosticsEngine Diags(DiagID, &*DiagOpts, TextDiagsBuffer);
+
   bool Success = CompilerInvocation::CreateFromArgs(
       Clang->getInvocation(), llvm::makeArrayRef(Argv.begin(), Argv.size()),
       Diags);
 
   // Infer the builtin include path if unspecified.
   if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
       Clang->getHeaderSearchOpts().ResourceDir.empty())
     Clang->getHeaderSearchOpts().ResourceDir =
         CompilerInvocation::GetResourcesPath(Argv[0], nullptr);
 
   // Create the actual diagnostics engine.
-  Clang->createDiagnostics();
+  IncrementalDiagnosticBuffer *DiagsBuffer =
+      new IncrementalDiagnosticBuffer(*DiagOpts);
+  Clang->createDiagnostics(DiagsBuffer);
   if (!Clang->hasDiagnostics())
     return llvm::createStringError(llvm::errc::not_supported,
                                    "Initialization failed. "
                                    "Unable to create diagnostics engine");
-
-  DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics());
+  TextDiagsBuffer->FlushDiagnostics(Clang->getDiagnostics());
   if (!Success)
     return llvm::createStringError(llvm::errc::not_supported,
                                    "Initialization failed. "
                                    "Unable to flush diagnostics");
 
   // FIXME: Merge with CompilerInstance::ExecuteAction.
   llvm::MemoryBuffer *MB = llvm::MemoryBuffer::getMemBuffer("").release();
   Clang->getPreprocessorOpts().addRemappedFile("<<< inputs >>>", MB);
IncrementalCompilerBuilder::create(std::vector<const char *> &ClangArgv) {
   return CreateCI(**ErrOrCC1Args);
 }
 
 Interpreter::Interpreter(std::unique_ptr<CompilerInstance> CI,
                          llvm::Error &Err) {
   llvm::ErrorAsOutParameter EAO(&Err);
   auto LLVMCtx = std::make_unique<llvm::LLVMContext>();
   TSCtx = std::make_unique<llvm::orc::ThreadSafeContext>(std::move(LLVMCtx));
-  IncrParser = std::make_unique<IncrementalParser>(std::move(CI),
-                                                   *TSCtx->getContext(), Err);
+  IncrParser = std::make_unique<IncrementalParser>(
+      std::move(CI),
+      reinterpret_cast<IncrementalDiagnosticBuffer &>(
+          CI->getDiagnosticClient()),
 }
 
 Interpreter::~Interpreter() {}
 
 llvm::Expected<std::unique_ptr<Interpreter>>
 Interpreter::create(std::unique_ptr<CompilerInstance> CI) {
   llvm::Error Err = llvm::Error::success();
   auto Interp =

 
 const llvm::orc::LLJIT *Interpreter::getExecutionEngine() const {
   if (IncrExecutor)
     return IncrExecutor->getExecutionEngine();
   return nullptr;
 }
 
 llvm::Expected<PartialTranslationUnit &>
-Interpreter::Parse(llvm::StringRef Code) {
-  return IncrParser->Parse(Code);
+Interpreter::Parse(llvm::StringRef Code, ReceiveAdditionalLine RecvLine) {
+  return IncrParser->Parse(Code, RecvLine);
 }
 
 llvm::Error Interpreter::Execute(PartialTranslationUnit &T) {
   assert(T.TheModule);
   if (!IncrExecutor) {
     const clang::TargetInfo &TI =
         getCompilerInstance()->getASTContext().getTargetInfo();
     llvm::Error Err = llvm::Error::success();

clang/test/Interpreter/multiline-func-macro-brace-error.cpp

+// REQUIRES: host-supports-jit
+// UNSUPPORTED: system-aix
+// RUN: cat %s | clang-repl 2>&1 | FileCheck %s
+// Check invalid brace counts are detected.
+// Brace counting is done to support multiline functions.
+extern "C" int printf(const char *, ...);
+
+#define ___DEFINED_SYMBOL
+
+int test_multiline_brace_count_error() {
+#ifdef ___UNDEFINED_SYMBOL
+  printf("Simple multiline brace count\n");
+#else
+}
+#endif
+}
+// CHECK: error: Parsing failed. Unmathced braces.
+
+#define A 1
+#define B 3
+#define C (A + B)
+#define D C
+
+int test_multiline_brace_count_complex_error() {
+#if A + B - 2 * C + D == 0
+}
+#else
+  printf("Complex multiline brace count\n");
+#endif
+}
+// CHECK-NEXT: error: Parsing failed. Unmathced braces.
+
+% quit

clang/test/Interpreter/multiline-func-macro-brace.cpp

+// REQUIRES: host-supports-jit
+// UNSUPPORTED: system-aix
+// RUN: cat %s | clang-repl | FileCheck %s
+// Check a brace counting is not broken by introduction of macro directives.
+// Brace counting is done to support multiline functions.
+extern "C" int printf(const char *, ...);
+
+#define ___DEFINED_SYMBOL
+
+int test_multiline_brace_count_simple() {
+#ifdef ___UNDEFINED_SYMBOL
+  {
+#else
+  printf("Simple multiline brace count\n");
+#endif
+    return 0;
+  }
+  auto r1 = test_multiline_brace_count_simple();
+  // CHECK: Simple multiline brace count
+
+  int test_multiline_brace_count_defined() {
+#ifdef ___DEFINED_SYMBOL
+    printf("Defined multiline brace count\n");
+#else
+}
+}
+}
+}
+}
+}
+#endif
+    return 0;
+  }
+  auto r2 = test_multiline_brace_count_defined();
+  // CHECK-NEXT: Defined multiline brace count
+
+#define A 1
+#define B 3
+#define C (A + B)
+#define D C
+
+  int test_multiline_brace_count_complex() {
+#if A + B - 2 * C + D == 0
+    printf("Complex multiline brace count\n");
+#else
+  {
+#endif
+    return 0;
+  }
+  auto r3 = test_multiline_brace_count_complex();
+  // CHECK-NEXT: Complex multiline brace count
+
+  % quit

clang/test/Interpreter/multiline-func.cpp

+// REQUIRES: host-supports-jit
+// UNSUPPORTED: system-aix
+// RUN: cat %s | clang-repl | FileCheck %s
+// Check a multiline function is parsed and executed correctly.
+extern "C" int printf(const char *, ...);
+int test_multiline_function() {
+  printf("Multiline\n");
+  printf("Function\n");
+  return 0;
+}
+
+auto r1 = test_multiline_function();
+// CHECK: Multiline
+// CHECK-NEXT: Function
+
+% quit

clang/tools/clang-repl/ClangRepl.cpp

while (llvm::Optional<std::string> Line = LE.readLine()) {
       if (*Line == R"(%quit)")
         break;
       if (*Line == R"(%undo)") {
         if (auto Err = Interp->Undo())
           llvm::logAllUnhandledErrors(std::move(Err), llvm::errs(), "error: ");
         continue;
       }
 
-      if (auto Err = Interp->ParseAndExecute(*Line))
+      if (auto Err =
+              Interp->ParseAndExecute(*Line, [&]() { return LE.readLine(); }))
         llvm::logAllUnhandledErrors(std::move(Err), llvm::errs(), "error: ");
     }
   }
 
   // Our error handler depends on the Diagnostics object, which we're
   // potentially about to delete. Uninstall the handler now so that any
   // later errors use the default handling behavior instead.
   llvm::remove_fatal_error_handler();
 
   llvm::llvm_shutdown();
 
   return checkDiagErrors(Interp->getCompilerInstance());
 }