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

package/src/ast.ts

@@ -0,0 +1,106 @@
+import type { AstNode } from './contracts'
+
+const ignoredKeys = new Set(['loc', 'range', 'parent', 'comments', 'tokens'])
+
+export function isAstNode(value: unknown): value is AstNode {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as AstNode).type === 'string' &&
+    typeof (value as AstNode).start === 'number' &&
+    typeof (value as AstNode).end === 'number'
+  )
+}
+
+export function walkAst(
+  node: AstNode,
+  visitor: (node: AstNode, parent: AstNode | null, key: string | null) => void,
+  parent: AstNode | null = null,
+  key: string | null = null
+): void {
+  visitor(node, parent, key)
+
+  for (const childKey of Object.keys(node)) {
+    if (ignoredKeys.has(childKey)) continue
+    const value = node[childKey]
+    if (isAstNode(value)) {
+      walkAst(value, visitor, node, childKey)
+    } else if (Array.isArray(value)) {
+      for (const child of value) {
+        if (isAstNode(child)) {
+          walkAst(child, visitor, node, childKey)
+        }
+      }
+    }
+  }
+}
+
+/** With a source range, only descend into nodes that contain that range. */
+export function findAstNode(
+  root: AstNode,
+  predicate: (node: AstNode, parent: AstNode | null, key: string | null) => boolean,
+  span?: Pick<AstNode, 'start' | 'end'>
+): AstNode | null {
+  function visit(
+    node: AstNode,
+    parent: AstNode | null,
+    key: string | null
+  ): AstNode | null {
+    if (span && (node.start > span.start || node.end < span.end)) return null
+    if (predicate(node, parent, key)) return node
+    for (const childKey of Object.keys(node)) {
+      if (ignoredKeys.has(childKey)) continue
+      const value = node[childKey]
+      if (isAstNode(value)) {
+        const found = visit(value, node, childKey)
+        if (found) return found
+      } else if (Array.isArray(value)) {
+        for (const child of value) {
+          if (!isAstNode(child)) continue
+          const found = visit(child, node, childKey)
+          if (found) return found
+        }
+      }
+    }
+    return null
+  }
+  return visit(root, null, null)
+}
+
+export function childNode(node: AstNode, key: string): AstNode | null {
+  const value = node[key]
+  return isAstNode(value) ? value : null
+}
+
+export function childNodes(node: AstNode, key: string): AstNode[] {
+  const value = node[key]
+  return Array.isArray(value) ? value.filter(isAstNode) : []
+}
+
+export function identifierName(node: AstNode | null): string | null {
+  if (!node || (node.type !== 'Identifier' && node.type !== 'JSXIdentifier')) return null
+  return typeof node.name === 'string' ? node.name : null
+}
+
+export function literalValue(node: AstNode | null): unknown {
+  if (!node) return undefined
+  if (node.type === 'Literal' || node.type.endsWith('Literal')) {
+    return node.value
+  }
+  return undefined
+}
+
+export function unwrapExpression(node: AstNode): AstNode {
+  let current = node
+  while (
+    current.type === 'TSAsExpression' ||
+    current.type === 'TSSatisfiesExpression' ||
+    current.type === 'TSNonNullExpression' ||
+    current.type === 'ParenthesizedExpression'
+  ) {
+    const expression = childNode(current, 'expression')
+    if (!expression) break
+    current = expression
+  }
+  return current
+}

package/src/contracts.ts

