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

package/src/contracts.ts

@@ -0,0 +1,148 @@
+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
+  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
+  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 }
+}