org-element-map: Allow TYPES t and add new arg NO-UNDEFER

* lisp/org-element-ast.el (org-element-ast-map):
* lisp/org-element.el (org-element-map): Treat TYPES t as all possible
types.  Add new optional parameter to no resolve deferred while
traversing the AST.

lisp/org-element-ast.el

@@ -817,13 +817,18 @@ The function takes care of setting `:parent' property for NEW."
   old)
 
 (defun org-element-ast-map
-    (data types fun &optional ignore first-match no-recursion with-properties no-secondary)
+    ( data types fun
+      &optional
+      ignore first-match no-recursion
+      with-properties no-secondary no-undefer)
   "Map a function on selected syntax nodes.
 
 DATA is a syntax tree.  TYPES is a symbol or list of symbols of
 node types.  FUN is the function called on the matching nodes.
 It has to accept one argument: the node itself.
 
+When TYPES is t, call FUN for all the node types.
+
 When optional argument IGNORE is non-nil, it should be a list holding
 nodes to be skipped.  In that case, the listed nodes and their
 contents will be skipped.
@@ -843,13 +848,20 @@ secondary properties.
 When optional argument NO-SECONDARY is non-nil, do not recurse into
 secondary strings.
 
+When optional argument NO-UNDEFER is non-nil, do not resolve deferred
+values.
+
 FUN may also throw `:org-element-skip' signal.  Then,
 `org-element-ast-map' will not recurse into the current node.
 
 Nil values returned from FUN do not appear in the results."
   (declare (indent 2))
   ;; Ensure TYPES and NO-RECURSION are a list, even of one node.
-  (let* ((types (if (listp types) types (list types)))
+  (when types
+    (let* ((types (pcase types
+                    ((pred listp) types)
+                    (`t t)
+                    (_ (list types))))
 	   (no-recursion (if (listp no-recursion) no-recursion
 			   (list no-recursion)))
 	   --acc)
@@ -857,20 +869,22 @@ Nil values returned from FUN do not appear in the results."
 	        (lambda (--data)
 		  ;; Recursively walk DATA.  INFO, if non-nil, is a plist
 		  ;; holding contextual information.
-		(let ((--type (org-element-type --data))
+		  (let ((--type (org-element-type --data t))
                         recurse)
 		    (cond
 		     ((not --data))
+                     ((not --type))
 		     ;; Ignored node in an export context.
 		     ((and ignore (memq --data ignore)))
 		     ;; List of elements or objects.
-		   ((not --type) (mapc --walk-tree --data))
+		     ((eq --type 'anonymous)
+                      (mapc --walk-tree (org-element-contents --data)))
 		     (t
 		      ;; Check if TYPE is matching among TYPES.  If so,
 		      ;; apply FUN to --DATA and accumulate return value
 		      ;; into --ACC (or exit if FIRST-MATCH is non-nil).
                       (setq recurse t)
-		    (when (memq --type types)
+		      (when (or (eq types t) (memq --type types))
 		        (let ((result
                                (catch :org-element-skip
                                  (setq recurse nil)
@@ -889,15 +903,23 @@ Nil values returned from FUN do not appear in the results."
 		       (t
 		        (when with-properties
 		          (dolist (p with-properties)
-                          (funcall --walk-tree (org-element-property p --data))))
+                            (funcall
+                             --walk-tree
+                             (if no-undefer
+                                 (org-element-property-1 p --data)
+                               (org-element-property p --data)))))
                         (unless no-secondary
 		          (dolist (p (org-element-property :secondary --data))
-			  (funcall --walk-tree (org-element-property p --data))))
+			    (funcall
+                             --walk-tree
+                             (if no-undefer
+                                 (org-element-property-1 p --data)
+                               (org-element-property p --data)))))
                         (mapc --walk-tree (org-element-contents --data))))))))))
         (catch :--map-first-match
 	  (funcall --walk-tree data)
 	  ;; Return value in a proper order.
-	(nreverse --acc)))))
+	  (nreverse --acc))))))
 
 (defun org-element-create (type &optional props &rest children)
   "Create a new syntax node of TYPE.

lisp/org-element.el

@@ -4568,7 +4568,10 @@ If STRING is the empty string or nil, return nil."
           rtn)))))
 
 (defun org-element-map
-    (data types fun &optional info first-match no-recursion with-affiliated)
+    ( data types fun
+      &optional
+      info first-match no-recursion
+      with-affiliated no-undefer)
   "Map a function on selected elements or objects.
 
 DATA is a parse tree (for example, returned by
@@ -4579,6 +4582,8 @@ elements or object types (see `org-element-all-elements' and
 function called on the matching element or object.  It has to accept
 one argument: the element or object itself.
 
+When TYPES is t, call FUN for all the elements and objects.
+
 When optional argument INFO is non-nil, it should be a plist
 holding export options.  In that case, elements of the parse tree
 \\(compared with `eq') not exportable according to `:ignore-list'
@@ -4596,6 +4601,9 @@ When optional argument WITH-AFFILIATED is non-nil, FUN will also
 apply to matching objects within parsed affiliated keywords (see
 `org-element-parsed-keywords').
 
+When optional argument NO-UNDEFER is non-nil, do not resolve deferred
+values.
+
 FUN may throw `:org-element-skip' signal.  Then, `org-element-map'
 will not recurse into the current element.
 
@@ -4641,11 +4649,13 @@ looking into captions:
    nil nil nil t)"
   (declare (indent 2))
   ;; Ensure TYPES and NO-RECURSION are a list, even of one element.
-  (let* ((types (if (listp types) types (list types)))
+  (when (and types data)
-         (ignore-list (plist-get info :ignore-list))
+    (let* ((ignore-list (plist-get info :ignore-list))
 	   (objects?
+            (or (eq types t)
                 (cl-intersection
-           (cons 'plain-text org-element-all-objects) types))
+                 (cons 'plain-text org-element-all-objects)
+                 (if (listp types) types (list types)))))
            (no-recursion
             (append
              (if (listp no-recursion) no-recursion
@@ -4666,7 +4676,8 @@ looking into captions:
           (when (and with-affiliated objects?)
             (mapcar #'cdr org-element--parsed-properties-alist))
           ;; Secondary strings may only contain objects.
-        (not objects?))))
+          (not objects?)
+          no-undefer))))
 
 ;; The following functions are internal parts of the parser.
 ;;