@@ -0,0 +1,150 @@
+export interface AstNode {
+  type: string
+  start: number
+  end: number
+  [key: string]: unknown
+}
+
+export type ResolvedModuleId = string & { readonly __resolvedModuleId: unique symbol }
+
+export interface SourceSpan {
+  id: ResolvedModuleId
+  /** UTF-16 source-string index, inclusive. */
+  start: number
+  /** UTF-16 source-string index, exclusive. */
+  end: number
+}
+
+export interface HostResolvedImport {
+  specifier: string
+  resolvedId: ResolvedModuleId
+  external?: boolean
+}
+
+export interface HostModuleInput {
+  id: ResolvedModuleId
+  source: string
+  /** Every import identity is canonical and resolved before the compiler sees it. */
+  imports: readonly HostResolvedImport[]
+}
+
+export interface HostResolvedProject {
+  modules: readonly HostModuleInput[]
+}
+
+export interface ProjectInput {
+  files: ReadonlyMap<string, string>
+  resolutions: ReadonlyMap<string, string>
+}
+
+export interface DefinitionSite {
+  id: ResolvedModuleId
+  name: string
+  start: number
+  end: number
+  initializer: AstNode | null
+  constant: boolean
+}
+
+export interface ReferenceSite {
+  id: ResolvedModuleId
+  name: string
+  start: number
+  end: number
+}
+
+export interface ParseDiagnostic {
+  kind: 'parse' | 'link'
+  id: ResolvedModuleId
+  message: string
+}
+
+export interface AnalyzerCandidate {
+  readonly name: string
+  addFile(id: string, source: string): void
+  removeFile(id: string): boolean
+  link(): void
+  definitionOf(id: string, localName: string): DefinitionSite | null
+  definitionAt(id: string, start: number, end: number): DefinitionSite | null
+  referencesOf(definition: DefinitionSite): ReferenceSite[]
+  dependenciesOf(id: string): string[]
+  dependentsOf(id: string): string[]
+  affectedBy(id: string): string[]
+  programOf(id: string): AstNode
+  sourceOf(id: string): string
+  parseCount(id: string): number
+  diagnostics(): ParseDiagnostic[]
+}
+
+export interface ExpressionReference extends SourceSpan {
+  readonly kind: 'expression'
+}
+
+export interface SymbolDefinition {
+  id: ResolvedModuleId
+  name: string
+  span: SourceSpan
+  initializer: ExpressionReference | null
+  constant: boolean
+}
+
+/** Parser-independent symbol access used by partial evaluation and element IR. */
+export interface SymbolResolver {
+  resolveBinding(id: ResolvedModuleId, localName: string): SymbolDefinition | null
+  resolveReference(reference: ExpressionReference): SymbolDefinition | null
+  expressionNode(reference: ExpressionReference): AstNode | null
+  sourceOf(id: ResolvedModuleId): string
+}
+
+export interface CandidateFactory {
+  name: AnalyzerCandidate['name']
+  create(project: ProjectInput): AnalyzerCandidate
+  /** Parser-owned static module scan; no parser-specific node types escape this boundary. */
+  scanImports(id: ResolvedModuleId, source: string): string[]
+}
+
+export function resolutionKey(importer: string, specifier: string): string {
+  return `${importer}\0${specifier}`
+}
+
+export function resolveFromHost(
+  resolutions: ReadonlyMap<string, string>,
+  specifier: string,
+  importer: string
+): string | null {
+  return resolutions.get(resolutionKey(importer, specifier)) ?? null
+}
+
+export function resolvedModuleId(id: string): ResolvedModuleId {
+  const isAbsolute =
+    id.startsWith('/') ||
+    id.startsWith('\\') ||
+    id.startsWith('\0') ||
+    /^[A-Za-z]:[\\/]/.test(id) ||
+    /^[A-Za-z][A-Za-z\d+.-]*:\/\//.test(id)
+  if (!isAbsolute) {
+    throw new Error(`Host module id must be canonical and already resolved: ${id}`)
+  }
+  return id as ResolvedModuleId
+}
+
+export function expressionReference(
+  id: ResolvedModuleId,
+  node: Pick<AstNode, 'start' | 'end'>
+): ExpressionReference {
+  return { kind: 'expression', id, start: node.start, end: node.end }
+}
+
+export function spanOf(
+  id: ResolvedModuleId,
+  node: Pick<AstNode, 'start' | 'end'>
+): SourceSpan {
+  return { id, start: node.start, end: node.end }
+}
+
+export function textOfSpan(
+  source: string,
+  span: Pick<SourceSpan, 'start' | 'end'>
+): string {
+  return source.slice(span.start, span.end)
+}

