all messages for Emacs-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed
From: Ihor Radchenko <yantar92@gmail.com>
To: Greg Coladonato <gcoladon@gmail.com>
Cc: emacs-orgmode@gnu.org
Subject: Re: [BUG] after update to 9.5, starting org mode results in cache error messages [9.5 (9.5-gd4e192 @ c:/Users/scott/.emacs.d/straight/build/org/)]
Date: Mon, 01 Nov 2021 20:42:01 +0800	[thread overview]
Message-ID: <874k8wavza.fsf@localhost> (raw)
In-Reply-To: <CAO09H5tp5Av9is5x8MV3mNNaJCfy=HwwYwQQcdMTZx_QXsr7Sw@mail.gmail.com>

[-- Attachment #1: Type: text/plain, Size: 642 bytes --]

Greg Coladonato <gcoladon@gmail.com> writes:

> I get a similar error to Scott's every time I save an org-mode file. I
> turned on backtrace and got this output:

Thanks for reporting and providing the detailed backtrace!
Backtrace is really strange because cache is clearly updated upon
changing the file, but somehow somewhere a stale element is still
returned.

Given that you are using org-roam, the only suspect that may create
stale copies of cached elements is org-element-parse-buffer. The
attached patch is making sure that org-element-parse-buffer never tries
to reuse cache. Can you try the patch and see if it helps?

Best,
Ihor


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-org-element-current-element-Do-not-use-cache.patch --]
[-- Type: text/x-diff, Size: 15783 bytes --]

From cc2b4081796ed3caeb193b45588bfb9fd3d77625 Mon Sep 17 00:00:00 2001
Message-Id: <cc2b4081796ed3caeb193b45588bfb9fd3d77625.1635770341.git.yantar92@gmail.com>
From: Ihor Radchenko <yantar92@gmail.com>
Date: Mon, 1 Nov 2021 20:38:11 +0800
Subject: [PATCH] org-element--current-element: Do not use cache

---
 lisp/org-element.el | 342 ++++++++++++++++++++------------------------
 1 file changed, 157 insertions(+), 185 deletions(-)

diff --git a/lisp/org-element.el b/lisp/org-element.el
index 9fa6fd5e2..caa714f34 100644
--- a/lisp/org-element.el
+++ b/lisp/org-element.el
@@ -4106,7 +4106,7 @@ ;;; Parsing Element Starting At Point
 ;; point.
 
 (defvar org-element--cache-sync-requests); Declared later
