dsh-ptc-plus 0.2.4 → 0.3.2

package/internal/cell-analysis.js

@@ -5,6 +5,11 @@ import {
   STRIP_SUFFIX,
   rewriteModuleImportsExports,
 } from './cell-rewriter.js'
+import {
+  LEGACY_DEFAULT_EXPORT_BINDING,
+  LIVE_DEFAULT_EXPORT_BINDING,
+  redeclarationCommitTarget,
+} from './repl-rewrite-contract.js'
 import {
   bindingNodes,
   createGeneratedNameAllocator,
@@ -17,7 +22,7 @@ import {
   renderDurabilityReason,
   renderDurabilityReasons,
 } from './module-policy.js'
-import { rewriteLooseRedeclarations } from './repl-convenience.js'
+import { rewriteReplRedeclarations } from './repl-convenience.js'
 import { applySourceEdits, mapSourceSpan } from './source-position-map.js'
 import { SKIP_AST_CHILDREN, walkAst } from './ast-traversal.js'
 
@@ -50,10 +55,13 @@ function addPatternBindings(pattern, names) {
   walkPattern(pattern, node => names.add(node.name))
 }
 
-function addPatternDeclarations(pattern, declarations) {
+function addPatternDeclarations(pattern, declarations, kind = 'variable', definitionSpan = undefined, writable = false) {
   bindingNodes(pattern).forEach(node => declarations.push({
     name: node.name,
+    kind,
     span: declarationSpan(node),
+    definitionSpan,
+    writable,
   }))
 }
 
@@ -61,16 +69,29 @@ function topLevelBindings(body) {
   return new Set(topLevelDeclarations(body).map(declaration => declaration.name))
 }
 
-function topLevelDeclarations(body) {
+function topLevelDeclarations(body, variableRedeclarations = false) {
   const declarations = []
   for (const statement of body) {
     if (statement.type === 'VariableDeclaration') {
-      for (const declaration of statement.declarations) addPatternDeclarations(declaration.id, declarations)
+      const definitionSpan = declarationSpan(statement)
+      for (const declaration of statement.declarations) {
+        addPatternDeclarations(
+          declaration.id,
+          declarations,
+          'variable',
+          definitionSpan,
+          statement.kind !== 'const' || variableRedeclarations,
+        )
+      }
     } else if ((statement.type === 'FunctionDeclaration' || statement.type === 'ClassDeclaration')
       && statement.id !== null) {
       declarations.push({
         name: statement.id.name,
+        kind: statement.type === 'ClassDeclaration' ? 'class' : 'function',
         span: declarationSpan(statement.id),
+        definitionSpan: declarationSpan(statement),
+        commitDependency: redeclarationCommitTarget(statement.id.name, statement.start),
+        writable: true,
       })
     }
   }
@@ -322,14 +343,31 @@ function rewriteCellReturns(code, sourceMap, unavailableNames) {
   return { ...applySourceEdits(code, sourceMap, edits), returnSignal }
 }
 
-export function prepareProgram(program, knownBindings, looseTopLevelRedeclarations, reservedBindings = new Set(), rewritesEnabled, importBindings = new Map(), importNamespaces = new Set()) {
+export function prepareProgram(program, knownBindings, bindingPolicy, reservedBindings = new Set(), rewritesEnabled, importBindings = new Map(), importNamespaces = new Set(), writableBindings = undefined, moduleSemantics = { defaultExportBinding: LIVE_DEFAULT_EXPORT_BINDING }) {
   if (typeof program !== 'string') throw new TypeError('ptc-plus: program must be a string')
+  if (typeof bindingPolicy === 'boolean') {
+    bindingPolicy = {
+      variableRedeclarations: bindingPolicy,
+      functionClassRedeclarations: false,
+    }
+  }
+  if (bindingPolicy === null || typeof bindingPolicy !== 'object' || Array.isArray(bindingPolicy)
+    || typeof bindingPolicy.variableRedeclarations !== 'boolean'
+    || typeof bindingPolicy.functionClassRedeclarations !== 'boolean') {
+    throw new TypeError('ptc-plus: binding policy must define variableRedeclarations and functionClassRedeclarations booleans')
+  }
+  writableBindings ??= bindingPolicy.variableRedeclarations ? new Set(knownBindings) : new Set()
   if (rewritesEnabled === null || typeof rewritesEnabled !== 'object' || Array.isArray(rewritesEnabled)
     || typeof rewritesEnabled.autoRewriteImports !== 'boolean'
     || typeof rewritesEnabled.autoStripExports !== 'boolean'
     || typeof rewritesEnabled.autoSplitRedeclarations !== 'boolean') {
     throw new TypeError('ptc-plus: rewrite policy must define autoRewriteImports, autoStripExports, and autoSplitRedeclarations booleans')
   }
+  if (moduleSemantics === null || typeof moduleSemantics !== 'object' || Array.isArray(moduleSemantics)
+    || ![LEGACY_DEFAULT_EXPORT_BINDING, LIVE_DEFAULT_EXPORT_BINDING]
+      .includes(moduleSemantics.defaultExportBinding)) {
+    throw new TypeError('ptc-plus: module semantics must define a supported defaultExportBinding')
+  }
   const unavailableGeneratedNames = new Set([
     ...knownBindings,
     ...reservedBindings,
@@ -342,6 +380,7 @@ export function prepareProgram(program, knownBindings, looseTopLevelRedeclaratio
     importBindings,
     importNamespaces,
     unavailableGeneratedNames,
+    moduleSemantics,
   )
   const staticModuleReasons = staticModuleClassification(moduleRewrite.moduleLoads)
   const wrapped = STRIP_PREFIX + moduleRewrite.code + STRIP_SUFFIX
@@ -360,8 +399,11 @@ export function prepareProgram(program, knownBindings, looseTopLevelRedeclaratio
   const code = stripped.slice(STRIP_PREFIX.length, stripped.length - STRIP_SUFFIX.length)
   const sourceMap = moduleRewrite.sourceMap
   const outer = tree.body[0]
+  const commitSignal = moduleRewrite.commitSignal
   /* c8 ignore next */
-  const generatedDeclarations = outer?.type === 'FunctionDeclaration' ? topLevelDeclarations(outer.body.body) : []
+  const generatedDeclarations = outer?.type === 'FunctionDeclaration'
+    ? topLevelDeclarations(outer.body.body, bindingPolicy.variableRedeclarations)
+    : []
   const collisionFor = (declaration) => {
     /* c8 ignore next */
     const mapped = declaration.original === true ? declaration.span : declaration.span === undefined
@@ -369,6 +411,12 @@ export function prepareProgram(program, knownBindings, looseTopLevelRedeclaratio
       : mapSourceSpan(declaration.span, code, program, sourceMap)
     return {
       name: declaration.name,
+      kind: declaration.kind,
+      replaceableByVariableDeclaration: declaration.replaceableByVariableDeclaration === true,
+      ...(declaration.reason === undefined ? {} : { reason: declaration.reason }),
+      ...(declaration.commitDependency === undefined
+        ? {}
+        : { commitDependency: declaration.commitDependency }),
       start: { line: mapped.line, column: mapped.column },
       /* c8 ignore next */
       ...(mapped.end === undefined ? {} : { end: mapped.end }),
@@ -395,9 +443,22 @@ export function prepareProgram(program, knownBindings, looseTopLevelRedeclaratio
     }
   }
   const importedNames = new Set(moduleRewrite.imports.keys())
+  const originalDeclarationNames = new Set(moduleRewrite.exportDeclarations.map(declaration => declaration.name))
   const declarations = [
-    ...moduleRewrite.importDeclarations,
-    ...generatedDeclarations.filter(declaration => !moduleRewrite.generatedNamespaces.has(declaration.name)),
+    ...moduleRewrite.importDeclarations.map(declaration => ({ ...declaration, writable: false })),
+    ...moduleRewrite.exportDeclarations.map(declaration => ({
+      ...declaration,
+      writable: bindingPolicy.variableRedeclarations,
+    })),
+    ...generatedDeclarations
+      .filter(declaration => !moduleRewrite.generatedNamespaces.has(declaration.name)
+        && !originalDeclarationNames.has(declaration.name))
+      .map(declaration => ({
+        ...declaration,
+        ...(declaration.definitionSpan === undefined ? {} : {
+          definitionSpan: mapSourceSpan(declaration.definitionSpan, code, program, sourceMap),
+        }),
+      })),
   ]
   const normalizeClassification = classification => {
     const imports = new Map(moduleRewrite.imports)
@@ -411,7 +472,9 @@ export function prepareProgram(program, knownBindings, looseTopLevelRedeclaratio
     }
   }
   const reserved = declarations.filter(declaration => (
-    reservedBindings.has(declaration.name) || moduleRewrite.importNamespaces.has(declaration.name)
+    reservedBindings.has(declaration.name)
+    || moduleRewrite.importNamespaces.has(declaration.name)
+    || (declaration.kind === 'import' && knownBindings.has(declaration.name))
   ))
   if (reserved.length > 0) {
     const classification = normalizeClassification(classifyPrepared(code, sourceMap))
@@ -427,18 +490,30 @@ export function prepareProgram(program, knownBindings, looseTopLevelRedeclaratio
       moduleLoads: moduleRewrite.moduleLoads,
     }
   }
-  const convenience = rewriteLooseRedeclarations({
+  const convenience = rewriteReplRedeclarations({
     code,
     sourceMap,
-    body: looseTopLevelRedeclarations && outer?.type === 'FunctionDeclaration' ? outer.body.body : undefined,
+    body: outer?.type === 'FunctionDeclaration' ? outer.body.body : undefined,
     offset: STRIP_PREFIX.length,
-    knownBindings: new Set([...knownBindings].filter(name => !importBindings.has(name))),
+    knownBindings,
+    variableRedeclarationBindings: bindingPolicy.variableRedeclarations
+      ? new Set([...knownBindings].filter(name => !importBindings.has(name)))
+      : new Set(knownBindings),
+    writableBindings: new Set([...writableBindings].filter(name => !importBindings.has(name))),
     declarations,
     declarationSpan,
     collisionFor,
+    bindingPolicy,
     autoSplitRedeclarations: rewritesEnabled.autoSplitRedeclarations,
+    commitSignal,
   })
   const { executableCode, executableSourceMap, collisions, redeclared, rewrites } = convenience
+  const commitTargets = new Set(moduleRewrite.commitTargets)
+  for (const declaration of redeclared) {
+    if (declaration.kind === 'function' || declaration.kind === 'class') {
+      commitTargets.add(declaration.commitDependency)
+    }
+  }
   // Classification sees the rewritten program so declared bindings reflect the
   // split form; it must never see the return rewrite, whose computed
   // globalThis access would mark every returning cell volatile.
@@ -463,5 +538,7 @@ export function prepareProgram(program, knownBindings, looseTopLevelRedeclaratio
     redeclared,
     rewrites: [...moduleRewrite.rewrites, ...rewrites],
     moduleLoads: moduleRewrite.moduleLoads,
+    commitSignal,
+    commitTargets,
   }
 }

package/internal/cell-rewriter.js

@@ -3,6 +3,10 @@ import { parse } from '@babel/parser'
 import traverseModule, { Hub, NodePath } from '@babel/traverse'
 import { bindingNodes, createGeneratedNameAllocator } from './binding-pattern.js'
 import { applySourceEdits, createMappedTextBuilder, identitySourceMap } from './source-position-map.js'
+import {
+  LEGACY_DEFAULT_EXPORT_BINDING,
+  LIVE_DEFAULT_EXPORT_BINDING,
+} from './repl-rewrite-contract.js'
 
 export const STRIP_PREFIX = 'async function __ptc_cell__(){\n'
 export const STRIP_SUFFIX = '\n}'
@@ -183,6 +187,7 @@ function importEdits(
     if (imported !== undefined && !requiredExports.includes(imported)) requiredExports.push(imported)
     importDeclarations.push({
       name: localName(specifier),
+      kind: 'import',
       span: {
         line: specifier.local.loc.start.line,
         column: specifier.local.loc.start.column + 1,
@@ -191,6 +196,14 @@ function importEdits(
           column: specifier.local.loc.end.column + 1,
         },
       },
+      definitionSpan: {
+        line: node.loc.start.line,
+        column: node.loc.start.column + 1,
+        end: {
+          line: node.loc.end.line,
+          column: node.loc.end.column + 1,
+        },
+      },
       original: true,
     })
   }
@@ -420,7 +433,96 @@ function exportAllEdits(node, code, edits, rewrites, moduleLoads) {
   rewrites.push(record('export', `converted the re-export of ${JSON.stringify(source)} into a side-effect import`, node, source))
 }
 
-function exportDefaultEdits(node, code, edits, rewrites, defaultNameAvailable) {
+function exportDefaultEdits({
+  node,
+  code,
+  edits,
+  rewrites,
+  defaultNameAvailable,
+  exportDeclarations,
+  imports,
+  allocateNamespace,
+  commitSignal,
+  commitTargets,
+}) {
+  const declaration = node.declaration
+  if (declaration.type === 'TSInterfaceDeclaration') {
+    editNode(edits, node, code)
+    rewrites.push(record('export', 'removed a type-only export declaration', node, 'interface'))
+    return
+  }
+  if (!defaultNameAvailable) {
+    throw new ModuleRewriteError(
+      'export default cannot be exposed as __default because that name is already declared',
+      { line: node.loc.start.line, column: node.loc.start.column + 1 },
+    )
+  }
+  const namedDeclaration = (declaration.type === 'FunctionDeclaration'
+    || declaration.type === 'ClassDeclaration') && declaration.id !== null
+  const retainedNamedDeclaration = namedDeclaration && declaration.id.name !== '__default'
+  const existingAlias = imports.get('__default')
+  const reuseAlias = existingAlias?.syntheticDefault === true
+  const namespace = reuseAlias ? existingAlias.namespace : allocateNamespace('default_namespace')
+  const member = importMember(namespace, 'default')
+  imports.set('__default', {
+    namespace,
+    imported: 'default',
+    syntheticDefault: true,
+    commitDependency: '__default',
+  })
+  commitTargets.add('__default')
+  if (declaration.type === 'ClassDeclaration' && declaration.id !== null) {
+    commitTargets.add(declaration.id.name)
+  }
+  exportDeclarations.push({
+    name: '__default',
+    kind: declaration.type === 'FunctionDeclaration'
+      ? 'function'
+      : declaration.type === 'ClassDeclaration' ? 'class' : 'variable',
+    commitDependency: '__default',
+    span: {
+      line: node.loc.start.line,
+      column: node.loc.start.column + 1,
+      end: {
+        line: node.loc.end.line,
+        column: node.loc.end.column + 1,
+      },
+    },
+    definitionSpan: {
+      line: node.loc.start.line,
+      column: node.loc.start.column + 1,
+      end: {
+        line: node.loc.end.line,
+        column: node.loc.end.column + 1,
+      },
+    },
+    original: true,
+  })
+  const rewrite = record('export', 'converted the default export into a local __default binding', node)
+  const commit = [...new Set([...(declaration.type === 'ClassDeclaration' && declaration.id !== null
+    ? [declaration.id.name]
+    : []), '__default'])]
+    .map(name => ` this[${JSON.stringify(commitSignal)}](${JSON.stringify(name)});`)
+    .join('')
+  const assignmentPrefix = reuseAlias ? `${member} = ` : `const ${namespace} = { default: `
+  const assignmentSuffix = reuseAlias ? '' : ' }'
+  if (retainedNamedDeclaration) {
+    edit(edits, node.start, declaration.start, preserveLines(code.slice(node.start, declaration.start)))
+    edit(edits, node.end, node.end,
+      `; ${assignmentPrefix}${declaration.id.name}${assignmentSuffix};${commit}`)
+  } else if (declaration.type === 'FunctionDeclaration' || declaration.type === 'ClassDeclaration') {
+    const prefix = code.slice(node.start, declaration.start)
+    edit(edits, node.start, declaration.start, preserveLines(prefix, assignmentPrefix))
+    edit(edits, node.end, node.end, `${assignmentSuffix};${commit}`)
+  } else {
+    const prefix = code.slice(node.start, declaration.start)
+    edit(edits, node.start, declaration.start, preserveLines(prefix, assignmentPrefix))
+    edit(edits, node.end, node.end, `${assignmentSuffix};${commit}`)
+  }
+  rewrites.push(rewrite)
+}
+
+function legacyExportDefaultEdits(node, code, edits, rewrites, defaultNameAvailable, exportDeclarations) {
   const declaration = node.declaration
   if (declaration.type === 'TSInterfaceDeclaration') {
     editNode(edits, node, code)
@@ -438,6 +540,29 @@ function exportDefaultEdits(node, code, edits, rewrites, defaultNameAvailable) {
       { line: node.loc.start.line, column: node.loc.start.column + 1 },
     )
   }
+  exportDeclarations.push({
+    name: '__default',
+    kind: declaration.type === 'FunctionDeclaration'
+      ? 'function'
+      : declaration.type === 'ClassDeclaration' ? 'class' : 'variable',
+    span: {
+      line: node.loc.start.line,
+      column: node.loc.start.column + 1,
+      end: {
+        line: node.loc.end.line,
+        column: node.loc.end.column + 1,
+      },
+    },
+    definitionSpan: {
+      line: node.loc.start.line,
+      column: node.loc.start.column + 1,
+      end: {
+        line: node.loc.end.line,
+        column: node.loc.end.column + 1,
+      },
+    },
+    original: true,
+  })
   const rewrite = record('export', 'converted the default export into a local __default binding', node)
   if (declaration.type === 'FunctionDeclaration' && declaration.id !== null) {
     const prefix = code.slice(node.start, declaration.start)
@@ -458,15 +583,21 @@ function exportDefaultEdits(node, code, edits, rewrites, defaultNameAvailable) {
 
 function ascending(left, right) { return left.at - right.at }
 
-export function rewriteModuleImportsExports(program, enabled, existingImports = new Map(), existingNamespaces = new Set(), unavailableNames = new Set()) {
+export function rewriteModuleImportsExports(program, enabled, existingImports = new Map(), existingNamespaces = new Set(), unavailableNames = new Set(), moduleSemantics = { defaultExportBinding: LIVE_DEFAULT_EXPORT_BINDING }) {
+  if (![LEGACY_DEFAULT_EXPORT_BINDING, LIVE_DEFAULT_EXPORT_BINDING]
+    .includes(moduleSemantics?.defaultExportBinding)) {
+    throw new TypeError('ptc-plus: unsupported default export binding semantics')
+  }
   const tree = parseCell(program)
   const edits = []
   const rewrites = []
   const imports = new Map(existingImports)
   const importDeclarations = []
+  const exportDeclarations = []
   const moduleLoads = []
   const importNamespaces = new Set(existingNamespaces)
   const allocateName = createGeneratedNameAllocator(tree, [...unavailableNames, ...importNamespaces])
+  const commitSignal = allocateName('redeclaration_commit')
   const generatedNamespaces = new Set()
   const allocateImportName = purpose => {
     const name = allocateName(purpose)
@@ -475,7 +606,8 @@ export function rewriteModuleImportsExports(program, enabled, existingImports =
     return name
   }
   const namespaceCaptures = []
-  const defaultNameAvailable = !tree.body.some((node) => {
+  const commitTargets = new Set()
+  const currentCellDefaultNameAvailable = !tree.body.some((node) => {
     const declaration = node.type === 'ExportNamedDeclaration' ? node.declaration : node
     if (declaration?.type === 'VariableDeclaration' && declaration.declare !== true) {
       return declaration.declarations.some(entry => bindingNodes(entry.id).some(binding => binding.name === '__default'))
@@ -487,6 +619,12 @@ export function rewriteModuleImportsExports(program, enabled, existingImports =
       specifier.importKind !== 'type' && specifier.local.name === '__default'
     ))
   })
+  const existingDefault = existingImports.get('__default')
+  const persistentDefaultNameAvailable = !unavailableNames.has('__default')
+    || existingDefault?.syntheticDefault === true
+  const defaultNameAvailable = currentCellDefaultNameAvailable
+    && (moduleSemantics.defaultExportBinding === LEGACY_DEFAULT_EXPORT_BINDING
+      || persistentDefaultNameAvailable)
   for (const node of tree.body) {
     if (node.type === 'ImportDeclaration' && enabled.autoRewriteImports) {
       importEdits(node, program, edits, rewrites, imports, importDeclarations,
@@ -499,7 +637,24 @@ export function rewriteModuleImportsExports(program, enabled, existingImports =
       exportAllEdits(node, program, edits, rewrites, moduleLoads)
     }
     else if (node.type === 'ExportDefaultDeclaration' && enabled.autoStripExports) {
-      exportDefaultEdits(node, program, edits, rewrites, defaultNameAvailable)
+      if (moduleSemantics.defaultExportBinding === LEGACY_DEFAULT_EXPORT_BINDING) {
+        legacyExportDefaultEdits(
+          node, program, edits, rewrites, defaultNameAvailable, exportDeclarations,
+        )
+      } else {
+        exportDefaultEdits({
+          node,
+          code: program,
+          edits,
+          rewrites,
+          defaultNameAvailable,
+          exportDeclarations,
+          imports,
+          allocateNamespace: allocateImportName,
+          commitSignal,
+          commitTargets,
+        })
+      }
     }
   }
   assertNoDynamicImportResolution(tree, imports)
@@ -514,7 +669,10 @@ export function rewriteModuleImportsExports(program, enabled, existingImports =
     importNamespaces,
     generatedNamespaces,
     importDeclarations,
+    exportDeclarations,
     moduleLoads,
+    commitSignal,
+    commitTargets,
     rewrites: rewrites.map(({ at: _at, ...rest }) => rest),
   }
 }