package/src/diagnostics.ts

@@ -0,0 +1,96 @@
+import type { ResolvedModuleId, SourceSpan } from './contracts'
+
+export type BailoutCode =
+  | 'local/invalid-element-call'
+  | 'local/unsupported-element-name'
+  | 'local/unsupported-prop-key'
+  | 'local/unsupported-child'
+  | 'local/unsupported-expression'
+  | 'local/unsupported-styled-definition'
+  | 'local/dynamic-style-value'
+  | 'local/unsafe-style-spread'
+  | 'local/unsupported-target'
+  | 'local/style-resolution-failed'
+  | 'local/overlapping-edit'
+  | 'local/non-object-spread'
+  | 'local/static-evaluation-cycle'
+  | 'local/parse-error'
+  | 'linked/unresolved-component-binding'
+  | 'linked/unresolved-binding'
+  | 'linked/missing-initializer'
+  | 'linked/unresolved-import'
+  | 'linked/unresolved-component-config'
+
+/**
+ * The zero-runtime rule a diagnostic belongs to. Set by whichever site knows the
+ * reason; `zeroRuleForBailout` supplies the default for the rest.
+ */
+export type ZeroRule = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
+
+export interface BailoutReason {
+  code: BailoutCode
+  kind: 'local' | 'linked'
+  message: string
+  span: SourceSpan
+  dependencyId?: ResolvedModuleId
+  component?: string
+  specifier?: string
+  prop?: string
+  /**
+   * True when this diagnostic stopped its candidate from lowering. Zero mode
+   * reports exactly these: a diagnostic recorded alongside a successful
+   * lowering describes a dropped prop, not a retained runtime.
+   */
+  blocking?: boolean
+  /** Set where the reporting site knows better than the code-level default. */
+  zeroRule?: ZeroRule
+  /** The design's fixed text for sites that have one, used verbatim. */
+  zeroMessage?: string
+}
+
+/**
+ * The rule a bailout code belongs to when its site did not name one. Ordinary
+ * compiler mode ignores this entirely.
+ */
+const ZERO_RULE_BY_CODE: Record<BailoutCode, ZeroRule> = {
+  'local/invalid-element-call': 2,
+  'local/unsupported-element-name': 2,
+  'local/unsupported-prop-key': 3,
+  'local/unsupported-child': 3,
+  'local/unsupported-expression': 3,
+  'local/unsupported-styled-definition': 3,
+  'local/dynamic-style-value': 3,
+  'local/unsafe-style-spread': 1,
+  'local/unsupported-target': 6,
+  'local/style-resolution-failed': 3,
+  'local/overlapping-edit': 6,
+  'local/non-object-spread': 1,
+  'local/static-evaluation-cycle': 3,
+  'local/parse-error': 3,
+  'linked/unresolved-component-binding': 2,
+  'linked/unresolved-binding': 2,
+  'linked/missing-initializer': 3,
+  'linked/unresolved-import': 2,
+  'linked/unresolved-component-config': 2,
+}
+
+export function zeroRuleForBailout(reason: BailoutReason): ZeroRule {
+  return reason.zeroRule ?? ZERO_RULE_BY_CODE[reason.code]
+}
+
+export function localBailout(
+  code: Extract<BailoutCode, `local/${string}`>,
+  span: SourceSpan,
+  message: string
+): BailoutReason {
+  return { code, kind: 'local', message, span }
+}
+
+export function linkedBailout(
+  code: Extract<BailoutCode, `linked/${string}`>,
+  span: SourceSpan,
+  message: string,
+  dependencyId?: ResolvedModuleId
+): BailoutReason {
+  return { code, kind: 'linked', message, span, dependencyId }
+}