@soundscript/soundscript 0.1.16 → 0.1.17

package/project-transform/src/frontend/macro_expander.ts

@@ -1572,15 +1572,13 @@ export function expandPreparedProgramWithFileRegistries(
   >,
   preserveMissingExpanders = false,
   annotateExpansions = false,
+  sourceFiles = preparedProgram.program.getSourceFiles(),
 ): ReadonlyMap<string, ts.SourceFile> {
-  const collected = collectResolvedMacroPlaceholders(preparedProgram);
+  const nonDeclarationSourceFiles = sourceFiles.filter((sourceFile) => !sourceFile.isDeclarationFile);
+  const collected = collectResolvedMacroPlaceholders(preparedProgram, nonDeclarationSourceFiles);
   const expandedFiles = new Map<string, ts.SourceFile>();
 
-  for (const sourceFile of preparedProgram.program.getSourceFiles()) {
-    if (sourceFile.isDeclarationFile) {
-      continue;
-    }
-
+  for (const sourceFile of nonDeclarationSourceFiles) {
     const fileRegistries = registriesByFile.get(sourceFile.fileName);
     const advancedRegistry = fileRegistries?.advancedRegistry ?? new Map();
     const registry = fileRegistries?.registry ?? new Map();

package/project-transform/src/frontend/macro_operand_semantics.js

@@ -4,6 +4,7 @@ import { createPreparedProgram, mapProgramPositionToSource, mapSourcePositionToP
 import { rewriteMacroSource } from './macro_rewrite.js';
 import { createMacroSemantics } from './macro_semantics.js';
 const COMPLETION_PLACEHOLDER_IDENTIFIER = '__sts_completion_target';
+const sharedExprOperandFileSourceCache = new WeakMap();
 function isNestedMacroHoverTarget(value) {
     return 'kind' in value;
 }
@@ -22,6 +23,18 @@ function getExprArgumentSpan(invocation, index) {
     const argument = invocation.argumentSpans[index];
     return argument?.kind === 'ExprArg' ? argument.span : undefined;
 }
+function exprArgumentContainsNestedMacroInvocation(fileName, originalText, exprSpan, nestedRegistries) {
+    const sourceFile = ts.createSourceFile(fileName, originalText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const importPrelude = sourceFile.statements
+        .filter(ts.isImportDeclaration)
+        .map((statement) => statement.getText(sourceFile))
+        .join('\n');
+    const operandText = originalText.slice(exprSpan.start, exprSpan.end);
+    const probeSourceText = importPrelude.length > 0
+        ? `${importPrelude}\nconst __sts_nested_probe = ${operandText};\n`
+        : `const __sts_nested_probe = ${operandText};\n`;
+    return rewriteMacroSource(fileName, probeSourceText, nestedRegistries.siteKindsBySpecifier ?? new Map(), getAlwaysAvailableBuiltinMacroSiteKinds()).replacements.length > 0;
+}
 function _getExpressionArgumentSpan(invocation, expressionArgumentIndex) {
     const expressionArguments = invocation.argumentSpans.filter((argument) => argument.kind === 'ExprArg');
     return expressionArguments[expressionArgumentIndex]?.span;
@@ -287,6 +300,7 @@ function expandNestedOperandSource(preparedProgram, resolved, patchedText, neste
     };
     const finalProgram = ts.createProgram({
         host: overrideHost,
+        oldProgram: nestedPreparedProgram.program,
         options: nestedPreparedProgram.options,
         rootNames: nestedPreparedProgram.rootNames.map((fileName) => nestedPreparedProgram.toProgramFileName(fileName)),
     });
@@ -407,6 +421,95 @@ function findExpressionAtSpan(sourceFile, start, end) {
     visit(sourceFile);
     return found;
 }
+function sharedExprOperandFileSourceCacheKey(rewrittenProgramFileName, index) {
+    return `${rewrittenProgramFileName}\0${index}`;
+}
+function buildSharedExprOperandFileSource(preparedProgram, preparedFile, sourceFileName, index, nestedRegistries) {
+    const rewrittenProgramFileName = preparedProgram.toProgramFileName(sourceFileName);
+    const replacements = [];
+    for (const replacement of preparedFile.rewriteResult.replacements) {
+        const invocation = preparedFile.rewriteResult.macrosById.get(replacement.id);
+        if (!invocation) {
+            continue;
+        }
+        const exprSpan = getExprArgumentSpan(invocation, index);
+        if (!exprSpan) {
+            continue;
+        }
+        if (exprArgumentContainsNestedMacroInvocation(sourceFileName, preparedFile.originalText, exprSpan, nestedRegistries)) {
+            continue;
+        }
+        const operandText = preparedFile.originalText.slice(exprSpan.start, exprSpan.end);
+        replacements.push({
+            id: replacement.id,
+            end: mapStageOnePositionToProgram(preparedFile, replacement.rewrittenSpan.end),
+            operandText,
+            start: mapStageOnePositionToProgram(preparedFile, replacement.rewrittenSpan.start),
+        });
+    }
+    replacements.sort((left, right) => left.start - right.start);
+    if (replacements.length === 0) {
+        return null;
+    }
+    let patchedText = '';
+    let cursor = 0;
+    const spansByPlaceholderId = new Map();
+    for (const replacement of replacements) {
+        patchedText += preparedFile.rewrittenText.slice(cursor, replacement.start);
+        const patchedStart = patchedText.length;
+        patchedText += replacement.operandText;
+        spansByPlaceholderId.set(replacement.id, {
+            end: patchedStart + replacement.operandText.length,
+            fileName: sourceFileName,
+            start: patchedStart,
+        });
+        cursor = replacement.end;
+    }
+    patchedText += preparedFile.rewrittenText.slice(cursor);
+    const overrideHost = {
+        ...preparedProgram.preparedHost.host,
+        getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile) {
+            if (fileName === rewrittenProgramFileName) {
+                return ts.createSourceFile(fileName, patchedText, languageVersion, true);
+            }
+            return preparedProgram.preparedHost.host.getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+        },
+        readFile(fileName) {
+            if (fileName === rewrittenProgramFileName) {
+                return patchedText;
+            }
+            return preparedProgram.preparedHost.host.readFile(fileName);
+        },
+    };
+    const patchedProgram = ts.createProgram({
+        host: overrideHost,
+        oldProgram: preparedProgram.program,
+        options: preparedProgram.options,
+        rootNames: preparedProgram.rootNames.map((fileName) => preparedProgram.toProgramFileName(fileName)),
+    });
+    const patchedSourceFile = patchedProgram.getSourceFile(rewrittenProgramFileName);
+    if (!patchedSourceFile) {
+        return null;
+    }
+    return {
+        semantics: createMacroSemantics(patchedProgram),
+        sourceFile: patchedSourceFile,
+        spansByPlaceholderId,
+    };
+}
+function getSharedExprOperandFileSource(preparedProgram, preparedFile, sourceFileName, index, nestedRegistries) {
+    let programCache = sharedExprOperandFileSourceCache.get(preparedProgram);
+    if (!programCache) {
+        programCache = new Map();
+        sharedExprOperandFileSourceCache.set(preparedProgram, programCache);
+    }
+    const rewrittenProgramFileName = preparedProgram.toProgramFileName(sourceFileName);
+    const cacheKey = sharedExprOperandFileSourceCacheKey(rewrittenProgramFileName, index);
+    if (!programCache.has(cacheKey)) {
+        programCache.set(cacheKey, buildSharedExprOperandFileSource(preparedProgram, preparedFile, sourceFileName, index, nestedRegistries));
+    }
+    return programCache.get(cacheKey) ?? null;
+}
 function findDeepestNodeContainingPosition(node, position) {
     if (position < node.getFullStart() || position >= node.getEnd()) {
         return undefined;
@@ -438,6 +541,7 @@ function createPatchedMacroSource(preparedProgram, resolved, replacementText) {
     };
     const patchedProgram = ts.createProgram({
         host: overrideHost,
+        oldProgram: preparedProgram.program,
         options: preparedProgram.options,
         rootNames: preparedProgram.rootNames.map((fileName) => preparedProgram.toProgramFileName(fileName)),
     });
@@ -747,11 +851,29 @@ export function resolveExprArgumentOperand(preparedProgram, resolved, index, nes
     const replacement = resolved.placeholder.replacement;
     const preparedFile = resolved.placeholder.preparedFile;
     const operandText = preparedFile.originalText.slice(exprSpan.start, exprSpan.end);
-    const nestedExpansion = materializeNestedOperandExpansion(preparedProgram, resolved, operandText, nestedRegistries) ?? { expressionText: operandText, preludeTexts: [] };
+    const nestedExpansion = exprArgumentContainsNestedMacroInvocation(resolved.placeholder.invocation.fileName, preparedFile.originalText, exprSpan, nestedRegistries)
+        ? materializeNestedOperandExpansion(preparedProgram, resolved, operandText, nestedRegistries) ?? { expressionText: operandText, preludeTexts: [] }
+        : { expressionText: operandText, preludeTexts: [] };
     if (!nestedExpansion) {
         return null;
     }
     const expandedText = nestedExpansion.expressionText;
+    if (nestedExpansion.preludeTexts.length === 0 && expandedText === operandText) {
+        const sharedSource = getSharedExprOperandFileSource(preparedProgram, preparedFile, resolved.placeholder.invocation.fileName, index, nestedRegistries);
+        const sharedSpan = sharedSource?.spansByPlaceholderId.get(resolved.placeholder.id);
+        if (sharedSource && sharedSpan) {
+            const patchedExpression = findExpressionAtSpan(sharedSource.sourceFile, sharedSpan.start, sharedSpan.end);
+            if (patchedExpression) {
+                return {
+                    expandedText,
+                    preludeTexts: nestedExpansion.preludeTexts,
+                    node: patchedExpression,
+                    semantics: sharedSource.semantics,
+                    sourceFile: sharedSource.sourceFile,
+                };
+            }
+        }
+    }
     const containingStatement = findContainingStatement(resolved.callExpression);
     const programReplacementStart = mapStageOnePositionToProgram(preparedFile, replacement.rewrittenSpan.start);
     const programReplacementEnd = mapStageOnePositionToProgram(preparedFile, replacement.rewrittenSpan.end);
@@ -787,6 +909,7 @@ export function resolveExprArgumentOperand(preparedProgram, resolved, index, nes
     };
     const patchedProgram = ts.createProgram({
         host: overrideHost,
+        oldProgram: preparedProgram.program,
         options: preparedProgram.options,
         rootNames: preparedProgram.rootNames.map((fileName) => preparedProgram.toProgramFileName(fileName)),
     });

package/project-transform/src/frontend/macro_operand_semantics.ts

@@ -30,6 +30,12 @@ export interface ResolvedExprArgumentOperand {
 
 export interface ResolvedPrimaryExprOperand extends ResolvedExprArgumentOperand {}
 
+interface SharedExprOperandFileSource {
+  semantics: ReturnType<typeof createMacroSemantics>;
+  sourceFile: ts.SourceFile;
+  spansByPlaceholderId: ReadonlyMap<number, SourceSpan>;
+}
+
 export interface MaterializedMacroMappingSegment {
   generatedEnd: number;
   generatedStart: number;
@@ -73,6 +79,10 @@ export interface NestedMacroHoverTarget {
 }
 
 const COMPLETION_PLACEHOLDER_IDENTIFIER = '__sts_completion_target';
+const sharedExprOperandFileSourceCache = new WeakMap<
+  PreparedProgram,
+  Map<string, SharedExprOperandFileSource | null>
+>();
 
 function isNestedMacroHoverTarget(
   value: MaterializedMacroHoverRegion | NestedMacroHoverTarget,
@@ -106,6 +116,36 @@ function getExprArgumentSpan(
   return argument?.kind === 'ExprArg' ? argument.span : undefined;
 }
 
+function exprArgumentContainsNestedMacroInvocation(
+  fileName: string,
+  originalText: string,
+  exprSpan: SourceSpan,
+  nestedRegistries: NestedMacroRegistries,
+): boolean {
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    originalText,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TSX,
+  );
+  const importPrelude = sourceFile.statements
+    .filter(ts.isImportDeclaration)
+    .map((statement) => statement.getText(sourceFile))
+    .join('\n');
+  const operandText = originalText.slice(exprSpan.start, exprSpan.end);
+  const probeSourceText = importPrelude.length > 0
+    ? `${importPrelude}\nconst __sts_nested_probe = ${operandText};\n`
+    : `const __sts_nested_probe = ${operandText};\n`;
+
+  return rewriteMacroSource(
+    fileName,
+    probeSourceText,
+    nestedRegistries.siteKindsBySpecifier ?? new Map(),
+    getAlwaysAvailableBuiltinMacroSiteKinds(),
+  ).replacements.length > 0;
+}
+
 function _getExpressionArgumentSpan(
   invocation: ParsedMacroInvocation,
   expressionArgumentIndex: number,
@@ -507,6 +547,7 @@ function expandNestedOperandSource(
   };
   const finalProgram = ts.createProgram({
     host: overrideHost,
+    oldProgram: nestedPreparedProgram.program,
     options: nestedPreparedProgram.options,
     rootNames: nestedPreparedProgram.rootNames.map((fileName) =>
       nestedPreparedProgram.toProgramFileName(fileName)
@@ -733,6 +774,153 @@ function findExpressionAtSpan(
   return found;
 }
 
+function sharedExprOperandFileSourceCacheKey(
+  rewrittenProgramFileName: string,
+  index: number,
+): string {
+  return `${rewrittenProgramFileName}\0${index}`;
+}
+
+function buildSharedExprOperandFileSource(
+  preparedProgram: PreparedProgram,
+  preparedFile: PreparedSourceFile,
+  sourceFileName: string,
+  index: number,
+  nestedRegistries: NestedMacroRegistries,
+): SharedExprOperandFileSource | null {
+  const rewrittenProgramFileName = preparedProgram.toProgramFileName(sourceFileName);
+  const replacements: Array<{ end: number; id: number; operandText: string; start: number }> = [];
+  for (const replacement of preparedFile.rewriteResult.replacements) {
+    const invocation = preparedFile.rewriteResult.macrosById.get(replacement.id);
+    if (!invocation) {
+      continue;
+    }
+
+    const exprSpan = getExprArgumentSpan(invocation, index);
+    if (!exprSpan) {
+      continue;
+    }
+
+    if (
+      exprArgumentContainsNestedMacroInvocation(
+        sourceFileName,
+        preparedFile.originalText,
+        exprSpan,
+        nestedRegistries,
+      )
+    ) {
+      continue;
+    }
+
+    const operandText = preparedFile.originalText.slice(exprSpan.start, exprSpan.end);
+    replacements.push({
+        id: replacement.id,
+        end: mapStageOnePositionToProgram(preparedFile, replacement.rewrittenSpan.end),
+        operandText,
+        start: mapStageOnePositionToProgram(preparedFile, replacement.rewrittenSpan.start),
+    });
+  }
+  replacements.sort((left, right) => left.start - right.start);
+
+  if (replacements.length === 0) {
+    return null;
+  }
+
+  let patchedText = '';
+  let cursor = 0;
+  const spansByPlaceholderId = new Map<number, SourceSpan>();
+  for (const replacement of replacements) {
+    patchedText += preparedFile.rewrittenText.slice(cursor, replacement.start);
+    const patchedStart = patchedText.length;
+    patchedText += replacement.operandText;
+    spansByPlaceholderId.set(replacement.id, {
+      end: patchedStart + replacement.operandText.length,
+      fileName: sourceFileName,
+      start: patchedStart,
+    });
+    cursor = replacement.end;
+  }
+  patchedText += preparedFile.rewrittenText.slice(cursor);
+
+  const overrideHost: ts.CompilerHost = {
+    ...preparedProgram.preparedHost.host,
+    getSourceFile(
+      fileName: string,
+      languageVersion: ts.ScriptTarget | ts.CreateSourceFileOptions,
+      onError?: (message: string) => void,
+      shouldCreateNewSourceFile?: boolean,
+    ): ts.SourceFile | undefined {
+      if (fileName === rewrittenProgramFileName) {
+        return ts.createSourceFile(fileName, patchedText, languageVersion, true);
+      }
+
+      return preparedProgram.preparedHost.host.getSourceFile(
+        fileName,
+        languageVersion,
+        onError,
+        shouldCreateNewSourceFile,
+      );
+    },
+    readFile(fileName: string): string | undefined {
+      if (fileName === rewrittenProgramFileName) {
+        return patchedText;
+      }
+
+      return preparedProgram.preparedHost.host.readFile(fileName);
+    },
+  };
+
+  const patchedProgram = ts.createProgram({
+    host: overrideHost,
+    oldProgram: preparedProgram.program,
+    options: preparedProgram.options,
+    rootNames: preparedProgram.rootNames.map((fileName) =>
+      preparedProgram.toProgramFileName(fileName)
+    ),
+  });
+  const patchedSourceFile = patchedProgram.getSourceFile(rewrittenProgramFileName);
+  if (!patchedSourceFile) {
+    return null;
+  }
+
+  return {
+    semantics: createMacroSemantics(patchedProgram),
+    sourceFile: patchedSourceFile,
+    spansByPlaceholderId,
+  };
+}
+
+function getSharedExprOperandFileSource(
+  preparedProgram: PreparedProgram,
+  preparedFile: PreparedSourceFile,
+  sourceFileName: string,
+  index: number,
+  nestedRegistries: NestedMacroRegistries,
+): SharedExprOperandFileSource | null {
+  let programCache = sharedExprOperandFileSourceCache.get(preparedProgram);
+  if (!programCache) {
+    programCache = new Map();
+    sharedExprOperandFileSourceCache.set(preparedProgram, programCache);
+  }
+
+  const rewrittenProgramFileName = preparedProgram.toProgramFileName(sourceFileName);
+  const cacheKey = sharedExprOperandFileSourceCacheKey(rewrittenProgramFileName, index);
+  if (!programCache.has(cacheKey)) {
+    programCache.set(
+      cacheKey,
+      buildSharedExprOperandFileSource(
+        preparedProgram,
+        preparedFile,
+        sourceFileName,
+        index,
+        nestedRegistries,
+      ),
+    );
+  }
+
+  return programCache.get(cacheKey) ?? null;
+}
+
 function findDeepestNodeContainingPosition(node: ts.Node, position: number): ts.Node | undefined {
   if (position < node.getFullStart() || position >= node.getEnd()) {
     return undefined;
@@ -805,6 +993,7 @@ function createPatchedMacroSource(
 
   const patchedProgram = ts.createProgram({
     host: overrideHost,
+    oldProgram: preparedProgram.program,
     options: preparedProgram.options,
     rootNames: preparedProgram.rootNames.map((fileName) =>
       preparedProgram.toProgramFileName(fileName)
@@ -1325,16 +1514,50 @@ export function resolveExprArgumentOperand(
   const replacement = resolved.placeholder.replacement;
   const preparedFile = resolved.placeholder.preparedFile;
   const operandText = preparedFile.originalText.slice(exprSpan.start, exprSpan.end);
-  const nestedExpansion = materializeNestedOperandExpansion(
-    preparedProgram,
-    resolved,
-    operandText,
-    nestedRegistries,
-  ) ?? { expressionText: operandText, preludeTexts: [] as readonly string[] };
+  const nestedExpansion = exprArgumentContainsNestedMacroInvocation(
+      resolved.placeholder.invocation.fileName,
+      preparedFile.originalText,
+      exprSpan,
+      nestedRegistries,
+    )
+    ? materializeNestedOperandExpansion(
+      preparedProgram,
+      resolved,
+      operandText,
+      nestedRegistries,
+    ) ?? { expressionText: operandText, preludeTexts: [] as readonly string[] }
+    : { expressionText: operandText, preludeTexts: [] as readonly string[] };
   if (!nestedExpansion) {
     return null;
   }
   const expandedText = nestedExpansion.expressionText;
+  if (nestedExpansion.preludeTexts.length === 0 && expandedText === operandText) {
+    const sharedSource = getSharedExprOperandFileSource(
+      preparedProgram,
+      preparedFile,
+      resolved.placeholder.invocation.fileName,
+      index,
+      nestedRegistries,
+    );
+    const sharedSpan = sharedSource?.spansByPlaceholderId.get(resolved.placeholder.id);
+    if (sharedSource && sharedSpan) {
+      const patchedExpression = findExpressionAtSpan(
+        sharedSource.sourceFile,
+        sharedSpan.start,
+        sharedSpan.end,
+      );
+      if (patchedExpression) {
+        return {
+          expandedText,
+          preludeTexts: nestedExpansion.preludeTexts,
+          node: patchedExpression,
+          semantics: sharedSource.semantics,
+          sourceFile: sharedSource.sourceFile,
+        };
+      }
+    }
+  }
+
   const containingStatement = findContainingStatement(resolved.callExpression);
   const programReplacementStart = mapStageOnePositionToProgram(
     preparedFile,
@@ -1397,6 +1620,7 @@ export function resolveExprArgumentOperand(
 
   const patchedProgram = ts.createProgram({
     host: overrideHost,
+    oldProgram: preparedProgram.program,
     options: preparedProgram.options,
     rootNames: preparedProgram.rootNames.map((fileName) =>
       preparedProgram.toProgramFileName(fileName)

package/project-transform/src/frontend/macro_resolver.js

@@ -41,9 +41,9 @@ export function resolveMacroPlaceholdersInSourceFile(sourceFile, placeholderInde
     visit(sourceFile);
     return resolved;
 }
-export function collectResolvedMacroPlaceholders(preparedProgram) {
+export function collectResolvedMacroPlaceholders(preparedProgram, sourceFiles = preparedProgram.program.getSourceFiles()) {
     const placeholderIndex = preparedProgram.placeholderIndex();
-    const collected = preparedProgram.program.getSourceFiles()
+    const collected = sourceFiles
         .filter((sourceFile) => !sourceFile.isDeclarationFile)
         .flatMap((sourceFile) => {
         const sourceFileName = preparedProgram.toSourceFileName(sourceFile.fileName);

package/project-transform/src/frontend/macro_resolver.ts

@@ -90,9 +90,10 @@ export function resolveMacroPlaceholdersInSourceFile(
 
 export function collectResolvedMacroPlaceholders(
   preparedProgram: MacroResolverPreparedProgram,
+  sourceFiles = preparedProgram.program.getSourceFiles(),
 ): CollectedResolvedMacroPlaceholder[] {
   const placeholderIndex = preparedProgram.placeholderIndex();
-  const collected = preparedProgram.program.getSourceFiles()
+  const collected = sourceFiles
     .filter((sourceFile) => !sourceFile.isDeclarationFile)
     .flatMap((sourceFile) => {
       const sourceFileName = preparedProgram.toSourceFileName(sourceFile.fileName);

package/project-transform/src/frontend/project_macro_support.js

@@ -1233,6 +1233,17 @@ export function createProjectMacroEnvironment(preparedProgram, builtinDefinition
             return cached;
         }
         const macroNames = macroNamesForFile(sourceFile);
+        if (macroNames.size === 0) {
+            const emptyBindings = {
+                advancedRegistry: new Map(),
+                definitions: new Map(),
+                importedBindingUsage: new Map(),
+                registry: new Map(),
+                siteKindsBySpecifier: new Map(),
+            };
+            bindingsByFile.set(sourceFile.fileName, emptyBindings);
+            return emptyBindings;
+        }
         const definitions = new Map();
         const registry = new Map();
         const advancedRegistry = new Map();
@@ -1372,7 +1383,18 @@ export function createProjectMacroEnvironment(preparedProgram, builtinDefinition
             const registriesByFile = new Map();
             const bindingUsageByFile = new Map();
             const hasBindingsByFile = new Map();
+            const expandedFiles = new Map();
+            const macroSourceFiles = [];
             for (const sourceFile of sourceFiles) {
+                const macroNames = macroNamesForFile(sourceFile);
+                if (macroNames.size === 0) {
+                    const sourceFileName = preparedProgram.toSourceFileName(sourceFile.fileName);
+                    const preparedSource = preparedProgram.preparedHost.getPreparedSourceFile(sourceFileName);
+                    expandedFiles.set(sourceFile.fileName, preparedSource
+                        ? ts.createSourceFile(sourceFile.fileName, preparedSource.originalText, preparedProgram.options.target ?? ts.ScriptTarget.Latest, true, scriptKindForHostFile(sourceFile.fileName))
+                        : sourceFile);
+                    continue;
+                }
                 const bindings = bindingsForSourceFile(sourceFile);
                 registriesByFile.set(sourceFile.fileName, {
                     registry: bindings.registry,
@@ -1381,21 +1403,23 @@ export function createProjectMacroEnvironment(preparedProgram, builtinDefinition
                 });
                 bindingUsageByFile.set(sourceFile.fileName, bindings.importedBindingUsage);
                 hasBindingsByFile.set(sourceFile.fileName, hasResolvedMacroBindings(bindings));
+                macroSourceFiles.push(sourceFile);
             }
-            const expanded = expandPreparedProgramWithFileRegistries(preparedProgram, registriesByFile, preserveMissingExpanders, annotateExpansions);
-            const stripped = new Map();
+            const expanded = macroSourceFiles.length > 0
+                ? expandPreparedProgramWithFileRegistries(preparedProgram, registriesByFile, preserveMissingExpanders, annotateExpansions, macroSourceFiles)
+                : new Map();
             for (const [fileName, sourceFile] of expanded.entries()) {
                 if (!hasBindingsByFile.get(fileName)) {
                     const sourceFileName = preparedProgram.toSourceFileName(fileName);
                     const preparedSource = preparedProgram.preparedHost.getPreparedSourceFile(sourceFileName);
-                    stripped.set(fileName, preparedSource
+                    expandedFiles.set(fileName, preparedSource
                         ? ts.createSourceFile(fileName, preparedSource.originalText, preparedProgram.options.target ?? ts.ScriptTarget.Latest, true, scriptKindForHostFile(fileName))
                         : sourceFile);
                     continue;
                 }
-                stripped.set(fileName, stripCompileTimeOnlyImportedBindings(sourceFile, bindingUsageByFile.get(fileName) ?? new Map(), preserveRemovedImportStatements));
+                expandedFiles.set(fileName, stripCompileTimeOnlyImportedBindings(sourceFile, bindingUsageByFile.get(fileName) ?? new Map(), preserveRemovedImportStatements));
             }
-            return stripped;
+            return expandedFiles;
         },
     };
 }

package/project-transform/src/frontend/project_macro_support.ts

@@ -1895,6 +1895,18 @@ export function createProjectMacroEnvironment(
     }
 
     const macroNames = macroNamesForFile(sourceFile);
+    if (macroNames.size === 0) {
+      const emptyBindings = {
+        advancedRegistry: new Map<string, AdvancedMacroExpander>(),
+        definitions: new Map<string, MacroDefinition>(),
+        importedBindingUsage: new Map<string, ImportedBindingUsage>(),
+        registry: new Map<string, RewriteMacroExpander>(),
+        siteKindsBySpecifier: new Map<string, Map<string, ImportedMacroSiteKind>>(),
+      };
+      bindingsByFile.set(sourceFile.fileName, emptyBindings);
+      return emptyBindings;
+    }
+
     const definitions = new Map<string, MacroDefinition>();
     const registry = new Map<string, RewriteMacroExpander>();
     const advancedRegistry = new Map<string, AdvancedMacroExpander>();
@@ -2084,8 +2096,29 @@ export function createProjectMacroEnvironment(
       >();
       const bindingUsageByFile = new Map<string, ReadonlyMap<string, ImportedBindingUsage>>();
       const hasBindingsByFile = new Map<string, boolean>();
+      const expandedFiles = new Map<string, ts.SourceFile>();
+      const macroSourceFiles: ts.SourceFile[] = [];
 
       for (const sourceFile of sourceFiles) {
+        const macroNames = macroNamesForFile(sourceFile);
+        if (macroNames.size === 0) {
+          const sourceFileName = preparedProgram.toSourceFileName(sourceFile.fileName);
+          const preparedSource = preparedProgram.preparedHost.getPreparedSourceFile(sourceFileName);
+          expandedFiles.set(
+            sourceFile.fileName,
+            preparedSource
+              ? ts.createSourceFile(
+                sourceFile.fileName,
+                preparedSource.originalText,
+                preparedProgram.options.target ?? ts.ScriptTarget.Latest,
+                true,
+                scriptKindForHostFile(sourceFile.fileName),
+              )
+              : sourceFile,
+          );
+          continue;
+        }
+
         const bindings = bindingsForSourceFile(sourceFile);
         registriesByFile.set(sourceFile.fileName, {
           registry: bindings.registry,
@@ -2094,20 +2127,23 @@ export function createProjectMacroEnvironment(
         });
         bindingUsageByFile.set(sourceFile.fileName, bindings.importedBindingUsage);
         hasBindingsByFile.set(sourceFile.fileName, hasResolvedMacroBindings(bindings));
+        macroSourceFiles.push(sourceFile);
       }
 
-      const expanded = expandPreparedProgramWithFileRegistries(
-        preparedProgram,
-        registriesByFile,
-        preserveMissingExpanders,
-        annotateExpansions,
-      );
-      const stripped = new Map<string, ts.SourceFile>();
+      const expanded = macroSourceFiles.length > 0
+        ? expandPreparedProgramWithFileRegistries(
+          preparedProgram,
+          registriesByFile,
+          preserveMissingExpanders,
+          annotateExpansions,
+          macroSourceFiles,
+        )
+        : new Map<string, ts.SourceFile>();
       for (const [fileName, sourceFile] of expanded.entries()) {
         if (!hasBindingsByFile.get(fileName)) {
           const sourceFileName = preparedProgram.toSourceFileName(fileName);
           const preparedSource = preparedProgram.preparedHost.getPreparedSourceFile(sourceFileName);
-          stripped.set(
+          expandedFiles.set(
             fileName,
             preparedSource
               ? ts.createSourceFile(
@@ -2122,7 +2158,7 @@ export function createProjectMacroEnvironment(
           continue;
         }
 
-        stripped.set(
+        expandedFiles.set(
           fileName,
           stripCompileTimeOnlyImportedBindings(
             sourceFile,
@@ -2131,7 +2167,7 @@ export function createProjectMacroEnvironment(
           ),
         );
       }
-      return stripped;
+      return expandedFiles;
     },
   };
 }