dsh-ptc-plus 0.3.2 → 0.4.2

package/internal/legacy-repl-convenience.js

@@ -0,0 +1,291 @@
+/** Historical legacy-v1 lowering, retained from c51616c8d6c8:repl-convenience.js. */
+import { bindingNodes, createGeneratedNameAllocator } from './binding-pattern.js'
+import {
+  CLASS_REDECLARATION_REWRITE,
+  FUNCTION_REDECLARATION_REWRITE,
+  MIXED_REDECLARATION_REWRITE,
+  redeclarationCommitTarget,
+} from './repl-rewrite-contract.js'
+import { applySourceEdits, createMappedTextBuilder, identitySourceMap } from './source-position-map.js'
+import { SKIP_AST_CHILDREN, walkAst } from './ast-traversal.js'
+
+/**
+ * Optional compatibility policy for a persistent REPL. The cell language does
+ * not own this policy: callers may replace it when persistence uses separate
+ * lexical frames instead of one shared REPL environment.
+ */
+
+function containsTopLevelAwait(node) {
+  let found = false
+  walkAst(node, current => {
+    if (current.type === 'AwaitExpression') found = true
+    if (current.type === 'FunctionDeclaration' || current.type === 'FunctionExpression'
+      || current.type === 'ArrowFunctionExpression') return SKIP_AST_CHILDREN
+  })
+  return found
+}
+
+function mixedDeclaratorText(statement, declarator, bindings, code, allocateName) {
+  const fresh = bindings.filter(binding => !binding.existing)
+  const existing = bindings.filter(binding => binding.existing)
+  const valueName = allocateName('mixed_value')
+  const commitName = allocateName('mixed_commit')
+  const valuesName = allocateName('mixed_values')
+  const positions = new Map(bindings.map((binding, index) => [binding.name, index]))
+  const asynchronous = containsTopLevelAwait(declarator.id)
+  const builder = createMappedTextBuilder(code)
+  const appendBindingName = binding => builder.appendMapped(binding.name, binding.start, binding.end)
+  builder.append(statement.kind === 'var' ? 'var [' : 'let [')
+  fresh.forEach((binding, index) => {
+    if (index > 0) builder.append(', ')
+    appendBindingName(binding)
+  })
+  builder.append(`] = ${asynchronous ? 'await ' : ''}(`)
+  builder.append(`(${asynchronous ? 'async ' : ''}(${valueName}, ${commitName}) => { ${statement.kind} `)
+  builder.appendSource(declarator.id.start, declarator.id.end)
+  builder.append(` = ${valueName}; return ${commitName}([`)
+  bindings.forEach((binding, index) => {
+    if (index > 0) builder.append(', ')
+    appendBindingName(binding)
+  })
+  builder.append(`]); })((`)
+  if (declarator.init === null) builder.append('undefined')
+  else builder.appendSource(declarator.init.start, declarator.init.end)
+  builder.append(`), (${valuesName}) => { `)
+  existing.forEach((binding, index) => {
+    if (index > 0) builder.append(' ')
+    appendBindingName(binding)
+    builder.append(` = ${valuesName}[${positions.get(binding.name)}];`)
+  })
+  builder.append(' return [')
+  fresh.forEach((binding, index) => {
+    if (index > 0) builder.append(', ')
+    builder.append(valuesName)
+    builder.append(`[${positions.get(binding.name)}]`)
+  })
+  builder.append(']; }) );')
+  return builder.result()
+}
+
+function existingDeclaratorText(declarator, code) {
+  const builder = createMappedTextBuilder(code)
+  builder.append(';(')
+  builder.appendSource(declarator.id.start, declarator.id.end)
+  builder.append(' = ')
+  if (declarator.init === null) builder.append('undefined')
+  else builder.appendSource(declarator.init.start, declarator.init.end)
+  builder.append(');')
+  return builder.result()
+}
+
+function freshDeclaratorText(statement, declarator, code) {
+  const builder = createMappedTextBuilder(code)
+  builder.append(statement.kind === 'var' ? 'var ' : 'let ')
+  builder.appendSource(declarator.start, declarator.end)
+  builder.append(';')
+  return builder.result()
+}
+
+function bindingEntries(pattern, declarationSpan) {
+  return bindingNodes(pattern).map(node => ({
+    name: node.name,
+    start: node.start,
+    end: node.end,
+    span: declarationSpan(node),
+  }))
+}
+
+function existingFunctionText(statement, code) {
+  const builder = createMappedTextBuilder(code)
+  builder.append(';(')
+  builder.appendMapped(statement.id.name, statement.id.start, statement.id.end)
+  builder.append(' = ')
+  builder.appendSource(statement.start, statement.id.start)
+  builder.appendSource(statement.id.end, statement.end)
+  builder.append(');')
+  return builder.result()
+}
+
+function existingClassText(statement, code) {
+  const builder = createMappedTextBuilder(code)
+  builder.append(';(')
+  builder.appendMapped(statement.id.name, statement.id.start, statement.id.end)
+  builder.append(' = ')
+  builder.appendSource(statement.start, statement.end)
+  builder.append(');')
+  return builder.result()
+}
+
+export function rewriteReplRedeclarations({
+  code,
+  sourceMap = identitySourceMap(code.length),
+  body,
+  knownBindings,
+  variableRedeclarationBindings = knownBindings,
+  writableBindings,
+  declarations,
+  declarationSpan,
+  collisionFor,
+  bindingPolicy,
+  autoSplitRedeclarations,
+  commitSignal,
+}) {
+  const redeclared = []
+  const rewrites = []
+  if (body === undefined) {
+    return {
+      executableCode: code,
+      executableSourceMap: sourceMap,
+      collisions: declarations.filter(declaration => knownBindings.has(declaration.name)).map(collisionFor),
+      redeclared,
+      rewrites,
+    }
+  }
+  const replacements = []
+  const rejected = []
+  const allocateName = createGeneratedNameAllocator(body)
+  for (const statement of body) {
+    if (statement.type !== 'VariableDeclaration') {
+      if ((statement.type === 'FunctionDeclaration' || statement.type === 'ClassDeclaration')
+        && statement.id !== null && knownBindings.has(statement.id.name)) {
+        const kind = statement.type === 'ClassDeclaration' ? 'class' : 'function'
+        if (!writableBindings.has(statement.id.name)) {
+          rejected.push({
+            name: statement.id.name,
+            kind,
+            reason: 'binding-not-writable',
+            span: declarationSpan(statement.id),
+          })
+        } else if (!bindingPolicy.functionClassRedeclarations) {
+          rejected.push({
+            name: statement.id.name,
+            kind,
+            reason: 'function-class-redeclarations-disabled',
+            span: declarationSpan(statement.id),
+          })
+        } else {
+          const commitDependency = redeclarationCommitTarget(statement.id.name, statement.start)
+          const replacement = kind === 'class'
+            ? existingClassText(statement, code)
+            : existingFunctionText(statement, code)
+          replacement.text += ` void 0; this[${JSON.stringify(commitSignal)}](${JSON.stringify(commitDependency)});`
+          replacements.push({
+            start: statement.start,
+            end: statement.end,
+            text: replacement.text,
+            mappings: replacement.mappings,
+          })
+          redeclared.push(collisionFor({
+            name: statement.id.name,
+            kind,
+            commitDependency,
+            span: declarationSpan(statement.id),
+          }))
+          rewrites.push({
+            kind: 'redeclaration',
+            description: kind === 'class'
+              ? CLASS_REDECLARATION_REWRITE
+              : FUNCTION_REDECLARATION_REWRITE,
+            source: statement.id.name,
+          })
+        }
+      }
+      continue
+    }
+    const entries = []
+    let statementRejected = false
+    for (const declarator of statement.declarations) {
+      const bindings = bindingEntries(declarator.id, declarationSpan)
+      const existing = bindings.filter(binding => variableRedeclarationBindings.has(binding.name))
+      const immutable = existing.filter(binding => !writableBindings.has(binding.name))
+      if (immutable.length > 0) {
+        rejected.push(...immutable.map(binding => ({
+          ...binding,
+          kind: 'variable',
+          reason: 'binding-not-writable',
+        })))
+        statementRejected = true
+        continue
+      }
+      if (existing.length > 0 && !bindingPolicy.variableRedeclarations) {
+        rejected.push(...existing.map(binding => ({
+          ...binding,
+          kind: 'variable',
+          reason: 'variable-redeclarations-disabled',
+        })))
+        statementRejected = true
+        continue
+      }
+      if (existing.length > 0 && existing.length < bindings.length) {
+        if (autoSplitRedeclarations) entries.push({ declarator, bindings, existing })
+        else {
+          rejected.push(...existing.map(binding => ({ ...binding, kind: 'variable',
+            reason: 'redeclaration-splitting-disabled' })))
+          statementRejected = true
+        }
+        continue
+      }
+      entries.push({ declarator, bindings, existing })
+    }
+    if (statementRejected) continue
+    if (!entries.some(entry => entry.existing.length > 0)) {
+      if (statement.kind === 'const' && bindingPolicy.variableRedeclarations) {
+        replacements.push({
+          start: statement.start,
+          end: statement.start + statement.kind.length,
+          text: 'let',
+        })
+      }
+      continue
+    }
+    let replacementText = ''
+    const replacementMappings = []
+    const appendPart = (part) => {
+      if (replacementText.length > 0) replacementText += '\n'
+      const partOffset = replacementText.length
+      replacementText += part.text
+      part.mappings.forEach(mapping => replacementMappings.push({
+        ...mapping,
+        generatedStart: mapping.generatedStart + partOffset,
+        generatedEnd: mapping.generatedEnd + partOffset,
+      }))
+    }
+    for (const { declarator, bindings, existing } of entries) {
+      if (existing.length > 0 && existing.length < bindings.length) {
+        appendPart(mixedDeclaratorText(
+          statement,
+          declarator,
+          bindings.map(binding => ({ ...binding, existing: existing.includes(binding) })),
+          code,
+          allocateName,
+        ))
+        redeclared.push(...existing.map(collisionFor))
+        rewrites.push({
+          kind: 'redeclaration',
+          description: MIXED_REDECLARATION_REWRITE,
+          source: existing.map(binding => binding.name).join(', '),
+        })
+      } else if (existing.length === bindings.length && bindings.length > 0) {
+        redeclared.push(...existing.map(collisionFor))
+        appendPart(existingDeclaratorText(declarator, code))
+      } else {
+        appendPart(freshDeclaratorText(statement, declarator, code))
+      }
+    }
+    replacements.push({
+      start: statement.start,
+      end: statement.end,
+      text: replacementText,
+      mappings: replacementMappings,
+    })
+  }
+  const collisions = rejected.map(collisionFor)
+  let executableCode = code
+  let executableSourceMap = sourceMap
+  if (collisions.length === 0) {
+    const applied = applySourceEdits(code, sourceMap, replacements)
+    executableCode = applied.code
+    executableSourceMap = applied.sourceMap
+  }
+  return { executableCode, executableSourceMap, collisions, redeclared, rewrites }
+}

