mirror of
https://github.com/morluto/rea.git
synced 2026-11-20 05:32:44 +00:00
fd2bc88d53256f9ee9e276d850b6020726eb975c
10
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
fd2bc88d53 | fix(javascript): retain effects only from reachable first defaults (#12659) | ||
|
|
7cb3f1090c |
fix(javascript): retain iterator prototype effects through array spreads (#12563)
* fix(javascript): retain ambient references through array spread * fix(javascript): retain spread aliases to inherited iterator close hooks * fix(javascript): share dense inline array spread layout (#12564) * fix(javascript): share dense inline array spread layout * fix(javascript): report exhausted dense spread layout allowance * fix(javascript): preserve getter receivers through array spread * fix(javascript): guard native array iteration from opaque global code * test(javascript): group spread receiver controls * test(javascript): preserve getter fixture tuple types * fix(javascript): preserve spread slot projections for iterator receivers |
||
|
|
473b3ee10e |
fix(javascript): preserve nested array iterator dependencies (#12558)
* fix(javascript): preserve nested array iterator dependencies * fix(javascript): retain reflected array prototype identity * fix(javascript): guard native arrays with ambient prototype effects Reuse the shared effect-log classifier first prepared for dense inline spread analysis. * test(javascript): keep array prototype alias fixture with sources |
||
|
|
f5573a0064 |
fix(javascript): acquire nested iterators from stored receivers (#12542)
* fix(javascript): acquire nested iterators from stored receivers * fix(javascript): preserve stored iterator branches and pattern timing |
||
|
|
1dc22f18cd |
fix(javascript): retain proven property presence at reads (#12477)
* fix(javascript): retain proven property presence at reads The read-time IR and projection boundary builds on the destructuring work in #7716. This change adds an indexed own-slot proof and uses it for ordinary member reads as well. Co-authored-by: SII-YDD <38822679+SII-YDD@users.noreply.github.com> * fix(javascript): retain destructuring proof in read order --------- Co-authored-by: SII-YDD <38822679+SII-YDD@users.noreply.github.com> |
||
|
|
cad3209533 |
fix(javascript): attribute call-path unknowns only where the walk can reach Electron (#4915)
* test(javascript): cover the isolated-world probe outside Electron identity
* fix(javascript): expand Electron call paths only with an Electron reference
* test(javascript): cover Electron reach through resolved names, aliases and worker URLs
* fix(javascript): attribute call-path unknowns only where the walk can reach Electron
* test(javascript): cover a hoisted read that precedes a loader alias
* fix(javascript): keep call-path unknowns for late-initialized loader aliases
* test(javascript): drop a duplicate loader-alias case
* test(javascript): cover loader aliases reached through bindings and calls
* fix(javascript): prove a late initializer loader-free before dropping its unknown
* test(javascript): cover loaders behind default parameters, wrappers and long alias chains
* fix(javascript): resolve identifiers inside late initializers and bound the loader proof
* fix(javascript): bound late loader proofs and preserve input uncertainty
* fix(javascript): fail closed for receiver and mutated loaders
* fix(javascript): close loader-free proof gaps
* fix(javascript): retain uncertain loader sources
* test(javascript): cover remaining loader proof gaps
* fix(javascript): bound alias writes and preserve loader uncertainty
* test(javascript): cover demand-driven loader mutation facts
* perf(javascript): index loader mutation facts on demand
* style(javascript): apply oxfmt to the loader proof changes
* test(javascript): cover inherited loaders and rebound alias writes
* fix(javascript): preserve inherited loaders and rebound aliases
* test(evaluation): update scoped feature coverage oracle
* test(javascript): cover inherited loader proof gaps
* fix(javascript): preserve projected and inherited loaders
* fix(javascript): prove safe parameter member reads
* test(javascript): cover loader proof review gaps
* fix(javascript): close remaining loader proof gaps
* fix(javascript): preserve qualified global replacements
* fix(javascript): preserve spread rest uncertainty
* fix(javascript): retain retried handler uncertainty
* fix(javascript): retain import.meta loader uncertainty
* fix(javascript): detach fresh constructed aliases
* fix(javascript): check inherited members of ambient loaders
* test(javascript): parse call-path gate fixtures as established CommonJS
* fix(javascript): prove projected locals inside late initializers
A function-local binding was accepted by scope alone, so a destructuring
projection such as `const { r } = {}` inside a late initializer never met
the inherited-member check that a top-level projection goes through. Route
projected locals through the binding proof; locals with inline initializers
keep the scope shortcut, since the walk already visits their expressions.
* fix(javascript): keep late results with changed prototypes or import.meta uncertain
The loader-free proof inspected member expressions inside a late function
but not what its caller does with the result. With `Object.prototype.load =
require`, `var load = () => ({})` and `load().load("electron")` reach the
loader through a member selected after the call, and a bare `import.meta`
returned after `import.meta.load = ...` does the same. Check each result
expression: a literal fails when its prototype chain gained members, a bare
`import.meta` when any of its members changed, and a result of unknown shape
when either happened. Promise and generator results inherit from
Object.prototype as well. `SemanticPropertyPathCoverage.touches` answers
whether any retained write or escape sits below a prefix.
* fix(javascript): detach replacements held by fresh bindings
`alias = replacement` with `const replacement = {}` selected an identifier
initializer, so the later `alias.other = 1` stayed a shared write on the
original alias group and the resolver treated `base` as overwritten,
dropping its bridge call path. Resolve the identifier to its binding and
accept it when that binding only ever received one fresh allocation.
Bindings that can hold the original object keep the shared write.
* fix(javascript): charge loader proofs through the wrapper-visit budget
#11319 replaced the wrapper-visit counter with a Budget, so the loader proof charge no longer compiled on current main. Spend it through the shared helper, which records the same limit.
* test(javascript): keep the alias bound off the quadratic write index
The 8,000 by 8,000 alias bound spent its time in the ambient write index, which walks every store to an object for each member write. That cost is the same on main and is not what the bound covers. Reach the same 64 million alias and write pairs with 32,000 aliases and 2,000 writes, which runs in about 2.5 seconds instead of 8.5 on the same host.
Drop the 30 second overrides on both alias bounds too. They halved the hosted CI deadline the source project gives them, and the testing guide asks tests to leave deadlines to the project.
* refactor(javascript): ask the effect log for loader proof effects
Main now guards reads of the effect indexes outside javascriptSemanticEffectLog.ts. The loader proof read them directly in 15 places. Route those reads through the log: the existing ambientPathMayHaveChanged and bindingHasMemberWrites queries, plus three timeless queries for a path or any member below it, an ambient binding write, and an escape at a site other than the call being proved. The answers are unchanged.
* fix(javascript): retain uncertainty for changed ambient values
---------
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
|
||
|
|
caab34d0de |
fix(javascript): qualify releases after resource method mutation (#10166)
* fix(javascript): qualify releases after resource method mutation * fix(javascript): qualify releases after opaque receiver mutation * fix(javascript): preserve release ordering and mutation facts * fix(javascript): order mutations of fresh resource receivers * fix(javascript): match release mutations to captured receivers * fix(javascript): check delegated release method identity * fix(javascript): track paths back to native resource prototypes * fix(javascript): respect native release member ownership * fix(javascript): retain shared prototype effects across calls * fix(javascript): order release effects after definite acquisition * fix(javascript): preserve prototype effects across receiver replacement * fix(javascript): preserve native release identity across proven effects * fix(javascript): preserve shared prototype uncertainty after opaque calls --------- Co-authored-by: morluto <76467478+morluto@users.noreply.github.com> |
||
|
|
a86a668718 |
fix(javascript): count escapes of Function.prototype before trusting call and apply (#11501)
* fix(javascript): count escapes of Function.prototype before trusting call and apply * fix(javascript): key cached returned references on ambient escapes too * fix(javascript): track arguments of directly invoked functions through their parameters (#11538) * fix(javascript): track arguments of directly invoked functions through their parameters Passing a value to a function expression invoked where it is defined, such as a UMD header (function(root, factory){...})(this, ...), recorded an escape of the argument to unevaluated code although the callee's body is source code whose effects are indexed. javascriptSemanticDirectInvocations owns which arguments reach such a callee only through a plain parameter; the ambient path resolver and member mutation indexing follow that parameter back to its argument, and neither records an escape for it. Spread and rest lists, pattern or default parameters, arguments and direct eval keep the escape, as do unknown callees. Refs #11499 * fix(javascript): escape values thrown out of a function and scan arguments once A value thrown out of a function or class body reaches handlers the throw-to-catch index does not link to it. Arguments of a directly invoked function used to hide this behind the call escape; they no longer do, and captured values had the same gap. The binding pass records such throws, and ambient and member effect indexing escape their values at the throw. Which functions name 'arguments' is now found in one program walk instead of one subtree scan per directly invoked function. * perf(javascript): find shadowed direct-invocation parameters in one pass * fix(javascript): settle Object and Reflect static call receivers in one owner (#11543) * fix(javascript): settle Object and Reflect static call receivers in one owner Ambient write indexing skipped the receiver escape of any resolved Object or Reflect static call, even when source code had replaced the method, while member mutation indexing escaped the constructor for every such call. The second escape (global.Object contents) made each later Function.prototype.call/apply check uncertain in bundles that call Object.defineProperty or Object.freeze. Ambient indexing now settles these receivers once all ambient writes are known: the constructor escapes only when a write or escape may replace the method before the call, and member mutation reuses that decision through retainedGlobalCallReceivers. Refs #11535 * fix(javascript): retain the receiver only for native Object and Reflect statics A resolved Object member that is not one of the language's own static methods (for example one Object inherits from Function.prototype, or an unknown name) may be user code that receives the constructor, so its call keeps the receiver escape. * fix(javascript): look up intrinsic and builtin method tables by own key only NATIVE_STATIC_METHODS and BUILTIN_RECEIVER_METHODS were plain objects, so an owner such as globalThis.constructor or a module named 'constructor' or 'toString' found an inherited Object.prototype function and analysis threw a TypeError on '.has'. Both are Maps now. * fix(javascript): escape values thrown uncaught at the top level (#11556) A value thrown uncaught at the top level reaches the host's uncaught-exception handlers (process.on('uncaughtException'), window.onerror), which may change it before a timer or callback reads it. The binding pass recorded escaping throws only when the walk reached a function or class body; a throw that reaches the program without a handler now escapes the same way. * fix(javascript): follow direct-invocation arguments through returned references and function arguments properties A callable argument of a directly invoked function no longer escapes at the call, but the shared returned-reference owner could not follow the parameter to it, so patch(get()) inside the callee lost the escape of the value get returns. The returned-reference walk now follows the parameter to its argument like the write and escape walkers. A sloppy function's arguments property (f["arguments"], g.caller.arguments from a function it calls) exposes its activation's arguments. A non-strict callee is no longer tracked through its parameters when the program reads an arguments or caller property by a static key. The strictness reader moves beside javaScriptProgramStrictness so both modules share it. |
||
|
|
0a7d288ed8 |
fix(javascript): move reader effect reads into the effect log and order require and process rebinding by activation (#11356)
* refactor(javascript): move the last reader effect reads into the effect log * refactor(javascript): skip escapes when a reader asks only about member writes * fix(javascript): order require and process rebinding by activation timing (#11479) * refactor(javascript): ask one ordering whether require was rebound before a call * refactor(javascript): order process replacement by activation, like require * fix(javascript): keep instance field values out of literal-loop source ordering * fix(javascript): stop effect ordering at instance field values inside the effect semanticEffectFollowsReference proved that an assignment follows a read written inside its own right-hand side, even when the read sits in an instance field value, which runs on construction after the assignment. process = class { value = process.env.MODE; }; new process() therefore kept the original process identity, and require = class { fs = require('fs') } kept a Node module origin. The first walk now stops at instance field values like it stops at function bodies. * fix(javascript): attribute process effects that may reach the original object (#11521) * fix(javascript): attribute process effects that may reach the original object A write or escape through the global process object was attributed to node:process only when no replacement of process may precede it. Effects need the opposite question: they reach the original unless a replacement with a fresh object is proven to run before them. The effect log gains ambientReplacementPrecedes (the must counterpart of the may-observe queries), RequireOrigin owns the effect question, and member mutation asks it for direct, qualified and ambient process effects. Refs #11488 * fix(javascript): prove a process replacement with the global path reader ambientReplacementPrecedes accepted any earlier fresh assignment of the process path, even when a later write might restore the original or when the assignment went through a possible alias of the global object. The global path reader already owns definite replacement at a site (it checks the written namespace and every competing write), so the effect question asks it and keeps only the freshness check. ambientReplacementPrecedes is removed. |
||
|
|
9efaaffd75 |
refactor(javascript): ask the effect log owner whether opaque and reference effects changed a read (#11252)
* refactor(javascript): ask one owner whether opaque code changed an intrinsic global read Six intrinsic global readers combined semanticOpaqueGlobalMayHaveChanged and semanticOpaqueNameMayHaveChanged themselves, each choosing which effect kinds applied and where to time them. isIntrinsicGlobalReference and opaqueCodeMayChangeGlobalRead in javascriptSemanticGlobalReference.ts now own both proofs: a sloppy direct eval visible from the reference may introduce its root name, and global code that may run before the observation site may replace a writable global. The owner also knows that undefined, NaN and Infinity are non-writable, so global code cannot replace them. Map lookups and XMLHttpRequest open calls pass the call as the observation site, keeping their call-time timing. An architecture guard forbids the two helpers outside their owners. Slice 1 of docs/adr/javascript/pushed-effect-invalidation.md (#11188). * refactor(javascript): ask one owner whether opaque code rebound a binding (#11254) Ten binding readers combined semanticBindingCanBeRebound, semanticBindingMayHaveOpaqueEffect and semanticOpaqueBindingReadMayHaveChanged themselves; three repeated the same rebindability-and-effect pairing. opaqueCodeMayRebindBinding(binding, state, read?) and opaqueCodeMayReachBindingReference(binding, state, capturePoint) in javascriptSemanticOpaqueEffects.ts now own the rebinding, read-timing, capture and introduced-name proofs. semanticBindingMayHaveOpaqueEffect is private to the owner and semanticOpaqueBindingReadMayHaveChanged is removed, so a reader cannot pick effect kinds again. Slice 2 of docs/adr/javascript/pushed-effect-invalidation.md (#11188). * refactor(javascript): ask one owner whether an intrinsic instance method changed (#11266) * refactor(javascript): ask one owner whether an intrinsic instance method changed Map lookups and XMLHttpRequest.open each walked receiver aliases and combined member-effect checks for the method, the instance prototype link and the intrinsic prototypes. isIntrinsicInstanceMethodCall now owns that walk; Map lookups also gain the prototype-link check XHR already made. The member-effect view asks semanticOpaqueReferenceEffects for opaque sites instead of combining the rebinding and reach helpers, which become private. Refs docs/adr/javascript/pushed-effect-invalidation.md (slice 3). * refactor(javascript): keep global opaque-effect checks private to their owner opaqueCodeMayChangeGlobalRead moves into javascriptSemanticOpaqueEffects.ts, so semanticOpaqueGlobalMayHaveChanged and semanticOpaqueNameMayHaveChanged are no longer exported and the slice 1 text guard is replaced by the compiler. * refactor(javascript): make the effect log the one reader of recorded opaque sites (#11282) * refactor(javascript): make the effect log the one reader of recorded opaque sites Rename javascriptSemanticOpaqueEffects.ts to javascriptSemanticEffectLog.ts (ADR decision 1) and move the reference-effects view (visitSemanticReferenceEffectsAtSite, the effect report, the member-path query and its completeness gate) out of javascriptSemanticAnalysis.ts into it. Recorded opaque sites move behind javascriptSemanticEffectRecord.ts accessors (direct-eval site, recorded direct eval, global-code sites), which the timing producer in javascriptSemanticMutationInitializers.ts and the call frontier in javascriptSemanticCalls.ts now ask instead of reading state.opaqueEffects. The member-mutation completeness WeakSet duplicated state.memberMutationFactsComplete and is removed. An architecture guard keeps `.opaqueEffects` reads inside the log and its record module. * refactor(javascript): keep the opaque reference-effect generator private to the effect log * refactor(javascript): drop analysis-hub imports that only the moved effect queries used * refactor(javascript): ask the effect log for a binding reference's recorded effects (#11295) The value engine applied member writes, escapes and direct-eval reach to a binding's reference itself, with its own capture proofs. That application moves into javascriptSemanticEffectLog.ts as applySemanticBindingReferenceEffects, and opaqueCodeMayReachBindingReference becomes private to the log. A counted guard (javascript-effect-index-read) records every remaining read of the per-kind effect indexes outside the log; it can only shrink, so new reader-side checks fail the guard. * refactor(javascript): ask the effect log whether an ambient path may have changed (#11308) * refactor(javascript): ask the effect log mayObserve for member-path reads (#11313) * refactor(javascript): name the member-path effect query mayObserve * refactor(javascript): ask the effect log whether an ambient path effect may precede a read * refactor(javascript): ask the effect log about require and process rebinding (#11318) refactor(javascript): ask the effect log about require and process rebinding and effect generations * refactor(javascript): build the ambient-write module interop in one owner (#11323) * refactor(javascript): build the ambient-write module interop in one owner and ask the effect log in CommonJS receivers * refactor(javascript): ask the effect log whether binding assignments precede a read (#11329) refactor(javascript): ask the effect log whether binding assignments or prototype writes precede a read * fix(javascript): count prototype escapes before resolving a URL object request target (#11368) fix(javascript): count URL and Object prototype escapes before resolving a URL object target |