Create @__FUNCTION__ and Expr(:thisfunction) as generic function self-reference

src/ast.scm

@@ -400,7 +400,7 @@
 
 (define (simple-atom? x)
   (or (number? x) (string? x) (char? x)
-      (and (pair? x) (memq (car x) '(ssavalue null true false thismodule)))
+      (and (pair? x) (memq (car x) '(ssavalue null true false thismodule thisfunction)))
       (eq? (typeof x) 'julia_value)))
 
 ;; identify some expressions that are safe to repeat

src/julia-syntax.scm

@@ -306,11 +306,17 @@
                (map (lambda (x) (replace-vars x renames))
                     (cdr e))))))
 
+;; Check if an expression contains thisfunction
+(define (contains-thisfunction? expr)
+  (cond ((atom? expr) #f)
+        ((not (pair? expr)) #f)
+        ((eq? (car expr) 'thisfunction) #t)
+        (else (or (contains-thisfunction? (car expr))
+                  (and (pair? (cdr expr))
+                       (contains-thisfunction? (cdr expr)))))))
+
 (define (make-generator-function name sp-names arg-names body)
-  (let ((arg-names (append sp-names
-                           (map (lambda (n)
-                                  (if (eq? n '|#self#|) (gensy) n))
-                                arg-names))))
+  (let ((arg-names (append sp-names arg-names)))
     (let ((body (insert-after-meta body  ;; don't specialize on generator arguments
                                    ;; arg-names slots start at 2 (after name)
                                    `((meta nospecialize ,@(map (lambda (idx) `(slot ,(+ idx 2))) (iota (length arg-names))))))))
@@ -552,7 +558,9 @@
           (insert-after-meta `(block
                                ,@stmts)
                              (cons `(meta nkw ,(+ (length vars) (length restkw)))
-                                   annotations))
+                                   (if (and (contains-thisfunction? `(block ,@stmts)) name (not (eq? name #f)))
+                                       (cons `(meta thisfunction-original ,name) annotations)
+                                       annotations)))
           rett)
 
         ;; call with no keyword args
@@ -1209,13 +1217,15 @@
                   (argl       (car argl-stmts))
                   (name       (check-dotop (car argl)))
                   (argname    (if (overlay? name) (caddr name) name))
+                  ;;
                   ;; fill in first (closure) argument
+                  (self-name  (if (nodot-sym-ref? argname) argname (gensy)))
                   (adj-decl (lambda (n) (if (and (decl? n) (length= n 2))
-                                            `(|::| |#self#| ,(cadr n))
+                                            `(|::| ,self-name ,(cadr n))
                                             n)))
                   (farg    (if (decl? argname)
                                (adj-decl argname)
-                               `(|::| |#self#| (call (core Typeof) ,argname))))
+                               `(|::| ,self-name (call (core Typeof) ,argname))))
                   (body       (insert-after-meta body (cdr argl-stmts)))
                   (argl    (cdr argl))
                   (argl    (fix-arglist
@@ -3437,7 +3447,7 @@
               vi)
     tab))
 
-;; env:      list of vinfo (includes any closure #self#; should not include globals)
+;; env:      list of vinfo (should not include globals)
 ;; captvars: list of vinfo
 ;; sp:       list of symbol
 ;; new-sp:   list of symbol (static params declared here)
@@ -3858,7 +3868,7 @@ f(x) = yt(x)
   (Set '(quote top core lineinfo line inert local-def unnecessary copyast
          meta inbounds boundscheck loopinfo decl aliasscope popaliasscope
          thunk with-static-parameters toplevel-only
-         global globalref global-if-global assign-const-if-global isglobal thismodule
+         global globalref global-if-global assign-const-if-global isglobal thismodule thisfunction
          const atomic null true false ssavalue isdefined toplevel module lambda
          error gc_preserve_begin gc_preserve_end export public inline noinline purity)))
 
@@ -4096,7 +4106,7 @@ f(x) = yt(x)
        ((atom? e) e)
        (else
         (case (car e)
-          ((quote top core global globalref thismodule lineinfo line break inert module toplevel null true false meta) e)
+          ((quote top core global globalref thismodule thisfunction lineinfo line break inert module toplevel null true false meta) e)
           ((toplevel-only)
            ;; hack to avoid generating a (method x) expr for struct types
            (if (eq? (cadr e) 'struct)
@@ -5136,6 +5146,43 @@ f(x) = yt(x)
 
             ((error)
              (error (cadr e)))
+
+            ;; thisfunction replaced with first argument name
+            ((thisfunction)
+             (let ((first-arg (and (pair? (lam:args lam)) (car (lam:args lam)))))
+               (if first-arg
+                   (let* ((arg-name (arg-name first-arg))
+                          ;; Check for struct constructor by looking for |#ctor-self#| in args
+                          (ctor-self-arg (let ((args (lam:args lam)))
+                                          (and (pair? args)
+                                               (let loop ((rest args))
+                                                 (cond ((null? rest) #f)
+                                                       ((eq? (car rest) '|#ctor-self#|) '|#ctor-self#|)
+                                                       (else (loop (cdr rest))))))))
+                          ;; Check for thisfunction-original metadata in keyword wrapper functions
+                          (original-name (let ((body (lam:body lam)))
+                                          (and (pair? body) (pair? (cdr body))
+                                               (let loop ((stmts (cdr body)))
+                                                 (if (pair? stmts)
+                                                     (let ((stmt (car stmts)))
+                                                       (if (and (pair? stmt) (eq? (car stmt) 'meta)
+                                                                (pair? (cdr stmt)) (eq? (cadr stmt) 'thisfunction-original)
+                                                                (pair? (cddr stmt)))
+                                                           (caddr stmt)
+                                                           (loop (cdr stmts))))
+                                                     #f)))))
+                          (final-name (cond (original-name original-name)
+                                            (ctor-self-arg ctor-self-arg)
+                                            (else arg-name))))
+                     (let ((e1 (if (and arg-map (symbol? final-name))
+                                   (get arg-map final-name final-name)
+                                   final-name)))
+                       (cond (tail  (emit-return tail e1))
+                             (value e1)
+                             ((symbol? e1) (emit e1) #f)
+                             (else (emit e1) #f))))
+                   (error "thisfunction used in context with no arguments"))))
+
             (else
              (error (string "invalid syntax " (deparse e)))))))
     ;; introduce new slots for assigned arguments

test/syntax.jl

@@ -4351,3 +4351,40 @@ let f = NoSpecClosure.K(1)
     @test f(2) == 1
     @test typeof(f).parameters == Core.svec()
 end
+
+# Expr(:thisfunction)
+# regular functions can use Expr(:thisfunction) to refer to the function itself
+@eval regular_func() = $(Expr(:thisfunction))
+@test regular_func() === regular_func
+
+# This also works in callable structs, which refers to the instance
+struct CallableStruct
+    value::Int
+end
+@eval (obj::CallableStruct)() = $(Expr(:thisfunction))
+@eval (obj::CallableStruct)(x) = $(Expr(:thisfunction)).value + x
+
+let cs = CallableStruct(42)
+    @test cs() === cs
+    @test cs(10) === 52
+end
+
+struct RecursiveCallableStruct; end
+@eval (::RecursiveCallableStruct)(n) = n <= 1 ? n : $(Expr(:thisfunction))(n-1) + $(Expr(:thisfunction))(n-2)
+
+@test RecursiveCallableStruct()(10) === 55
+
+# In closures, var"#self#" should refer to the enclosing function,
+# NOT the enclosing struct instance
+struct CallableStruct2; end
+@eval function (obj::CallableStruct2)()
+    function inner_func()
+        $(Expr(:thisfunction))
+    end
+    inner_func
+end
+
+let cs = CallableStruct2()
+    @test cs()() === cs()
+    @test cs()() !== cs
+end