package/internal/managed-module-operations.js

@@ -0,0 +1,170 @@
+import { commonJsCompilerImport } from './compiler-module-links.js'
+import { parse } from '@babel/parser'
+import traverseModule from '@babel/traverse'
+import { bindingNodes, createGeneratedNameAllocator } from './binding-pattern.js'
+import { applySourceEdits, sourceOffsetAt } from './source-position-map.js'
+import { visitRegionSource, applyRegionEdits } from './compiler-region-output.js'
+import { visitSource } from './compiler-source-regions.js'
+import { CELL_PARSER_PLUGINS, analyzeLogicalScopes } from './repl-scope-normalizer.js'
+import { resolveSourceBinding } from './compiler-scope-facts.js'
+
+const traverse = traverseModule.default ?? traverseModule
+
+/** Every module environment owns imports, including runtime-created source. */
+export function adaptModuleOperations(normalized, { target, url }) {
+  let allocate, insertion, strictCommonJs = false, sourceRequire = false
+  const calls = []
+  visitRegionSource(normalized, { sourceType: target === 'module' ? 'module' : 'commonjs', plugins: CELL_PARSER_PLUGINS }, input => {
+    allocate ??= normalized.sourceRegions?.allocate ?? createGeneratedNameAllocator(input.tree)
+    if (input.region.kind === 'program') {
+      insertion = input.tree.program.directives.at(-1)?.end ?? 0
+      strictCommonJs = target === 'commonjs' && input.tree.program.directives.some(item => item.value.value === 'use strict')
+      sourceRequire = target === 'commonjs' && input.tree.program.body.some(item =>
+        item.type === 'FunctionDeclaration' && item.id.name === 'require')
+    }
+    visitSource(input.tree, { CallExpression(path) {
+      if (path.node.callee.type === 'Import') calls.push({ start: sourceOffsetAt(input.sourceMap, path.node.callee.start),
+        end: sourceOffsetAt(input.sourceMap, path.node.callee.end - 1) + 1 })
+    } })
+  })
+  const runtime = allocate('module_operations')
+  const importer = allocate('module_import')
+  const runtimeUrl = new URL('./stateful-module-runtime.js', import.meta.url)
+  const bootstrap = target === 'commonjs' ? allocate('module_bootstrap') : undefined
+  const originalRequire = strictCommonJs && !sourceRequire ? allocate('wrapper_require') : undefined
+  const parent = target === 'module' ? 'import.meta.url' : url === undefined
+    ? `(typeof __filename === 'string' ? ${runtime}.pathToFileURL(__filename).href : ${JSON.stringify(import.meta.url)})` : JSON.stringify(url)
+  const edits = calls.map(node => ({ start: node.start, end: node.end, text: importer }))
+  const nativeRequire = `typeof __filename === 'string' ? process.getBuiltinModule('module').createRequire(__filename) : ${sourceRequire ? 'arguments[1]' : 'require'}`
+  const loaderSetup = sourceRequire
+    ? strictCommonJs ? `arguments[1]=${runtime}.managedRequire(${parent},${nativeRequire});` : ''
+    : `${originalRequire ? `const ${originalRequire}=require;` : ''}require=${runtime}.managedRequire(${parent},${nativeRequire});`
+      // Sloppy wrappers have mapped arguments. Strict wrappers need their
+      // original host argument adapted once before source observes either path.
+      + (originalRequire ? `if(arguments[1]===${originalRequire})arguments[1]=require;` : '')
+  const setup = target === 'module'
+    ? `import * as ${runtime} from ${JSON.stringify(runtimeUrl.href)};`
+    : `const ${runtime}=${commonJsCompilerImport(runtimeUrl)};const ${bootstrap}=(()=>{${loaderSetup}})();`
+  // Function declarations remain usable during cyclic module instantiation.
+  const operation = `function ${importer}(source,options){return ${runtime}.managedModuleImport(${parent},source,options)}`
+  edits.push({ start: insertion, end: insertion, text: `\n${setup}\n${operation}\n` })
+  return { ...applyRegionEdits(normalized, edits), importOperation: importer,
+    internalBindings: new Set([...normalized.internalBindings ?? [], runtime, importer,
+      ...bootstrap ? [bootstrap] : [], ...originalRequire ? [originalRequire] : []]) }
+}
+
+/** Root compilation supplies the execution-owned operation without globals. */
+export function adaptRootModuleImports(normalized, runtime) {
+  const tree = parse(normalized.code, { sourceType: 'script', allowAwaitOutsideFunction: true,
+    allowReturnOutsideFunction: true, plugins: CELL_PARSER_PLUGINS })
+  const edits = []
+  traverse(tree, { noScope: true, CallExpression(path) {
+    if (path.node.callee.type === 'Import') edits.push({ start: path.node.callee.start,
+      end: path.node.callee.end, text: `${runtime}.importModule` })
+  } })
+  return { ...normalized, ...applySourceEdits(normalized.code, normalized.sourceMap, edits) }
+}
+
+/** Retain the frozen legacy lowering; adapt only its module operation entry. */
+export function adaptLegacyModuleImports(prepared, options) {
+  if (prepared.collisions.length !== 0) return prepared
+  const tree = parse(prepared.code, { sourceType: 'script', allowAwaitOutsideFunction: true,
+    allowReturnOutsideFunction: true, plugins: CELL_PARSER_PLUGINS })
+  const calls = []
+  traverse(tree, { noScope: true, CallExpression(path) {
+    if (path.node.callee.type === 'Import') calls.push(path.node.callee)
+  } })
+  if (calls.length === 0) return prepared
+  const allocate = createGeneratedNameAllocator(tree, [...prepared.importNamespaces,
+    ...options.knownBindings ?? [], ...options.reservedBindings ?? []])
+  const importer = allocate('module_import')
+  const global = allocate('module_import_global')
+  const edits = calls.map(node => ({ start: node.start, end: node.end, text: importer }))
+  const insertion = tree.program.directives.at(-1)?.end ?? tree.program.interpreter?.end ?? 0
+  edits.push({ start: insertion, end: insertion, text: `;\nconst ${importer}=${global};\n` })
+  return { ...prepared, ...applySourceEdits(prepared.code, prepared.sourceMap, edits),
+    importNamespaces: new Set([...prepared.importNamespaces, importer]),
+    moduleLoads: [...prepared.moduleLoads, { operation: 'import', global }] }
+}
+
+/** Legacy module bindings stay native; only reads cross the managed interface. */
+export function adaptLegacyModuleReferences(normalized) {
+  const facts = analyzeLogicalScopes(normalized.code, { target: 'module', compact: true })
+  const { tree, allocate } = facts
+  for (const [node, name] of facts.names) node.name = name
+  const reader = allocate('module_import_read')
+  const imported = new Map()
+  const dynamicBindings = []
+  const accessors = []
+  const exports = []
+  const stars = []
+  const name = node => node.name ?? node.value
+  const relation = node => ({ source: node.source.value, attributes: Object.fromEntries(
+    (node.attributes ?? []).map(item => [name(item.key), item.value.value])) })
+  for (const node of tree.program.body) {
+    if (node.type !== 'ImportDeclaration') continue
+    for (const item of node.specifiers) imported.set(item.local.name, { ...relation(node),
+      imported: item.type === 'ImportNamespaceSpecifier' ? null
+        : item.type === 'ImportDefaultSpecifier' ? 'default' : name(item.imported), local: item.local })
+  }
+  for (const node of tree.program.body) {
+    if (node.type === 'ExportDefaultDeclaration') exports.push({ name: 'default', kind: 'native' })
+    if (node.type === 'ExportAllDeclaration') stars.push(relation(node))
+    if (node.type !== 'ExportNamedDeclaration') continue
+    if (node.declaration != null) {
+      const declaration = node.declaration
+      const names = declaration.type === 'VariableDeclaration'
+        ? declaration.declarations.flatMap(item => bindingNodes(item.id)).map(item => item.name) : [declaration.id.name]
+      exports.push(...names.map(name => ({ name, kind: 'native' })))
+    }
+    for (const item of node.specifiers) {
+      const exported = name(item.exported)
+      const source = node.source == null ? imported.get(name(item.local)) : { ...relation(node),
+        imported: item.type === 'ExportNamespaceSpecifier' ? null : name(item.local) }
+      exports.push(source === undefined ? { name: exported, kind: 'native' }
+        : { name: exported, kind: source.imported === null ? 'namespace' : 'forward',
+          source: source.source, imported: source.imported, attributes: source.attributes })
+    }
+  }
+  const edits = []
+  const sourceFor = path => {
+    const source = imported.get(path.node.name)
+    return source !== undefined && resolveSourceBinding(facts, facts.paths.get(path.node), path.node.name)
+      ?.occurrences.some(item => item.node === source.local) ? source : undefined
+  }
+  const read = (path, source) => `${reader}(import.meta.url,${JSON.stringify(source.source)},${JSON.stringify(source.imported)},()=>${path.node.name},${JSON.stringify(source.attributes)})`
+  const write = path => {
+    const source = sourceFor(path)
+    if (source === undefined) return
+    const value = allocate('module_import_value')
+    // Read-modify-write observes the logical value and its coercion effects,
+    // then delegates the forbidden import write to its native binding.
+    edits.push({ start: path.node.start, end: path.node.end,
+      text: `({get v(){return ${read(path, source)}},set v(${value}){${path.node.name}=${value}}}).v` })
+  }
+  visitSource(tree, {
+    AssignmentExpression(path) { if (path.node.operator !== '=' && path.node.left.type === 'Identifier') write(path.get('left')) },
+    UpdateExpression(path) { if (path.node.argument.type === 'Identifier') write(path.get('argument')) },
+    ReferencedIdentifier(path) {
+      const source = sourceFor(path)
+      if (source === undefined || path.parentPath.isExportSpecifier() || path.parentPath.isUpdateExpression()
+        || (path.parentPath.isForInStatement() || path.parentPath.isForOfStatement()) && path.key === 'left') return
+      const value = `(${read(path, source)})`
+      edits.push({ start: path.node.start, end: path.node.end,
+        text: path.parentPath.isObjectProperty({ shorthand: true }) ? `[${JSON.stringify(path.node.name)}]:${value}` : value })
+    },
+  })
+  const runtime = new URL('./stateful-module-runtime.js', import.meta.url).href
+  for (const [name, source] of imported) {
+    const physicalName = allocate('module_import_cell')
+    const value = allocate('module_import_value')
+    const get = `${reader}(import.meta.url,${JSON.stringify(source.source)},${JSON.stringify(source.imported)},()=>${name},${JSON.stringify(source.attributes)})`
+    accessors.push(`function ${physicalName}(){return {get v(){return ${get}},set v(${value}){${name}=${value}}}}`)
+    dynamicBindings.push({ name, physicalName, kind: 'module', accessor: true, property: 'v' })
+  }
+  edits.push({ start: 0, end: 0,
+    text: `import {readModuleImport as ${reader}} from ${JSON.stringify(runtime)};\n${accessors.join('\n')}\n` })
+  return { ...applyRegionEdits(normalized, edits),
+    moduleInterface: { exports, stars }, dynamicBindings: [...normalized.dynamicBindings ?? [], ...dynamicBindings],
+    internalBindings: new Set([...normalized.internalBindings ?? [], reader, ...imported.keys()]) }
+}