@tamagui/compiler-core 0.0.0-bootstrap.0 → 3.0.0-beta.1093.1

package/src/session.ts

@@ -0,0 +1,192 @@
+import type { HostModuleInput, ResolvedModuleId } from './contracts'
+import type { GraphInvalidation } from './graph'
+import { ProjectGraph } from './graph'
+import type {
+  CompilerLoweringHost,
+  CompilerTarget,
+  LoweredModulePlan,
+  StructuralModulePass,
+} from './lower'
+import { lowerModule } from './lower'
+import { materializeModule, type MaterializedModule } from './materialize'
+import type { AppliedLoweredModule } from './output'
+import { applyLoweredModule } from './output'
+import type { ModulePlanCache } from './planCache'
+import {
+  PLAN_CACHE_SCHEMA_VERSION,
+  createExternalClosureLookup,
+  moduleClosureDigest,
+  planCacheKey,
+} from './planCache'
+import { yukuFactory } from './yuku'
+
+export interface CompilerAdapter {
+  target: CompilerTarget
+  projectGeneration: string
+  host: CompilerLoweringHost
+  load(id: ResolvedModuleId): Promise<HostModuleInput | null>
+  /**
+   * Runs after a module is materialized and before it lowers, once per uncached
+   * compile. The frontend evaluates component modules the host does not know
+   * yet here (element and styled() base provenance outside the configured
+   * `components`), so lowering never meets an import it could have resolved.
+   */
+  prepare?(module: MaterializedModule): Promise<void>
+  /**
+   * Persistent per-module plan reuse across processes. Absent means the host
+   * could not produce a content stamp for this project, so nothing is cached
+   * rather than cached under a stamp that does not describe the config.
+   */
+  planCache?: { store: ModulePlanCache; stamp: string }
+}
+
+export interface CompileModuleInput {
+  module: HostModuleInput
+  adapter: CompilerAdapter
+  structuralPass?: StructuralModulePass
+}
+
+export interface CompilerSessionResult {
+  plan: LoweredModulePlan
+  output: AppliedLoweredModule
+  invalidatedIds: ResolvedModuleId[]
+}
+
+function compareIds(left: ResolvedModuleId, right: ResolvedModuleId): number {
+  return left < right ? -1 : left > right ? 1 : 0
+}
+
+/**
+ * Bundler-neutral compiler state. The adapter owns module resolution and loading;
+ * the session only accepts canonical host-resolved module records.
+ */
+export class CompilerSession {
+  readonly #graph = new ProjectGraph(yukuFactory, { modules: [] })
+  readonly #externalClosure = createExternalClosureLookup()
+  #queue: Promise<unknown> = Promise.resolve()
+
+  compile(input: CompileModuleInput): Promise<CompilerSessionResult> {
+    const operation = this.#queue.then(() => this.#compile(input))
+    this.#queue = operation.catch(() => undefined)
+    return operation
+  }
+
+  update(module: HostModuleInput): Promise<ResolvedModuleId[]> {
+    return this.#enqueue(() => this.#graph.updateModule(module).invalidatedIds)
+  }
+
+  has(id: ResolvedModuleId): boolean {
+    return this.#graph.contentHash(id) !== null
+  }
+
+  dependentsOf(id: ResolvedModuleId): ResolvedModuleId[] {
+    return this.#graph.dependentsOf(id)
+  }
+
+  remove(id: ResolvedModuleId): Promise<GraphInvalidation> {
+    return this.#enqueue(() => this.#graph.removeModule(id))
+  }
+
+  parseCount(id: ResolvedModuleId): number {
+    return this.#graph.parseCount(id)
+  }
+
+  #enqueue<T>(operation: () => T | Promise<T>): Promise<T> {
+    const queued = this.#queue.then(operation)
+    this.#queue = queued.catch(() => undefined)
+    return queued
+  }
+
+  async #compile({
+    module,
+    adapter,
+    structuralPass,
+  }: CompileModuleInput): Promise<CompilerSessionResult> {
+    const invalidated = new Set<ResolvedModuleId>()
+    await this.#install(module, adapter, new Set(), invalidated)
+    const graph = this.#graph
+    // an empty stamp is not an identity: a key without one would be shared by
+    // every project and every config, so such a project simply does not cache
+    const cache = adapter.planCache?.stamp ? adapter.planCache : null
+    const closureDigest = cache
+      ? moduleClosureDigest(module.id, (id) => {
+          const hash = graph.contentHash(id)
+          if (hash) {
+            return {
+              contentHash: hash,
+              dependencies: [...graph.dependenciesOf(id), ...graph.externalImportsOf(id)],
+            }
+          }
+          return this.#externalClosure(id)
+        })
+      : null
+    const entry =
+      cache && closureDigest
+        ? {
+            store: cache.store,
+            digest: closureDigest,
+            key: planCacheKey(
+              {
+                stamp: cache.stamp,
+                target: adapter.target,
+                structuralPassHash:
+                  structuralPass?.versionHash ?? `${adapter.target}-noop-v1`,
+              },
+              module.id,
+              closureDigest
+            ),
+          }
+        : null
+
+    const cached = entry
+      ? await entry.store.read(entry.key, module.id, entry.digest)
+      : null
+    let plan = cached?.plan
+    if (!plan) {
+      const materialized = materializeModule(graph, module.id)
+      if (adapter.prepare) await adapter.prepare(materialized)
+      plan = lowerModule({
+        module: materialized,
+        source: module.source,
+        target: adapter.target,
+        host: adapter.host,
+        options: { projectGeneration: adapter.projectGeneration },
+        structuralPass,
+      })
+    }
+    if (entry && !cached) {
+      await entry.store.write(entry.key, {
+        schemaVersion: PLAN_CACHE_SCHEMA_VERSION,
+        moduleId: module.id,
+        closureDigest: entry.digest,
+        plan,
+      })
+    }
+    return {
+      plan,
+      output: applyLoweredModule(module.source, module.id, plan),
+      invalidatedIds: [...invalidated].sort(compareIds),
+    }
+  }
+
+  async #install(
+    module: HostModuleInput,
+    adapter: CompilerAdapter,
+    visited: Set<ResolvedModuleId>,
+    invalidated: Set<ResolvedModuleId>
+  ): Promise<void> {
+    if (visited.has(module.id)) return
+    visited.add(module.id)
+
+    for (const dependency of module.imports) {
+      if (dependency.external || this.has(dependency.resolvedId)) continue
+      const loaded = await adapter.load(dependency.resolvedId)
+      if (loaded) {
+        await this.#install(loaded, adapter, visited, invalidated)
+      }
+    }
+
+    const update = this.#graph.updateModule(module)
+    for (const id of update.invalidatedIds) invalidated.add(id)
+  }
+}

