@abide/abide 0.123.2 → 0.124.0

package/src/compiler/appLayout.ts

@@ -16,16 +16,15 @@ import {
 } from '#shared/routePattern.ts'
 
 import { abideImportsOf, componentGraph } from './componentGraph.ts'
+import { type Diagnosis, Diagnostics } from './Diagnostics.ts'
 import type { HandlerFile } from './handlersUnder.ts'
 import { hookCalls, hooksIn } from './hookCalls.ts'
 import { matchersOf, type MountedTree } from './matchersOf.ts'
 import { mountsOf } from './mountsOf.ts'
 import { type AbideFile, scriptBodies } from './parseAbide.ts'
 import { type ParsedSource, parseSources } from './readSources.ts'
-import { Refusals } from './Refusals.ts'
 import { resolverIn } from './resolverIn.ts'
 import { attributedImports } from './splitImports.ts'
-import type { Diagnosis } from './TypeSession.ts'
 
 // THE APP, LAID OUT ONCE PER COMPILE OR CHECK: every `.abide` and handler file it holds — its own, a
 // dependency's it imports, a package's it mounts — each with where it sits and what that makes it
@@ -110,15 +109,15 @@ export type AppLayout = {
  */
 export async function appLayout(root: string): Promise<AppLayout> {
     // COLLECTED, whoever asks: a layout is kept across checks (`AppChecker`), and a build adopts
-    // what it found (`Refusals.adopt`).
-    const refusals = new Refusals(root, true)
+    // what it found (`Diagnostics.adopt`).
+    const refusals = new Diagnostics(root, true)
     const { abide, handlers, params, modules, published } = appFiles(
         root,
         refusals,
     )
     await refuseModuleHooks(root, modules, refusals)
     const resolve = resolverIn()
-    const unparsed = new Refusals(root, true)
+    const unparsed = new Diagnostics(root, true)
     const own = parseSources(
         await textsAt(abide.map((path) => `${root}/${path}`)),
         unparsed,
@@ -140,13 +139,7 @@ export async function appLayout(root: string): Promise<AppLayout> {
             found.positions.get(source.path) ?? relative,
         )
         refusePlace(source, placed, resolve, refusals)
-        sources.push({
-            ...source,
-            ...placed,
-            paints: paints(source.file),
-            invoked: invoked.has(source.path),
-            hooks: hooksIn(scriptBodies(source.file)),
-        })
+        sources.push(placedSource(source, placed, invoked.has(source.path)))
     }
     const texts = await textsAt(found.handlers.map((file) => file.path))
     const placedHandlers: PlacedHandler[] = []
@@ -209,8 +202,8 @@ export async function appLayout(root: string): Promise<AppLayout> {
         errors,
         published,
         addresses: [...addresses].sort(),
-        refused: refusals.found,
-        unparsed: unparsed.found,
+        refused: refusals.refused,
+        unparsed: unparsed.refused,
         resolve,
     }
 }
@@ -250,9 +243,9 @@ export async function withDependencies(
     parsed: readonly ParsedSource[],
     own: readonly string[],
     resolve: (specifier: string, from: string) => string | undefined,
-    refusals: Refusals,
+    refusals: Diagnostics,
     /** Where what the parser refuses of a file reached here goes, where apart from `refusals`. */
-    unparsed: Refusals = refusals,
+    unparsed: Diagnostics = refusals,
 ): Promise<{
     sources: ParsedSource[]
     handlers: HandlerFile[]
@@ -347,6 +340,21 @@ export async function withDependencies(
 }
 
 /** Whether a page or an error page has anything to paint: a template, or a head. 23.3, 35.14. */
+/** `source` at `placed`, with what its own text says it paints and calls. */
+export function placedSource(
+    source: ParsedSource,
+    placed: Placement,
+    invoked: boolean,
+): PlacedSource {
+    return {
+        ...source,
+        ...placed,
+        paints: paints(source.file),
+        invoked,
+        hooks: hooksIn(scriptBodies(source.file)),
+    }
+}
+
 export function paints(file: AbideFile): boolean {
     return file.template.length > 0 || file.head.length > 0
 }
@@ -362,7 +370,7 @@ function refusePlace(
     source: ParsedSource,
     placed: Placement,
     resolve: (specifier: string, from: string) => string | undefined,
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): void {
     const { relative, place, kind } = placed
     if (source.file.servers.length > 0 && place === 'public')
@@ -404,7 +412,7 @@ function refusePlace(
 async function refuseModuleHooks(
     root: string,
     modules: readonly string[],
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): Promise<void> {
     const texts = await textsAt(modules.map((module) => `${root}/${module}`))
     for (let at = 0; at < modules.length; at += 1) {
@@ -428,7 +436,7 @@ async function refuseModuleHooks(
 function refuseStrayLauncher(
     sources: readonly PlacedSource[],
     handlers: readonly PlacedHandler[],
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): void {
     const stray = (relative: string): void =>
         refusals.at(
@@ -457,7 +465,7 @@ function refuseStrayLauncher(
  */
 function routesOf(
     sources: readonly PlacedSource[],
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): { routes: AppRoute[]; errors: AppRoute[] } {
     const layouts: { source: string; segments: Segment[] }[] = []
     const layoutAt = new Map<string, string>()

package/src/compiler/appLints.ts

@@ -0,0 +1,109 @@
+import { AMBIENT_SOURCES, ambientReadsIn } from './ambientReadsIn.ts'
+import { argsDefaultsIn } from './argsDefaultsIn.ts'
+import {
+    byPlace,
+    type Diagnosis,
+    type Finding,
+    placedFindings,
+} from './Diagnostics.ts'
+import { projectShadow } from './projectShadow.ts'
+import type { ParsedSource } from './readSources.ts'
+import type { ShadowHost } from './ShadowHost.ts'
+import { ShadowMap } from './ShadowMap.ts'
+
+/**
+ * What the build refuses and warns on in the app's `.ts` files and its `.abide` `sources`.
+ *
+ * 11.37 — `ambient`: every read of a request's ambient inside a `global` value's body, as errors.
+ * 11.30 — `unkeyed`: every `args` defaulting a member its body's parameter does not, as warnings.
+ * Both over every `.ts` under `within` and each of `sources` as the shadow its reads registered
+ * for it, because a keyed value is declared in a `.ts` as often as in a `.abide` — one walk of
+ * the files for the two, each finding on its own line of the file an author wrote. `scripts`
+ * as a diagnosis reads it: an editor asking about one page does not walk the app's `.ts`.
+ */
+export async function appLints(
+    host: ShadowHost,
+    within: string,
+    sources: readonly Omit<ParsedSource, 'quiet'>[],
+    scripts: boolean,
+): Promise<{ ambient: Diagnosis[]; unkeyed: Diagnosis[] }> {
+    const ambient: Diagnosis[] = []
+    const unkeyed: Diagnosis[] = []
+    await host.ask(async (project) => {
+        const checker = project.checker
+        const ambientPaths = new Map<string, string>()
+        const declared = await Promise.all(
+            AMBIENT_SOURCES.map((source) =>
+                project.program.getSourceFile(source),
+            ),
+        )
+        for (let at = 0; at < AMBIENT_SOURCES.length; at += 1) {
+            const found = declared[at]?.path
+            if (found !== undefined)
+                ambientPaths.set(AMBIENT_SOURCES[at] as string, found)
+        }
+        const authored = new Map<
+            string,
+            { source: (typeof sources)[number]; map: ShadowMap }
+        >()
+        for (const source of sources) {
+            const map = new ShadowMap(
+                host.canonical(source.path),
+                projectShadow(source.file).origins,
+            )
+            authored.set(host.keyOf(map.shadowPath), { source, map })
+        }
+        // A file of the host's own is one of `sources`' shadows or not walked at all: a checked
+        // module is the lowering's, and placed nowhere an author wrote.
+        const files: string[] = []
+        if (scripts)
+            for (const path of host.rootsUnder(project, within)) {
+                if (authored.has(host.keyOf(path)) || !host.holds(path))
+                    files.push(path)
+            }
+        else for (const { map } of authored.values()) files.push(map.shadowPath)
+        await Promise.all(
+            files.map(async (path) => {
+                const sourceFile = await project.program.getSourceFile(path)
+                if (sourceFile === undefined) return
+                const [reads, defaults] = await Promise.all([
+                    ambientPaths.size === 0
+                        ? []
+                        : ambientReadsIn(checker, sourceFile, ambientPaths),
+                    argsDefaultsIn(checker, sourceFile),
+                ])
+                if (reads.length === 0 && defaults.length === 0) return
+                const shadow = authored.get(host.keyOf(path))
+                const source = shadow?.source
+                const text =
+                    source === undefined
+                        ? await Bun.file(path).text()
+                        : source.text
+                const place = (at: number): number =>
+                    shadow === undefined ? at : shadow.map.toSource(path, at)
+                const named = source?.path ?? path
+                const ambientReads: Finding[] = []
+                for (const read of reads)
+                    ambientReads.push({
+                        at: read.at,
+                        message: `abide: a \`global\` value's body reads \`${read.ambient}\`, which belongs to the request it was built in — every later request would be answered with this one's. Take it out of the body, or drop \`global\`. RULEBOOK 11.37.`,
+                    })
+                ambient.push(
+                    ...placedFindings(
+                        named,
+                        text,
+                        ambientReads,
+                        place,
+                        'error',
+                    ),
+                )
+                unkeyed.push(
+                    ...placedFindings(named, text, defaults, place, 'warning'),
+                )
+            }),
+        )
+    })
+    ambient.sort(byPlace)
+    unkeyed.sort(byPlace)
+    return { ambient, unkeyed }
+}

package/src/compiler/argsDefaultsIn.ts

@@ -17,7 +17,7 @@ import {
 } from 'typescript/unstable/ast/is'
 import { type Checker, SymbolFlags, type Type } from 'typescript/unstable/async'
 
-import type { Finding } from './Finding.ts'
+import type { Finding } from './Diagnostics.ts'
 import { optionNamed, reactiveOptions } from './reactiveOptions.ts'
 
 // 11.30 — AN `args` SCHEMA DEFAULTING A MEMBER THE BODY'S PARAMETER DOES NOT. The key is taken before

package/src/compiler/checkApp.ts

@@ -1,15 +1,14 @@
 import { relative } from 'node:path' // bun exposes no path helpers of its own
 
-import { type Placement, placement } from '#server/placement.ts'
+import { placement } from '#server/placement.ts'
 
-import type { PlacedSource } from './appLayout.ts'
-import { type AppChecker, compiled } from './compileApp.ts'
+import { type PlacedSource, placedSource } from './appLayout.ts'
+import { type AppChecker, compiled, compiledSources } from './compileApp.ts'
 import { abideImportsOf } from './componentGraph.ts'
+import { type Diagnosis, Diagnostics } from './Diagnostics.ts'
 import { hooksIn } from './hookCalls.ts'
 import { parseAbide, scriptBodies } from './parseAbide.ts'
 import { parseSources, readSources } from './readSources.ts'
-import { Refusals } from './Refusals.ts'
-import type { Diagnosis } from './TypeSession.ts'
 
 /**
  * Every finding `abide check` reports for the app at `appRoot`.
@@ -50,74 +49,71 @@ export async function checkSource(
 ): Promise<Diagnosis[]> {
     const { session, root } = checker
     const layout = await checker.layout()
+    const diagnostics = new Diagnostics(root, true)
     // 38.33 — WHAT THE TREE REFUSES OF IT, off the layout the checker keeps until a move is heard.
     // What the parser refuses is the held text's, below, never the disk's (`layout.unparsed`).
-    const tree: Diagnosis[] = []
-    for (const refused of layout.refused)
-        if (refused.path === path) tree.push(refused)
-    const refusals = new Refusals(root, true)
-    const [page] = parseSources([{ path, text }], refusals)
-    if (page === undefined) return [...tree, ...refusals.found]
+    diagnostics.adopt(layout.refused)
+    const [page] = parseSources([{ path, text }], diagnostics)
     // 23.19 — WHERE THE APP PLACES IT, so a mounted page's `route.params` is typed by the route its
     // mount gives it, as `checkApp` types it; a file the layout has not seen is placed at its path.
-    const placed: Pick<Placement, 'kind' | 'route'> =
-        layout.sources.find((source) => source.path === path) ??
-        placement(relative(root, path))
-    const imports: { path: string; text: string; quiet: boolean }[] = []
-    for (const imported of abideImportsOf(
-        path,
-        page.file,
-        layout.resolve,
-    ).values())
-        try {
-            imports.push({
-                path: imported,
-                text: held(imported) ?? (await Bun.file(imported).text()),
-                quiet: true,
-            })
-        } catch {
-            // A component that cannot be read takes anything here.
-        }
-    // 27.13 — AND EVERY FILE FILING `onConfig`, quietly, so a page that only reads `config()` is
-    // typed by defaults it never imported — as `checkApp`'s whole-app program types it. The calls
-    // only name candidates; the checker decides which file.
-    const lowered = new Set(imports.map((one) => one.path))
-    for (const other of layout.sources) {
-        if (other.path === path || lowered.has(other.path)) continue
-        const editing = held(other.path)
-        if (
-            editing === undefined || editing === other.text
-                ? other.hooks.includes('onConfig')
-                : filesConfig(editing)
+    const own: PlacedSource[] = []
+    const beside: { path: string; text: string; quiet: boolean }[] = []
+    if (page !== undefined) {
+        const laid = layout.sources.find((source) => source.path === path)
+        own.push(
+            laid === undefined
+                ? placedSource(page, placement(relative(root, path)), false)
+                : { ...laid, ...page },
         )
-            imports.push({
-                path: other.path,
-                text: editing ?? other.text,
-                quiet: true,
-            })
+        for (const imported of abideImportsOf(
+            path,
+            page.file,
+            layout.resolve,
+        ).values())
+            try {
+                beside.push({
+                    path: imported,
+                    text: held(imported) ?? (await Bun.file(imported).text()),
+                    quiet: true,
+                })
+            } catch {
+                // A component that cannot be read takes anything here.
+            }
+        // 27.13 — AND EVERY FILE FILING `onConfig`, quietly, so a page that only reads `config()`
+        // is typed by defaults it never imported — as `checkApp`'s whole-app program types it. The
+        // calls only name candidates; the checker decides which file.
+        const lowered = new Set(beside.map((one) => one.path))
+        for (const other of layout.sources) {
+            if (other.path === path || lowered.has(other.path)) continue
+            const editing = held(other.path)
+            if (
+                editing === undefined || editing === other.text
+                    ? other.hooks.includes('onConfig')
+                    : filesConfig(editing)
+            )
+                beside.push({
+                    path: other.path,
+                    text: editing ?? other.text,
+                    quiet: true,
+                })
+        }
     }
     // A component that does not parse, or that the checker refuses, is its own file's finding and
     // takes anything here: a quiet source's refusal is reported by nobody.
-    const { read, warnings } = await readSources(
-        session,
-        [page, ...parseSources(imports, refusals)],
-        refusals,
-    )
-    if (refusals.found.length > 0) return [...tree, ...refusals.found]
-    const own: Diagnosis[] = []
-    for (const warning of warnings) if (warning.path === path) own.push(warning)
-    const [checked, ...beside] = read
-    const { diagnoses } = await session.diagnose(
-        checked === undefined
-            ? beside
-            : [
-                  { ...checked, kind: placed.kind, route: placed.route },
-                  ...beside,
-              ],
-        layout,
-        false,
-    )
-    return [...tree, ...own, ...diagnoses]
+    if (own.length > 0)
+        await compiledSources(
+            layout,
+            session,
+            own,
+            parseSources(beside, diagnostics),
+            diagnostics,
+            true,
+            false,
+        )
+    const found: Diagnosis[] = []
+    for (const finding of diagnostics.findings)
+        if (finding.path === path) found.push(finding)
+    return found
 }
 
 /**
@@ -132,7 +128,7 @@ export async function lowerApp(
     held: (path: string) => string | undefined,
 ): Promise<void> {
     const layout = await checker.layout()
-    const refusals = new Refusals(checker.root, true)
+    const diagnostics = new Diagnostics(checker.root, true)
     const sources: (PlacedSource & { quiet: true })[] = []
     for (const source of layout.sources) {
         const editing = held(source.path)
@@ -142,12 +138,12 @@ export async function lowerApp(
         }
         const [parsed] = parseSources(
             [{ path: source.path, text: editing, quiet: true }],
-            refusals,
+            diagnostics,
         )
         if (parsed !== undefined)
             sources.push({ ...source, ...parsed, quiet: true })
     }
-    const { read } = await readSources(checker.session, sources, refusals)
+    const read = await readSources(checker.session, sources, diagnostics)
     await checker.session.diagnose(read, layout, false)
 }
 

package/src/compiler/checkedShadow.ts

@@ -1,7 +1,7 @@
 import { SERVER_SPECIFIER } from '#shared/SPECIFIERS.ts'
 
 import type { CheckerAnswer } from './CheckerAnswer.ts'
-import type { Finding } from './Finding.ts'
+import type { Finding } from './Diagnostics.ts'
 import { hookCalls } from './hookCalls.ts'
 import {
     CHECKED_CONFIG,
@@ -40,7 +40,7 @@ export type CheckedShadow = {
 
 /**
  * What a checked module's default export is declared as. Scaffolding, so a jump to it is a jump to
- * the component's file (`TypeSession.inspect`).
+ * the component's file (`LoweredFile.inspect`).
  */
 export const COMPONENT_STAND_IN = '__component'
 

package/src/compiler/classifyRead.ts

@@ -46,7 +46,8 @@ export type Read = {
      * `value` lowers to `n()`; `asWritten` stays as written (`n.set(v)`, 31.5); `member` is one of
      * the `Reactive`'s own members referenced rather than called, named by `path`; `call` is the
      * explicit `n()` (31.7), which `arguments` says was given any; `shorthand` is `{ n }`;
-     * `write` and `update` are 31.4, and 31.8 where `path` is not empty.
+     * `write` and `update` are 31.4, and 31.8 where `path` is not empty. `mutate` is 31.9: an
+     * array mutator called through `path`, its `value` the call from the receiver's end.
      *
      * 33's five: the `props<Props>()` call, which lowers to the record the caller passed; the pair
      * that brackets a binding element's initializer, which together make a default an accessor;
@@ -63,6 +64,7 @@ export type Read = {
         | 'shorthand'
         | 'write'
         | 'update'
+        | 'mutate'
         | 'props'
         | 'defaultOpen'
         | 'defaultClose'
@@ -244,6 +246,7 @@ export function classifyPropRead(node: Node): Read | undefined {
 export function classifyRead(
     node: Node,
     valueMember = false,
+    mutator = false,
 ): Read | undefined {
     const parent = node.parent
     if (isNotARead(parent)) return undefined
@@ -325,6 +328,18 @@ export function classifyRead(
         top = up
     }
 
+    // 31.9 — the walk took the mutator's own name as a step: it is the call, not the path.
+    if (
+        mutator &&
+        isPropertyAccessExpression(top) &&
+        isCallExpression(top.parent)
+    ) {
+        read.path.pop()
+        read.shape = 'mutate'
+        read.to = top.parent.end
+        read.value = { start: top.expression.end, end: top.parent.end }
+        return read
+    }
     const outer = top.parent
     if (isAssigned(outer, top)) {
         read.shape = 'write'