dsh-ptc-plus 0.3.2 → 0.4.2

package/internal/ast-traversal.js

@@ -8,10 +8,13 @@ export function walkAst(node, enter, leave = undefined, context = undefined, par
   const entered = enter(node, parent, parentKey, context)
   if (entered === SKIP_AST_CHILDREN) return
   const childContext = entered === undefined ? context : entered
-  for (const [key, value] of Object.entries(node)) {
+  const keys = Object.keys(node)
+  for (let index = 0; index < keys.length; index++) {
+    const key = keys[index]
     if (AST_METADATA_KEYS.has(key)) continue
+    const value = node[key]
     if (Array.isArray(value)) {
-      for (const child of value) walkAst(child, enter, leave, childContext, node, key)
+      for (let child = 0; child < value.length; child++) walkAst(value[child], enter, leave, childContext, node, key)
     } else {
       walkAst(value, enter, leave, childContext, node, key)
     }

package/internal/async-local-storage-intrinsics.js

@@ -0,0 +1,38 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+const bind = Function.prototype.call.bind(Function.prototype.bind)
+const defineProperty = Object.defineProperty
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+const apply = Reflect.apply
+const nativeGetStore = AsyncLocalStorage.prototype.getStore
+const nativeEnterWith = AsyncLocalStorage.prototype.enterWith
+const nativeRun = AsyncLocalStorage.prototype.run
+const nativeRunDescriptor = getOwnPropertyDescriptor(AsyncLocalStorage.prototype, 'run')
+
+function protect(scope) {
+  defineProperty(scope, 'getStore', { value: bind(nativeGetStore, scope) })
+  defineProperty(scope, 'enterWith', { value: bind(nativeEnterWith, scope) })
+  defineProperty(scope, 'run', { value: bind(nativeRun, scope) })
+  return scope
+}
+
+export function createPrivateAsyncLocalStorage() {
+  return protect(new AsyncLocalStorage())
+}
+
+export function protectNextAsyncLocalStorageRun(invoke) {
+  let scope
+  defineProperty(AsyncLocalStorage.prototype, 'run', {
+    ...nativeRunDescriptor,
+    value: function (...args) {
+      scope ??= protect(this)
+      return apply(nativeRun, this, args)
+    },
+  })
+  try {
+    invoke()
+  } finally {
+    defineProperty(AsyncLocalStorage.prototype, 'run', nativeRunDescriptor)
+  }
+  return scope
+}

package/internal/binding-declaration-contract.js

@@ -0,0 +1,8 @@
+const BINDING_TYPE_NAMESPACE_TOKEN = '__ptcBindingTypes'
+
+export function bindingTypeNamespaceToken(source) {
+  let token = BINDING_TYPE_NAMESPACE_TOKEN
+  let suffix = 0
+  while (source.includes(token)) token = `${BINDING_TYPE_NAMESPACE_TOKEN}_${++suffix}`
+  return token
+}

package/internal/binding-descriptors.js

@@ -86,6 +86,7 @@ export function normalizeBindingDescriptors(bindings) {
     workerDescriptors: Object.freeze(namespaces.map(namespace => Object.freeze({
       global: namespace.global,
       members: namespace.members,
+      ...(reservedNames.has(namespace.global) ? {} : { shadowable: true }),
       ...(namespace.emptyObjectMembers === undefined
         ? {}
         : { emptyObjectMembers: namespace.emptyObjectMembers }),

package/internal/binding-pattern-traversal.js

@@ -0,0 +1,25 @@
+/** Read binding names from Acorn or Babel patterns without compiler dependencies. */
+export function walkBindingPattern(pattern, visit) {
+  if (pattern === null || typeof pattern !== 'object') return
+  if (pattern.type === 'Identifier') {
+    visit(pattern)
+    return
+  }
+  if (pattern.type === 'RestElement') return walkBindingPattern(pattern.argument, visit)
+  if (pattern.type === 'AssignmentPattern') return walkBindingPattern(pattern.left, visit)
+  if (pattern.type === 'ArrayPattern') {
+    for (const element of pattern.elements) walkBindingPattern(element, visit)
+    return
+  }
+  if (pattern.type === 'ObjectPattern') {
+    for (const property of pattern.properties) {
+      walkBindingPattern(property.type === 'RestElement' ? property.argument : property.value, visit)
+    }
+  }
+}
+
+export function bindingNodes(pattern) {
+  const nodes = []
+  walkBindingPattern(pattern, node => nodes.push(node))
+  return nodes
+}

package/internal/binding-pattern.js

@@ -1,51 +1,48 @@
 /** Shared binding-pattern traversal used by cell analysis and REPL policy code. */
+import { types as t } from '@babel/core'
 
-export function walkBindingPattern(pattern, visit) {
-  if (pattern === null || typeof pattern !== 'object') return
-  if (pattern.type === 'Identifier') {
-    visit(pattern)
-    return
-  }
-  if (pattern.type === 'RestElement') return walkBindingPattern(pattern.argument, visit)
-  if (pattern.type === 'AssignmentPattern') return walkBindingPattern(pattern.left, visit)
-  if (pattern.type === 'ArrayPattern') {
-    for (const element of pattern.elements) walkBindingPattern(element, visit)
-    return
-  }
-  if (pattern.type === 'ObjectPattern') {
-    for (const property of pattern.properties) {
-      walkBindingPattern(property.type === 'RestElement' ? property.argument : property.value, visit)
-    }
-  }
-}
+export { walkBindingPattern, bindingNodes } from './binding-pattern-traversal.js'
 
-export function bindingNodes(pattern) {
-  const nodes = []
-  walkBindingPattern(pattern, node => nodes.push(node))
-  return nodes
+/** Recognize an actual assignment target through erased expression syntax. */
+export function isWriteIdentifier(path) {
+  let selected = path
+  while (selected.parentPath?.isObjectProperty() && selected.key === 'value'
+    || selected.parentPath?.isObjectPattern() || selected.parentPath?.isArrayPattern()
+    || selected.parentPath?.isRestElement() && selected.key === 'argument'
+    || selected.parentPath?.isAssignmentPattern() && selected.key === 'left'
+    || selected.parent?.type.startsWith('TS') && selected.key === 'expression'
+    || selected.parentPath?.isParenthesizedExpression() && selected.key === 'expression') selected = selected.parentPath
+  const parent = selected.parentPath
+  return parent?.isAssignmentExpression() && selected.key === 'left'
+    || parent?.isUpdateExpression() && selected.key === 'argument'
+    || (parent?.isForOfStatement() || parent?.isForInStatement()) && selected.key === 'left'
 }
 
 /** Allocate private identifiers outside both source and caller-owned name sets. */
-export function createGeneratedNameAllocator(root, unavailableNames = []) {
+export function createGeneratedNameAllocator(root, unavailableNames = [], { compact = false } = {}) {
   const used = new Set(unavailableNames)
-  const seen = new Set()
   const pending = [root]
   while (pending.length > 0) {
     const value = pending.pop()
-    if (value === null || typeof value !== 'object' || seen.has(value)) continue
-    seen.add(value)
+    if (value === null || typeof value !== 'object') continue
+    if (Array.isArray(value)) {
+      for (const item of value) pending.push(item)
+      continue
+    }
     if (value.type === 'Identifier') used.add(value.name)
-    for (const child of Object.values(value)) {
-      if (Array.isArray(child)) pending.push(...child)
+    for (const key of t.VISITOR_KEYS[value.type] ?? Object.keys(value)) {
+      const child = value[key]
+      if (Array.isArray(child)) for (const item of child) pending.push(item)
       else if (child !== null && typeof child === 'object') pending.push(child)
     }
   }
   const sequences = new Map()
+  let nextCompact = 0
   return (purpose) => {
     let sequence = sequences.get(purpose) ?? 0
     let name
     do {
-      name = `__dsh_ptc_${purpose}_${sequence++}__`
+      name = compact ? `__ptc$${(nextCompact++).toString(36)}` : `__dsh_ptc_${purpose}_${sequence++}__`
     } while (used.has(name))
     sequences.set(purpose, sequence)
     used.add(name)