package/src/yuku.ts

@@ -0,0 +1,197 @@
+import { Analyzer, type Module, type Symbol as YukuSymbol } from 'yuku-analyzer'
+
+import type {
+  AnalyzerCandidate,
+  AstNode,
+  CandidateFactory,
+  DefinitionSite,
+  ParseDiagnostic,
+  ProjectInput,
+  ReferenceSite,
+} from './contracts'
+import { resolveFromHost, resolvedModuleId } from './contracts'
+import { childNode, walkAst } from './ast'
+import { asAstNode, definitionFromDeclaration, nodeAtSpan } from './normalize'
+
+class YukuCandidate implements AnalyzerCandidate {
+  readonly name = 'yuku' as const
+  readonly #analyzer: Analyzer
+  readonly #parseCounts = new Map<string, number>()
+
+  constructor(private readonly project: ProjectInput) {
+    this.#analyzer = new Analyzer({
+      resolve: (specifier, importer) =>
+        resolveFromHost(this.project.resolutions, specifier, importer),
+    })
+    for (const [id, source] of project.files) this.addFile(id, source)
+  }
+
+  addFile(id: string, source: string): void {
+    this.#analyzer.addFile(id, source, { preserveParens: true, sourceType: 'module' })
+    this.#parseCounts.set(id, (this.#parseCounts.get(id) ?? 0) + 1)
+  }
+
+  removeFile(id: string): boolean {
+    return this.#analyzer.removeFile(id)
+  }
+
+  link(): void {
+    this.#analyzer.link()
+  }
+
+  #module(id: string): Module {
+    const module = this.#analyzer.module(id)
+    if (!module) throw new Error(`yuku: unknown module ${id}`)
+    return module
+  }
+
+  #canonicalSymbol(id: string, localName: string): YukuSymbol | null {
+    const symbol = this.#module(id).resolve(localName)
+    return symbol ? (this.#analyzer.definitionOf(symbol)?.symbol ?? null) : null
+  }
+
+  #definitionSite(symbol: YukuSymbol): DefinitionSite | null {
+    const declaration = symbol.declarations[0]
+    if (!declaration) return null
+    return definitionFromDeclaration(
+      symbol.module.path,
+      symbol.name,
+      asAstNode(declaration, `${symbol.name} declaration`),
+      (node) => symbol.module.parentOf(node as any) as AstNode | null
+    )
+  }
+
+  definitionOf(id: string, localName: string): DefinitionSite | null {
+    const symbol = this.#canonicalSymbol(id, localName)
+    return symbol ? this.#definitionSite(symbol) : null
+  }
+
+  definitionAt(id: string, start: number, end: number): DefinitionSite | null {
+    const module = this.#module(id)
+    const node = nodeAtSpan(asAstNode(module.ast, `${module.path} program`), start, end)
+    if (!node) return null
+    const symbol = module.symbolOf(node as any)
+    const definition = symbol && this.#analyzer.definitionOf(symbol)?.symbol
+    return definition ? this.#definitionSite(definition) : null
+  }
+
+  referencesOf(definition: DefinitionSite): ReferenceSite[] {
+    const symbol = this.#canonicalSymbol(definition.id, definition.name)
+    if (!symbol) return []
+    return this.#analyzer.referencesOf(symbol).map(({ module, reference }) => ({
+      id: resolvedModuleId(module.path),
+      name: reference.name,
+      start: reference.node.start,
+      end: reference.node.end,
+    }))
+  }
+
+  dependenciesOf(id: string): string[] {
+    return this.#module(id)
+      .dependencies.map((module) => module.path)
+      .sort()
+  }
+
+  dependentsOf(id: string): string[] {
+    return this.#module(id)
+      .dependents.map((module) => module.path)
+      .sort()
+  }
+
+  affectedBy(id: string): string[] {
+    const affected = new Set([id])
+    const queue = [id]
+    while (queue.length) {
+      const current = queue.shift()!
+      for (const dependent of this.dependentsOf(current)) {
+        if (!affected.has(dependent)) {
+          affected.add(dependent)
+          queue.push(dependent)
+        }
+      }
+    }
+    return [...affected].sort()
+  }
+
+  programOf(id: string) {
+    return asAstNode(this.#module(id).ast, `${id} program`)
+  }
+
+  sourceOf(id: string): string {
+    return this.#module(id).source
+  }
+
+  parseCount(id: string): number {
+    return this.#parseCounts.get(id) ?? 0
+  }
+
+  diagnostics(): ParseDiagnostic[] {
+    const parseDiagnostics = [...this.#analyzer.modules.values()].flatMap((module) =>
+      module.diagnostics.map((diagnostic) => ({
+        kind: 'parse' as const,
+        id: resolvedModuleId(module.path),
+        message: diagnostic.message,
+      }))
+    )
+    return [
+      ...parseDiagnostics,
+      ...this.#analyzer.diagnostics.map((diagnostic) => ({
+        kind: 'link' as const,
+        id: resolvedModuleId(diagnostic.module),
+        message: diagnostic.message,
+      })),
+    ]
+  }
+}
+
+export const yukuFactory: CandidateFactory = {
+  name: 'yuku',
+  create: (project) => new YukuCandidate(project),
+  scanImports(id, source) {
+    const candidate = new YukuCandidate({
+      files: new Map([[id, source]]),
+      resolutions: new Map(),
+    })
+    const found: { start: number; specifier: string }[] = []
+    walkAst(candidate.programOf(id), (node) => {
+      if (
+        node.type !== 'ImportDeclaration' &&
+        node.type !== 'ExportNamedDeclaration' &&
+        node.type !== 'ExportAllDeclaration' &&
+        node.type !== 'ImportExpression'
+      ) {
+        return
+      }
+      const sourceNode = childNode(node, 'source')
+      if (sourceNode && typeof sourceNode.value === 'string') {
+        found.push({ start: node.start, specifier: sourceNode.value })
+      }
+    })
+    return [
+      ...new Set(
+        found
+          .sort((left, right) => left.start - right.start)
+          .map(({ specifier }) => specifier)
+      ),
+    ]
+  },
+}
+
+export function parseModuleAst(
+  source: string,
+  id = '/tamagui/compiler-module.tsx'
+): AstNode {
+  const candidate = yukuFactory.create({
+    files: new Map([[id, source]]),
+    resolutions: new Map(),
+  })
+  const diagnostics = candidate
+    .diagnostics()
+    .filter((diagnostic) => diagnostic.kind === 'parse')
+  if (diagnostics.length) {
+    throw new Error(
+      `Unable to parse ${id}: ${diagnostics.map(({ message }) => message).join('; ')}`
+    )
+  }
+  return candidate.programOf(id)
+}