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

package/src/graph.ts

@@ -0,0 +1,425 @@
+import { createHash } from 'node:crypto'
+
+import type {
+  AnalyzerCandidate,
+  CandidateFactory,
+  ExpressionReference,
+  HostModuleInput,
+  HostResolvedImport,
+  HostResolvedProject,
+  ProjectInput,
+  ResolvedModuleId,
+  SourceSpan,
+  SymbolDefinition,
+  SymbolResolver,
+} from './contracts'
+import { expressionReference, resolutionKey, resolvedModuleId, spanOf } from './contracts'
+import { childNode, childNodes, identifierName, unwrapExpression } from './ast'
+import { linkedBailout, localBailout, type BailoutReason } from './diagnostics'
+import {
+  evaluateBinding,
+  evaluateBranches,
+  evaluateDynamicExpression,
+  evaluateExpression,
+  type BranchDecisionNode,
+  type DynamicEvaluation,
+  type EvaluationResult,
+} from './evaluate'
+import type { ElementIRResult } from './ir'
+import { nodeAtSpan, normalizeElements } from './normalize'
+
+interface ModuleRecord {
+  input: HostModuleInput
+  hash: string
+}
+
+interface CachedElements {
+  hash: string
+  result: ElementIRResult
+}
+
+export interface GraphInvalidation {
+  changed: boolean
+  id: ResolvedModuleId
+  previousHash: string | null
+  contentHash: string | null
+  invalidatedIds: ResolvedModuleId[]
+}
+
+function compareIds(left: ResolvedModuleId, right: ResolvedModuleId): number {
+  return compareCodeUnits(left, right)
+}
+
+function compareCodeUnits(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0
+}
+
+function stableImports(imports: readonly HostResolvedImport[]): HostResolvedImport[] {
+  return [...imports].sort((left, right) => {
+    const bySpecifier = compareCodeUnits(left.specifier, right.specifier)
+    return bySpecifier || compareCodeUnits(left.resolvedId, right.resolvedId)
+  })
+}
+
+export function moduleContentHash(input: HostModuleInput): string {
+  const hash = createHash('sha256')
+  hash.update(input.source)
+  hash.update('\0')
+  for (const dependency of stableImports(input.imports)) {
+    hash.update(dependency.specifier)
+    hash.update('\0')
+    hash.update(dependency.resolvedId)
+    hash.update('\0')
+    hash.update(dependency.external ? 'external' : 'internal')
+    hash.update('\0')
+  }
+  return hash.digest('hex')
+}
+
+/**
+ * Long-lived semantic graph. The host owns resolution and supplies every canonical id;
+ * this service owns parsing, linking, hashes, reverse edges, IR, and evaluation caches.
+ */
+export class ProjectGraph implements SymbolResolver {
+  readonly #files = new Map<string, string>()
+  readonly #resolutions = new Map<string, string>()
+  readonly #modules = new Map<ResolvedModuleId, ModuleRecord>()
+  readonly #dependencies = new Map<ResolvedModuleId, Set<ResolvedModuleId>>()
+  readonly #dependents = new Map<ResolvedModuleId, Set<ResolvedModuleId>>()
+  readonly #elementCache = new Map<ResolvedModuleId, CachedElements>()
+  readonly #candidate: AnalyzerCandidate
+
+  constructor(factory: CandidateFactory, project: HostResolvedProject) {
+    for (const input of project.modules) this.#installHostRecord(input)
+    const candidateProject: ProjectInput = {
+      files: this.#files,
+      resolutions: this.#resolutions,
+    }
+    this.#candidate = factory.create(candidateProject)
+    this.#candidate.link()
+  }
+
+  moduleIds(): ResolvedModuleId[] {
+    return [...this.#modules.keys()].sort(compareIds)
+  }
+
+  contentHash(id: ResolvedModuleId): string | null {
+    return this.#modules.get(id)?.hash ?? null
+  }
+
+  sourceOf(id: ResolvedModuleId): string {
+    const source = this.#modules.get(id)?.input.source
+    if (source === undefined) throw new Error(`Unknown host module ${id}`)
+    return source
+  }
+
+  dependenciesOf(id: ResolvedModuleId): ResolvedModuleId[] {
+    return [...(this.#dependencies.get(id) ?? [])].sort(compareIds)
+  }
+
+  dependentsOf(id: ResolvedModuleId): ResolvedModuleId[] {
+    return [...(this.#dependents.get(id) ?? [])].sort(compareIds)
+  }
+
+  /** resolved ids a module imports that the graph does not own (package entries) */
+  externalImportsOf(id: ResolvedModuleId): ResolvedModuleId[] {
+    const record = this.#modules.get(id)
+    if (!record) return []
+    const ids = new Set<ResolvedModuleId>()
+    for (const dependency of record.input.imports) {
+      if (dependency.external) ids.add(dependency.resolvedId)
+    }
+    return [...ids].sort(compareIds)
+  }
+
+  affectedBy(id: ResolvedModuleId): ResolvedModuleId[] {
+    const affected = new Set<ResolvedModuleId>([id])
+    const queue = [id]
+    while (queue.length) {
+      const current = queue.shift()!
+      for (const dependent of this.#dependents.get(current) ?? []) {
+        if (affected.has(dependent)) continue
+        affected.add(dependent)
+        queue.push(dependent)
+      }
+    }
+    return [...affected].sort(compareIds)
+  }
+
+  parseCount(id: ResolvedModuleId): number {
+    return this.#candidate.parseCount(id)
+  }
+
+  resolveBinding(id: ResolvedModuleId, localName: string): SymbolDefinition | null {
+    const definition = this.#candidate.definitionOf(id, localName)
+    if (!definition) return null
+    return {
+      id: definition.id,
+      name: definition.name,
+      span: {
+        id: definition.id,
+        start: definition.start,
+        end: definition.end,
+      },
+      initializer: definition.initializer
+        ? expressionReference(definition.id, definition.initializer)
+        : null,
+      constant: definition.constant,
+    }
+  }
+
+  resolveReference(reference: ExpressionReference): SymbolDefinition | null {
+    const definition = this.#candidate.definitionAt(
+      reference.id,
+      reference.start,
+      reference.end
+    )
+    if (!definition) return null
+    return {
+      id: definition.id,
+      name: definition.name,
+      span: {
+        id: definition.id,
+        start: definition.start,
+        end: definition.end,
+      },
+      initializer: definition.initializer
+        ? expressionReference(definition.id, definition.initializer)
+        : null,
+      constant: definition.constant,
+    }
+  }
+
+  expressionNode(reference: ExpressionReference) {
+    if (!this.#modules.has(reference.id)) return null
+    return nodeAtSpan(
+      this.#candidate.programOf(reference.id),
+      reference.start,
+      reference.end
+    )
+  }
+
+  /**
+   * The members of a plain object literal, each as its own expression:
+   * `{ width: expr, height: 10 }`. Null for anything else, and for an object
+   * that spreads, computes a key, or defines a method or accessor.
+   */
+  objectMembers(
+    reference: ExpressionReference
+  ): { name: string; span: SourceSpan; value: ExpressionReference }[] | null {
+    const node = this.expressionNode(reference)
+    if (!node) return null
+    const object = unwrapExpression(node)
+    if (object.type !== 'ObjectExpression') return null
+    const members: { name: string; span: SourceSpan; value: ExpressionReference }[] = []
+    for (const property of childNodes(object, 'properties')) {
+      if (
+        (property.type !== 'Property' && property.type !== 'ObjectProperty') ||
+        property.computed === true ||
+        property.method === true ||
+        (property.kind !== undefined && property.kind !== 'init')
+      ) {
+        return null
+      }
+      const key = childNode(property, 'key')
+      const value = childNode(property, 'value')
+      if (!key || !value) return null
+      const name =
+        identifierName(key) ?? (typeof key.value === 'string' ? key.value : null)
+      if (name === null) return null
+      members.push({
+        name,
+        span: spanOf(reference.id, property),
+        value: expressionReference(reference.id, value),
+      })
+    }
+    return members
+  }
+
+  evaluate(reference: ExpressionReference): EvaluationResult {
+    return evaluateExpression(this, reference)
+  }
+
+  evaluateBranches(reference: ExpressionReference): BranchDecisionNode | null {
+    return evaluateBranches(this, reference)
+  }
+
+  evaluateDynamic(reference: ExpressionReference): DynamicEvaluation | null {
+    return evaluateDynamicExpression(this, reference)
+  }
+
+  evaluateBinding(id: ResolvedModuleId, localName: string): EvaluationResult {
+    return evaluateBinding(this, id, localName)
+  }
+
+  elementsOf(id: ResolvedModuleId): ElementIRResult {
+    const record = this.#modules.get(id)
+    if (!record) throw new Error(`Unknown host module ${id}`)
+    const cached = this.#elementCache.get(id)
+    if (cached?.hash === record.hash) return cached.result
+    const result = normalizeElements(this.#candidate, id, record.input.imports)
+    this.#elementCache.set(id, { hash: record.hash, result })
+    return result
+  }
+
+  diagnostics(): BailoutReason[] {
+    const diagnostics = this.#candidate
+      .diagnostics()
+      .map((diagnostic) =>
+        diagnostic.kind === 'parse'
+          ? localBailout(
+              'local/parse-error',
+              { id: diagnostic.id, start: 0, end: 0 },
+              diagnostic.message
+            )
+          : linkedBailout(
+              'linked/unresolved-binding',
+              { id: diagnostic.id, start: 0, end: 0 },
+              diagnostic.message
+            )
+      )
+    for (const [id, record] of this.#modules) {
+      for (const dependency of record.input.imports) {
+        if (dependency.external) continue
+        if (this.#modules.has(dependency.resolvedId)) continue
+        diagnostics.push(
+          linkedBailout(
+            'linked/unresolved-import',
+            { id, start: 0, end: 0 },
+            `Host-resolved import ${dependency.specifier} points outside the project graph`,
+            dependency.resolvedId
+          )
+        )
+      }
+    }
+    return diagnostics.sort((left, right) => {
+      const byId = compareCodeUnits(left.span.id, right.span.id)
+      return (
+        byId ||
+        left.span.start - right.span.start ||
+        compareCodeUnits(left.code, right.code)
+      )
+    })
+  }
+
+  updateModule(input: HostModuleInput): GraphInvalidation {
+    const previous = this.#modules.get(input.id)
+    const nextHash = moduleContentHash(input)
+    if (previous?.hash === nextHash) {
+      return {
+        changed: false,
+        id: input.id,
+        previousHash: previous.hash,
+        contentHash: previous.hash,
+        invalidatedIds: [],
+      }
+    }
+
+    const invalidatedIds = this.affectedBy(input.id)
+    const previousHash = previous?.hash ?? null
+    if (previous) this.#candidate.removeFile(input.id)
+    this.#installHostRecord(input)
+    this.#candidate.addFile(input.id, input.source)
+    this.#candidate.link()
+    for (const id of invalidatedIds) this.#elementCache.delete(id)
+
+    return {
+      changed: true,
+      id: input.id,
+      previousHash,
+      contentHash: nextHash,
+      invalidatedIds,
+    }
+  }
+
+  removeModule(id: ResolvedModuleId): GraphInvalidation {
+    const previous = this.#modules.get(id)
+    if (!previous) {
+      return {
+        changed: false,
+        id,
+        previousHash: null,
+        contentHash: null,
+        invalidatedIds: [],
+      }
+    }
+    const invalidatedIds = this.affectedBy(id)
+    this.#candidate.removeFile(id)
+    this.#removeOutgoingEdges(id)
+    this.#removeResolutions(id)
+    this.#modules.delete(id)
+    this.#files.delete(id)
+    this.#candidate.link()
+    for (const invalidated of invalidatedIds) this.#elementCache.delete(invalidated)
+    return {
+      changed: true,
+      id,
+      previousHash: previous.hash,
+      contentHash: null,
+      invalidatedIds,
+    }
+  }
+
+  #installHostRecord(input: HostModuleInput): void {
+    resolvedModuleId(input.id)
+    const seenSpecifiers = new Set<string>()
+    for (const dependency of input.imports) {
+      resolvedModuleId(dependency.resolvedId)
+      if (seenSpecifiers.has(dependency.specifier)) {
+        throw new Error(
+          `Duplicate host resolution for ${input.id}:${dependency.specifier}`
+        )
+      }
+      seenSpecifiers.add(dependency.specifier)
+    }
+
+    this.#removeOutgoingEdges(input.id)
+    this.#removeResolutions(input.id)
+    const dependencies = new Set(
+      input.imports
+        .filter(({ external }) => !external)
+        .map(({ resolvedId }) => resolvedId)
+    )
+    this.#dependencies.set(input.id, dependencies)
+    for (const dependency of dependencies) {
+      let reverse = this.#dependents.get(dependency)
+      if (!reverse) {
+        reverse = new Set()
+        this.#dependents.set(dependency, reverse)
+      }
+      reverse.add(input.id)
+    }
+    for (const dependency of input.imports) {
+      if (dependency.external) continue
+      this.#resolutions.set(
+        resolutionKey(input.id, dependency.specifier),
+        dependency.resolvedId
+      )
+    }
+    const installedInput: HostModuleInput = {
+      ...input,
+      imports: input.imports.map((dependency) => ({ ...dependency })),
+    }
+    this.#files.set(installedInput.id, installedInput.source)
+    this.#modules.set(installedInput.id, {
+      input: installedInput,
+      hash: moduleContentHash(installedInput),
+    })
+  }
+
+  #removeOutgoingEdges(id: ResolvedModuleId): void {
+    for (const dependency of this.#dependencies.get(id) ?? []) {
+      const reverse = this.#dependents.get(dependency)
+      reverse?.delete(id)
+      if (reverse?.size === 0) this.#dependents.delete(dependency)
+    }
+    this.#dependencies.delete(id)
+  }
+
+  #removeResolutions(id: ResolvedModuleId): void {
+    const prefix = `${id}\0`
+    for (const key of this.#resolutions.keys()) {
+      if (key.startsWith(prefix)) this.#resolutions.delete(key)
+    }
+  }
+}

package/src/hash.ts

@@ -0,0 +1,36 @@
+import { createHash } from 'node:crypto'
+
+/** The one content hash every compiler cache identity is built from. */
+export function contentHash(value: string | Uint8Array): string {
+  return createHash('sha256').update(value).digest('hex')
+}
+
+function compareCodeUnits(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0
+}
+
+function stringify(value: unknown): string | undefined {
+  if (Array.isArray(value)) {
+    return `[${value.map((child) => stringify(child) ?? 'null').join(',')}]`
+  }
+  if (value && typeof value === 'object') {
+    const entries = Object.entries(value as Record<string, unknown>)
+      .sort(([left], [right]) => compareCodeUnits(left, right))
+      .map(([key, child]) => [key, stringify(child)] as const)
+      .filter((entry): entry is readonly [string, string] => entry[1] !== undefined)
+    return `{${entries
+      .map(([key, child]) => `${JSON.stringify(key)}:${child}`)
+      .join(',')}}`
+  }
+  return JSON.stringify(value)
+}
+
+/**
+ * Key-order-independent JSON. Cache identities are hashed from this, so two
+ * objects that differ only in property order must serialize identically.
+ */
+export function stableStringify(value: unknown): string {
+  const serialized = stringify(value)
+  if (serialized === undefined) throw new Error('Cannot serialize undefined cache root')
+  return serialized
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from './ast'
+export * from './contracts'
+export * from './diagnostics'
+export * from './evaluate'
+export * from './graph'
+export * from './hash'
+export * from './ir'
+export * from './lower'
+export * from './materialize'
+export * from './output'
+export * from './planCache'
+export * from './session'
+export { normalizeElements } from './normalize'
+export * from './zero'
+export { parseModuleAst, yukuFactory } from './yuku'

package/src/ir.ts

@@ -0,0 +1,156 @@
+import type {
+  ExpressionReference,
+  HostResolvedImport,
+  ResolvedModuleId,
+  SourceSpan,
+  SymbolDefinition,
+} from './contracts'
+import type { BailoutReason } from './diagnostics'
+
+export type ElementForm = 'jsx' | 'jsx-runtime' | 'create-element'
+
+export type StaticValue = string | number | boolean | null
+
+export type ElementValue =
+  | { kind: 'static'; value: StaticValue; span: SourceSpan }
+  | ExpressionReference
+  | DOMStyleProgramIR
+
+export interface DOMStyleProgramIR {
+  kind: 'dom-style'
+  span: SourceSpan
+  items: {
+    condition: ExpressionReference | null
+    value: ExpressionReference
+  }[]
+}
+
+export interface ComponentImportProvenance {
+  specifier: string
+  importedName: string
+  resolvedId: ResolvedModuleId
+  external: boolean
+}
+
+export interface ElementComponentIR {
+  kind: 'binding' | 'intrinsic'
+  name: string
+  span: SourceSpan
+  closingSpan: SourceSpan | null
+  definition: SymbolDefinition | null
+  provenance: ComponentImportProvenance | null
+}
+
+export interface ElementPropIR {
+  kind: 'prop'
+  name: string
+  span: SourceSpan
+  value: ElementValue
+}
+
+export interface ElementSpreadIR {
+  kind: 'spread'
+  span: SourceSpan
+  value: ExpressionReference
+}
+
+export interface ElementChildIR {
+  kind: 'child'
+  span: SourceSpan
+  value:
+    | ElementValue
+    | { kind: 'element'; span: SourceSpan }
+    | { kind: 'empty'; span: SourceSpan }
+}
+
+/**
+ * Entries remain in source order. Consumers must apply duplicate props in this order;
+ * the last statically evaluated value wins exactly as it does at runtime.
+ */
+export type ElementEntryIR = ElementPropIR | ElementSpreadIR | ElementChildIR
+
+export interface ElementIRBase {
+  kind: 'element'
+  form: ElementForm
+  id: ResolvedModuleId
+  span: SourceSpan
+  /** JSX opening element or compiled props argument, used for punctuation-safe edits. */
+  propsSpan: SourceSpan | null
+  component: ElementComponentIR
+}
+
+export interface CompleteElementIR extends ElementIRBase {
+  complete: true
+  entries: ElementEntryIR[]
+  bailouts: readonly []
+}
+
+export interface IncompleteElementIR extends ElementIRBase {
+  complete: false
+  /** Preserved only for diagnostics; incomplete entries must never be optimized. */
+  bailedEntries: ElementEntryIR[]
+  bailouts: readonly [BailoutReason, ...BailoutReason[]]
+}
+
+export type ElementIR = CompleteElementIR | IncompleteElementIR
+
+export interface StyledDefinitionIRBase {
+  kind: 'styled-definition'
+  id: ResolvedModuleId
+  name: string
+  span: SourceSpan
+  definitionSpan: SourceSpan
+  factory: ComponentImportProvenance
+  base: ElementComponentIR
+  baseClassName: ElementValue | null
+  options: ExpressionReference
+  /** the object form's third argument, `styled(Base, options, staticConfig)` */
+  staticConfig: ExpressionReference | null
+}
+
+export interface CompleteStyledDefinitionIR extends StyledDefinitionIRBase {
+  complete: true
+  bailouts: readonly []
+}
+
+export interface IncompleteStyledDefinitionIR extends StyledDefinitionIRBase {
+  complete: false
+  bailouts: readonly [BailoutReason, ...BailoutReason[]]
+}
+
+export type StyledDefinitionIR = CompleteStyledDefinitionIR | IncompleteStyledDefinitionIR
+
+/** A compile-time style handle declared by a Tamagui style frontend. */
+export interface DOMStyleDefinitionIR {
+  kind: 'dom-style-definition'
+  id: ResolvedModuleId
+  name: string
+  /** Span of the complete style(...) call. */
+  span: SourceSpan
+  definitionSpan: SourceSpan
+  factory: ComponentImportProvenance
+  value: ExpressionReference
+}
+
+export interface ElementIRResult {
+  elements: ElementIR[]
+  styledDefinitions: StyledDefinitionIR[]
+  domStyleDefinitions: DOMStyleDefinitionIR[]
+  bailouts: BailoutReason[]
+}
+
+export function hostImportProvenance(
+  imports: readonly HostResolvedImport[],
+  specifier: string,
+  importedName: string
+): ComponentImportProvenance | null {
+  const resolution = imports.find((candidate) => candidate.specifier === specifier)
+  return resolution
+    ? {
+        specifier,
+        importedName,
+        resolvedId: resolution.resolvedId,
+        external: resolution.external === true,
+      }
+    : null
+}