Make emacs show when clang-format encountered a syntax error.

[klimek]

Summary

Propagate the 'incomplete-format' state back through clang-format's command
line interace and adapt the emacs integration to show a better result.

[djasper]

Looks good.

test/Format/cursor.cpp

 // RUN: grep -Ev "// *[A-Z-]+:" %s > %t2.cpp
 // RUN: clang-format -style=LLVM %t2.cpp -cursor=6 > %t.cpp
 // RUN: FileCheck -strict-whitespace -input-file=%t.cpp %s
-// CHECK: {{^\{ "Cursor": 4 \}$}}
+// CHECK: {{^\{ "Cursor": 4, }}
 // CHECK: {{^int\ \i;$}}
  int    i;

test/Format/incomplete.cpp

 // RUN: grep -Ev "// *[A-Z-]+:" %s > %t2.cpp
-// RUN: clang-format -style=LLVM %t2.cpp -cursor=6 > %t.cpp
+// RUN: clang-format -style=LLVM %t2.cpp > %t.cpp
 // RUN: FileCheck -strict-whitespace -input-file=%t.cpp %s
-// CHECK: {{^\{ "Cursor": 4 \}$}}
+// CHECK: {{^\{ "IncompleteFormat": true }}
 // CHECK: {{^int\ \i;$}}
  int    i;
+// CHECK: {{^f  \( g  \(;$}}
+f  ( g  (;

tools/clang-format/ClangFormat.cpp

if (Code->getBufferSize() == 0)
     return false; // Empty files are formatted correctly.
   FileID ID = createInMemoryFile(FileName, Code.get(), Sources, Files);
   std::vector<CharSourceRange> Ranges;
   if (fillRanges(Sources, ID, Code.get(), Ranges))
     return true;
 
   FormatStyle FormatStyle = getStyle(
       Style, (FileName == "-") ? AssumeFilename : FileName, FallbackStyle);
-  tooling::Replacements Replaces = reformat(FormatStyle, Sources, ID, Ranges);
+  bool IncompleteFormat = false;
+  tooling::Replacements Replaces = reformat(FormatStyle, Sources, ID, Ranges, &IncompleteFormat);
   if (OutputXML) {
-    llvm::outs()
-        << "<?xml version='1.0'?>\n<replacements xml:space='preserve'>\n";
+    llvm::outs() << "<?xml version='1.0'?>\n<replacements "
+                    "xml:space='preserve' incomplete_format='"
+                 << (IncompleteFormat ? "true" : "false") << "'>\n";
     if (Cursor.getNumOccurrences() != 0)
       llvm::outs() << "<cursor>"
                    << tooling::shiftedCodePosition(Replaces, Cursor)
                    << "</cursor>\n";
+
     for (tooling::Replacements::const_iterator I = Replaces.begin(),
                                                E = Replaces.end();
          I != E; ++I) {
       llvm::outs() << "<replacement "
                    << "offset='" << I->getOffset() << "' "
                    << "length='" << I->getLength() << "'>";
       outputReplacementXML(I->getReplacementText());
       llvm::outs() << "</replacement>\n";
     }
     llvm::outs() << "</replacements>\n";
   } else {
     Rewriter Rewrite(Sources, LangOptions());
     tooling::applyAllReplacements(Replaces, Rewrite);
     if (Inplace) {
       if (FileName == "-")
         llvm::errs() << "error: cannot use -i when reading from stdin.\n";
       else if (Rewrite.overwriteChangedFiles())
         return true;
     } else {
+      outs() << "{";
       if (Cursor.getNumOccurrences() != 0)
-        outs() << "{ \"Cursor\": "
-               << tooling::shiftedCodePosition(Replaces, Cursor) << " }\n";
+        outs() << " \"Cursor\": "
+               << tooling::shiftedCodePosition(Replaces, Cursor) << ",";
+      outs() << " \"IncompleteFormat\": "
+             << (IncompleteFormat ? "true" : "false") << " }\n";
       Rewrite.getEditBuffer(ID).write(outs());
     }
   }
   return false;
 }
 
 }  // namespace format
 }  // namespace clang

tools/clang-format/clang-format.el

of the buffer."
   :safe #'stringp)
 (make-variable-buffer-local 'clang-format-style)
 
 (defun clang-format--extract (xml-node)
   "Extract replacements and cursor information from XML-NODE."
   (unless (and (listp xml-node) (eq (xml-node-name xml-node) 'replacements))
     (error "Expected <replacements> node"))
   (let ((nodes (xml-node-children xml-node))
+        (incomplete-format (xml-get-attribute xml-node 'incomplete_format))
         replacements
         cursor)
     (dolist (node nodes)
       (when (listp node)
         (let* ((children (xml-node-children node))
                (text (car children)))
           (cl-case (xml-node-name node)
             ('replacement
(let ((nodes (xml-node-children xml-node))
 
     ;; Sort by decreasing offset, length.
     (setq replacements (sort (delq nil replacements)
                              (lambda (a b)
                                (or (> (car a) (car b))
                                    (and (= (car a) (car b))
                                         (> (cadr a) (cadr b)))))))
 
-    (cons replacements cursor)))
+    (list replacements cursor (string= incomplete-format "true"))))
 
 (defun clang-format--replace (offset length &optional text)
   (let ((start (byte-to-position (1+ offset)))
         (end (byte-to-position (+ 1 offset length))))
     (goto-char start)
     (delete-region start end)
     (when text
       (insert text))))
(unwind-protect
                     (insert ": "))
                   (buffer-substring-no-properties
                    (point-min) (line-end-position))))
 
           (cond
            ((stringp status)
             (error "(clang-format killed by signal %s%s)" status stderr))
            ((not (equal 0 status))
-            (error "(clang-format failed with code %d%s)" status stderr))
-           (t (message "(clang-format succeeded%s)" stderr)))
+            (error "(clang-format failed with code %d%s)" status stderr)))
 
           (with-current-buffer temp-buffer
             (setq operations (clang-format--extract (car (xml-parse-region)))))
 
-          (let ((replacements (car operations))
-                (cursor (cdr operations)))
+          (let ((replacements (nth 0 operations))
+                (cursor (nth 1 operations))
+                (incomplete-format (nth 2 operations)))
             (save-excursion
               (mapc (lambda (rpl)
                       (apply #'clang-format--replace rpl))
                     replacements))
             (when cursor
-              (goto-char (byte-to-position (1+ cursor))))))
+              (goto-char (byte-to-position (1+ cursor))))
+            (message "%s" incomplete-format)
+            (if incomplete-format
+                (message "(clang-format: incomplete (syntax errors)%s)" stderr)
+              (message "(clang-format: success%s)" stderr))))
       (delete-file temp-file)
       (when (buffer-name temp-buffer) (kill-buffer temp-buffer)))))
 
 ;;;###autoload
 (defun clang-format-buffer (&optional style)
   "Use clang-format to format the current buffer according to STYLE."
   (interactive)
   (clang-format-region (point-min) (point-max) style))
 
 ;;;###autoload
 (defalias 'clang-format 'clang-format-region)
 
 (provide 'clang-format)
 ;;; clang-format.el ends here