Enforce autopticity, i.e. a requirement that the structural syntax objects parsed by a macro call are within the lexical scope of a hypothetical binding located at the call site location. Some of the things we defined using define-match-expander-attenuated, define-match-expander-from-match-and-make, and define-imitation-simple-struct were already enforcing autopticity since those utilities have recently been updated to enforce it.

Author: rocketnia

.github/workflows/ci.yml

@@ -28,7 +28,7 @@ jobs:
             racket-catalogs-id: "racksnaps"
             racket-catalogs: |
               https://download.racket-lang.org/releases/8.18/catalog/,
-              https://racksnaps.defn.io/built-snapshots/2025/09/03/catalog/
+              https://racksnaps.defn.io/built-snapshots/2025/09/08/catalog/
     steps:
       - name: Checkout
         uses: actions/checkout@v4

notes/code-sketches/hypertee-macros/hypertee-macro.rkt

@@ -4,7 +4,7 @@
 ;
 ; A framework for macros which take hypersnippet-shaped syntax.
 
-;   Copyright 2018-2019, 2021 The Lathe Authors
+;   Copyright 2018-2019, 2021, 2025 The Lathe Authors
 ;
 ;   Licensed under the Apache License, Version 2.0 (the "License");
 ;   you may not use this file except in compliance with the License.
