[nongnu] elpa/typescript-mode a8b7e76e85 171/222: Fix infinite loop in indentation.

[ELPA Syncer]

branch: elpa/typescript-mode
commit a8b7e76e85c1f8b4e353498e3e2d52f1dbcfb6d9
Author: Louis-Dominique Dubeau <ldd@lddubeau.com>
Commit: Louis-Dominique Dubeau <ldd@lddubeau.com>

    Fix infinite loop in indentation.
    
    This fixes an issue that was introduced in #126
    
    In a case like this:
    
    ```
    if (...) {
      .bleh();
    }
    ```
    
    running indentation on the line with `.bleh()` would (prior to this commit)
    result in an infinite loop. The solution is to treat the dot as not being an
    expression continuation. It is the start of the expression, not the 
continuation
    of an expression already started earlier.
---
 typescript-mode.el | 38 +++++++++++++++++++++++++-------------
 1 file changed, 25 insertions(+), 13 deletions(-)

diff --git a/typescript-mode.el b/typescript-mode.el
index 7806053db4..ff2f8674cc 100644
--- a/typescript-mode.el
+++ b/typescript-mode.el
@@ -2244,19 +2244,31 @@ Searches specifically for any of \"=\", \"}\", and 
\"type\"."
   "Return non-nil if the current line continues an expression."
   (save-excursion
     (back-to-indentation)
-    (and
-     ;; Don't identify the spread syntax or rest operator as a
-     ;; "continuation".
-     (not (looking-at "\\.\\.\\."))
-     (or (typescript--looking-at-operator-p)
-         (and (progn
-                (typescript--backward-syntactic-ws)
-                (or (bobp) (backward-char))
-                (and (> (point) (point-min))
-                     (save-excursion (backward-char) (not (looking-at 
"[/*]/")))
-                     (typescript--looking-at-operator-p)
-                     (and (progn (backward-char)
-                                 (not (looking-at "++\\|--\\|/[/*]")))))))))))
+    (let ((list-start (nth 1 (syntax-ppss))))
+      (and
+       ;; This not clause is there to eliminate degenerate cases where we have
+       ;; something that looks like a continued expression but we are in fact 
at
+       ;; the beginning of the expression. Example: in `if (a) { .q(1)` when 
the
+       ;; point is on the dot, the expression that follows looks like a member
+       ;; expression but the object on which it is a member is missing. If we
+       ;; naively treat this as a continued expression, we run into trouble
+       ;; later. (An infinite loop.)
+       (not (and list-start
+                 (save-excursion
+                   (typescript--backward-syntactic-ws)
+                   (backward-char)
+                   (eq (point) list-start))))
+       ;; Don't identify the spread syntax or rest operator as a 
"continuation".
+       (not (looking-at "\\.\\.\\."))
+       (or (typescript--looking-at-operator-p)
+           (and (progn
+                  (typescript--backward-syntactic-ws)
+                  (or (bobp) (backward-char))
+                  (and (> (point) (point-min))
+                       (save-excursion (backward-char) (not (looking-at 
"[/*]/")))
+                       (typescript--looking-at-operator-p)
+                       (and (progn (backward-char)
+                                   (not (looking-at 
"++\\|--\\|/[/*]"))))))))))))
 
 (cl-defun typescript--compute-member-expression-indent ()
   "Determine the indent of a member expression.