-(defun org-element--current-element (limit &optional granularity mode structure add-to-cache)
+(defun org-element--current-element (limit &optional granularity mode structure)
   "Parse the element starting at point.
 
 Return value is a list like (TYPE PROPS) where TYPE is the type
@@ -4138,190 +4138,162 @@ (defun org-element--current-element (limit &optional granularity mode structure
 
 This function assumes point is always at the beginning of the
 element it has to parse."
-  (let* ((element (and (not (buffer-narrowed-p))
-                       (org-element--cache-active-p)
-                       (not org-element--cache-sync-requests)
-                       (org-element--cache-find (point) t)))
-         (element (progn (while (and element
-                                     (not (and (eq (point) (org-element-property :begin element))
-                                             (eq mode (org-element-property :mode element)))))
-                           (setq element (org-element-property :parent element)))
-                         element))
-         (old-element element)
-         (element (when
-                      (pcase (org-element-property :granularity element)
-                        (`nil t)
-                        (`object t)
-                        (`element (not (memq granularity '(nil object))))
-                        (`greater-element (not (memq granularity '(nil object element))))
-                        (`headline (eq granularity 'headline)))
-                    element)))
-    (if element
-        element
-      (save-excursion
-        (let ((case-fold-search t)
-	      ;; Determine if parsing depth allows for secondary strings
-	      ;; parsing.  It only applies to elements referenced in
-	      ;; `org-element-secondary-value-alist'.
-	      (raw-secondary-p (and granularity (not (eq granularity 'object))))
-              result)
-          (setq
-           result
-           (cond
-            ;; Item.
-            ((eq mode 'item)
-	     (org-element-item-parser limit structure raw-secondary-p))
-            ;; Table Row.
-            ((eq mode 'table-row) (org-element-table-row-parser limit))
-            ;; Node Property.
-            ((eq mode 'node-property) (org-element-node-property-parser limit))
-            ;; Headline.
-            ((org-with-limited-levels (org-at-heading-p))
-             (org-element-headline-parser limit raw-secondary-p))
-            ;; Sections (must be checked after headline).
-            ((eq mode 'section) (org-element-section-parser limit))
-            ((eq mode 'first-section)
-	     (org-element-section-parser
-	      (or (save-excursion (org-with-limited-levels (outline-next-heading)))
-	          limit)))
-            ;; Comments.
-            ((looking-at "^[ \t]*#\\(?: \\|$\\)")
-	     (org-element-comment-parser limit))
-            ;; Planning.
-            ((and (eq mode 'planning)
-	          (eq ?* (char-after (line-beginning-position 0)))
-	          (looking-at org-planning-line-re))
-	     (org-element-planning-parser limit))
-            ;; Property drawer.
-            ((and (pcase mode
-	            (`planning (eq ?* (char-after (line-beginning-position 0))))
-	            ((or `property-drawer `top-comment)
-		     (save-excursion
-		       (beginning-of-line 0)
-		       (not (looking-at "[[:blank:]]*$"))))
-	            (_ nil))
-	          (looking-at org-property-drawer-re))
-	     (org-element-property-drawer-parser limit))
-            ;; When not at bol, point is at the beginning of an item or
-            ;; a footnote definition: next item is always a paragraph.
-            ((not (bolp)) (org-element-paragraph-parser limit (list (point))))
-            ;; Clock.
-            ((looking-at org-clock-line-re) (org-element-clock-parser limit))
-            ;; Inlinetask.
-            ((looking-at "^\\*+ ")
-	     (org-element-inlinetask-parser limit raw-secondary-p))
-            ;; From there, elements can have affiliated keywords.
-            (t (let ((affiliated (org-element--collect-affiliated-keywords
-			          limit (memq granularity '(nil object)))))
-	         (cond
-	          ;; Jumping over affiliated keywords put point off-limits.
-	          ;; Parse them as regular keywords.
-	          ((and (cdr affiliated) (>= (point) limit))
-	           (goto-char (car affiliated))
-	           (org-element-keyword-parser limit nil))
-	          ;; LaTeX Environment.
-	          ((looking-at org-element--latex-begin-environment)
-	           (org-element-latex-environment-parser limit affiliated))
-	          ;; Drawer.
-	          ((looking-at org-drawer-regexp)
-	           (org-element-drawer-parser limit affiliated))
-	          ;; Fixed Width
-	          ((looking-at "[ \t]*:\\( \\|$\\)")
-	           (org-element-fixed-width-parser limit affiliated))
-	          ;; Inline Comments, Blocks, Babel Calls, Dynamic Blocks and
-	          ;; Keywords.
-	          ((looking-at "[ \t]*#\\+")
-	           (goto-char (match-end 0))
-	           (cond
-	            ((looking-at "BEGIN_\\(\\S-+\\)")
-		     (beginning-of-line)
-		     (funcall (pcase (upcase (match-string 1))
-			        ("CENTER"  #'org-element-center-block-parser)
-			        ("COMMENT" #'org-element-comment-block-parser)
-			        ("EXAMPLE" #'org-element-example-block-parser)
-			        ("EXPORT"  #'org-element-export-block-parser)
-			        ("QUOTE"   #'org-element-quote-block-parser)
-			        ("SRC"     #'org-element-src-block-parser)
-			        ("VERSE"   #'org-element-verse-block-parser)
-			        (_         #'org-element-special-block-parser))
-			      limit
-			      affiliated))
-	            ((looking-at "CALL:")
-		     (beginning-of-line)
-		     (org-element-babel-call-parser limit affiliated))
-	            ((looking-at "BEGIN:? ")
-		     (beginning-of-line)
-		     (org-element-dynamic-block-parser limit affiliated))
-	            ((looking-at "\\S-+:")
-		     (beginning-of-line)
-		     (org-element-keyword-parser limit affiliated))
-	            (t
-		     (beginning-of-line)
-		     (org-element-paragraph-parser limit affiliated))))
-	          ;; Footnote Definition.
-	          ((looking-at org-footnote-definition-re)
-	           (org-element-footnote-definition-parser limit affiliated))
-	          ;; Horizontal Rule.
-	          ((looking-at "[ \t]*-\\{5,\\}[ \t]*$")
-	           (org-element-horizontal-rule-parser limit affiliated))
-	          ;; Diary Sexp.
-	          ((looking-at "%%(")
-	           (org-element-diary-sexp-parser limit affiliated))
-	          ;; Table.
-	          ((or (looking-at "[ \t]*|")
-		       ;; There is no strict definition of a table.el
-		       ;; table.  Try to prevent false positive while being
-		       ;; quick.
-		       (let ((rule-regexp
-			      (rx (zero-or-more (any " \t"))
-			          "+"
-			          (one-or-more (one-or-more "-") "+")
-			          (zero-or-more (any " \t"))
-			          eol))
-			     (non-table.el-line
-			      (rx bol
-			          (zero-or-more (any " \t"))
-			          (or eol (not (any "+| \t")))))
-			     (next (line-beginning-position 2)))
-		         ;; Start with a full rule.
-		         (and
-		          (looking-at rule-regexp)
-		          (< next limit)	;no room for a table.el table
-		          (save-excursion
-		            (end-of-line)
-		            (cond
-			     ;; Must end with a full rule.
-			     ((not (re-search-forward non-table.el-line limit 'move))
-			      (if (bolp) (forward-line -1) (beginning-of-line))
-			      (looking-at rule-regexp))
-			     ;; Ignore pseudo-tables with a single
-			     ;; rule.
-			     ((= next (line-beginning-position))
-			      nil)
-			     ;; Must end with a full rule.
-			     (t
-			      (forward-line -1)
-			      (looking-at rule-regexp)))))))
-	           (org-element-table-parser limit affiliated))
-	          ;; List.
-	          ((looking-at (org-item-re))
-	           (org-element-plain-list-parser
-	            limit affiliated
-	            (or structure (org-element--list-struct limit))))
-	          ;; Default element: Paragraph.
-	          (t (org-element-paragraph-parser limit affiliated)))))))
-          (when result
-            (org-element-put-property result :mode mode)
-            (org-element-put-property result :granularity granularity))
-          (when (and (not (buffer-narrowed-p))
-                     (org-element--cache-active-p)
-                     (not org-element--cache-sync-requests)
-                     add-to-cache)
-            (if (not old-element)
-                (setq result (org-element--cache-put result))
-              (org-element-set-element old-element result)
-              (setq result old-element)))
-          result)))))
+  (save-excursion
+    (let ((case-fold-search t)
+	  ;; Determine if parsing depth allows for secondary strings
+	  ;; parsing.  It only applies to elements referenced in
+	  ;; `org-element-secondary-value-alist'.
+	  (raw-secondary-p (and granularity (not (eq granularity 'object))))
+          result)
+      (setq
+       result
+       (cond
+        ;; Item.
+        ((eq mode 'item)
+	 (org-element-item-parser limit structure raw-secondary-p))
+        ;; Table Row.
+        ((eq mode 'table-row) (org-element-table-row-parser limit))
+        ;; Node Property.
+        ((eq mode 'node-property) (org-element-node-property-parser limit))
+        ;; Headline.
+        ((org-with-limited-levels (org-at-heading-p))
+         (org-element-headline-parser limit raw-secondary-p))
+        ;; Sections (must be checked after headline).
+        ((eq mode 'section) (org-element-section-parser limit))
+        ((eq mode 'first-section)
+	 (org-element-section-parser
+	  (or (save-excursion (org-with-limited-levels (outline-next-heading)))
+	      limit)))
+        ;; Comments.
+        ((looking-at "^[ \t]*#\\(?: \\|$\\)")
+	 (org-element-comment-parser limit))
+        ;; Planning.
+        ((and (eq mode 'planning)
+	      (eq ?* (char-after (line-beginning-position 0)))
+	      (looking-at org-planning-line-re))
+	 (org-element-planning-parser limit))
+        ;; Property drawer.
+        ((and (pcase mode
+	        (`planning (eq ?* (char-after (line-beginning-position 0))))
+	        ((or `property-drawer `top-comment)
+		 (save-excursion
+		   (beginning-of-line 0)
+		   (not (looking-at "[[:blank:]]*$"))))
+	        (_ nil))
+	      (looking-at org-property-drawer-re))
+	 (org-element-property-drawer-parser limit))
+        ;; When not at bol, point is at the beginning of an item or
+        ;; a footnote definition: next item is always a paragraph.
+        ((not (bolp)) (org-element-paragraph-parser limit (list (point))))
+        ;; Clock.
+        ((looking-at org-clock-line-re) (org-element-clock-parser limit))
+        ;; Inlinetask.
+        ((looking-at "^\\*+ ")
+	 (org-element-inlinetask-parser limit raw-secondary-p))
+        ;; From there, elements can have affiliated keywords.
+        (t (let ((affiliated (org-element--collect-affiliated-keywords
+			      limit (memq granularity '(nil object)))))
+	     (cond
+	      ;; Jumping over affiliated keywords put point off-limits.
+	      ;; Parse them as regular keywords.
+	      ((and (cdr affiliated) (>= (point) limit))
+	       (goto-char (car affiliated))
+	       (org-element-keyword-parser limit nil))
+	      ;; LaTeX Environment.
+	      ((looking-at org-element--latex-begin-environment)
+	       (org-element-latex-environment-parser limit affiliated))
+	      ;; Drawer.
+	      ((looking-at org-drawer-regexp)
+	       (org-element-drawer-parser limit affiliated))
+	      ;; Fixed Width
+	      ((looking-at "[ \t]*:\\( \\|$\\)")
+	       (org-element-fixed-width-parser limit affiliated))
+	      ;; Inline Comments, Blocks, Babel Calls, Dynamic Blocks and
+	      ;; Keywords.
+	      ((looking-at "[ \t]*#\\+")
+	       (goto-char (match-end 0))
+	       (cond
+	        ((looking-at "BEGIN_\\(\\S-+\\)")
+		 (beginning-of-line)
+		 (funcall (pcase (upcase (match-string 1))
+			    ("CENTER"  #'org-element-center-block-parser)
+			    ("COMMENT" #'org-element-comment-block-parser)
+			    ("EXAMPLE" #'org-element-example-block-parser)
+			    ("EXPORT"  #'org-element-export-block-parser)
+			    ("QUOTE"   #'org-element-quote-block-parser)
+			    ("SRC"     #'org-element-src-block-parser)
+			    ("VERSE"   #'org-element-verse-block-parser)
+			    (_         #'org-element-special-block-parser))
+			  limit
+			  affiliated))
+	        ((looking-at "CALL:")
+		 (beginning-of-line)
+		 (org-element-babel-call-parser limit affiliated))
+	        ((looking-at "BEGIN:? ")
+		 (beginning-of-line)
+		 (org-element-dynamic-block-parser limit affiliated))
+	        ((looking-at "\\S-+:")
+		 (beginning-of-line)
+		 (org-element-keyword-parser limit affiliated))
+	        (t
+		 (beginning-of-line)
+		 (org-element-paragraph-parser limit affiliated))))
+	      ;; Footnote Definition.
+	      ((looking-at org-footnote-definition-re)
+	       (org-element-footnote-definition-parser limit affiliated))
+	      ;; Horizontal Rule.
+	      ((looking-at "[ \t]*-\\{5,\\}[ \t]*$")
+	       (org-element-horizontal-rule-parser limit affiliated))
+	      ;; Diary Sexp.
+	      ((looking-at "%%(")
+	       (org-element-diary-sexp-parser limit affiliated))
+	      ;; Table.
+	      ((or (looking-at "[ \t]*|")
+		   ;; There is no strict definition of a table.el
+		   ;; table.  Try to prevent false positive while being
+		   ;; quick.
+		   (let ((rule-regexp
+			  (rx (zero-or-more (any " \t"))
+			      "+"
+			      (one-or-more (one-or-more "-") "+")
+			      (zero-or-more (any " \t"))
+			      eol))
+			 (non-table.el-line
+			  (rx bol
+			      (zero-or-more (any " \t"))
+			      (or eol (not (any "+| \t")))))
+			 (next (line-beginning-position 2)))
+		     ;; Start with a full rule.
+		     (and
+		      (looking-at rule-regexp)
+		      (< next limit)	;no room for a table.el table
+		      (save-excursion
+		        (end-of-line)
+		        (cond
+			 ;; Must end with a full rule.
+			 ((not (re-search-forward non-table.el-line limit 'move))
+			  (if (bolp) (forward-line -1) (beginning-of-line))
+			  (looking-at rule-regexp))
+			 ;; Ignore pseudo-tables with a single
+			 ;; rule.
+			 ((= next (line-beginning-position))
+			  nil)
+			 ;; Must end with a full rule.
+			 (t
+			  (forward-line -1)
+			  (looking-at rule-regexp)))))))
+	       (org-element-table-parser limit affiliated))
+	      ;; List.
+	      ((looking-at (org-item-re))
+	       (org-element-plain-list-parser
+	        limit affiliated
+	        (or structure (org-element--list-struct limit))))
+	      ;; Default element: Paragraph.
+	      (t (org-element-paragraph-parser limit affiliated)))))))
+      (when result
+        (org-element-put-property result :mode mode)
+        (org-element-put-property result :granularity granularity))
+      result)))
 
 
 ;; Most elements can have affiliated keywords.  When looking for an
-- 
2.32.0


  reply	other threads:[~2021-11-01 12:41 UTC|newest]

Thread overview: 10+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2021-10-31 19:26 [BUG] after update to 9.5, starting org mode results in cache error messages [9.5 (9.5-gd4e192 @ c:/Users/scott/.emacs.d/straight/build/org/)] Greg Coladonato
2021-11-01 12:42 ` Ihor Radchenko [this message]
2021-11-02  3:25   ` Greg Coladonato
2021-11-02  4:05     ` Ihor Radchenko
2021-11-02  4:33       ` Greg Coladonato
2021-11-02  5:26         ` Ihor Radchenko
2021-11-02 23:06           ` Greg Coladonato
2021-11-03 11:50             ` Ihor Radchenko
  -- strict thread matches above, loose matches on Subject: below --
2021-10-31  3:19 Scott Otterson
2021-10-31  3:53 ` Ihor Radchenko

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=874k8wavza.fsf@localhost \
    --to=yantar92@gmail.com \
    --cc=emacs-orgmode@gnu.org \
    --cc=gcoladon@gmail.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/emacs.git
	https://git.savannah.gnu.org/cgit/emacs/org-mode.git

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.