@@ -21,13 +21,14 @@
 
 (require #/only-in racket/contract/base -> any/c list/c)
 (require #/only-in racket/contract/region define/contract)
-(require #/only-in syntax/parse id syntax-parse)
+(require #/only-in syntax/parse ~not id syntax-parse)
 
 (require #/only-in lathe-comforts dissect expect fn mat w- w-loop)
 (require #/only-in lathe-comforts/list list-foldr list-map)
 (require #/only-in lathe-comforts/maybe
   just maybe? maybe-bind maybe-map nothing)
 (require #/only-in lathe-comforts/struct struct-easy)
+(require #/only-in lathe-comforts/syntax ~autoptic-to)
 (require #/only-in lathe-comforts/trivial trivial)
 
 (require #/only-in punctaffy/hypersnippet/dim
@@ -159,19 +160,31 @@
 (struct-easy (ht-tag-2-prefab key stx-example) #:equal)
 (struct-easy (ht-tag-2-other val) #:equal)
 
-; This recursively converts the given Racket syntax object into an
+; This recursively converts the given Racket syntax object into a
 ; degree-omega hypertee. It performs a kind of macroexpansion on lists
 ; that begin with an identifier with an appropriate
 ; `syntax-local-value` binding. For everything else, it uses
 ; particular data structures in the holes of the result hypertee to
 ; represent the other atoms, proper lists, improper lists, vectors,
 ; and prefab structs it encounters.
 ;
-(define/contract (s-expr-stx->ht-expr stx)
-  (-> syntax? hypertee?)
-  (mat
+(define/contract (s-expr-stx->ht-expr err-dsl-stx stx)
+  (-> syntax? syntax? hypertee?)
+  (w- default
+    (fn
+      ; We return a degree-omega hypertee with trivial contents in its
+      ; degree-0 hole, and with a single degree-1 hole that contains
+      ; `stx` itself (perhaps put in some kind of container so that it
+      ; can be distinguished from degree-1 holes that a user-defined
+      ; syntax introduces for a different reason).
+      (ht-bracs ds (omega) (htb-labeled 1 #/ht-tag-1-s-expr-stx stx) 0
+      #/htb-labeled 0 #/trivial))
+  #/syntax-parse stx #:context err-dsl-stx
+    [{~not #/~autoptic-to err-dsl-stx _} (default)]
+  #/ _
+  #/mat
     (syntax-parse stx
-      [ (op:id arg ...)
+      [ (op:id . args)
         (maybe-bind (syntax-local-maybe #'op) #/fn op
         #/maybe-map (ht-builder-syntax-maybe op) #/fn proc
         #/list op proc)]
@@ -208,10 +221,11 @@
     ; `s-expr-stx->ht-expr` reports that it has broken its own
     ; contract.
     ;
-    (proc op stx)
+    (proc op err-dsl-stx stx)
   #/w- process-list
     (fn elems
-      (list-map elems #/fn elem #/s-expr-stx->ht-expr elem))
+      (list-map elems #/fn elem
+        (s-expr-stx->ht-expr err-dsl-stx elem)))
   ; NOTE: We go to some trouble to detect improper lists here. This is
   ; so we can preserve the metadata of syntax objects occurring in
   ; tail positions partway through the list, which we would lose track
@@ -250,7 +264,7 @@
     ; Usually it'll be wrapped up as an atom. However, it could still
     ; be expanded as a identifier syntax or processed as a vector or
     ; as a prefab struct.
-    #/w- tail (s-expr-stx->ht-expr tail)
+    #/w- tail (s-expr-stx->ht-expr err-dsl-stx tail)
       ; This is like the proper list case, but this time the metadata
       ; represents an improper list operation (`list*`) rather than a
       ; proper list operation (`list`).
@@ -271,17 +285,9 @@
         ; metadata represents a vector operation (`vector`) rather
         ; than a proper list operation (`list`).
         (make-list-layer (ht-tag-2-vector stx-example) elems))]
-    
-    [_
-      ; We return a degree-omega hypertee with trivial contents in its
-      ; degree-0 hole, and with a single degree-1 hole that contains
-      ; `stx` itself (perhaps put in some kind of container so that it
-      ; can be distinguished from degree-1 holes that a user-defined
-      ; syntax introduces for a different reason).
-      (ht-bracs ds (omega) (htb-labeled 1 #/ht-tag-1-s-expr-stx stx) 0
-      #/htb-labeled 0 #/trivial)]))
+    [_ (default)]))
 
-; This recursively converts the given Racket syntax object into an
+; This recursively converts the given Racket syntax object into a
 ; degree-omega hypertee just like `s-expr-stx->ht-expr`, but it
 ; expects the outermost layer of the syntax object to be a proper
 ; list, and it does not represent that list in the result, so the
@@ -292,20 +298,20 @@
 ; reminder that ht-expressions aren't quite "expressions" so much as
 ; snippets of expression-like data.
 ;
-(define/contract (splicing-s-expr-stx->ht-expr stx)
-  (-> syntax? hypertee?)
+(define/contract (splicing-s-expr-stx->ht-expr err-dsl-stx stx)
+  (-> syntax? syntax? hypertee?)
   (hypertee-append-zero ds (omega)
   #/list-map (syntax->list stx) #/fn elem
-    (s-expr-stx->ht-expr elem)))
+    (s-expr-stx->ht-expr err-dsl-stx elem)))
 
 
 (struct-easy (simple-ht-builder-syntax impl)
   #:other
   #:property prop:ht-builder-syntax
-  (fn this stx
+  (fn this err-dsl-stx stx
     (expect this (simple-ht-builder-syntax impl)
       (error "Expected this to be a simple-ht-builder-syntax")
-    #/impl stx)))
+    #/impl err-dsl-stx stx)))
 
 (struct-easy
   (syntax-and-ht-builder-syntax syntax-impl ht-builder-syntax-impl)
@@ -320,10 +326,10 @@
     #/syntax-impl stx))
 
   #:property prop:ht-builder-syntax
-  (fn this stx
+  (fn this err-dsl-stx stx
     (expect this
       (syntax-and-ht-builder-syntax
         syntax-impl ht-builder-syntax-impl)
       (error "Expected this to be a syntax-and-ht-builder-syntax")
-    #/ht-builder-syntax-impl stx))
+    #/ht-builder-syntax-impl err-dsl-stx stx))
 )

notes/code-sketches/hypertee-macros/qq.rkt

@@ -6,7 +6,7 @@
 ; sequences which can generalize unquotation and nested
 ; quasiquotation.
 
-;   Copyright 2018-2019, 2021 The Lathe Authors
+;   Copyright 2018-2019, 2021, 2025 The Lathe Authors
 ;
 ;   Licensed under the Apache License, Version 2.0 (the "License");
 ;   you may not use this file except in compliance with the License.
@@ -22,7 +22,10 @@
 
 
 (require #/for-syntax racket/base)
-(require #/for-syntax #/only-in syntax/parse id syntax-parse)
+(require #/for-syntax #/only-in syntax/parse
+  id syntax-parse this-syntax)
+
+(require #/only-in lathe-comforts define-syntax-parse-rule/autoptic)
 
 (provide my-quasiquote)
 
@@ -37,6 +40,7 @@
   (require #/only-in lathe-comforts dissect expect fn mat w-)
   (require #/only-in lathe-comforts/maybe just)
   (require #/only-in lathe-comforts/struct struct-easy)
+  (require #/only-in lathe-comforts/syntax ~autoptic-list)
   (require #/only-in lathe-comforts/trivial trivial)
 
   (require #/only-in "hypertee-macro.rkt"
@@ -77,7 +81,7 @@
     #:equal)
 
   (define (make-op-bracket call-stx)
-    (syntax-parse call-stx #/ (op body)
+    (syntax-parse call-stx #/ {~autoptic-list (op body)}
     #/ht-bracs ds (omega)
       (htb-labeled 2 #/ht-tag-2-list #/datum->syntax call-stx #/list)
       1
@@ -90,7 +94,7 @@
     #/htb-labeled 0 #/trivial))
 
   (define my-quasiquote-uq
-    (simple-ht-builder-syntax #/fn stx
+    (simple-ht-builder-syntax #/fn err-dsl-stx stx
       (syntax-parse stx
         [op:id
           ; If this syntax transformer is used in an identifier
@@ -103,7 +107,7 @@
             (htb-labeled 1 #/ht-tag-1-s-expr-stx stx)
             0
           #/htb-labeled 0 #/trivial)]
-      #/ (op interpolation)
+      #/ {~autoptic-list (op interpolation)}
       #/ht-bracs ds (omega)
         (htb-labeled 1
         #/ht-tag-1-other #/my-quasiquote-tag-1-unmatched-unquote
@@ -113,7 +117,7 @@
       #/htb-labeled 0 #/trivial)))
 
   (define my-quasiquote-qq
-    (simple-ht-builder-syntax #/fn stx
+    (simple-ht-builder-syntax #/fn err-dsl-stx stx
       (syntax-parse stx
         [op:id
           ; If this syntax transformer is used in an identifier
@@ -123,8 +127,8 @@
             (htb-labeled 1 #/ht-tag-1-s-expr-stx stx)
             0
           #/htb-labeled 0 #/trivial)]
-      #/ (op body)
-      #/w- body (s-expr-stx->ht-expr #'body)
+      #/ {~autoptic-list (op body)}
+      #/w- body (s-expr-stx->ht-expr err-dsl-stx #'body)
       ; We make a hypertee with a single degree-2 hole (annotated with
       ; the body of the quasiquotation) and some degree-1 holes
       ; (annotated with the `s-expr-stx->ht-expr` expansions of the
@@ -149,7 +153,7 @@
               closing-bracket interpolation)
             (hypertee-increase-degree-to (omega) hole)
           #/hypertee-done (omega)
-            (s-expr-stx->ht-expr interpolation)
+            (s-expr-stx->ht-expr err-dsl-stx interpolation)
             hole)))))
 
   (define (my-quasiquote-ht-expr->stx ht-expr)
@@ -291,16 +295,18 @@
       stx))
 
   (define (my-quasiquote-begin-fn stx)
-    (syntax-parse stx #/ (_ quotation:expr)
-    #/my-quasiquote-ht-expr->stx #/s-expr-stx->ht-expr #'quotation))
+    (syntax-parse stx #/
+      {~autoptic-list (_ err-dsl-stx quotation:expr)}
+    #/my-quasiquote-ht-expr->stx
+      (s-expr-stx->ht-expr #'err-dsl-stx #'quotation)))
 
 )
 (require #/for-syntax 'part1-private)
 
 
 (define-syntax my-quasiquote-begin my-quasiquote-begin-fn)
 
-(define-syntax (my-quasiquote stx)
-  (syntax-parse stx #/ (_ uq:id (qq:id body))
-    #'(let-syntax ([uq my-quasiquote-uq] [qq my-quasiquote-qq])
-      #/my-quasiquote-begin body)))
+(define-syntax-parse-rule/autoptic (my-quasiquote uq:id (qq:id body))
+  #:with err-dsl-stx this-syntax
+  (let-syntax ([uq my-quasiquote-uq] [qq my-quasiquote-qq])
+  #/my-quasiquote-begin err-dsl-stx body))

punctaffy-doc/scribblings/private/shim.rkt

@@ -25,18 +25,24 @@
 (require #/for-syntax #/only-in syntax/parse syntax-parse)
 
 (require #/for-syntax #/only-in lathe-comforts fn w-)
+(require #/for-syntax #/only-in lathe-comforts/syntax ~autoptic-list)
 
-(require scribble/base)
+(require scribble/manual)
+
+(require #/only-in lathe-comforts define-syntax-parse-rule/autoptic)
 
 
 (provide
   shim-require-various-for-label
-  code-block)
+  lathe-comforts-doc
+  code-block
+  enforces-autopticity
+  constructor-enforces-autopticity)
 
 
 (define-syntax (shim-require-various-for-label stx)
   (syntax-protect
-  #/syntax-parse stx #/ (_)
+  #/syntax-parse stx #/ {~autoptic-list (_)}
   #/w- break (fn id #/datum->syntax stx id)
     #`(require #/for-label
 
@@ -60,12 +66,11 @@
         (only-in #,(break 'syntax/datum) datum with-datum)
         (only-in #,(break 'syntax/parse)
           ~optional prop:pattern-expander ~seq syntax-parse)
-        (only-in #,(break 'syntax/parse/define)
-          define-syntax-parse-rule)
         (only-in #,(break 'syntax/parse/experimental/template)
           define-template-metafunction)
 
-        (only-in #,(break 'lathe-comforts) fn)
+        (only-in #,(break 'lathe-comforts)
+          define-syntax-parse-rule/autoptic fn)
         (only-in #,(break 'lathe-comforts/contract)
           flat-obstinacy obstinacy? obstinacy-contract/c)
         (only-in #,(break 'lathe-comforts/list) list-bind)
@@ -104,5 +109,19 @@
         )))
 
 
-(define-syntax-rule @code-block[args ...]
+(define lathe-comforts-doc
+  '(lib "lathe-comforts/scribblings/lathe-comforts.scrbl"))
+
+
+(define-syntax-parse-rule/autoptic @code-block[args ...]
   @nested[#:style 'code-inset]{@verbatim[args ...]})
+
+(define @enforces-autopticity[]
+  @list{
+    This syntax must be called with @tech[#:doc lathe-comforts-doc]{autopticity}.
+  })
+
+(define @constructor-enforces-autopticity[]
+  @list{
+    The constructor syntax must be called with @tech[#:doc lathe-comforts-doc]{autopticity}.
+  })

punctaffy-doc/scribblings/punctaffy/baseline-hyperbracket.scrbl

@@ -4,7 +4,7 @@
 @;
 @; Baseline hyperbracket notations.
 
-@;   Copyright 2021, 2022 The Lathe Authors
+@;   Copyright 2021, 2022, 2025 The Lathe Authors
 @;
 @;   Licensed under the Apache License, Version 2.0 (the "License");
 @;   you may not use this file except in compliance with the License.
@@ -47,6 +47,8 @@ Whether a certain notation uses Punctaffy's hyperbrackets or not, if it has a st
   This notation is an instance of @racket[taffy-notation-akin-to-^<>d?] at compile time, so a hyperbracket parser which recognizes such syntaxes will be sufficient for parsing it.
 
   For the common case where @racket[degree] is 2, see the shorthand @racket[^<], which has examples in @secref["intro"]. For a rare example of hypothetical code where @racket[degree] would be 3, see @secref["potential-use-case-ellipsis-unsyntax"].
+  
+  @enforces-autopticity[]
 }
 
 @defform[(^>d degree term ...)]{
@@ -57,6 +59,8 @@ Whether a certain notation uses Punctaffy's hyperbrackets or not, if it has a st
   This notation is an instance of @racket[taffy-notation-akin-to-^<>d?] at compile time, so a hyperbracket parser which recognizes such syntaxes will be sufficient for parsing it.
 
   For the common case where @racket[degree] is 1, see the shorthand @racket[^>], which has examples in @secref["intro"]. For a rare example of hypothetical code where @racket[degree] would be 2, see @secref["potential-use-case-ellipsis-unsyntax"].
+  
+  @enforces-autopticity[]
 }
 
 @defform[(^< term ...)]{
@@ -71,6 +75,8 @@ Whether a certain notation uses Punctaffy's hyperbrackets or not, if it has a st
   This notation is an instance of @racket[taffy-notation-akin-to-^<>d?] at compile time, so a hyperbracket parser which recognizes such syntaxes will be sufficient for parsing it.
 
   For examples of how to use @racket[^<] and @racket[^>], see @secref["intro"].
+  
+  @enforces-autopticity[]
 }
 
 @defform[(^> term ...)]{
@@ -85,4 +91,6 @@ Whether a certain notation uses Punctaffy's hyperbrackets or not, if it has a st
   This notation is an instance of @racket[taffy-notation-akin-to-^<>d?] at compile time, so a hyperbracket parser which recognizes such syntaxes will be sufficient for parsing it.
 
   For examples of how to use @racket[^<] and @racket[^>], see @secref["intro"].
+  
+  @enforces-autopticity[]
 }