refactor(common/utils): simplify context implementation

Author: exuanbo

eslint.config.js

@@ -51,7 +51,6 @@ export default defineConfig(
   {
     name: 'exuanbo/react',
     basePath: 'src',
-    ignores: ['core/**'],
     extends: [
       {
         name: 'react/jsx',

src/common/utils/context.ts

@@ -2,72 +2,52 @@
 // https://blog.skk.moe/post/context-in-javascript/
 // CC BY-NC-SA 4.0 https://creativecommons.org/licenses/by-nc-sa/4.0/deed.zh
 
-export type ApplyProvider = <R>(callback: () => R) => R
-
-export interface ContextProvider<T> {
-  <R>(props: { value: T, callback: () => R }): R
-  (props: { value: T }): ApplyProvider
-}
-
-export interface ContextConsumer<T> {
-  <R>(callback: (value: T) => R): R
-  (): T
-}
+import { invariant } from './invariant'
 
 export interface Context<T> {
-  Provider: ContextProvider<T>
-  Consumer: ContextConsumer<T>
+  get(): T
+  run<R>(value: T, fn: () => R): R
+  run(value: T): <R>(fn: () => R) => R
 }
 
-const NO_VALUE_DEFAULT = Symbol('NO_VALUE_DEFAULT')
-type ContextValue<T> = T | typeof NO_VALUE_DEFAULT
+const NIL = Symbol('NIL')
+
+export function createContext<T>(defaultValue: T | typeof NIL = NIL): Context<T> {
+  let value = defaultValue
 
-export function createContext<T>(defaultValue: ContextValue<T> = NO_VALUE_DEFAULT): Context<T> {
-  let contextValue = defaultValue
+  function get() {
+    invariant(value != NIL)
+    return value
+  }
 
-  const Provider = <R>({ value, callback }: { value: T, callback?: () => R }) => {
-    if (!callback) {
-      return (fn: typeof callback) => Provider({ value, callback: fn })
+  function run<R>(next: T, cb?: () => R) {
+    if (!cb) {
+      return (fn: typeof cb) => run(next, fn)
     }
-    const currentValue = contextValue
-    contextValue = value
+    const prev = value
+    value = next
     try {
-      return callback()
+      return cb()
     }
     finally {
-      contextValue = currentValue
+      value = prev
     }
   }
 
-  const Consumer = <R>(callback?: (value: T) => R) => {
-    if (contextValue === NO_VALUE_DEFAULT) {
-      throw new TypeError('Missing context: use within Provider or set default value.')
-    }
-    if (!callback) {
-      return contextValue
-    }
-    return callback(contextValue)
-  }
-
   return {
-    Provider,
-    Consumer,
+    get,
+    run,
   }
 }
 
-export function useContext<T>(Context: Context<T>): T {
-  return Context.Consumer()
-}
+export type Executor = <R>(fn: () => R) => R
 
-export interface ContextComposeProviderProps<R> {
-  contexts: ApplyProvider[]
-  callback: () => R
-}
+export function compose<R>(executors: Executor[], fn: () => R): R
 
-export function ComposeProvider<R>({ contexts, callback }: ContextComposeProviderProps<R>): R {
-  const applyProviders = contexts.reduceRight(
+export function compose<R>(executors: Executor[], cb: () => R) {
+  const execute = executors.reduceRight(
     (composed, current) => (fn) => current(() => composed(fn)),
     (fn) => fn(),
   )
-  return applyProviders(callback)
+  return execute(cb)
 }

src/core/assembler/assembler.state.ts

@@ -1,4 +1,4 @@
-import { createContext, useContext } from '@/common/utils/context'
+import { createContext } from '@/common/utils/context'
 
 import { getSize } from './assembler.utils'
 import type { AssemblyNode } from './assemblyunit'
@@ -36,7 +36,3 @@ export function createAssemblerState(initialAddress = 0): AssemblerState {
 }
 
 export const AssemblerState = createContext<AssemblerState>()
-
-export function useAssemblerState(): AssemblerState {
-  return useContext(AssemblerState)
-}

src/core/assembler/assembler.ts

@@ -1,9 +1,9 @@
 import { expectNever } from 'ts-expect'
 
-import { ComposeProvider } from '@/common/utils/context'
+import { compose } from '@/common/utils/context'
 import { invariant } from '@/common/utils/invariant'
 
-import { AssemblerState, createAssemblerState, useAssemblerState } from './assembler.state'
+import { AssemblerState, createAssemblerState } from './assembler.state'
 import { getSize, hasIdentifier, type WithIdentifier } from './assembler.utils'
 import {
   type AssemblyNode,
@@ -18,7 +18,7 @@ import * as InstrSet from './instrset'
 import { resolveOpcode } from './instrset.utils'
 import { createLexer } from './lexer'
 import { createParser } from './parser'
-import { createParserContext, ParserContext, useParserContext } from './parser.context'
+import { createParserContext, ParserContext } from './parser.context'
 import { createTokenStream, TokenStream } from './token.stream'
 
 interface PendingChunk extends CodeChunk {
@@ -44,26 +44,27 @@ export class Assembler {
   assemble(input: string): AssemblyUnit {
     const lexer = createLexer(input)
     const stream = createTokenStream(lexer)
+
     const context = createParserContext()
     const initialState = createAssemblerState()
-    return ComposeProvider({
-      contexts: [
-        AssemblerState.Provider({ value: initialState }),
-        ParserContext.Provider({ value: context }),
-        TokenStream.Provider({ value: stream }),
+    return compose(
+      [
+        AssemblerState.run(initialState),
+        ParserContext.run(context),
+        TokenStream.run(stream),
       ],
-      callback: () => {
+      () => {
         const unit = this.setup()
         const ast = this.parse()
         return this.hasError()
           ? finalize(unit, { chunks: [] })
           : finalize(unit, { ast, labels: context.labels })
       },
-    })
+    )
   }
 
   private parse(): AST.Program | null {
-    const context = useParserContext()
+    const context = ParserContext.get()
     const parser = createParser()
     try {
       while (true) {
@@ -125,7 +126,7 @@ export class Assembler {
   }
 
   private updateAddress(node: AST.Immediate | ProcessableNode): void {
-    const state = useAssemblerState()
+    const state = AssemblerState.get()
     if (node.type === AST.NodeType.Immediate) {
       this.catchError(() => state.setAddress(node))
     }
@@ -158,15 +159,15 @@ export class Assembler {
   }
 
   private processLabel({ children: [name] }: AST.Identifier): void {
-    const state = useAssemblerState()
-    const context = useParserContext()
+    const state = AssemblerState.get()
+    const context = ParserContext.get()
     const label = context.labels.get(name)
     invariant(label?.loc, `Label '${name}' is undefined`)
     label.address = state.address
   }
 
   private processInstruction(node: AST.Instruction): void {
-    const state = useAssemblerState()
+    const state = AssemblerState.get()
     const buffer = new Uint8Array(getSize(node))
     const baseChunk = {
       offset: state.address,
@@ -185,7 +186,7 @@ export class Assembler {
   }
 
   private processDataByte(node: AST.Db): void {
-    const state = useAssemblerState()
+    const state = AssemblerState.get()
     const buffer = new Uint8Array(this.resolve(node.children))
     this.unit.chunks.push({
       offset: state.address,
@@ -197,10 +198,7 @@ export class Assembler {
   private processPendingChunks(): void {
     this.pendings.forEach((chunk) => {
       const state = createAssemblerState(chunk.offset)
-      AssemblerState.Provider({
-        value: state,
-        callback: () => this.encodePending(chunk),
-      })
+      AssemblerState.run(state, () => this.encodePending(chunk))
     })
   }
 
@@ -243,8 +241,8 @@ function unsafe_resolve(nodes: ResolvableNode[]): number[] {
 }
 
 function resolveIdentifier({ children: [name], loc }: AST.Identifier): number {
-  const state = useAssemblerState()
-  const context = useParserContext()
+  const state = AssemblerState.get()
+  const context = ParserContext.get()
   const label = context.labels.get(name)
   invariant(label, `Label '${name}' is not added`)
   invariant(!Number.isNaN(label.address), `Label '${name}' is not processed`)

src/core/assembler/parser.context.ts

@@ -1,4 +1,4 @@
-import { createContext, useContext } from '@/common/utils/context'
+import { createContext } from '@/common/utils/context'
 
 import type * as AST from './ast'
 import { ErrorCode, type ParserDiagnostic, ParserError, ParserWarning } from './errors'
@@ -80,7 +80,3 @@ export function createParserContext(): ParserContext {
 }
 
 export const ParserContext = createContext<ParserContext>()
-
-export function useParserContext(): ParserContext {
-  return useContext(ParserContext)
-}

src/core/assembler/parser.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { ComposeProvider } from '@/common/utils/context'
+import { compose } from '@/common/utils/context'
 import { examples } from '@/features/editor/examples'
 
 import * as AST from './ast'
@@ -33,13 +33,13 @@ function applyParser<Node extends AST.Node>(
 ) {
   const lexer = createLexer(input)
   const stream = createTokenStream(lexer)
-  return ComposeProvider({
-    contexts: [
-      ParserContext.Provider({ value: context }),
-      TokenStream.Provider({ value: stream }),
+  return compose(
+    [
+      ParserContext.run(context),
+      TokenStream.run(stream),
     ],
-    callback: parse,
-  })
+    parse,
+  )
 }
 
 describe('Parser', () => {