@noego/trust 0.5.1-dev.4 → 0.5.1-dev.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/{chunk-35ETSKEC.js → chunk-QTS55J43.js} +1823 -122
- package/dist/chunk-QTS55J43.js.map +1 -0
- package/dist/cli/index.js +1 -1
- package/dist/eslint/index.js +1 -1
- package/dist/index.cjs +971 -4
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +125 -1
- package/dist/index.d.ts +125 -1
- package/dist/index.js +965 -1
- package/dist/index.js.map +1 -1
- package/dist/native/trust_native_wasm.wasm +0 -0
- package/package.json +4 -4
- package/dist/chunk-35ETSKEC.js.map +0 -1
|
@@ -354,7 +354,7 @@ var TrustPolicy = class {
|
|
|
354
354
|
// src/core/dropped-results.ts
|
|
355
355
|
var ANY_KIND = "*";
|
|
356
356
|
function droppedResultContext(ts, checker, policy) {
|
|
357
|
-
return { ts, checker, policy, kindCache: /* @__PURE__ */ new WeakMap() };
|
|
357
|
+
return { ts, checker, policy, kindCache: /* @__PURE__ */ new WeakMap(), stateCache: /* @__PURE__ */ new WeakMap() };
|
|
358
358
|
}
|
|
359
359
|
function droppedResultData(dropped) {
|
|
360
360
|
return { subject: dropped.subject, kinds: formatFailureKinds(dropped.kinds, ANY_KIND) };
|
|
@@ -362,6 +362,13 @@ function droppedResultData(dropped) {
|
|
|
362
362
|
function droppedResultMessage(dropped) {
|
|
363
363
|
return fillMessage(DROPPED_RESULT_MESSAGES[dropped.origin], droppedResultData(dropped));
|
|
364
364
|
}
|
|
365
|
+
var State = class extends Map {
|
|
366
|
+
outstandingIterables;
|
|
367
|
+
constructor(source) {
|
|
368
|
+
super(source);
|
|
369
|
+
this.outstandingIterables = new Set(source?.outstandingIterables);
|
|
370
|
+
}
|
|
371
|
+
};
|
|
365
372
|
var NOTHING = /* @__PURE__ */ new Set();
|
|
366
373
|
var ELEMENT_METHODS = /* @__PURE__ */ new Set([
|
|
367
374
|
"filter",
|
|
@@ -397,19 +404,108 @@ function union(a, b) {
|
|
|
397
404
|
if (b.size === 0) return a;
|
|
398
405
|
return /* @__PURE__ */ new Set([...a, ...b]);
|
|
399
406
|
}
|
|
407
|
+
function intersectPeers(a, b) {
|
|
408
|
+
if (!a?.size || !b?.size) return void 0;
|
|
409
|
+
const out = /* @__PURE__ */ new Set();
|
|
410
|
+
for (const s of a) if (b.has(s)) out.add(s);
|
|
411
|
+
return out.size ? out : void 0;
|
|
412
|
+
}
|
|
413
|
+
function sideKinds(side, other, symbol) {
|
|
414
|
+
const entry = side.get(symbol);
|
|
415
|
+
if (!entry) return NOTHING;
|
|
416
|
+
if (!entry.peers?.size || entry.version === void 0) return entry.kinds;
|
|
417
|
+
let groupKinds = NOTHING;
|
|
418
|
+
let hasSurvivor = false;
|
|
419
|
+
for (const p of entry.peers) {
|
|
420
|
+
const pv = side.get(p);
|
|
421
|
+
if (pv?.kinds.size) groupKinds = union(groupKinds, pv.kinds);
|
|
422
|
+
if (other.get(p)?.version === entry.version) hasSurvivor = true;
|
|
423
|
+
}
|
|
424
|
+
if (!groupKinds.size) return NOTHING;
|
|
425
|
+
if (!hasSurvivor) return entry.kinds;
|
|
426
|
+
return other.get(symbol)?.version === entry.version ? groupKinds : NOTHING;
|
|
427
|
+
}
|
|
400
428
|
function merge(a, b) {
|
|
401
|
-
if (!a) return b ? new
|
|
402
|
-
|
|
403
|
-
|
|
429
|
+
if (!a) return b ? new State(b) : null;
|
|
430
|
+
if (!b) return new State(a);
|
|
431
|
+
const merged = new State();
|
|
432
|
+
for (const path of [a, b]) for (const loop of path.outstandingIterables) merged.outstandingIterables.add(loop);
|
|
433
|
+
for (const [symbol, left] of a) {
|
|
434
|
+
const right = b.get(symbol);
|
|
435
|
+
if (right) {
|
|
436
|
+
let peers = intersectPeers(left.peers, right.peers);
|
|
437
|
+
if (peers && peers.size <= 1) peers = void 0;
|
|
438
|
+
const version = left.version !== void 0 && left.version === right.version ? left.version : void 0;
|
|
439
|
+
const kinds = union(sideKinds(a, b, symbol), sideKinds(b, a, symbol));
|
|
440
|
+
merged.set(symbol, {
|
|
441
|
+
kinds,
|
|
442
|
+
err: left.err && right.err,
|
|
443
|
+
...peers ? { peers } : {},
|
|
444
|
+
...version !== void 0 ? { version } : {}
|
|
445
|
+
});
|
|
446
|
+
} else {
|
|
447
|
+
merged.set(symbol, {
|
|
448
|
+
kinds: sideKinds(a, b, symbol),
|
|
449
|
+
err: left.err
|
|
450
|
+
});
|
|
451
|
+
}
|
|
452
|
+
}
|
|
404
453
|
for (const [symbol, right] of b) {
|
|
405
|
-
|
|
406
|
-
|
|
454
|
+
if (!a.has(symbol)) {
|
|
455
|
+
merged.set(symbol, {
|
|
456
|
+
kinds: sideKinds(b, a, symbol),
|
|
457
|
+
err: right.err
|
|
458
|
+
});
|
|
459
|
+
}
|
|
460
|
+
}
|
|
461
|
+
const byPeerGroup = /* @__PURE__ */ new Map();
|
|
462
|
+
for (const [symbol, val] of merged) {
|
|
463
|
+
if (!val.peers?.size) continue;
|
|
464
|
+
let foundKey;
|
|
465
|
+
for (const k of byPeerGroup.keys()) {
|
|
466
|
+
if (k.size === val.peers.size && [...k].every((s) => val.peers.has(s))) {
|
|
467
|
+
foundKey = k;
|
|
468
|
+
break;
|
|
469
|
+
}
|
|
470
|
+
}
|
|
471
|
+
if (foundKey) byPeerGroup.get(foundKey).push(symbol);
|
|
472
|
+
else byPeerGroup.set(val.peers, [symbol]);
|
|
473
|
+
}
|
|
474
|
+
for (const [groupKey, membersList] of byPeerGroup) {
|
|
475
|
+
let combined = NOTHING;
|
|
476
|
+
for (const s of membersList) {
|
|
477
|
+
const sv = merged.get(s);
|
|
478
|
+
if (sv?.kinds.size) combined = union(combined, sv.kinds);
|
|
479
|
+
}
|
|
480
|
+
if (combined.size) {
|
|
481
|
+
const owner = membersList[0];
|
|
482
|
+
for (const s of membersList) {
|
|
483
|
+
const sv = merged.get(s);
|
|
484
|
+
merged.set(s, {
|
|
485
|
+
kinds: s === owner ? combined : NOTHING,
|
|
486
|
+
err: sv.err,
|
|
487
|
+
peers: groupKey,
|
|
488
|
+
...sv.version !== void 0 ? { version: sv.version } : {}
|
|
489
|
+
});
|
|
490
|
+
}
|
|
491
|
+
}
|
|
407
492
|
}
|
|
408
493
|
return merged;
|
|
409
494
|
}
|
|
495
|
+
function memberAccessName(ts, node) {
|
|
496
|
+
if (ts.isPropertyAccessExpression(node)) return node.name.text;
|
|
497
|
+
if (ts.isElementAccessExpression(node) && node.argumentExpression) return stringLiteral(ts, node.argumentExpression);
|
|
498
|
+
return void 0;
|
|
499
|
+
}
|
|
410
500
|
function mergeAll(states) {
|
|
411
501
|
return states.reduce((merged, state) => merge(merged, state), null);
|
|
412
502
|
}
|
|
503
|
+
function replaceState(state, joined) {
|
|
504
|
+
state.clear();
|
|
505
|
+
for (const [symbol, value] of joined) state.set(symbol, value);
|
|
506
|
+
state.outstandingIterables.clear();
|
|
507
|
+
for (const loop of joined.outstandingIterables) state.outstandingIterables.add(loop);
|
|
508
|
+
}
|
|
413
509
|
function argumentsOf(call) {
|
|
414
510
|
return call.arguments ?? [];
|
|
415
511
|
}
|
|
@@ -459,6 +555,31 @@ function failureKinds(context, type) {
|
|
|
459
555
|
context.kindCache.set(type, result);
|
|
460
556
|
return result;
|
|
461
557
|
}
|
|
558
|
+
function okStateKinds(context, type, states) {
|
|
559
|
+
const { ts, checker, policy } = context;
|
|
560
|
+
if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) return;
|
|
561
|
+
for (const member of members(checker.getAwaitedType(type) ?? type)) {
|
|
562
|
+
for (const name of policy.okStates(member) ?? []) states.add(name);
|
|
563
|
+
}
|
|
564
|
+
}
|
|
565
|
+
function stateKinds(context, type) {
|
|
566
|
+
const cached = context.stateCache?.get(type);
|
|
567
|
+
if (cached !== void 0) return cached;
|
|
568
|
+
const { ts, checker, policy } = context;
|
|
569
|
+
let result = null;
|
|
570
|
+
if (!(type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never))) {
|
|
571
|
+
const states = /* @__PURE__ */ new Set();
|
|
572
|
+
okStateKinds(context, type, states);
|
|
573
|
+
for (const member of members(checker.getAwaitedType(type) ?? type)) {
|
|
574
|
+
if (member.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.Any) || policy.resultVariant(member) !== null) continue;
|
|
575
|
+
const element = checker.getIndexTypeOfType(member, ts.IndexKind.Number);
|
|
576
|
+
if (element) okStateKinds(context, element, states);
|
|
577
|
+
}
|
|
578
|
+
result = states.size ? states : null;
|
|
579
|
+
}
|
|
580
|
+
context.stateCache?.set(type, result);
|
|
581
|
+
return result;
|
|
582
|
+
}
|
|
462
583
|
function subjectOf(node, sourceFile) {
|
|
463
584
|
const text = node.getText(sourceFile).replace(/\s+/g, " ").trim();
|
|
464
585
|
return text.length > SUBJECT_LIMIT ? `${text.slice(0, SUBJECT_LIMIT - 1)}\u2026` : text;
|
|
@@ -511,18 +632,25 @@ var DropWalk = class {
|
|
|
511
632
|
failureCarriers = /* @__PURE__ */ new Map();
|
|
512
633
|
targets = [];
|
|
513
634
|
reported = /* @__PURE__ */ new Set();
|
|
635
|
+
callStates = /* @__PURE__ */ new Map();
|
|
636
|
+
activeForOfs = /* @__PURE__ */ new Map();
|
|
637
|
+
handedSnapshots = /* @__PURE__ */ new Map();
|
|
638
|
+
handedSources = /* @__PURE__ */ new Map();
|
|
639
|
+
handedVersions = /* @__PURE__ */ new Map();
|
|
640
|
+
spliceEmptyBeforeCall = /* @__PURE__ */ new Set();
|
|
641
|
+
nextVersion = 1;
|
|
514
642
|
/** Where `var` declarations live. */
|
|
515
643
|
functionScope;
|
|
516
644
|
run() {
|
|
517
645
|
const ts = this.ts;
|
|
518
646
|
const owner = this.owner;
|
|
519
647
|
if (ts.isSourceFile(owner)) {
|
|
520
|
-
this.statements(owner.statements,
|
|
648
|
+
this.statements(owner.statements, new State(), owner);
|
|
521
649
|
return;
|
|
522
650
|
}
|
|
523
651
|
const body = owner.body;
|
|
524
652
|
if (!body) return;
|
|
525
|
-
const state =
|
|
653
|
+
const state = new State();
|
|
526
654
|
if (!ts.isClassStaticBlockDeclaration(owner) && !this.isPredicateCallback(owner)) {
|
|
527
655
|
for (const parameter of owner.parameters) this.declare(parameter.name, body, state, true);
|
|
528
656
|
}
|
|
@@ -533,14 +661,31 @@ var DropWalk = class {
|
|
|
533
661
|
this.visit(body, state);
|
|
534
662
|
this.checkReturn(body, body, state);
|
|
535
663
|
}
|
|
536
|
-
/** The function is the
|
|
664
|
+
/** The function is the callback of `xs.forEach(…)` (or another call whose signature ignores the callback return value). */
|
|
665
|
+
isDiscardedReturnCallback(owner) {
|
|
666
|
+
const ts = this.ts;
|
|
667
|
+
if (!ts.isArrowFunction(owner) && !ts.isFunctionExpression(owner)) return false;
|
|
668
|
+
const call = esParent(ts, owner);
|
|
669
|
+
if (!call || !(ts.isCallExpression(call) || ts.isNewExpression(call))) return false;
|
|
670
|
+
const args = argumentsOf(call);
|
|
671
|
+
const argIndex = args.findIndex((a) => unparen(ts, a) === owner);
|
|
672
|
+
if (argIndex < 0) return false;
|
|
673
|
+
const callee = ts.isCallExpression(call) ? unparen(ts, call.expression) : void 0;
|
|
674
|
+
if (callee && memberAccessName(ts, callee) === "forEach") return argIndex === 0;
|
|
675
|
+
const paramType = this.instantiatedParameterType(call, argIndex) ?? this.declaredParameterType(call, argIndex);
|
|
676
|
+
if (!paramType) return false;
|
|
677
|
+
const sigs = members(paramType).flatMap((m) => m.getCallSignatures());
|
|
678
|
+
if (!sigs.length) return false;
|
|
679
|
+
return sigs.every((sig) => (sig.getReturnType().flags & ts.TypeFlags.Void) !== 0 && !this.typeKinds(sig.getReturnType()));
|
|
680
|
+
}
|
|
537
681
|
isPredicateCallback(owner) {
|
|
538
682
|
const ts = this.ts;
|
|
539
683
|
if (!ts.isArrowFunction(owner) && !ts.isFunctionExpression(owner)) return false;
|
|
540
684
|
const call = owner.parent;
|
|
541
685
|
if (!ts.isCallExpression(call) || !call.arguments.includes(owner)) return false;
|
|
542
686
|
const callee = unparen(ts, call.expression);
|
|
543
|
-
|
|
687
|
+
const methodName = memberAccessName(ts, callee);
|
|
688
|
+
return methodName !== void 0 && PREDICATE_METHODS.has(methodName);
|
|
544
689
|
}
|
|
545
690
|
// ---- reporting ----
|
|
546
691
|
report(origin, at, subject, kinds) {
|
|
@@ -555,12 +700,48 @@ var DropWalk = class {
|
|
|
555
700
|
/** Reports and forgets the variables living in `scope` (or, with `inside`, anywhere inside it) that can still fail. */
|
|
556
701
|
leaveScope(scope, state, at, inside = false, keep) {
|
|
557
702
|
if (!state) return null;
|
|
558
|
-
const left = new
|
|
703
|
+
const left = new State(state);
|
|
559
704
|
for (const [symbol, info] of this.tracked) {
|
|
560
705
|
const leaving = inside ? within(info.scope, scope) : info.scope === scope;
|
|
561
706
|
if (!leaving || keep?.(info)) continue;
|
|
562
707
|
const value = left.get(symbol);
|
|
563
|
-
if (value && value.kinds.size > 0)
|
|
708
|
+
if (value && value.kinds.size > 0) {
|
|
709
|
+
let transferred = false;
|
|
710
|
+
if (this.stateFound && value.peers?.size) {
|
|
711
|
+
const surviving = [...value.peers].filter((peer) => {
|
|
712
|
+
if (peer === symbol || !left.has(peer)) return false;
|
|
713
|
+
const pInfo = this.tracked.get(peer);
|
|
714
|
+
if (!pInfo) return false;
|
|
715
|
+
const pLeaving = inside ? within(pInfo.scope, scope) : pInfo.scope === scope;
|
|
716
|
+
return !pLeaving || Boolean(keep?.(pInfo));
|
|
717
|
+
});
|
|
718
|
+
if (surviving.length) {
|
|
719
|
+
const owner = surviving[0];
|
|
720
|
+
const existing = left.get(owner);
|
|
721
|
+
if (existing) {
|
|
722
|
+
const nextPeers = new Set(surviving);
|
|
723
|
+
left.set(owner, { kinds: union(existing.kinds, value.kinds), err: existing.err, peers: nextPeers, ...existing.version !== void 0 ? { version: existing.version } : {} });
|
|
724
|
+
for (const s of surviving.slice(1)) {
|
|
725
|
+
const sv = left.get(s);
|
|
726
|
+
if (sv) left.set(s, { kinds: sv.kinds, err: sv.err, peers: nextPeers, ...sv.version !== void 0 ? { version: sv.version } : {} });
|
|
727
|
+
}
|
|
728
|
+
transferred = true;
|
|
729
|
+
}
|
|
730
|
+
}
|
|
731
|
+
}
|
|
732
|
+
if (!transferred) this.reportVariable("end", at, symbol, value.kinds);
|
|
733
|
+
}
|
|
734
|
+
if (value?.peers?.size) {
|
|
735
|
+
for (const peer of value.peers) {
|
|
736
|
+
if (peer === symbol) continue;
|
|
737
|
+
const pv = left.get(peer);
|
|
738
|
+
if (pv?.peers?.has(symbol)) {
|
|
739
|
+
const nextPeers = new Set(pv.peers);
|
|
740
|
+
nextPeers.delete(symbol);
|
|
741
|
+
left.set(peer, { kinds: pv.kinds, err: pv.err, ...nextPeers.size > 1 ? { peers: nextPeers } : {}, ...pv.version !== void 0 ? { version: pv.version } : {} });
|
|
742
|
+
}
|
|
743
|
+
}
|
|
744
|
+
}
|
|
564
745
|
left.delete(symbol);
|
|
565
746
|
}
|
|
566
747
|
return left;
|
|
@@ -571,12 +752,7 @@ var DropWalk = class {
|
|
|
571
752
|
}
|
|
572
753
|
typeKinds(type) {
|
|
573
754
|
if (!type) return null;
|
|
574
|
-
|
|
575
|
-
const states = /* @__PURE__ */ new Set();
|
|
576
|
-
for (const member of members(this.checker.getAwaitedType(type) ?? type)) {
|
|
577
|
-
for (const name of this.context.policy.okStates(member) ?? []) states.add(name);
|
|
578
|
-
}
|
|
579
|
-
return states.size ? states : null;
|
|
755
|
+
return this.stateFound ? stateKinds(this.context, type) : failureKinds(this.context, type);
|
|
580
756
|
}
|
|
581
757
|
trackedSymbol(node, state) {
|
|
582
758
|
const inner = unparen(this.ts, node);
|
|
@@ -589,38 +765,99 @@ var DropWalk = class {
|
|
|
589
765
|
const name = this.context.policy.trustFunctionName(call);
|
|
590
766
|
return name === "decide" || name === "translate";
|
|
591
767
|
}
|
|
768
|
+
tupleSlotAt(ref, idx, sourceLen) {
|
|
769
|
+
const flags = ref.target.elementFlags;
|
|
770
|
+
const elems = this.checker.getTypeArguments(ref);
|
|
771
|
+
const varIdx = elems.findIndex((_, ti) => (flags[ti] & this.ts.ElementFlags.Variable) !== 0);
|
|
772
|
+
if (varIdx < 0) return elems[idx];
|
|
773
|
+
if (idx < varIdx) return elems[idx];
|
|
774
|
+
const suffixCount = elems.length - 1 - varIdx;
|
|
775
|
+
if (sourceLen !== void 0 && suffixCount > 0 && idx >= sourceLen - suffixCount) {
|
|
776
|
+
return elems[elems.length - (sourceLen - idx)];
|
|
777
|
+
}
|
|
778
|
+
return this.checker.getIndexTypeOfType(elems[varIdx], this.ts.IndexKind.Number) ?? elems[varIdx];
|
|
779
|
+
}
|
|
780
|
+
tupleSlotFromEnd(ref, fromEnd) {
|
|
781
|
+
const flags = ref.target.elementFlags;
|
|
782
|
+
const elems = this.checker.getTypeArguments(ref);
|
|
783
|
+
const varIdx = elems.findIndex((_, ti) => (flags[ti] & this.ts.ElementFlags.Variable) !== 0);
|
|
784
|
+
if (varIdx >= 0) {
|
|
785
|
+
const suffixCount = elems.length - 1 - varIdx;
|
|
786
|
+
if (fromEnd <= suffixCount) return elems[elems.length - fromEnd];
|
|
787
|
+
return this.checker.getIndexTypeOfType(elems[varIdx], this.ts.IndexKind.Number) ?? elems[varIdx];
|
|
788
|
+
}
|
|
789
|
+
return elems.length >= fromEnd ? elems[elems.length - fromEnd] : void 0;
|
|
790
|
+
}
|
|
791
|
+
restSlotTypes(call, restStart, restType, offset, totalRestArgs, fromEndOffset, fullRestSpread) {
|
|
792
|
+
const unwrapped = this.checker.getAwaitedType(restType) ?? restType;
|
|
793
|
+
const rawMs = members(unwrapped);
|
|
794
|
+
const compatible = fullRestSpread && typeof this.checker.isTypeAssignableTo === "function" ? rawMs.filter((tm) => this.checker.isTypeAssignableTo(fullRestSpread, tm)) : rawMs.length > 1 && typeof this.checker.isTypeAssignableTo === "function" && !argumentsOf(call).some(this.ts.isSpreadElement) ? rawMs.filter((tm) => {
|
|
795
|
+
if (this.checker.isTupleType(tm)) {
|
|
796
|
+
const tuple = tm.target;
|
|
797
|
+
const count = argumentsOf(call).length - restStart;
|
|
798
|
+
if (count < tuple.minLength || !(tuple.combinedFlags & this.ts.ElementFlags.Variable) && count > tuple.elementFlags.length) return false;
|
|
799
|
+
}
|
|
800
|
+
return argumentsOf(call).slice(restStart).every((a, i) => {
|
|
801
|
+
const slot = this.checker.isTupleType(tm) ? this.tupleSlotAt(tm, i, totalRestArgs) : this.checker.getIndexTypeOfType(tm, this.ts.IndexKind.Number);
|
|
802
|
+
return slot && this.checker.isTypeAssignableTo(this.checker.getTypeAtLocation(a), slot);
|
|
803
|
+
});
|
|
804
|
+
}) : [];
|
|
805
|
+
const ms = compatible.length ? compatible : rawMs;
|
|
806
|
+
const out = [];
|
|
807
|
+
for (const m of ms) {
|
|
808
|
+
if (this.checker.isTupleType(m)) {
|
|
809
|
+
const ref = m;
|
|
810
|
+
const slot = fromEndOffset !== void 0 ? this.tupleSlotFromEnd(ref, fromEndOffset) : this.tupleSlotAt(ref, offset, totalRestArgs);
|
|
811
|
+
if (slot) out.push(slot);
|
|
812
|
+
} else {
|
|
813
|
+
const indexed = this.checker.getIndexTypeOfType(m, this.ts.IndexKind.Number);
|
|
814
|
+
if (indexed) out.push(indexed);
|
|
815
|
+
}
|
|
816
|
+
}
|
|
817
|
+
return out;
|
|
818
|
+
}
|
|
592
819
|
/** The declared (not instantiated) type of the parameter that receives argument `index`. */
|
|
593
|
-
|
|
820
|
+
declaredParameterTypes(call, index, totalArgs, fromEndArgs, fullRestSpread) {
|
|
594
821
|
const ts = this.ts;
|
|
595
822
|
const declaration = this.checker.getResolvedSignature(call)?.getDeclaration();
|
|
596
|
-
if (!declaration || ts.isJSDocSignature(declaration)) return
|
|
823
|
+
if (!declaration || ts.isJSDocSignature(declaration)) return [];
|
|
597
824
|
const parameters = declaration.parameters;
|
|
598
825
|
const last = parameters[parameters.length - 1];
|
|
599
826
|
if (last?.dotDotDotToken && index >= parameters.length - 1) {
|
|
827
|
+
const restStart = parameters.length - 1;
|
|
600
828
|
const restType = this.checker.getTypeAtLocation(last);
|
|
601
|
-
|
|
829
|
+
const totalRest = totalArgs !== void 0 && totalArgs >= restStart ? totalArgs - restStart : void 0;
|
|
830
|
+
return this.restSlotTypes(call, restStart, restType, index - restStart, totalRest, fromEndArgs, fullRestSpread);
|
|
602
831
|
}
|
|
603
832
|
const parameter = parameters[index];
|
|
604
|
-
return parameter ? this.checker.getTypeAtLocation(parameter) :
|
|
833
|
+
return parameter ? [this.checker.getTypeAtLocation(parameter)] : [];
|
|
834
|
+
}
|
|
835
|
+
declaredParameterType(call, index, totalArgs, fromEndArgs) {
|
|
836
|
+
return this.declaredParameterTypes(call, index, totalArgs, fromEndArgs)[0];
|
|
605
837
|
}
|
|
606
838
|
/**
|
|
607
839
|
* The type of the parameter that receives argument `index` at this call: type parameters filled in, so
|
|
608
840
|
* `resolve` of a `new Promise<Result<…>>`, `map.set(id, pending)` on a `Map<string, Promise<Result<…>>>` or
|
|
609
841
|
* `Result.ok(() => …)` take a Result here.
|
|
610
842
|
*/
|
|
611
|
-
|
|
843
|
+
instantiatedParameterTypes(call, index, totalArgs, fromEndArgs, fullRestSpread) {
|
|
612
844
|
const ts = this.ts;
|
|
613
845
|
const signature = this.checker.getResolvedSignature(call);
|
|
614
|
-
if (!signature) return
|
|
846
|
+
if (!signature) return [];
|
|
615
847
|
const parameters = signature.getParameters();
|
|
616
848
|
const last = parameters[parameters.length - 1];
|
|
617
849
|
const lastDeclaration = last?.valueDeclaration;
|
|
618
850
|
const isRest = lastDeclaration !== void 0 && ts.isParameter(lastDeclaration) && lastDeclaration.dotDotDotToken !== void 0;
|
|
619
851
|
if (isRest && index >= parameters.length - 1) {
|
|
620
|
-
|
|
852
|
+
const restStart = parameters.length - 1;
|
|
853
|
+
const totalRest = totalArgs !== void 0 && totalArgs >= restStart ? totalArgs - restStart : void 0;
|
|
854
|
+
return this.restSlotTypes(call, restStart, this.checker.getTypeOfSymbolAtLocation(last, call), index - restStart, totalRest, fromEndArgs, fullRestSpread);
|
|
621
855
|
}
|
|
622
856
|
const parameter = parameters[index];
|
|
623
|
-
return parameter ? this.checker.getTypeOfSymbolAtLocation(parameter, call) :
|
|
857
|
+
return parameter ? [this.checker.getTypeOfSymbolAtLocation(parameter, call)] : [];
|
|
858
|
+
}
|
|
859
|
+
instantiatedParameterType(call, index, totalArgs, fromEndArgs) {
|
|
860
|
+
return this.instantiatedParameterTypes(call, index, totalArgs, fromEndArgs)[0];
|
|
624
861
|
}
|
|
625
862
|
/** A Result, or a function returning one. */
|
|
626
863
|
takesResult(type) {
|
|
@@ -628,26 +865,262 @@ var DropWalk = class {
|
|
|
628
865
|
if (this.typeKinds(type)) return true;
|
|
629
866
|
return members(type).some((member) => member.getCallSignatures().some((signature) => this.typeKinds(signature.getReturnType()) !== null));
|
|
630
867
|
}
|
|
868
|
+
targetTakesValue(sourceType, targetType, seen = /* @__PURE__ */ new Set()) {
|
|
869
|
+
if (!targetType) return false;
|
|
870
|
+
const targetUnwrapped = this.checker.getAwaitedType(targetType) ?? targetType;
|
|
871
|
+
const sourceUnwrapped = this.checker.getAwaitedType(sourceType) ?? sourceType;
|
|
872
|
+
const sId = sourceUnwrapped.id;
|
|
873
|
+
const tId = targetUnwrapped.id;
|
|
874
|
+
if (sId !== void 0 && tId !== void 0) {
|
|
875
|
+
const pairKey = `${sId}:${tId}`;
|
|
876
|
+
if (seen.has(pairKey)) return this.takesResult(targetType);
|
|
877
|
+
seen.add(pairKey);
|
|
878
|
+
}
|
|
879
|
+
const tms = members(targetUnwrapped);
|
|
880
|
+
const nonNullishTms = tms.filter((tm) => !(tm.flags & (this.ts.TypeFlags.Undefined | this.ts.TypeFlags.Null | this.ts.TypeFlags.Void)));
|
|
881
|
+
if (nonNullishTms.length && nonNullishTms.every((tm) => this.checker.isTupleType(tm))) {
|
|
882
|
+
const sms = members(sourceUnwrapped);
|
|
883
|
+
for (const sm of sms) {
|
|
884
|
+
if (sm.flags & (this.ts.TypeFlags.Undefined | this.ts.TypeFlags.Null | this.ts.TypeFlags.Void)) continue;
|
|
885
|
+
const compatibleTargets = typeof this.checker.isTypeAssignableTo === "function" ? nonNullishTms.filter((tm) => this.checker.isTypeAssignableTo(sm, tm)) : [];
|
|
886
|
+
const activeTargets = compatibleTargets.length ? compatibleTargets : nonNullishTms;
|
|
887
|
+
if (this.checker.isTupleType(sm)) {
|
|
888
|
+
const sRef = sm;
|
|
889
|
+
const sFlags = sRef.target.elementFlags;
|
|
890
|
+
const sElems = this.checker.getTypeArguments(sRef);
|
|
891
|
+
const sHasVar = Boolean(sRef.target.combinedFlags & this.ts.ElementFlags.Variable);
|
|
892
|
+
for (const tm of activeTargets) {
|
|
893
|
+
const tRef = tm;
|
|
894
|
+
const tFlags = tRef.target.elementFlags;
|
|
895
|
+
const tElems = this.checker.getTypeArguments(tRef);
|
|
896
|
+
const tVarIdx = tElems.findIndex((_, ti) => (tFlags[ti] & this.ts.ElementFlags.Variable) !== 0);
|
|
897
|
+
const tSuffixCount = tVarIdx >= 0 ? tElems.length - 1 - tVarIdx : 0;
|
|
898
|
+
for (let k = 0; k < sElems.length; k++) {
|
|
899
|
+
const sIsVar = (sFlags[k] & this.ts.ElementFlags.Variable) !== 0;
|
|
900
|
+
const sElem = sIsVar ? this.checker.getIndexTypeOfType(sElems[k], this.ts.IndexKind.Number) ?? sElems[k] : sElems[k];
|
|
901
|
+
if (!this.typeKinds(sElem)) continue;
|
|
902
|
+
if (sIsVar) {
|
|
903
|
+
const sSuffixCount = sElems.length - 1 - k;
|
|
904
|
+
if (tVarIdx >= 0) {
|
|
905
|
+
const varType = this.checker.getIndexTypeOfType(tElems[tVarIdx], this.ts.IndexKind.Number) ?? tElems[tVarIdx];
|
|
906
|
+
if (!this.targetTakesValue(sElem, varType, seen)) return false;
|
|
907
|
+
for (let p = k; p < tVarIdx; p++) if (!this.targetTakesValue(sElem, tElems[p], seen)) return false;
|
|
908
|
+
const extraSuffix = tSuffixCount - sSuffixCount;
|
|
909
|
+
for (let s = 0; s < extraSuffix; s++) {
|
|
910
|
+
if (!this.targetTakesValue(sElem, tElems[tVarIdx + 1 + s], seen)) return false;
|
|
911
|
+
}
|
|
912
|
+
} else {
|
|
913
|
+
const end = Math.max(tElems.length - sSuffixCount, k);
|
|
914
|
+
for (let p = k; p < end; p++) if (!this.targetTakesValue(sElem, tElems[p], seen)) return false;
|
|
915
|
+
}
|
|
916
|
+
} else {
|
|
917
|
+
let pt;
|
|
918
|
+
if (!sHasVar) {
|
|
919
|
+
pt = this.tupleSlotAt(tRef, k, sElems.length);
|
|
920
|
+
} else {
|
|
921
|
+
const sVarIdx = sElems.findIndex((_, si) => (sFlags[si] & this.ts.ElementFlags.Variable) !== 0);
|
|
922
|
+
if (k < sVarIdx) pt = this.tupleSlotAt(tRef, k);
|
|
923
|
+
else {
|
|
924
|
+
const offsetFromEnd = sElems.length - k;
|
|
925
|
+
if (tVarIdx >= 0) {
|
|
926
|
+
if (offsetFromEnd <= tSuffixCount) pt = tElems[tElems.length - offsetFromEnd];
|
|
927
|
+
else pt = this.checker.getIndexTypeOfType(tElems[tVarIdx], this.ts.IndexKind.Number) ?? tElems[tVarIdx];
|
|
928
|
+
} else {
|
|
929
|
+
pt = tElems.length >= offsetFromEnd ? tElems[tElems.length - offsetFromEnd] : void 0;
|
|
930
|
+
}
|
|
931
|
+
}
|
|
932
|
+
}
|
|
933
|
+
if (!this.targetTakesValue(sElem, pt, seen)) return false;
|
|
934
|
+
}
|
|
935
|
+
}
|
|
936
|
+
}
|
|
937
|
+
} else {
|
|
938
|
+
const sElem = this.checker.getIndexTypeOfType(sm, this.ts.IndexKind.Number);
|
|
939
|
+
if (!sElem || !this.typeKinds(sElem)) continue;
|
|
940
|
+
for (const tm of activeTargets) {
|
|
941
|
+
const tRef = tm;
|
|
942
|
+
const tFlags = tRef.target.elementFlags;
|
|
943
|
+
const tElems = this.checker.getTypeArguments(tRef);
|
|
944
|
+
for (let p = 0; p < tElems.length; p++) {
|
|
945
|
+
const pt = (tFlags[p] & this.ts.ElementFlags.Variable) !== 0 ? this.checker.getIndexTypeOfType(tElems[p], this.ts.IndexKind.Number) ?? tElems[p] : tElems[p];
|
|
946
|
+
if (!this.targetTakesValue(sElem, pt, seen)) return false;
|
|
947
|
+
}
|
|
948
|
+
}
|
|
949
|
+
}
|
|
950
|
+
}
|
|
951
|
+
return this.takesResult(targetType);
|
|
952
|
+
}
|
|
953
|
+
return this.takesResult(targetType);
|
|
954
|
+
}
|
|
955
|
+
callEffectiveParamCount(call) {
|
|
956
|
+
const signature = this.checker.getResolvedSignature(call);
|
|
957
|
+
if (!signature) return 0;
|
|
958
|
+
const parameters = signature.getParameters();
|
|
959
|
+
const last = parameters[parameters.length - 1];
|
|
960
|
+
const lastDecl = last?.valueDeclaration;
|
|
961
|
+
if (lastDecl && this.ts.isParameter(lastDecl) && lastDecl.dotDotDotToken) {
|
|
962
|
+
const restType = this.checker.getTypeOfSymbolAtLocation(last, call);
|
|
963
|
+
const unwrapped = this.checker.getAwaitedType(restType) ?? restType;
|
|
964
|
+
let maxExtra = 1;
|
|
965
|
+
for (const m of members(unwrapped)) {
|
|
966
|
+
if (this.checker.isTupleType(m)) maxExtra = Math.max(maxExtra, this.checker.getTypeArguments(m).length);
|
|
967
|
+
}
|
|
968
|
+
return parameters.length - 1 + maxExtra;
|
|
969
|
+
}
|
|
970
|
+
return parameters.length;
|
|
971
|
+
}
|
|
972
|
+
callExactArgCount(call) {
|
|
973
|
+
const ts = this.ts;
|
|
974
|
+
let total = 0;
|
|
975
|
+
for (const current of argumentsOf(call)) {
|
|
976
|
+
if (!ts.isSpreadElement(current)) {
|
|
977
|
+
total += 1;
|
|
978
|
+
continue;
|
|
979
|
+
}
|
|
980
|
+
const type = this.checker.getTypeAtLocation(current.expression);
|
|
981
|
+
const unwrapped = this.checker.getAwaitedType(type) ?? type;
|
|
982
|
+
const ms = members(unwrapped);
|
|
983
|
+
if (!ms.length || !ms.every((m) => this.checker.isTupleType(m))) return void 0;
|
|
984
|
+
let len;
|
|
985
|
+
for (const m of ms) {
|
|
986
|
+
const ref = m;
|
|
987
|
+
if (ref.target.combinedFlags & ts.ElementFlags.NonRequired) return void 0;
|
|
988
|
+
const mLen = this.checker.getTypeArguments(ref).length;
|
|
989
|
+
if (len === void 0) len = mLen;
|
|
990
|
+
else if (len !== mLen) return void 0;
|
|
991
|
+
}
|
|
992
|
+
total += len ?? 0;
|
|
993
|
+
}
|
|
994
|
+
return total;
|
|
995
|
+
}
|
|
631
996
|
/**
|
|
632
997
|
* The callee takes the failure over: its parameter is a Result (or a function returning one), as declared or as
|
|
633
998
|
* this call fills in its type parameters. `console.log(…)` (`any`) and `String(…)` (`unknown`) take nothing.
|
|
634
999
|
*/
|
|
635
1000
|
acceptsArgument(call, argument) {
|
|
636
|
-
const
|
|
637
|
-
|
|
638
|
-
|
|
1001
|
+
const ts = this.ts;
|
|
1002
|
+
const args = argumentsOf(call);
|
|
1003
|
+
const totalArgs = this.callExactArgCount(call);
|
|
1004
|
+
const signature = this.checker.getResolvedSignature(call);
|
|
1005
|
+
const sigParams = signature?.getParameters() ?? [];
|
|
1006
|
+
const lastParam = sigParams[sigParams.length - 1];
|
|
1007
|
+
const lastDecl = lastParam?.valueDeclaration;
|
|
1008
|
+
const hasRestParam = Boolean(lastDecl && ts.isParameter(lastDecl) && lastDecl.dotDotDotToken);
|
|
1009
|
+
const restStart = sigParams.length - 1;
|
|
1010
|
+
const takesValueAt = (sourceType, index, fromEndArgs, fullRestSpread) => {
|
|
1011
|
+
const declTypes = this.declaredParameterTypes(call, index, totalArgs, fromEndArgs, fullRestSpread);
|
|
1012
|
+
if (declTypes.length && declTypes.every((pt) => this.targetTakesValue(sourceType, pt))) return true;
|
|
1013
|
+
const instTypes = this.instantiatedParameterTypes(call, index, totalArgs, fromEndArgs, fullRestSpread);
|
|
1014
|
+
return instTypes.length > 0 && instTypes.every((pt) => this.targetTakesValue(sourceType, pt));
|
|
1015
|
+
};
|
|
1016
|
+
const paramCount = this.callEffectiveParamCount(call);
|
|
1017
|
+
let cursor = 0;
|
|
1018
|
+
let seenVariadic = false;
|
|
1019
|
+
for (let argIdx = 0; argIdx < args.length; argIdx++) {
|
|
1020
|
+
const current = args[argIdx];
|
|
1021
|
+
if (current === argument) {
|
|
1022
|
+
const trailingFixedArgs = (() => {
|
|
1023
|
+
let count = 0;
|
|
1024
|
+
for (let j = argIdx + 1; j < args.length; j++) {
|
|
1025
|
+
const nextArg = args[j];
|
|
1026
|
+
if (!ts.isSpreadElement(nextArg)) {
|
|
1027
|
+
count += 1;
|
|
1028
|
+
continue;
|
|
1029
|
+
}
|
|
1030
|
+
const nt = this.checker.getTypeAtLocation(nextArg.expression);
|
|
1031
|
+
const nu = this.checker.getAwaitedType(nt) ?? nt;
|
|
1032
|
+
const nms = members(nu);
|
|
1033
|
+
if (!nms.length || !nms.every((m) => this.checker.isTupleType(m))) return void 0;
|
|
1034
|
+
let len;
|
|
1035
|
+
for (const m of nms) {
|
|
1036
|
+
const r = m;
|
|
1037
|
+
if (r.target.combinedFlags & ts.ElementFlags.NonRequired) return void 0;
|
|
1038
|
+
const mLen = this.checker.getTypeArguments(r).length;
|
|
1039
|
+
if (len === void 0) len = mLen;
|
|
1040
|
+
else if (len !== mLen) return void 0;
|
|
1041
|
+
}
|
|
1042
|
+
count += len ?? 0;
|
|
1043
|
+
}
|
|
1044
|
+
return count;
|
|
1045
|
+
})();
|
|
1046
|
+
if (!ts.isSpreadElement(argument)) {
|
|
1047
|
+
const fromEnd = seenVariadic && trailingFixedArgs !== void 0 ? trailingFixedArgs + 1 : void 0;
|
|
1048
|
+
return takesValueAt(this.checker.getTypeAtLocation(argument), cursor, fromEnd);
|
|
1049
|
+
}
|
|
1050
|
+
const type = this.checker.getTypeAtLocation(argument.expression);
|
|
1051
|
+
const unwrapped = this.checker.getAwaitedType(type) ?? type;
|
|
1052
|
+
const ms = members(unwrapped);
|
|
1053
|
+
const isSoleRestSpread = hasRestParam && cursor === restStart && !seenVariadic && argIdx === args.length - 1;
|
|
1054
|
+
if (ms.length && ms.every((m) => this.checker.isTupleType(m))) {
|
|
1055
|
+
let checked = false;
|
|
1056
|
+
for (const m of ms) {
|
|
1057
|
+
const fullRest = isSoleRestSpread ? m : void 0;
|
|
1058
|
+
const ref = m;
|
|
1059
|
+
const flags = ref.target.elementFlags;
|
|
1060
|
+
const elemTypes = this.checker.getTypeArguments(ref);
|
|
1061
|
+
const varIdx = elemTypes.findIndex((_, si) => (flags[si] & ts.ElementFlags.Variable) !== 0);
|
|
1062
|
+
for (let i = 0; i < elemTypes.length; i++) {
|
|
1063
|
+
const isVar = (flags[i] & ts.ElementFlags.Variable) !== 0;
|
|
1064
|
+
const elemType2 = isVar ? this.checker.getIndexTypeOfType(elemTypes[i], ts.IndexKind.Number) ?? elemTypes[i] : elemTypes[i];
|
|
1065
|
+
if (!this.typeKinds(elemType2)) continue;
|
|
1066
|
+
checked = true;
|
|
1067
|
+
if (isVar) {
|
|
1068
|
+
if (!takesValueAt(elemType2, cursor + i, void 0, fullRest)) return false;
|
|
1069
|
+
for (let p = cursor + i + 1; p < paramCount; p++) if (!takesValueAt(elemType2, p, void 0, fullRest)) return false;
|
|
1070
|
+
} else {
|
|
1071
|
+
const hasAfterVar = varIdx >= 0 && i > varIdx;
|
|
1072
|
+
const fromEnd = (seenVariadic || hasAfterVar) && trailingFixedArgs !== void 0 ? trailingFixedArgs + (elemTypes.length - i) : void 0;
|
|
1073
|
+
if (!takesValueAt(elemType2, cursor + i, fromEnd, fullRest)) return false;
|
|
1074
|
+
}
|
|
1075
|
+
}
|
|
1076
|
+
}
|
|
1077
|
+
return checked || takesValueAt(type, cursor);
|
|
1078
|
+
}
|
|
1079
|
+
if (paramCount <= cursor) return false;
|
|
1080
|
+
const elemType = this.checker.getIndexTypeOfType(unwrapped, ts.IndexKind.Number) ?? unwrapped;
|
|
1081
|
+
for (let p = cursor; p < paramCount; p++) if (!takesValueAt(elemType, p)) return false;
|
|
1082
|
+
return true;
|
|
1083
|
+
}
|
|
1084
|
+
if (ts.isSpreadElement(current)) {
|
|
1085
|
+
const type = this.checker.getTypeAtLocation(current.expression);
|
|
1086
|
+
const unwrapped = this.checker.getAwaitedType(type) ?? type;
|
|
1087
|
+
const ms = members(unwrapped);
|
|
1088
|
+
if (ms.length && ms.every((m) => this.checker.isTupleType(m))) {
|
|
1089
|
+
const allExactSameLen = ms.every((m) => !(m.target.combinedFlags & ts.ElementFlags.NonRequired)) && new Set(ms.map((m) => this.checker.getTypeArguments(m).length)).size === 1;
|
|
1090
|
+
if (allExactSameLen) {
|
|
1091
|
+
cursor += this.checker.getTypeArguments(ms[0]).length;
|
|
1092
|
+
continue;
|
|
1093
|
+
}
|
|
1094
|
+
}
|
|
1095
|
+
seenVariadic = true;
|
|
1096
|
+
}
|
|
1097
|
+
cursor += 1;
|
|
1098
|
+
}
|
|
1099
|
+
return false;
|
|
639
1100
|
}
|
|
640
1101
|
/** `results.push(f())`: the receiver is itself a collection of Results, so the value is kept in it. */
|
|
641
1102
|
receiverKeeps(call) {
|
|
642
1103
|
const callee = this.ts.isCallExpression(call) ? unparen(this.ts, call.expression) : void 0;
|
|
643
|
-
return callee !== void 0 && this.ts.isPropertyAccessExpression(callee) && this.kindsOf(callee.expression) !== null;
|
|
1104
|
+
return callee !== void 0 && memberAccessName(this.ts, callee) !== void 0 && (this.ts.isPropertyAccessExpression(callee) || this.ts.isElementAccessExpression(callee)) && this.kindsOf(callee.expression) !== null;
|
|
644
1105
|
}
|
|
645
1106
|
// ---- flow of a value to the place its fate is decided ----
|
|
646
1107
|
/** The expression `child`'s value flows into unchanged (wrappers, branches, collections, calls returning it), else null. */
|
|
1108
|
+
receiverOfIdentityCall(node) {
|
|
1109
|
+
const ts = this.ts;
|
|
1110
|
+
if (!this.stateFound || !ts.isCallExpression(node)) return;
|
|
1111
|
+
const access = node.expression;
|
|
1112
|
+
if ((ts.isPropertyAccessExpression(access) || ts.isElementAccessExpression(access)) && ["reverse", "sort"].includes(memberAccessName(ts, access) ?? "") && this.libOrigin(node) !== null) return access.expression;
|
|
1113
|
+
}
|
|
1114
|
+
identitySource(expr) {
|
|
1115
|
+
const inner = unparen(this.ts, expr);
|
|
1116
|
+
const receiver = this.receiverOfIdentityCall(inner);
|
|
1117
|
+
return receiver ? this.identitySource(receiver) : inner;
|
|
1118
|
+
}
|
|
647
1119
|
flowsInto(child) {
|
|
648
1120
|
const ts = this.ts;
|
|
649
1121
|
const parent = child.parent;
|
|
650
1122
|
if (!parent) return null;
|
|
1123
|
+
if (parent.parent && this.receiverOfIdentityCall(parent.parent) === child) return parent.parent;
|
|
651
1124
|
if (ts.isParenthesizedExpression(parent) || ts.isAwaitExpression(parent) || ts.isAsExpression(parent) || ts.isNonNullExpression(parent) || ts.isSatisfiesExpression(parent) || ts.isTypeAssertionExpression(parent)) {
|
|
652
1125
|
return parent;
|
|
653
1126
|
}
|
|
@@ -714,8 +1187,9 @@ var DropWalk = class {
|
|
|
714
1187
|
}
|
|
715
1188
|
if ((ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === carrier) {
|
|
716
1189
|
const call = parent.parent;
|
|
717
|
-
const
|
|
718
|
-
const
|
|
1190
|
+
const methodName = memberAccessName(ts, parent);
|
|
1191
|
+
const predicate = methodName !== void 0 && PREDICATE_METHODS.has(methodName);
|
|
1192
|
+
const handsOver = !predicate && ts.isCallExpression(call) && call.expression === parent && call.arguments.some((argument, argIndex) => this.isElementCallbackPosition(call, parent, argIndex) && isOwner(ts, unparen(ts, argument)));
|
|
719
1193
|
return handsOver ? "consume" : "discarded";
|
|
720
1194
|
}
|
|
721
1195
|
if ((ts.isForOfStatement(parent) || ts.isForInStatement(parent)) && parent.expression === carrier) return "consume";
|
|
@@ -728,45 +1202,468 @@ var DropWalk = class {
|
|
|
728
1202
|
}
|
|
729
1203
|
return "discarded";
|
|
730
1204
|
}
|
|
1205
|
+
libOrigin(node) {
|
|
1206
|
+
const resolved = this.context.policy.calleeDeclaration(node);
|
|
1207
|
+
const origin = resolved && this.context.policy.origins.originOf(resolved.declaration);
|
|
1208
|
+
return origin?.kind === "external" && origin.origin.startsWith("js:") ? origin.origin : null;
|
|
1209
|
+
}
|
|
1210
|
+
isEmptyArrayInitializer(node) {
|
|
1211
|
+
const ts = this.ts;
|
|
1212
|
+
const inner = unparen(ts, node);
|
|
1213
|
+
if (ts.isArrayLiteralExpression(inner)) return inner.elements.length === 0;
|
|
1214
|
+
if (ts.isCallExpression(inner) || ts.isNewExpression(inner)) {
|
|
1215
|
+
const origin = this.libOrigin(inner);
|
|
1216
|
+
if (origin === "js:Array.of") return argumentsOf(inner).length === 0;
|
|
1217
|
+
if (origin === "js:Array") {
|
|
1218
|
+
const args = argumentsOf(inner);
|
|
1219
|
+
if (args.length === 0) return true;
|
|
1220
|
+
if (args.length === 1 && !ts.isSpreadElement(args[0])) {
|
|
1221
|
+
const argType = this.checker.getTypeAtLocation(args[0]);
|
|
1222
|
+
return (argType.flags & ts.TypeFlags.NumberLike) !== 0;
|
|
1223
|
+
}
|
|
1224
|
+
}
|
|
1225
|
+
}
|
|
1226
|
+
return false;
|
|
1227
|
+
}
|
|
1228
|
+
/** Unbound states left when `pattern` destructures a value of `type` (empty set when every stated element is bound). */
|
|
1229
|
+
unboundPatternStates(pattern, type) {
|
|
1230
|
+
const ts = this.ts;
|
|
1231
|
+
const target = unparen(ts, pattern);
|
|
1232
|
+
const kindStates = this.typeKinds(type);
|
|
1233
|
+
if (!type || !kindStates || !kindStates.size) return NOTHING;
|
|
1234
|
+
if (ts.isIdentifier(target)) return this.moduleHeld(target) ? kindStates : NOTHING;
|
|
1235
|
+
const unwrapped = this.checker.getAwaitedType(type) ?? type;
|
|
1236
|
+
if (ts.isArrayBindingPattern(target)) {
|
|
1237
|
+
const restIndex = target.elements.findIndex((e) => !ts.isOmittedExpression(e) && e.dotDotDotToken !== void 0);
|
|
1238
|
+
const hasRest = restIndex >= 0;
|
|
1239
|
+
const prefixLen = hasRest ? restIndex : target.elements.length;
|
|
1240
|
+
const unbound = /* @__PURE__ */ new Set();
|
|
1241
|
+
for (const m of members(unwrapped)) {
|
|
1242
|
+
if (m.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.Any) || this.context.policy.resultVariant(m) !== null) continue;
|
|
1243
|
+
if (this.checker.isTupleType(m)) {
|
|
1244
|
+
const ref = m;
|
|
1245
|
+
const flags = ref.target.elementFlags;
|
|
1246
|
+
const elemTypes = this.checker.getTypeArguments(ref);
|
|
1247
|
+
const hasMidVariadic = elemTypes.some((_, idx) => (flags[idx] & ts.ElementFlags.Variable) !== 0 && idx < prefixLen);
|
|
1248
|
+
if (hasMidVariadic && hasRest && target.elements.every((el) => !ts.isOmittedExpression(el) && ts.isIdentifier(el.name) && !this.moduleHeld(el.name))) continue;
|
|
1249
|
+
if (hasMidVariadic) {
|
|
1250
|
+
for (const s of this.typeKinds(m) ?? []) unbound.add(s);
|
|
1251
|
+
continue;
|
|
1252
|
+
}
|
|
1253
|
+
for (let i = 0; i < elemTypes.length; i++) {
|
|
1254
|
+
const isVar = (flags[i] & ts.ElementFlags.Variable) !== 0;
|
|
1255
|
+
const slotType = isVar ? this.checker.getIndexTypeOfType(elemTypes[i], ts.IndexKind.Number) ?? elemTypes[i] : elemTypes[i];
|
|
1256
|
+
if (i < prefixLen && !isVar) {
|
|
1257
|
+
const el = target.elements[i];
|
|
1258
|
+
if (ts.isOmittedExpression(el)) {
|
|
1259
|
+
for (const s of this.typeKinds(slotType) ?? []) unbound.add(s);
|
|
1260
|
+
} else {
|
|
1261
|
+
for (const s of this.unboundPatternStates(el.name, slotType)) unbound.add(s);
|
|
1262
|
+
}
|
|
1263
|
+
} else if (hasRest) {
|
|
1264
|
+
const restEl = target.elements[restIndex];
|
|
1265
|
+
if (!ts.isIdentifier(restEl.name)) {
|
|
1266
|
+
for (const s of this.typeKinds(slotType) ?? []) unbound.add(s);
|
|
1267
|
+
}
|
|
1268
|
+
} else {
|
|
1269
|
+
for (const s of this.typeKinds(slotType) ?? []) unbound.add(s);
|
|
1270
|
+
}
|
|
1271
|
+
}
|
|
1272
|
+
} else {
|
|
1273
|
+
const elem = this.checker.getIndexTypeOfType(m, ts.IndexKind.Number);
|
|
1274
|
+
if (!elem) continue;
|
|
1275
|
+
for (let i = 0; i < prefixLen; i++) {
|
|
1276
|
+
const el = target.elements[i];
|
|
1277
|
+
if (ts.isOmittedExpression(el)) {
|
|
1278
|
+
for (const s of this.typeKinds(elem) ?? []) unbound.add(s);
|
|
1279
|
+
} else {
|
|
1280
|
+
for (const s of this.unboundPatternStates(el.name, elem)) unbound.add(s);
|
|
1281
|
+
}
|
|
1282
|
+
}
|
|
1283
|
+
if (!hasRest || !ts.isIdentifier(target.elements[restIndex].name)) {
|
|
1284
|
+
for (const s of this.typeKinds(elem) ?? []) unbound.add(s);
|
|
1285
|
+
}
|
|
1286
|
+
}
|
|
1287
|
+
}
|
|
1288
|
+
return unbound;
|
|
1289
|
+
}
|
|
1290
|
+
if (ts.isArrayLiteralExpression(target)) {
|
|
1291
|
+
const restIndex = target.elements.findIndex((e) => ts.isSpreadElement(e));
|
|
1292
|
+
const hasRest = restIndex >= 0;
|
|
1293
|
+
const prefixLen = hasRest ? restIndex : target.elements.length;
|
|
1294
|
+
const unbound = /* @__PURE__ */ new Set();
|
|
1295
|
+
for (const m of members(unwrapped)) {
|
|
1296
|
+
if (m.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.Any) || this.context.policy.resultVariant(m) !== null) continue;
|
|
1297
|
+
if (this.checker.isTupleType(m)) {
|
|
1298
|
+
const ref = m;
|
|
1299
|
+
const flags = ref.target.elementFlags;
|
|
1300
|
+
const elemTypes = this.checker.getTypeArguments(ref);
|
|
1301
|
+
const hasMidVariadic = elemTypes.some((_, idx) => (flags[idx] & ts.ElementFlags.Variable) !== 0 && idx < prefixLen);
|
|
1302
|
+
if (hasMidVariadic && hasRest && target.elements.every((el) => ts.isIdentifier(ts.isSpreadElement(el) ? el.expression : el) && !this.moduleHeld(ts.isSpreadElement(el) ? el.expression : el))) continue;
|
|
1303
|
+
if (hasMidVariadic) {
|
|
1304
|
+
for (const s of this.typeKinds(m) ?? []) unbound.add(s);
|
|
1305
|
+
continue;
|
|
1306
|
+
}
|
|
1307
|
+
for (let i = 0; i < elemTypes.length; i++) {
|
|
1308
|
+
const isVar = (flags[i] & ts.ElementFlags.Variable) !== 0;
|
|
1309
|
+
const slotType = isVar ? this.checker.getIndexTypeOfType(elemTypes[i], ts.IndexKind.Number) ?? elemTypes[i] : elemTypes[i];
|
|
1310
|
+
if (i < prefixLen && !isVar) {
|
|
1311
|
+
const el = target.elements[i];
|
|
1312
|
+
const elInner = ts.isBinaryExpression(el) && el.operatorToken.kind === ts.SyntaxKind.EqualsToken ? el.left : el;
|
|
1313
|
+
if (ts.isOmittedExpression(elInner)) {
|
|
1314
|
+
for (const s of this.typeKinds(slotType) ?? []) unbound.add(s);
|
|
1315
|
+
} else {
|
|
1316
|
+
for (const s of this.unboundPatternStates(elInner, slotType)) unbound.add(s);
|
|
1317
|
+
}
|
|
1318
|
+
} else if (hasRest) {
|
|
1319
|
+
const spread = target.elements[restIndex];
|
|
1320
|
+
const spreadTarget = unparen(ts, spread.expression);
|
|
1321
|
+
if (!ts.isIdentifier(spreadTarget) || this.moduleHeld(spreadTarget)) {
|
|
1322
|
+
for (const s of this.typeKinds(slotType) ?? []) unbound.add(s);
|
|
1323
|
+
}
|
|
1324
|
+
} else {
|
|
1325
|
+
for (const s of this.typeKinds(slotType) ?? []) unbound.add(s);
|
|
1326
|
+
}
|
|
1327
|
+
}
|
|
1328
|
+
} else {
|
|
1329
|
+
const elem = this.checker.getIndexTypeOfType(m, ts.IndexKind.Number);
|
|
1330
|
+
if (!elem) continue;
|
|
1331
|
+
for (let i = 0; i < prefixLen; i++) {
|
|
1332
|
+
const el = target.elements[i];
|
|
1333
|
+
const elInner = ts.isBinaryExpression(el) && el.operatorToken.kind === ts.SyntaxKind.EqualsToken ? el.left : el;
|
|
1334
|
+
if (ts.isOmittedExpression(elInner)) {
|
|
1335
|
+
for (const s of this.typeKinds(elem) ?? []) unbound.add(s);
|
|
1336
|
+
} else {
|
|
1337
|
+
for (const s of this.unboundPatternStates(elInner, elem)) unbound.add(s);
|
|
1338
|
+
}
|
|
1339
|
+
}
|
|
1340
|
+
if (!hasRest) {
|
|
1341
|
+
for (const s of this.typeKinds(elem) ?? []) unbound.add(s);
|
|
1342
|
+
} else {
|
|
1343
|
+
const spread = target.elements[restIndex];
|
|
1344
|
+
const spreadTarget = unparen(ts, spread.expression);
|
|
1345
|
+
if (!ts.isIdentifier(spreadTarget) || this.moduleHeld(spreadTarget)) {
|
|
1346
|
+
for (const s of this.typeKinds(elem) ?? []) unbound.add(s);
|
|
1347
|
+
}
|
|
1348
|
+
}
|
|
1349
|
+
}
|
|
1350
|
+
}
|
|
1351
|
+
return unbound;
|
|
1352
|
+
}
|
|
1353
|
+
return kindStates;
|
|
1354
|
+
}
|
|
1355
|
+
patternStoresModuleHeld(pattern) {
|
|
1356
|
+
const ts = this.ts;
|
|
1357
|
+
const target = unparen(ts, pattern);
|
|
1358
|
+
if (ts.isOmittedExpression(target)) return false;
|
|
1359
|
+
if (ts.isIdentifier(target)) return this.moduleHeld(target);
|
|
1360
|
+
if (ts.isArrayLiteralExpression(target)) {
|
|
1361
|
+
return target.elements.some((el) => {
|
|
1362
|
+
if (ts.isOmittedExpression(el)) return false;
|
|
1363
|
+
if (ts.isSpreadElement(el)) return this.patternStoresModuleHeld(el.expression);
|
|
1364
|
+
if (ts.isBinaryExpression(el) && el.operatorToken.kind === ts.SyntaxKind.EqualsToken) return this.patternStoresModuleHeld(el.left);
|
|
1365
|
+
return this.patternStoresModuleHeld(el);
|
|
1366
|
+
});
|
|
1367
|
+
}
|
|
1368
|
+
if (ts.isObjectLiteralExpression(target)) return true;
|
|
1369
|
+
return true;
|
|
1370
|
+
}
|
|
1371
|
+
forOfElementKinds(node) {
|
|
1372
|
+
const ts = this.ts;
|
|
1373
|
+
const exprType = this.checker.getTypeAtLocation(node.expression);
|
|
1374
|
+
const unwrapped = node.awaitModifier ? this.checker.getAwaitedType(exprType) ?? exprType : exprType;
|
|
1375
|
+
if (ts.isVariableDeclarationList(node.initializer)) {
|
|
1376
|
+
const decl = node.initializer.declarations[0];
|
|
1377
|
+
if (decl && ts.isIdentifier(decl.name)) return this.kindsOf(decl.name) ?? NOTHING;
|
|
1378
|
+
}
|
|
1379
|
+
const states = /* @__PURE__ */ new Set();
|
|
1380
|
+
for (const m of members(unwrapped)) {
|
|
1381
|
+
const elem = this.checker.getIndexTypeOfType(m, ts.IndexKind.Number);
|
|
1382
|
+
if (elem) {
|
|
1383
|
+
const elemUnwrapped = node.awaitModifier ? this.checker.getAwaitedType(elem) ?? elem : elem;
|
|
1384
|
+
for (const s of this.typeKinds(elemUnwrapped) ?? []) states.add(s);
|
|
1385
|
+
}
|
|
1386
|
+
}
|
|
1387
|
+
if (states.size) return states;
|
|
1388
|
+
if (!ts.isVariableDeclarationList(node.initializer)) return this.kindsOf(node.initializer) ?? NOTHING;
|
|
1389
|
+
return NOTHING;
|
|
1390
|
+
}
|
|
1391
|
+
forOfUnboundStates(node, pattern) {
|
|
1392
|
+
const ts = this.ts;
|
|
1393
|
+
const exprType = this.checker.getTypeAtLocation(node.expression);
|
|
1394
|
+
const unwrapped = node.awaitModifier ? this.checker.getAwaitedType(exprType) ?? exprType : exprType;
|
|
1395
|
+
if (ts.isVariableDeclarationList(node.initializer)) {
|
|
1396
|
+
const decl = node.initializer.declarations[0];
|
|
1397
|
+
if (decl && ts.isIdentifier(decl.name)) return this.unboundPatternStates(pattern, this.checker.getTypeAtLocation(decl.name));
|
|
1398
|
+
}
|
|
1399
|
+
const unbound = /* @__PURE__ */ new Set();
|
|
1400
|
+
let anyElem = false;
|
|
1401
|
+
for (const m of members(unwrapped)) {
|
|
1402
|
+
const elem = this.checker.getIndexTypeOfType(m, ts.IndexKind.Number);
|
|
1403
|
+
if (elem) {
|
|
1404
|
+
anyElem = true;
|
|
1405
|
+
const elemUnwrapped = node.awaitModifier ? this.checker.getAwaitedType(elem) ?? elem : elem;
|
|
1406
|
+
for (const s of this.unboundPatternStates(pattern, elemUnwrapped)) unbound.add(s);
|
|
1407
|
+
}
|
|
1408
|
+
}
|
|
1409
|
+
if (anyElem) return unbound;
|
|
1410
|
+
if (!ts.isVariableDeclarationList(node.initializer)) return this.unboundPatternStates(pattern, this.checker.getTypeAtLocation(node.initializer));
|
|
1411
|
+
return NOTHING;
|
|
1412
|
+
}
|
|
1413
|
+
initializerKinds(expr) {
|
|
1414
|
+
return this.stateFound && this.isEmptyArrayInitializer(expr) ? null : this.kindsOf(expr);
|
|
1415
|
+
}
|
|
1416
|
+
consumesCallbackElements(argument, rejectStatedReturn = false, elementIndex) {
|
|
1417
|
+
const ts = this.ts;
|
|
1418
|
+
const inner = unparen(ts, argument);
|
|
1419
|
+
if (isOwner(ts, inner) && !ts.isClassStaticBlockDeclaration(inner)) {
|
|
1420
|
+
if (!inner.parameters.some((parameter, i) => (elementIndex === void 0 || i === elementIndex) && this.kindsOf(parameter) !== null)) return false;
|
|
1421
|
+
if (rejectStatedReturn) {
|
|
1422
|
+
const sig = this.checker.getSignatureFromDeclaration(inner);
|
|
1423
|
+
if (sig && this.typeKinds(this.checker.getReturnTypeOfSignature(sig)) !== null) return false;
|
|
1424
|
+
}
|
|
1425
|
+
return true;
|
|
1426
|
+
}
|
|
1427
|
+
const type = this.checker.getTypeAtLocation(inner);
|
|
1428
|
+
let anyAccepted = false;
|
|
1429
|
+
for (const member of members(type)) {
|
|
1430
|
+
for (const signature of member.getCallSignatures()) {
|
|
1431
|
+
const declaration = signature.getDeclaration();
|
|
1432
|
+
if (!declaration || ts.isJSDocSignature(declaration)) continue;
|
|
1433
|
+
const origin = this.context.policy.origins.originOf(declaration);
|
|
1434
|
+
if (origin.kind === "local" && origin.zone === "checked" && signature.getParameters().some((parameter, i) => (elementIndex === void 0 || i === elementIndex) && this.typeKinds(this.checker.getTypeOfSymbolAtLocation(parameter, inner)) !== null)) {
|
|
1435
|
+
if (rejectStatedReturn && this.typeKinds(this.checker.getReturnTypeOfSignature(signature)) !== null) return false;
|
|
1436
|
+
anyAccepted = true;
|
|
1437
|
+
}
|
|
1438
|
+
}
|
|
1439
|
+
}
|
|
1440
|
+
return anyAccepted;
|
|
1441
|
+
}
|
|
731
1442
|
/** The state pass reuses the control-flow engine, but not failure handoff rules. */
|
|
732
|
-
stateUse(node, states, temporary = true) {
|
|
1443
|
+
stateUse(node, states, temporary = true, state) {
|
|
733
1444
|
if (!states.size) return false;
|
|
734
1445
|
const ts = this.ts;
|
|
735
|
-
const
|
|
1446
|
+
const arg = ts.isSpreadElement(node.parent) && (ts.isCallExpression(node.parent.parent) || ts.isNewExpression(node.parent.parent)) ? node.parent : node;
|
|
1447
|
+
const parent = arg.parent;
|
|
736
1448
|
let origin;
|
|
737
1449
|
let callee;
|
|
1450
|
+
let reportStates = states;
|
|
738
1451
|
if (ts.isPropertyDeclaration(parent) || ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent)) origin = "stored-state";
|
|
739
1452
|
else if (ts.isVariableDeclaration(parent)) {
|
|
1453
|
+
if (parent.initializer !== node) return false;
|
|
740
1454
|
if (ts.isSourceFile(this.owner)) origin = "stored-state";
|
|
741
|
-
else return
|
|
1455
|
+
else if (ts.isIdentifier(parent.name)) return temporary || this.kindsOf(parent.name) !== null;
|
|
1456
|
+
else if (ts.isArrayBindingPattern(parent.name)) {
|
|
1457
|
+
const unbound = this.unboundPatternStates(parent.name, this.checker.getTypeAtLocation(node));
|
|
1458
|
+
const remaining = new Set([...unbound].filter((s) => states.has(s)));
|
|
1459
|
+
if (remaining.size === 0) return true;
|
|
1460
|
+
if (!temporary) return remaining;
|
|
1461
|
+
origin = "unchecked-state";
|
|
1462
|
+
reportStates = remaining;
|
|
1463
|
+
} else origin = "unchecked-state";
|
|
742
1464
|
} else if (ts.isBinaryExpression(parent) && isPlainOrLogicalAssignment(ts, parent.operatorToken.kind) && parent.right === node) {
|
|
743
|
-
|
|
1465
|
+
const target = unparen(ts, parent.left);
|
|
1466
|
+
if (this.patternStoresModuleHeld(target)) origin = "stored-state";
|
|
1467
|
+
else if (ts.isIdentifier(target)) {
|
|
1468
|
+
const symbol = this.checker.getSymbolAtLocation(target);
|
|
1469
|
+
return temporary || Boolean(symbol && this.tracked.has(symbol));
|
|
1470
|
+
} else if (ts.isArrayLiteralExpression(target)) {
|
|
1471
|
+
const unbound = this.unboundPatternStates(target, this.checker.getTypeAtLocation(node));
|
|
1472
|
+
const remaining = new Set([...unbound].filter((s) => states.has(s)));
|
|
1473
|
+
if (remaining.size === 0) return true;
|
|
1474
|
+
if (!temporary) return remaining;
|
|
1475
|
+
origin = "unchecked-state";
|
|
1476
|
+
reportStates = remaining;
|
|
1477
|
+
} else origin = "stored-state";
|
|
1478
|
+
} else if (ts.isReturnStatement(parent) && parent.expression === node) {
|
|
1479
|
+
if (!ts.isSourceFile(this.owner) && this.isDiscardedReturnCallback(this.owner)) origin = "unchecked-state";
|
|
744
1480
|
else return true;
|
|
745
|
-
} else if (ts.
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
1481
|
+
} else if (ts.isYieldExpression(parent) || ts.isArrowFunction(parent) && parent.body === node) {
|
|
1482
|
+
if (ts.isArrowFunction(parent) && parent.body === node && this.isDiscardedReturnCallback(parent)) origin = "unchecked-state";
|
|
1483
|
+
else return true;
|
|
1484
|
+
} else if (ts.isForOfStatement(parent) && parent.expression === node) {
|
|
1485
|
+
let remaining;
|
|
1486
|
+
if (ts.isVariableDeclarationList(parent.initializer)) {
|
|
1487
|
+
const decl = parent.initializer.declarations[0];
|
|
1488
|
+
if (!decl) origin = "unchecked-state";
|
|
1489
|
+
else {
|
|
1490
|
+
const unbound = this.forOfUnboundStates(parent, decl.name);
|
|
1491
|
+
remaining = new Set([...unbound].filter((s) => states.has(s)));
|
|
1492
|
+
}
|
|
1493
|
+
} else if (this.patternStoresModuleHeld(parent.initializer)) origin = "stored-state";
|
|
1494
|
+
else {
|
|
1495
|
+
const unbound = this.forOfUnboundStates(parent, parent.initializer);
|
|
1496
|
+
remaining = new Set([...unbound].filter((s) => states.has(s)));
|
|
1497
|
+
}
|
|
1498
|
+
if (remaining !== void 0) {
|
|
1499
|
+
const bound = new Set([...states].filter((s) => !remaining.has(s)));
|
|
1500
|
+
if (bound.size) {
|
|
1501
|
+
const trackedSym = !temporary && state ? this.trackedSymbol(node, state) ?? void 0 : void 0;
|
|
1502
|
+
const trackedVer = trackedSym && state ? state.get(trackedSym)?.version : void 0;
|
|
1503
|
+
const prev = this.activeForOfs.get(parent);
|
|
1504
|
+
const symbol = trackedSym ?? prev?.symbol;
|
|
1505
|
+
const version = trackedVer ?? prev?.version;
|
|
1506
|
+
this.activeForOfs.set(parent, {
|
|
1507
|
+
...symbol ? { symbol } : {},
|
|
1508
|
+
...version !== void 0 ? { version } : {},
|
|
1509
|
+
node,
|
|
1510
|
+
states: union(prev?.states ?? NOTHING, bound)
|
|
1511
|
+
});
|
|
1512
|
+
}
|
|
1513
|
+
if (remaining.size === 0) return true;
|
|
1514
|
+
if (!temporary) return remaining;
|
|
1515
|
+
origin = "unchecked-state";
|
|
1516
|
+
reportStates = remaining;
|
|
1517
|
+
}
|
|
1518
|
+
} else if ((ts.isCallExpression(parent) || ts.isNewExpression(parent)) && argumentsOf(parent).includes(arg)) {
|
|
1519
|
+
const index = argumentsOf(parent).indexOf(arg);
|
|
1520
|
+
if (ts.isCallExpression(parent) && index === 0 && arg === node && (this.isDecideOrTranslate(parent) || this.context.policy.trustFunctionName(parent) === "match")) return true;
|
|
749
1521
|
const expression = unparen(ts, parent.expression);
|
|
750
|
-
const
|
|
1522
|
+
const methodName = memberAccessName(ts, expression);
|
|
1523
|
+
const receiver = methodName !== void 0 && (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) ? expression.expression : void 0;
|
|
751
1524
|
const resolved = this.context.policy.calleeDeclaration(parent);
|
|
752
1525
|
const external = resolved ? this.context.policy.origins.originOf(resolved.declaration) : void 0;
|
|
753
1526
|
const lib = external?.kind === "external" && external.origin.startsWith("js:");
|
|
754
|
-
|
|
755
|
-
|
|
1527
|
+
const container = lib && receiver && state && methodName !== void 0 && ["push", "unshift", "splice"].includes(methodName) ? this.trackedSymbol(receiver, state) : null;
|
|
1528
|
+
if (lib && receiver && this.moduleHeld(receiver) && methodName !== void 0 && ["push", "unshift", "splice", "set", "add"].includes(methodName)) origin = "stored-state";
|
|
1529
|
+
else if (container) {
|
|
1530
|
+
const existing = state.get(container);
|
|
1531
|
+
if (existing) {
|
|
1532
|
+
const source = ts.isSpreadElement(arg) && this.trackedSymbol(arg.expression, state);
|
|
1533
|
+
if (source && (source === container || existing.peers?.has(source))) return false;
|
|
1534
|
+
let owner = container;
|
|
1535
|
+
let ownerState = existing;
|
|
1536
|
+
if (existing.peers?.size) {
|
|
1537
|
+
const activePeer = [...existing.peers].find((p) => (state.get(p)?.kinds.size ?? 0) > 0);
|
|
1538
|
+
if (activePeer) {
|
|
1539
|
+
owner = activePeer;
|
|
1540
|
+
ownerState = state.get(activePeer);
|
|
1541
|
+
}
|
|
1542
|
+
}
|
|
1543
|
+
state.set(owner, {
|
|
1544
|
+
kinds: union(ownerState.kinds, states),
|
|
1545
|
+
err: ownerState.err,
|
|
1546
|
+
...ownerState.peers ? { peers: ownerState.peers } : {},
|
|
1547
|
+
...ownerState.version !== void 0 ? { version: ownerState.version } : {}
|
|
1548
|
+
});
|
|
1549
|
+
}
|
|
1550
|
+
return true;
|
|
1551
|
+
} else if (external && !(external.kind === "local" && external.zone === "checked") && !(lib && (this.typeKinds(this.instantiatedParameterType(parent, index)) || this.kindsOf(parent)))) {
|
|
756
1552
|
origin = "stated-leaves";
|
|
757
1553
|
callee = parent.expression.getText(this.sourceFile);
|
|
758
|
-
} else if (this.acceptsArgument(parent,
|
|
759
|
-
|
|
760
|
-
|
|
1554
|
+
} else if (this.acceptsArgument(parent, arg) || lib && this.kindsOf(parent) !== null) {
|
|
1555
|
+
if (lib && ts.isCallExpression(parent) && methodName !== void 0 && ["concat", "toSpliced"].includes(methodName)) {
|
|
1556
|
+
this.callStates.set(parent, union(this.callStates.get(parent) ?? NOTHING, states));
|
|
1557
|
+
}
|
|
1558
|
+
return true;
|
|
1559
|
+
} else return false;
|
|
1560
|
+
} else if ((ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === node) {
|
|
1561
|
+
const call = parent.parent;
|
|
1562
|
+
const accessMethod = memberAccessName(ts, parent);
|
|
1563
|
+
if ((accessMethod === "concat" || accessMethod === "slice" && ts.isCallExpression(call) && call.arguments.length === 0) && ts.isCallExpression(call) && call.expression === parent && this.libOrigin(call) !== null && !["discarded", "read"].includes(this.fate(this.carrier(call)))) {
|
|
1564
|
+
this.callStates.set(call, union(this.callStates.get(call) ?? NOTHING, states));
|
|
1565
|
+
return true;
|
|
1566
|
+
}
|
|
1567
|
+
const predicate = accessMethod !== void 0 && PREDICATE_METHODS.has(accessMethod);
|
|
1568
|
+
const isForEach = accessMethod === "forEach";
|
|
1569
|
+
const handsOver = !predicate && ts.isCallExpression(call) && call.expression === parent && call.arguments.some((argument, argIndex) => {
|
|
1570
|
+
if (!this.isElementCallbackPosition(call, parent, argIndex)) return false;
|
|
1571
|
+
let rejectStatedReturn = isForEach;
|
|
1572
|
+
if (!rejectStatedReturn) {
|
|
1573
|
+
const paramType = this.instantiatedParameterType(call, argIndex) ?? this.declaredParameterType(call, argIndex);
|
|
1574
|
+
if (paramType) {
|
|
1575
|
+
const sigs = members(paramType).flatMap((m) => m.getCallSignatures());
|
|
1576
|
+
if (sigs.length && sigs.every((sig) => (sig.getReturnType().flags & ts.TypeFlags.Void) !== 0 && !this.typeKinds(sig.getReturnType()))) {
|
|
1577
|
+
rejectStatedReturn = true;
|
|
1578
|
+
}
|
|
1579
|
+
}
|
|
1580
|
+
}
|
|
1581
|
+
const reduce = (accessMethod === "reduce" || accessMethod === "reduceRight") && this.libOrigin(call) !== null;
|
|
1582
|
+
return (!reduce || call.arguments.length > 1 || this.consumesCallbackElements(argument, rejectStatedReturn, 0)) && this.consumesCallbackElements(argument, rejectStatedReturn, reduce ? 1 : void 0);
|
|
1583
|
+
});
|
|
1584
|
+
if (handsOver) return true;
|
|
1585
|
+
origin = "unchecked-state";
|
|
1586
|
+
} else if (ts.isExpressionStatement(parent) || ts.isVoidExpression(parent)) origin = "unchecked-state";
|
|
761
1587
|
if (!origin || origin === "unchecked-state" && !temporary) return false;
|
|
762
1588
|
const key = node;
|
|
763
1589
|
if (!this.reported.has(key)) {
|
|
764
1590
|
this.reported.add(key);
|
|
765
|
-
this.stateFound?.push({ origin, start: node.getStart(this.sourceFile), subject: subjectOf(node, this.sourceFile), states: [...
|
|
1591
|
+
this.stateFound?.push({ origin, start: node.getStart(this.sourceFile), subject: subjectOf(node, this.sourceFile), states: [...reportStates].sort(), ...callee ? { callee } : {} });
|
|
766
1592
|
}
|
|
767
1593
|
return true;
|
|
768
1594
|
}
|
|
769
|
-
|
|
1595
|
+
isElementCallbackPosition(call, propAccess, argIndex) {
|
|
1596
|
+
if (this.libOrigin(call) !== null && memberAccessName(this.ts, propAccess) !== void 0) {
|
|
1597
|
+
return argIndex === 0;
|
|
1598
|
+
}
|
|
1599
|
+
const paramType = this.instantiatedParameterType(call, argIndex) ?? this.declaredParameterType(call, argIndex);
|
|
1600
|
+
if (!paramType) return argIndex === 0;
|
|
1601
|
+
const sigs = members(paramType).flatMap((m) => m.getCallSignatures());
|
|
1602
|
+
if (!sigs.length) return false;
|
|
1603
|
+
return sigs.some(
|
|
1604
|
+
(sig) => sig.getParameters().some((p) => this.typeKinds(this.checker.getTypeOfSymbolAtLocation(p, call)) !== null)
|
|
1605
|
+
);
|
|
1606
|
+
}
|
|
1607
|
+
isStateContainerType(type) {
|
|
1608
|
+
if (!type) return false;
|
|
1609
|
+
const unwrapped = this.checker.getAwaitedType(type) ?? type;
|
|
1610
|
+
if (unwrapped.flags & (this.ts.TypeFlags.Any | this.ts.TypeFlags.Unknown | this.ts.TypeFlags.Never)) return false;
|
|
1611
|
+
for (const m of members(unwrapped)) {
|
|
1612
|
+
if (m.flags & (this.ts.TypeFlags.StringLike | this.ts.TypeFlags.Any) || this.context.policy.resultVariant(m) !== null) continue;
|
|
1613
|
+
const elem = this.checker.getIndexTypeOfType(m, this.ts.IndexKind.Number);
|
|
1614
|
+
if (elem && this.typeKinds(elem) !== null) return true;
|
|
1615
|
+
}
|
|
1616
|
+
return false;
|
|
1617
|
+
}
|
|
1618
|
+
detachFromPeers(symbol, state) {
|
|
1619
|
+
const current = state.get(symbol);
|
|
1620
|
+
if (!current?.peers?.size) return;
|
|
1621
|
+
const survivors = [...current.peers].filter((p) => p !== symbol && state.has(p));
|
|
1622
|
+
let nextKinds = current.kinds;
|
|
1623
|
+
if (current.kinds.size > 0 && survivors.length > 0) {
|
|
1624
|
+
const owner = survivors[0];
|
|
1625
|
+
const ov = state.get(owner);
|
|
1626
|
+
if (ov) {
|
|
1627
|
+
state.set(owner, { ...ov, kinds: union(ov.kinds, current.kinds) });
|
|
1628
|
+
nextKinds = NOTHING;
|
|
1629
|
+
}
|
|
1630
|
+
}
|
|
1631
|
+
const nextGroup = survivors.length > 1 ? new Set(survivors) : void 0;
|
|
1632
|
+
for (const p of survivors) {
|
|
1633
|
+
const pv = state.get(p);
|
|
1634
|
+
if (pv) state.set(p, { kinds: pv.kinds, err: pv.err, ...nextGroup ? { peers: nextGroup } : {}, ...pv.version !== void 0 ? { version: pv.version } : {} });
|
|
1635
|
+
}
|
|
1636
|
+
state.set(symbol, { kinds: nextKinds, err: current.err, ...current.version !== void 0 ? { version: current.version } : {} });
|
|
1637
|
+
}
|
|
1638
|
+
linkContainerAlias(targetSym, rhs, state) {
|
|
1639
|
+
if (!this.stateFound) return;
|
|
1640
|
+
const inner = this.identitySource(rhs);
|
|
1641
|
+
if (!this.ts.isIdentifier(inner)) return;
|
|
1642
|
+
const sourceSym = this.handedSources.get(inner) ?? this.trackedSymbol(inner, state);
|
|
1643
|
+
if (!sourceSym || sourceSym === targetSym || !state.has(sourceSym) || !state.has(targetSym)) return;
|
|
1644
|
+
if (!this.isStateContainerType(this.checker.getTypeOfSymbol(sourceSym))) return;
|
|
1645
|
+
const sourceState = state.get(sourceSym);
|
|
1646
|
+
const sharedVersion = sourceState.version ?? this.handedVersions.get(inner) ?? this.nextVersion++;
|
|
1647
|
+
const group = new Set(sourceState.peers ?? [sourceSym]);
|
|
1648
|
+
group.add(sourceSym);
|
|
1649
|
+
group.add(targetSym);
|
|
1650
|
+
for (const member of group) {
|
|
1651
|
+
const mv = state.get(member);
|
|
1652
|
+
if (mv) state.set(member, { kinds: mv.kinds, err: mv.err, peers: group, version: sharedVersion });
|
|
1653
|
+
}
|
|
1654
|
+
}
|
|
1655
|
+
clearPeerGroup(symbol, state, remaining = NOTHING) {
|
|
1656
|
+
const current = state.get(symbol);
|
|
1657
|
+
if (!current) return;
|
|
1658
|
+
if (current.peers?.size) {
|
|
1659
|
+
for (const peer of current.peers) {
|
|
1660
|
+
if (peer === symbol) continue;
|
|
1661
|
+
const pv = state.get(peer);
|
|
1662
|
+
if (pv) state.set(peer, { kinds: NOTHING, err: pv.err, peers: pv.peers, ...pv.version !== void 0 ? { version: pv.version } : {} });
|
|
1663
|
+
}
|
|
1664
|
+
}
|
|
1665
|
+
state.set(symbol, { kinds: remaining, err: current.err, ...current.peers ? { peers: current.peers } : {}, ...current.version !== void 0 ? { version: current.version } : {} });
|
|
1666
|
+
}
|
|
770
1667
|
moduleHeld(node) {
|
|
771
1668
|
const ts = this.ts;
|
|
772
1669
|
const inner = unparen(ts, node);
|
|
@@ -785,8 +1682,42 @@ var DropWalk = class {
|
|
|
785
1682
|
const ts = this.ts;
|
|
786
1683
|
const current = state.get(symbol);
|
|
787
1684
|
if (!current) return;
|
|
1685
|
+
if (current.version !== void 0 && state.outstandingIterables.size) {
|
|
1686
|
+
const arg = this.carrier(node);
|
|
1687
|
+
const call = arg.parent;
|
|
1688
|
+
if ((ts.isCallExpression(call) || ts.isNewExpression(call)) && argumentsOf(call).includes(arg) && this.acceptsArgument(call, arg)) {
|
|
1689
|
+
for (const target of this.targets) if (target.activeIterable?.version === current.version) state.outstandingIterables.delete(target.node);
|
|
1690
|
+
}
|
|
1691
|
+
}
|
|
788
1692
|
if (!current.kinds.size) {
|
|
789
|
-
|
|
1693
|
+
if (current.peers?.size) {
|
|
1694
|
+
const activePeer = [...current.peers].find((p) => (state.get(p)?.kinds.size ?? 0) > 0);
|
|
1695
|
+
if (activePeer) {
|
|
1696
|
+
const activeCurrent = state.get(activePeer);
|
|
1697
|
+
const carrier3 = this.carrier(node);
|
|
1698
|
+
if (ts.isBinaryExpression(carrier3.parent) && carrier3.parent.left === carrier3 && isPlainOrLogicalAssignment(ts, carrier3.parent.operatorToken.kind)) return;
|
|
1699
|
+
if ((ts.isForOfStatement(carrier3.parent) || ts.isForInStatement(carrier3.parent)) && carrier3.parent.initializer === carrier3) return;
|
|
1700
|
+
const outcome2 = this.stateUse(carrier3, activeCurrent.kinds, false, state);
|
|
1701
|
+
if (outcome2 === true) {
|
|
1702
|
+
this.handedSnapshots.set(node, activeCurrent.kinds);
|
|
1703
|
+
this.handedSources.set(node, symbol);
|
|
1704
|
+
const ver = activeCurrent.version ?? current.version;
|
|
1705
|
+
if (ver !== void 0) this.handedVersions.set(node, ver);
|
|
1706
|
+
this.clearPeerGroup(activePeer, state, NOTHING);
|
|
1707
|
+
} else if (outcome2) {
|
|
1708
|
+
this.clearPeerGroup(activePeer, state, outcome2);
|
|
1709
|
+
}
|
|
1710
|
+
return;
|
|
1711
|
+
}
|
|
1712
|
+
}
|
|
1713
|
+
const carrier2 = this.carrier(node);
|
|
1714
|
+
if (ts.isBinaryExpression(carrier2.parent) && carrier2.parent.left === carrier2 && isPlainOrLogicalAssignment(ts, carrier2.parent.operatorToken.kind)) return;
|
|
1715
|
+
if ((ts.isForOfStatement(carrier2.parent) || ts.isForInStatement(carrier2.parent)) && carrier2.parent.initializer === carrier2) return;
|
|
1716
|
+
const value = this.checker.getTypeAtLocation(node);
|
|
1717
|
+
if (this.context.policy.isResultType(value)) this.stateUse(carrier2, this.typeKinds(value) ?? NOTHING, false);
|
|
1718
|
+
this.handedSnapshots.set(node, NOTHING);
|
|
1719
|
+
this.handedSources.set(node, symbol);
|
|
1720
|
+
if (current.version !== void 0) this.handedVersions.set(node, current.version);
|
|
790
1721
|
return;
|
|
791
1722
|
}
|
|
792
1723
|
let wrapped = node;
|
|
@@ -795,16 +1726,24 @@ var DropWalk = class {
|
|
|
795
1726
|
const property = ts.isPropertyAccessExpression(parent) && parent.expression === wrapped ? parent.name.text : ts.isElementAccessExpression(parent) && parent.expression === wrapped && parent.argumentExpression ? stringLiteral(ts, parent.argumentExpression) : void 0;
|
|
796
1727
|
const destructured = ts.isVariableDeclaration(parent) && parent.initializer === wrapped && ts.isObjectBindingPattern(parent.name) && parent.name.elements.some((element) => (element.propertyName ?? element.name).getText(this.sourceFile) === "value");
|
|
797
1728
|
if (property === "value" || destructured) {
|
|
798
|
-
|
|
799
|
-
|
|
1729
|
+
const symbolType = this.checker.getTypeOfSymbol(symbol);
|
|
1730
|
+
if (current.kinds.size === 1 && current.err) state.set(symbol, { kinds: NOTHING, err: false, ...current.peers ? { peers: current.peers } : {}, ...current.version !== void 0 ? { version: current.version } : {} });
|
|
1731
|
+
else if (members(symbolType).some((m) => this.context.policy.resultVariant(m) === "ok") && this.typeKinds(symbolType)?.size === 1) {
|
|
800
1732
|
this.stateFound?.push({ origin: "unnarrowed-value", start: parent.getStart(this.sourceFile), subject: node.text, states: [...current.kinds].sort() });
|
|
801
|
-
state.set(symbol, { kinds: NOTHING, err: false });
|
|
1733
|
+
state.set(symbol, { kinds: NOTHING, err: false, ...current.peers ? { peers: current.peers } : {}, ...current.version !== void 0 ? { version: current.version } : {} });
|
|
802
1734
|
}
|
|
803
1735
|
return;
|
|
804
1736
|
}
|
|
805
|
-
|
|
806
|
-
if (ts.isBinaryExpression(parent) && parent.left ===
|
|
807
|
-
if (
|
|
1737
|
+
const carrier = this.carrier(node);
|
|
1738
|
+
if (ts.isBinaryExpression(carrier.parent) && carrier.parent.left === carrier && isPlainOrLogicalAssignment(ts, carrier.parent.operatorToken.kind)) return;
|
|
1739
|
+
if ((ts.isForOfStatement(carrier.parent) || ts.isForInStatement(carrier.parent)) && carrier.parent.initializer === carrier) return;
|
|
1740
|
+
const outcome = this.stateUse(carrier, current.kinds, false, state);
|
|
1741
|
+
if (outcome === true) {
|
|
1742
|
+
this.handedSnapshots.set(node, current.kinds);
|
|
1743
|
+
this.handedSources.set(node, symbol);
|
|
1744
|
+
if (current.version !== void 0) this.handedVersions.set(node, current.version);
|
|
1745
|
+
this.clearPeerGroup(symbol, state, NOTHING);
|
|
1746
|
+
} else if (outcome) this.clearPeerGroup(symbol, state, outcome);
|
|
808
1747
|
}
|
|
809
1748
|
// ---- expressions ----
|
|
810
1749
|
/** Visits the expressions under `node` (not into nested functions) in source order, deciding the fate of each value that can fail. */
|
|
@@ -818,11 +1757,70 @@ var DropWalk = class {
|
|
|
818
1757
|
if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
|
|
819
1758
|
this.visit(node.right, state);
|
|
820
1759
|
this.visit(node.left, state);
|
|
821
|
-
|
|
1760
|
+
let pattern = node;
|
|
1761
|
+
while (ts.isArrayLiteralExpression(pattern.parent)) pattern = pattern.parent;
|
|
1762
|
+
if (!(this.stateFound && pattern !== node && ts.isBinaryExpression(pattern.parent) && pattern.parent.left === pattern && pattern.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken)) this.assign(node, state);
|
|
822
1763
|
return;
|
|
823
1764
|
}
|
|
1765
|
+
if (this.stateFound && ts.isBinaryExpression(node) && node.operatorToken.kind !== ts.SyntaxKind.EqualsToken && isPlainOrLogicalAssignment(ts, node.operatorToken.kind)) {
|
|
1766
|
+
this.visit(node.left, state);
|
|
1767
|
+
const taken = new State(state);
|
|
1768
|
+
const target = unparen(ts, node.left);
|
|
1769
|
+
const symbol = ts.isIdentifier(target) ? this.checker.getSymbolAtLocation(target) : void 0;
|
|
1770
|
+
const held = symbol ? taken.get(symbol) : void 0;
|
|
1771
|
+
if (symbol && held && node.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandEqualsToken) taken.set(symbol, { ...held, kinds: NOTHING });
|
|
1772
|
+
this.visit(node.right, taken);
|
|
1773
|
+
this.assign(node, taken);
|
|
1774
|
+
replaceState(state, merge(taken, state));
|
|
1775
|
+
return;
|
|
1776
|
+
}
|
|
1777
|
+
if (this.stateFound && ts.isConditionalExpression(node)) {
|
|
1778
|
+
this.visit(node.condition, state);
|
|
1779
|
+
const yes = this.branch(node.condition, state, true), no = this.branch(node.condition, state, false);
|
|
1780
|
+
this.visit(node.whenTrue, yes);
|
|
1781
|
+
this.visit(node.whenFalse, no);
|
|
1782
|
+
replaceState(state, merge(yes, no));
|
|
1783
|
+
return;
|
|
1784
|
+
}
|
|
1785
|
+
if (this.stateFound && ts.isBinaryExpression(node) && [ts.SyntaxKind.AmpersandAmpersandToken, ts.SyntaxKind.BarBarToken, ts.SyntaxKind.QuestionQuestionToken].includes(node.operatorToken.kind)) {
|
|
1786
|
+
this.visit(node.left, state);
|
|
1787
|
+
const op = node.operatorToken.kind;
|
|
1788
|
+
const taken = op === ts.SyntaxKind.QuestionQuestionToken ? new State(state) : this.branch(node.left, state, op === ts.SyntaxKind.AmpersandAmpersandToken);
|
|
1789
|
+
const skipped = op === ts.SyntaxKind.QuestionQuestionToken ? new State(state) : this.branch(node.left, state, op !== ts.SyntaxKind.AmpersandAmpersandToken);
|
|
1790
|
+
this.visit(node.right, taken);
|
|
1791
|
+
replaceState(state, merge(taken, skipped));
|
|
1792
|
+
return;
|
|
1793
|
+
}
|
|
1794
|
+
if (this.stateFound && ts.isCallExpression(node)) {
|
|
1795
|
+
const callee = unparen(ts, node.expression);
|
|
1796
|
+
const methodName = memberAccessName(ts, callee);
|
|
1797
|
+
if (methodName === "splice" && (ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee))) {
|
|
1798
|
+
this.visit(node.expression, state);
|
|
1799
|
+
const recvSym = this.trackedSymbol(callee.expression, state);
|
|
1800
|
+
if (recvSym) {
|
|
1801
|
+
const existing = state.get(recvSym);
|
|
1802
|
+
let hasLiveStates = Boolean(existing && existing.kinds.size > 0);
|
|
1803
|
+
if (!hasLiveStates && existing?.peers?.size) {
|
|
1804
|
+
hasLiveStates = [...existing.peers].some((p) => (state.get(p)?.kinds.size ?? 0) > 0);
|
|
1805
|
+
}
|
|
1806
|
+
if (!hasLiveStates) this.spliceEmptyBeforeCall.add(node);
|
|
1807
|
+
else if (node.arguments.length === 1 && this.libOrigin(node) !== null) {
|
|
1808
|
+
const start = unparen(ts, node.arguments[0]);
|
|
1809
|
+
if (ts.isNumericLiteral(start) && Number(start.text) === 0) {
|
|
1810
|
+
let removed = existing?.kinds ?? NOTHING;
|
|
1811
|
+
for (const peer of existing?.peers ?? []) removed = union(removed, state.get(peer)?.kinds ?? NOTHING);
|
|
1812
|
+
this.callStates.set(node, removed);
|
|
1813
|
+
this.clearPeerGroup(recvSym, state, NOTHING);
|
|
1814
|
+
}
|
|
1815
|
+
}
|
|
1816
|
+
}
|
|
1817
|
+
for (const arg of node.arguments) this.visit(arg, state);
|
|
1818
|
+
this.temporary(node, state);
|
|
1819
|
+
return;
|
|
1820
|
+
}
|
|
1821
|
+
}
|
|
824
1822
|
ts.forEachChild(node, (child) => this.visit(child, state));
|
|
825
|
-
if (ts.isCallExpression(node) || ts.isNewExpression(node) || ts.isTaggedTemplateExpression(node)) this.temporary(node);
|
|
1823
|
+
if (ts.isCallExpression(node) || ts.isNewExpression(node) || ts.isTaggedTemplateExpression(node)) this.temporary(node, state);
|
|
826
1824
|
else if (ts.isIdentifier(node)) this.reference(node, state);
|
|
827
1825
|
}
|
|
828
1826
|
/**
|
|
@@ -834,20 +1832,27 @@ var DropWalk = class {
|
|
|
834
1832
|
const ts = this.ts;
|
|
835
1833
|
if (!ts.isCallExpression(node)) return false;
|
|
836
1834
|
const callee = unparen(ts, node.expression);
|
|
837
|
-
|
|
1835
|
+
const methodName = memberAccessName(ts, callee);
|
|
1836
|
+
if (this.stateFound && methodName === "splice" && (ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee)) && this.libOrigin(node) !== null) {
|
|
1837
|
+
const isNoDelete = node.arguments.length === 0 || Boolean(node.arguments.length >= 2 && ts.isNumericLiteral(unparen(ts, node.arguments[1])) && Number(unparen(ts, node.arguments[1]).text) === 0);
|
|
1838
|
+
if (isNoDelete) return true;
|
|
1839
|
+
if (this.moduleHeld(callee.expression)) return false;
|
|
1840
|
+
if (this.spliceEmptyBeforeCall.has(node)) return true;
|
|
1841
|
+
return false;
|
|
1842
|
+
}
|
|
1843
|
+
if (this.stateFound && this.callStates.has(node)) return false;
|
|
1844
|
+
if (!methodName || !ts.isPropertyAccessExpression(callee) && !ts.isElementAccessExpression(callee) || !ELEMENT_METHODS.has(methodName)) return false;
|
|
838
1845
|
return this.kindsOf(callee.expression) !== null;
|
|
839
1846
|
}
|
|
840
1847
|
/** A call's value: reported where it is dropped; followed when it is kept in a variable. */
|
|
841
|
-
temporary(node) {
|
|
1848
|
+
temporary(node, state) {
|
|
842
1849
|
if (!this.kindsOf(node) || this.derivedFromReceiver(node)) return;
|
|
843
|
-
if (this.stateFound && this.ts.isCallExpression(node))
|
|
844
|
-
const resolved = this.context.policy.calleeDeclaration(node);
|
|
845
|
-
const origin = resolved && this.context.policy.origins.originOf(resolved.declaration);
|
|
846
|
-
if (origin?.kind === "external" && origin.origin.startsWith("js:") && node.arguments.some((arg) => this.kindsOf(arg))) return;
|
|
847
|
-
}
|
|
1850
|
+
if (this.stateFound && (this.ts.isCallExpression(node) || this.ts.isNewExpression(node)) && this.isEmptyArrayInitializer(node)) return;
|
|
848
1851
|
const carrier = this.carrier(node);
|
|
849
1852
|
if (this.stateFound) {
|
|
850
|
-
|
|
1853
|
+
const contributed = this.callStates.get(node);
|
|
1854
|
+
const kinds = contributed || carrier !== node && this.kindsOf(carrier) || this.kindsOf(node) || NOTHING;
|
|
1855
|
+
this.stateUse(carrier, kinds, true, state);
|
|
851
1856
|
return;
|
|
852
1857
|
}
|
|
853
1858
|
const fate = this.fate(carrier);
|
|
@@ -900,24 +1905,78 @@ var DropWalk = class {
|
|
|
900
1905
|
if (!kinds || this.kindsOf(call) !== null || this.acceptsArgument(call, node)) return;
|
|
901
1906
|
this.report("callback", node, subjectOf(call.expression, this.sourceFile), kinds);
|
|
902
1907
|
}
|
|
1908
|
+
patternIdentifiers(pattern) {
|
|
1909
|
+
const ts = this.ts;
|
|
1910
|
+
const target = unparen(ts, pattern);
|
|
1911
|
+
if (ts.isIdentifier(target)) return [target];
|
|
1912
|
+
if (ts.isArrayLiteralExpression(target)) {
|
|
1913
|
+
const out = [];
|
|
1914
|
+
for (const el of target.elements) {
|
|
1915
|
+
if (ts.isOmittedExpression(el)) continue;
|
|
1916
|
+
if (ts.isSpreadElement(el)) out.push(...this.patternIdentifiers(el.expression));
|
|
1917
|
+
else if (ts.isBinaryExpression(el) && el.operatorToken.kind === ts.SyntaxKind.EqualsToken) out.push(...this.patternIdentifiers(el.left));
|
|
1918
|
+
else out.push(...this.patternIdentifiers(el));
|
|
1919
|
+
}
|
|
1920
|
+
return out;
|
|
1921
|
+
}
|
|
1922
|
+
return [];
|
|
1923
|
+
}
|
|
1924
|
+
rhsStateKinds(expr, state) {
|
|
1925
|
+
const ts = this.ts;
|
|
1926
|
+
const inner = this.identitySource(expr);
|
|
1927
|
+
if (this.stateFound) {
|
|
1928
|
+
const contributed = this.callStates.get(inner);
|
|
1929
|
+
if (contributed) return contributed;
|
|
1930
|
+
if (ts.isIdentifier(inner)) {
|
|
1931
|
+
const snapshot = this.handedSnapshots.get(inner);
|
|
1932
|
+
if (snapshot !== void 0) return snapshot;
|
|
1933
|
+
const sym = this.trackedSymbol(inner, state);
|
|
1934
|
+
if (sym) return state.get(sym)?.kinds ?? NOTHING;
|
|
1935
|
+
}
|
|
1936
|
+
}
|
|
1937
|
+
return this.initializerKinds(expr);
|
|
1938
|
+
}
|
|
903
1939
|
assign(node, state) {
|
|
904
1940
|
const ts = this.ts;
|
|
905
1941
|
const target = unparen(ts, node.left);
|
|
906
|
-
const names =
|
|
1942
|
+
const names = this.patternIdentifiers(target);
|
|
1943
|
+
const live = this.stateFound && ts.isArrayLiteralExpression(target) ? this.rhsStateKinds(node.right, state) : null;
|
|
1944
|
+
const rhsInner = this.identitySource(node.right);
|
|
1945
|
+
const rhsSym = ts.isIdentifier(target) && ts.isIdentifier(rhsInner) ? this.handedSources.get(rhsInner) ?? this.trackedSymbol(node.right, state) : null;
|
|
1946
|
+
const rhsVersion = this.stateFound && ts.isIdentifier(target) && ts.isIdentifier(rhsInner) ? this.handedVersions.get(rhsInner) ?? (rhsSym ? state.get(rhsSym)?.version : void 0) : void 0;
|
|
907
1947
|
for (const name of names) {
|
|
908
1948
|
const symbol = this.checker.getSymbolAtLocation(name);
|
|
909
1949
|
if (!symbol || !this.tracked.has(symbol)) continue;
|
|
1950
|
+
if (this.stateFound) {
|
|
1951
|
+
const existing = state.get(symbol);
|
|
1952
|
+
if (existing?.peers?.size && (!rhsSym || !existing.peers.has(rhsSym))) {
|
|
1953
|
+
this.detachFromPeers(symbol, state);
|
|
1954
|
+
}
|
|
1955
|
+
}
|
|
910
1956
|
const current = state.get(symbol);
|
|
911
|
-
if (current && current.kinds.size > 0
|
|
912
|
-
|
|
913
|
-
|
|
1957
|
+
if (current && current.kinds.size > 0 && (!this.stateFound || !current.peers?.size || (rhsSym && current.peers.has(rhsSym) ? false : true))) {
|
|
1958
|
+
this.reportVariable("overwritten", node, symbol, current.kinds);
|
|
1959
|
+
}
|
|
1960
|
+
let kinds = ts.isIdentifier(target) ? this.rhsStateKinds(node.right, state) : this.kindsOf(name);
|
|
1961
|
+
if (live && kinds) {
|
|
1962
|
+
let available = live;
|
|
1963
|
+
for (let child = name; child !== target; child = child.parent) {
|
|
1964
|
+
const parent = child.parent;
|
|
1965
|
+
if (ts.isBinaryExpression(parent) && parent.left === child && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken)
|
|
1966
|
+
available = union(available, this.rhsStateKinds(parent.right, state) ?? NOTHING);
|
|
1967
|
+
}
|
|
1968
|
+
kinds = new Set([...kinds].filter((k) => available.has(k)));
|
|
1969
|
+
}
|
|
1970
|
+
const version = this.stateFound ? rhsVersion ?? this.nextVersion++ : void 0;
|
|
1971
|
+
state.set(symbol, { kinds: kinds ?? NOTHING, err: false, ...version !== void 0 ? { version } : {} });
|
|
1972
|
+
if (ts.isIdentifier(target)) this.linkContainerAlias(symbol, node.right, state);
|
|
914
1973
|
}
|
|
915
1974
|
}
|
|
916
1975
|
/**
|
|
917
1976
|
* Starts following the variables `name` binds that can fail (a module-level variable is never followed). With an
|
|
918
1977
|
* `initializer`, what can fail is what the initializer holds (`let scope: Result<…> | null = null` holds nothing yet).
|
|
919
1978
|
*/
|
|
920
|
-
declare(name, scope, state, assigned, initializer) {
|
|
1979
|
+
declare(name, scope, state, assigned, initializer, live) {
|
|
921
1980
|
const ts = this.ts;
|
|
922
1981
|
if (ts.isSourceFile(this.owner)) return;
|
|
923
1982
|
if (ts.isIdentifier(name)) {
|
|
@@ -925,11 +1984,28 @@ var DropWalk = class {
|
|
|
925
1984
|
const kinds = symbol ? this.kindsOf(name) : null;
|
|
926
1985
|
if (!symbol || !kinds) return;
|
|
927
1986
|
this.tracked.set(symbol, { name: name.text, scope });
|
|
928
|
-
if (assigned)
|
|
1987
|
+
if (assigned) {
|
|
1988
|
+
let initVersion;
|
|
1989
|
+
if (this.stateFound && initializer) {
|
|
1990
|
+
const inner = this.identitySource(initializer);
|
|
1991
|
+
if (ts.isIdentifier(inner)) {
|
|
1992
|
+
const srcSym = this.handedSources.get(inner) ?? this.trackedSymbol(initializer, state);
|
|
1993
|
+
initVersion = this.handedVersions.get(inner) ?? (srcSym ? state.get(srcSym)?.version : void 0);
|
|
1994
|
+
}
|
|
1995
|
+
}
|
|
1996
|
+
const version = this.stateFound ? initVersion ?? this.nextVersion++ : void 0;
|
|
1997
|
+
state.set(symbol, {
|
|
1998
|
+
kinds: initializer ? this.rhsStateKinds(initializer, state) ?? NOTHING : live ? new Set([...kinds].filter((k) => live.has(k))) : kinds,
|
|
1999
|
+
err: false,
|
|
2000
|
+
...version !== void 0 ? { version } : {}
|
|
2001
|
+
});
|
|
2002
|
+
if (initializer) this.linkContainerAlias(symbol, initializer, state);
|
|
2003
|
+
}
|
|
929
2004
|
return;
|
|
930
2005
|
}
|
|
2006
|
+
const source = this.stateFound && initializer && ts.isArrayBindingPattern(name) ? this.rhsStateKinds(initializer, state) ?? void 0 : live;
|
|
931
2007
|
for (const element of name.elements) {
|
|
932
|
-
if (!ts.isOmittedExpression(element)) this.declare(element.name, scope, state, assigned);
|
|
2008
|
+
if (!ts.isOmittedExpression(element)) this.declare(element.name, scope, state, assigned, void 0, element.initializer ? void 0 : source);
|
|
933
2009
|
}
|
|
934
2010
|
}
|
|
935
2011
|
declarations(list, scope, state) {
|
|
@@ -940,7 +2016,7 @@ var DropWalk = class {
|
|
|
940
2016
|
this.visit(declaration.initializer, state);
|
|
941
2017
|
this.recordErrorAlias(declaration, state);
|
|
942
2018
|
}
|
|
943
|
-
const initializer =
|
|
2019
|
+
const initializer = declaration.initializer;
|
|
944
2020
|
this.declare(declaration.name, blockScoped ? scope : this.functionScope, state, declaration.initializer !== void 0, initializer);
|
|
945
2021
|
}
|
|
946
2022
|
}
|
|
@@ -1002,10 +2078,17 @@ var DropWalk = class {
|
|
|
1002
2078
|
return this.trackedSymbol(error.expression, state);
|
|
1003
2079
|
}
|
|
1004
2080
|
withOk(state, symbol, isOk) {
|
|
1005
|
-
const narrowed = new
|
|
2081
|
+
const narrowed = new State(state);
|
|
1006
2082
|
const current = state.get(symbol);
|
|
1007
2083
|
if (this.stateFound) {
|
|
1008
|
-
if (current && !isOk)
|
|
2084
|
+
if (current && !isOk) {
|
|
2085
|
+
narrowed.set(symbol, {
|
|
2086
|
+
kinds: NOTHING,
|
|
2087
|
+
err: false,
|
|
2088
|
+
...current.peers ? { peers: current.peers } : {},
|
|
2089
|
+
...current.version !== void 0 ? { version: current.version } : {}
|
|
2090
|
+
});
|
|
2091
|
+
}
|
|
1009
2092
|
return narrowed;
|
|
1010
2093
|
}
|
|
1011
2094
|
if (current) narrowed.set(symbol, isOk ? { kinds: NOTHING, err: false } : { kinds: current.kinds, err: true });
|
|
@@ -1013,18 +2096,19 @@ var DropWalk = class {
|
|
|
1013
2096
|
}
|
|
1014
2097
|
/** A branch that names `kind` handles it; the other branch keeps the kinds that are not `kind`. */
|
|
1015
2098
|
withKind(state, symbol, kind, isKind) {
|
|
1016
|
-
const narrowed = new
|
|
2099
|
+
const narrowed = new State(state);
|
|
1017
2100
|
const current = state.get(symbol);
|
|
1018
2101
|
if (current) {
|
|
1019
2102
|
const rest = new Set(current.kinds);
|
|
1020
2103
|
rest.delete(kind);
|
|
1021
|
-
|
|
2104
|
+
const extra = this.stateFound ? { ...current.peers ? { peers: current.peers } : {}, ...current.version !== void 0 ? { version: current.version } : {} } : {};
|
|
2105
|
+
narrowed.set(symbol, isKind ? { kinds: NOTHING, err: true, ...extra } : { kinds: rest, err: this.stateFound ? current.err || rest.size < current.kinds.size : true, ...extra });
|
|
1022
2106
|
}
|
|
1023
2107
|
return narrowed;
|
|
1024
2108
|
}
|
|
1025
2109
|
/** The state a branch starts with: narrowed by its condition, and its own copy (a branch's declarations stay in it). */
|
|
1026
2110
|
branch(condition, state, outcome) {
|
|
1027
|
-
return new
|
|
2111
|
+
return new State(this.narrow(condition, state, outcome));
|
|
1028
2112
|
}
|
|
1029
2113
|
narrow(condition, state, outcome) {
|
|
1030
2114
|
const ts = this.ts;
|
|
@@ -1077,8 +2161,16 @@ var DropWalk = class {
|
|
|
1077
2161
|
return truthy && !outcome ? this.withNothing(state, truthy) : state;
|
|
1078
2162
|
}
|
|
1079
2163
|
withNothing(state, symbol) {
|
|
1080
|
-
const narrowed = new
|
|
1081
|
-
|
|
2164
|
+
const narrowed = new State(state);
|
|
2165
|
+
const current = narrowed.get(symbol);
|
|
2166
|
+
if (current) {
|
|
2167
|
+
narrowed.set(symbol, {
|
|
2168
|
+
kinds: NOTHING,
|
|
2169
|
+
err: false,
|
|
2170
|
+
...this.stateFound && current.peers ? { peers: current.peers } : {},
|
|
2171
|
+
...this.stateFound && current.version !== void 0 ? { version: current.version } : {}
|
|
2172
|
+
});
|
|
2173
|
+
}
|
|
1082
2174
|
return narrowed;
|
|
1083
2175
|
}
|
|
1084
2176
|
// ---- statements ----
|
|
@@ -1141,7 +2233,66 @@ var DropWalk = class {
|
|
|
1141
2233
|
*/
|
|
1142
2234
|
checkReturn(at, expression, state) {
|
|
1143
2235
|
if (this.stateFound) {
|
|
1144
|
-
|
|
2236
|
+
if (!this.ts.isSourceFile(this.owner) && this.isDiscardedReturnCallback(this.owner) && expression) {
|
|
2237
|
+
const inner = unparen(this.ts, expression);
|
|
2238
|
+
const retStates = this.ts.isIdentifier(inner) ? this.handedSnapshots.get(inner) : void 0;
|
|
2239
|
+
if (retStates?.size) {
|
|
2240
|
+
const sym = this.checker.getSymbolAtLocation(inner);
|
|
2241
|
+
if (sym && this.tracked.has(sym)) this.reportVariable("return", at, sym, retStates);
|
|
2242
|
+
}
|
|
2243
|
+
}
|
|
2244
|
+
const returnedSymbols = /* @__PURE__ */ new Set();
|
|
2245
|
+
let returnedVersion;
|
|
2246
|
+
if (expression) {
|
|
2247
|
+
const inner = this.identitySource(expression);
|
|
2248
|
+
if (this.ts.isIdentifier(inner)) {
|
|
2249
|
+
const sym = this.checker.getSymbolAtLocation(inner);
|
|
2250
|
+
if (sym) returnedSymbols.add(sym);
|
|
2251
|
+
returnedVersion = this.handedVersions.get(inner) ?? (sym ? state.get(sym)?.version : void 0);
|
|
2252
|
+
}
|
|
2253
|
+
}
|
|
2254
|
+
const restored = new State(state);
|
|
2255
|
+
for (const candidate of this.targets) {
|
|
2256
|
+
const active = candidate.activeIterable;
|
|
2257
|
+
if (!active?.states.size || !state.outstandingIterables.has(candidate.node)) continue;
|
|
2258
|
+
if (active.symbol) {
|
|
2259
|
+
if (active.version !== void 0) {
|
|
2260
|
+
if (returnedVersion !== void 0 && returnedVersion === active.version) continue;
|
|
2261
|
+
let holder;
|
|
2262
|
+
if (restored.get(active.symbol)?.version === active.version) {
|
|
2263
|
+
holder = active.symbol;
|
|
2264
|
+
} else {
|
|
2265
|
+
for (const [sym, val] of restored) {
|
|
2266
|
+
if (val.version === active.version) {
|
|
2267
|
+
holder = sym;
|
|
2268
|
+
break;
|
|
2269
|
+
}
|
|
2270
|
+
}
|
|
2271
|
+
}
|
|
2272
|
+
if (holder) {
|
|
2273
|
+
const prev = restored.get(holder);
|
|
2274
|
+
restored.set(holder, {
|
|
2275
|
+
kinds: union(prev.kinds, active.states),
|
|
2276
|
+
err: prev.err,
|
|
2277
|
+
...prev.peers ? { peers: prev.peers } : {},
|
|
2278
|
+
...prev.version !== void 0 ? { version: prev.version } : {}
|
|
2279
|
+
});
|
|
2280
|
+
} else {
|
|
2281
|
+
this.reportVariable("return", at, active.symbol, active.states);
|
|
2282
|
+
}
|
|
2283
|
+
} else {
|
|
2284
|
+
const prev = restored.get(active.symbol);
|
|
2285
|
+
const groupPeers = prev?.peers;
|
|
2286
|
+
const groupReturned = returnedSymbols.has(active.symbol) || Boolean(groupPeers && [...groupPeers].some((p) => returnedSymbols.has(p)));
|
|
2287
|
+
if (groupReturned) continue;
|
|
2288
|
+
restored.set(active.symbol, { kinds: union(prev?.kinds ?? NOTHING, active.states), err: prev?.err ?? false, ...prev?.peers ? { peers: prev.peers } : {} });
|
|
2289
|
+
}
|
|
2290
|
+
} else if (!this.reported.has(active.node)) {
|
|
2291
|
+
this.reported.add(active.node);
|
|
2292
|
+
this.stateFound.push({ origin: "unchecked-state", start: active.node.getStart(this.sourceFile), subject: subjectOf(active.node, this.sourceFile), states: [...active.states].sort() });
|
|
2293
|
+
}
|
|
2294
|
+
}
|
|
2295
|
+
for (const [symbol, value] of restored) if (value.kinds.size) this.reportVariable("return", at, symbol, value.kinds);
|
|
1145
2296
|
return;
|
|
1146
2297
|
}
|
|
1147
2298
|
const ts = this.ts;
|
|
@@ -1190,15 +2341,61 @@ var DropWalk = class {
|
|
|
1190
2341
|
const ts = this.ts;
|
|
1191
2342
|
const label = node.label?.text;
|
|
1192
2343
|
const isBreak = ts.isBreakStatement(node);
|
|
1193
|
-
let
|
|
1194
|
-
for (let index = this.targets.length - 1; index >= 0 &&
|
|
2344
|
+
let targetIndex = -1;
|
|
2345
|
+
for (let index = this.targets.length - 1; index >= 0 && targetIndex < 0; index -= 1) {
|
|
1195
2346
|
const candidate = this.targets[index];
|
|
1196
|
-
if (label !== void 0 ? candidate.label === label : isBreak ? candidate.kind !== "labeled" : candidate.kind === "loop")
|
|
2347
|
+
if (label !== void 0 ? candidate.label === label : isBreak ? candidate.kind !== "labeled" : candidate.kind === "loop") targetIndex = index;
|
|
1197
2348
|
}
|
|
1198
|
-
if (
|
|
1199
|
-
const to =
|
|
2349
|
+
if (targetIndex < 0) return null;
|
|
2350
|
+
const to = this.targets[targetIndex];
|
|
1200
2351
|
const keeps = (info) => !isBreak && ts.isForStatement(to.node) && info.scope === to.node;
|
|
1201
|
-
|
|
2352
|
+
let left = this.leaveScope(to.node, state, node, true, keeps) ?? new State(state);
|
|
2353
|
+
if (this.stateFound) {
|
|
2354
|
+
for (let idx = this.targets.length - 1; idx >= targetIndex; idx -= 1) {
|
|
2355
|
+
if (!isBreak && idx === targetIndex) continue;
|
|
2356
|
+
const exited = this.targets[idx];
|
|
2357
|
+
const active = exited.activeIterable;
|
|
2358
|
+
if (!active?.states.size || !state.outstandingIterables.has(exited.node)) continue;
|
|
2359
|
+
if (active.symbol) {
|
|
2360
|
+
const info = this.tracked.get(active.symbol);
|
|
2361
|
+
const alsoLeaving = info !== void 0 && within(info.scope, to.node) && !keeps(info);
|
|
2362
|
+
if (alsoLeaving && active.version === void 0) {
|
|
2363
|
+
this.reportVariable("end", node, active.symbol, active.states);
|
|
2364
|
+
} else if (active.version !== void 0) {
|
|
2365
|
+
let holder;
|
|
2366
|
+
if (left.get(active.symbol)?.version === active.version) {
|
|
2367
|
+
holder = active.symbol;
|
|
2368
|
+
} else {
|
|
2369
|
+
for (const [sym, val] of left) {
|
|
2370
|
+
if (val.version === active.version) {
|
|
2371
|
+
holder = sym;
|
|
2372
|
+
break;
|
|
2373
|
+
}
|
|
2374
|
+
}
|
|
2375
|
+
}
|
|
2376
|
+
if (holder) {
|
|
2377
|
+
const prev = left.get(holder);
|
|
2378
|
+
left = new State(left);
|
|
2379
|
+
left.set(holder, {
|
|
2380
|
+
kinds: union(prev.kinds, active.states),
|
|
2381
|
+
err: prev.err,
|
|
2382
|
+
...prev.peers ? { peers: prev.peers } : {},
|
|
2383
|
+
...prev.version !== void 0 ? { version: prev.version } : {}
|
|
2384
|
+
});
|
|
2385
|
+
} else {
|
|
2386
|
+
this.reportVariable("end", node, active.symbol, active.states);
|
|
2387
|
+
}
|
|
2388
|
+
} else {
|
|
2389
|
+
const prev = left.get(active.symbol);
|
|
2390
|
+
left = new State(left);
|
|
2391
|
+
left.set(active.symbol, { kinds: union(prev?.kinds ?? NOTHING, active.states), err: prev?.err ?? false, ...prev?.peers ? { peers: prev.peers } : {} });
|
|
2392
|
+
}
|
|
2393
|
+
} else if (!this.reported.has(active.node)) {
|
|
2394
|
+
this.reported.add(active.node);
|
|
2395
|
+
this.stateFound.push({ origin: "unchecked-state", start: active.node.getStart(this.sourceFile), subject: subjectOf(active.node, this.sourceFile), states: [...active.states].sort() });
|
|
2396
|
+
}
|
|
2397
|
+
}
|
|
2398
|
+
}
|
|
1202
2399
|
(isBreak ? to.breaks : to.continues).push(left);
|
|
1203
2400
|
return null;
|
|
1204
2401
|
}
|
|
@@ -1222,7 +2419,7 @@ var DropWalk = class {
|
|
|
1222
2419
|
return kind === void 0 ? [] : [kind];
|
|
1223
2420
|
});
|
|
1224
2421
|
const rest = () => {
|
|
1225
|
-
if (!kindOf) return new
|
|
2422
|
+
if (!kindOf) return new State(state);
|
|
1226
2423
|
let narrowed = state;
|
|
1227
2424
|
for (const kind of labels) narrowed = this.withKind(narrowed, kindOf, kind, false);
|
|
1228
2425
|
return narrowed;
|
|
@@ -1236,7 +2433,7 @@ var DropWalk = class {
|
|
|
1236
2433
|
if (ts.isCaseClause(clause)) {
|
|
1237
2434
|
this.visit(clause.expression, state);
|
|
1238
2435
|
const kind = stringLiteral(ts, clause.expression);
|
|
1239
|
-
entry = kindOf && kind !== void 0 ? this.withKind(state, kindOf, kind, true) : new
|
|
2436
|
+
entry = kindOf && kind !== void 0 ? this.withKind(state, kindOf, kind, true) : new State(state);
|
|
1240
2437
|
} else {
|
|
1241
2438
|
hasDefault = true;
|
|
1242
2439
|
entry = rest();
|
|
@@ -1249,7 +2446,7 @@ var DropWalk = class {
|
|
|
1249
2446
|
}
|
|
1250
2447
|
loop(node, state, label) {
|
|
1251
2448
|
const ts = this.ts;
|
|
1252
|
-
let entry = new
|
|
2449
|
+
let entry = new State(state);
|
|
1253
2450
|
let skip = entry;
|
|
1254
2451
|
if (ts.isForStatement(node)) {
|
|
1255
2452
|
if (node.initializer && ts.isVariableDeclarationList(node.initializer)) this.declarations(node.initializer, node, entry);
|
|
@@ -1262,12 +2459,33 @@ var DropWalk = class {
|
|
|
1262
2459
|
skip = null;
|
|
1263
2460
|
}
|
|
1264
2461
|
} else if (ts.isForOfStatement(node) || ts.isForInStatement(node)) {
|
|
1265
|
-
|
|
1266
|
-
|
|
2462
|
+
const iterable = unparen(ts, node.expression);
|
|
2463
|
+
if (this.stateFound && ts.isForOfStatement(node) && ts.isConditionalExpression(iterable)) {
|
|
2464
|
+
this.visit(iterable.condition, entry);
|
|
2465
|
+
const yes = this.branch(iterable.condition, entry, true), no = this.branch(iterable.condition, entry, false);
|
|
2466
|
+
this.visit(iterable.whenTrue, yes);
|
|
2467
|
+
this.visit(iterable.whenFalse, no);
|
|
2468
|
+
entry = merge(yes, no);
|
|
2469
|
+
} else this.visit(node.expression, entry);
|
|
2470
|
+
skip = new State(entry);
|
|
2471
|
+
const live = this.stateFound && ts.isForOfStatement(node) ? this.rhsStateKinds(node.expression, entry) ?? void 0 : void 0;
|
|
1267
2472
|
if (ts.isVariableDeclarationList(node.initializer)) {
|
|
1268
|
-
for (const declaration of node.initializer.declarations) this.declare(declaration.name, node, entry, true);
|
|
2473
|
+
for (const declaration of node.initializer.declarations) this.declare(declaration.name, node, entry, true, void 0, live);
|
|
1269
2474
|
} else {
|
|
1270
2475
|
this.visit(node.initializer, entry);
|
|
2476
|
+
if (ts.isForOfStatement(node)) {
|
|
2477
|
+
const elemKinds = this.forOfElementKinds(node);
|
|
2478
|
+
const target2 = unparen(ts, node.initializer);
|
|
2479
|
+
for (const name of this.patternIdentifiers(target2)) {
|
|
2480
|
+
const symbol = this.checker.getSymbolAtLocation(name);
|
|
2481
|
+
if (!symbol || !this.tracked.has(symbol)) continue;
|
|
2482
|
+
if (this.stateFound) this.detachFromPeers(symbol, entry);
|
|
2483
|
+
const current = entry.get(symbol);
|
|
2484
|
+
if (current && current.kinds.size > 0) this.reportVariable("overwritten", node.initializer, symbol, current.kinds);
|
|
2485
|
+
const kinds = ts.isIdentifier(target2) ? elemKinds.size ? elemKinds : this.kindsOf(name) : this.kindsOf(name);
|
|
2486
|
+
entry.set(symbol, { kinds: live && kinds ? new Set([...kinds].filter((k) => live.has(k))) : kinds ?? NOTHING, err: false, ...this.stateFound ? { version: this.nextVersion++ } : {} });
|
|
2487
|
+
}
|
|
2488
|
+
}
|
|
1271
2489
|
}
|
|
1272
2490
|
} else if (ts.isWhileStatement(node)) {
|
|
1273
2491
|
this.visit(node.expression, entry);
|
|
@@ -1276,7 +2494,9 @@ var DropWalk = class {
|
|
|
1276
2494
|
} else {
|
|
1277
2495
|
skip = null;
|
|
1278
2496
|
}
|
|
1279
|
-
const
|
|
2497
|
+
const activeIterable = ts.isForOfStatement(node) ? this.activeForOfs.get(node) : void 0;
|
|
2498
|
+
const target = { node, label, kind: "loop", breaks: [], continues: [], ...activeIterable ? { activeIterable } : {} };
|
|
2499
|
+
if (activeIterable) entry.outstandingIterables.add(node);
|
|
1280
2500
|
this.targets.push(target);
|
|
1281
2501
|
let out = this.statement(node.statement, entry, node);
|
|
1282
2502
|
this.targets.pop();
|
|
@@ -1285,15 +2505,16 @@ var DropWalk = class {
|
|
|
1285
2505
|
if (ts.isDoStatement(node) && repeat) this.visit(node.expression, repeat);
|
|
1286
2506
|
if (ts.isForOfStatement(node) || ts.isForInStatement(node)) out = this.leaveScope(node, out, node.statement.end - 1);
|
|
1287
2507
|
const exit = mergeAll([skip, out, ...target.continues, ...target.breaks]);
|
|
2508
|
+
exit?.outstandingIterables.delete(node);
|
|
1288
2509
|
return ts.isForStatement(node) ? this.leaveScope(node, exit, node.end - 1) : exit;
|
|
1289
2510
|
}
|
|
1290
2511
|
tryStatement(node, state) {
|
|
1291
|
-
const tried = this.block(node.tryBlock, new
|
|
2512
|
+
const tried = this.block(node.tryBlock, new State(state));
|
|
1292
2513
|
let caught = null;
|
|
1293
|
-
if (node.catchClause) caught = this.block(node.catchClause.block, new
|
|
2514
|
+
if (node.catchClause) caught = this.block(node.catchClause.block, new State(state));
|
|
1294
2515
|
const out = node.catchClause ? merge(tried, caught) : tried;
|
|
1295
2516
|
if (!node.finallyBlock) return out;
|
|
1296
|
-
const finished = this.block(node.finallyBlock, out ?? new
|
|
2517
|
+
const finished = this.block(node.finallyBlock, out ?? new State(state));
|
|
1297
2518
|
return out ? finished : null;
|
|
1298
2519
|
}
|
|
1299
2520
|
};
|
|
@@ -2071,6 +3292,43 @@ function trustedStatesIn(sourceFile, context) {
|
|
|
2071
3292
|
const stated = members2.filter((m) => policy.resultVariant(m) === "ok" && policy.okStates(m) !== null);
|
|
2072
3293
|
return { stated: stated.length > 0, states: [...new Set(stated.flatMap((m) => policy.okStates(m) ?? []))].sort() };
|
|
2073
3294
|
};
|
|
3295
|
+
const isPresentResult = (type) => {
|
|
3296
|
+
const present = (type.isUnion() ? type.types : [type]).filter((t) => !(t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void)));
|
|
3297
|
+
return present.length > 0 && present.every((t) => policy.isResultType(t));
|
|
3298
|
+
};
|
|
3299
|
+
const isStatelessResultArray = (type) => {
|
|
3300
|
+
if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) return false;
|
|
3301
|
+
const members2 = type.isUnion() ? type.types : [type];
|
|
3302
|
+
if (!members2.length) return false;
|
|
3303
|
+
return members2.every((m) => {
|
|
3304
|
+
if (m.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never) || policy.resultVariant(m) !== null) return false;
|
|
3305
|
+
const element = checker.getIndexTypeOfType(m, ts.IndexKind.Number);
|
|
3306
|
+
if (!element) return false;
|
|
3307
|
+
const unwrapped = awaited(element);
|
|
3308
|
+
if (unwrapped.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) return false;
|
|
3309
|
+
const present = (unwrapped.isUnion() ? unwrapped.types : [unwrapped]).filter((t) => !(t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)));
|
|
3310
|
+
return present.length > 0 && present.every((t) => policy.isResultType(t) && !stateInfo(t).stated);
|
|
3311
|
+
});
|
|
3312
|
+
};
|
|
3313
|
+
const arrayStateInfo = (type) => {
|
|
3314
|
+
if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) return { stated: false, states: [] };
|
|
3315
|
+
const members2 = type.isUnion() ? type.types : [type];
|
|
3316
|
+
let stated = false;
|
|
3317
|
+
const states = /* @__PURE__ */ new Set();
|
|
3318
|
+
for (const m of members2) {
|
|
3319
|
+
if (m.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never) || policy.resultVariant(m) !== null) continue;
|
|
3320
|
+
const element = checker.getIndexTypeOfType(m, ts.IndexKind.Number);
|
|
3321
|
+
if (!element) continue;
|
|
3322
|
+
const unwrapped = awaited(element);
|
|
3323
|
+
if (unwrapped.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) continue;
|
|
3324
|
+
const info = stateInfo(unwrapped);
|
|
3325
|
+
if (info.stated) {
|
|
3326
|
+
stated = true;
|
|
3327
|
+
for (const s of info.states) states.add(s);
|
|
3328
|
+
}
|
|
3329
|
+
}
|
|
3330
|
+
return { stated, states: [...states].sort() };
|
|
3331
|
+
};
|
|
2074
3332
|
const subjectOf2 = (node) => {
|
|
2075
3333
|
const text = node.getText(sourceFile).replace(/\s+/g, " ").trim();
|
|
2076
3334
|
return text.length > 60 ? `${text.slice(0, 59)}\u2026` : text;
|
|
@@ -2088,23 +3346,173 @@ function trustedStatesIn(sourceFile, context) {
|
|
|
2088
3346
|
report(name, "unnarrowed-value", { subject: subjectOf2(receiver), states: formatStates(info.states) });
|
|
2089
3347
|
}
|
|
2090
3348
|
};
|
|
2091
|
-
const
|
|
3349
|
+
const recordErasedArg = (expr) => {
|
|
3350
|
+
const argument = unparen(ts, expr);
|
|
3351
|
+
const callArg = ts.isSpreadElement(expr.parent) ? expr.parent : expr;
|
|
3352
|
+
if (ts.isCallExpression(callArg.parent) && callArg.parent.arguments.includes(callArg) && ts.isIdentifier(argument)) {
|
|
3353
|
+
const symbol = checker.getSymbolAtLocation(argument);
|
|
3354
|
+
const statement = callArg.parent.parent;
|
|
3355
|
+
if (symbol && ts.isExpressionStatement(statement) && ts.isBlock(statement.parent)) {
|
|
3356
|
+
const entries = erasedArguments.get(symbol) ?? [];
|
|
3357
|
+
entries.push({ after: statement.end, exit: statement.parent.end - 1 });
|
|
3358
|
+
erasedArguments.set(symbol, entries);
|
|
3359
|
+
}
|
|
3360
|
+
}
|
|
3361
|
+
};
|
|
3362
|
+
const tupleSlotAt = (tRef, idx, sourceLen) => {
|
|
3363
|
+
const tFlags = tRef.target.elementFlags;
|
|
3364
|
+
const tElems = checker.getTypeArguments(tRef);
|
|
3365
|
+
const varIdx = tElems.findIndex((_, ti) => (tFlags[ti] & ts.ElementFlags.Variable) !== 0);
|
|
3366
|
+
if (varIdx < 0) return tElems[idx];
|
|
3367
|
+
if (idx < varIdx) return tElems[idx];
|
|
3368
|
+
const suffixCount = tElems.length - 1 - varIdx;
|
|
3369
|
+
if (sourceLen !== void 0 && suffixCount > 0 && idx >= sourceLen - suffixCount) {
|
|
3370
|
+
return tElems[tElems.length - (sourceLen - idx)];
|
|
3371
|
+
}
|
|
3372
|
+
return checker.getIndexTypeOfType(tElems[varIdx], ts.IndexKind.Number) ?? tElems[varIdx];
|
|
3373
|
+
};
|
|
3374
|
+
const erasedStatesFor = (sourceType, target, seen = /* @__PURE__ */ new Set()) => {
|
|
2092
3375
|
target = awaited(target);
|
|
2093
|
-
if (
|
|
2094
|
-
|
|
2095
|
-
if (
|
|
2096
|
-
|
|
2097
|
-
|
|
2098
|
-
|
|
2099
|
-
|
|
2100
|
-
|
|
2101
|
-
|
|
2102
|
-
|
|
2103
|
-
|
|
2104
|
-
|
|
3376
|
+
if (target.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) return { states: [], allAccountedFor: false };
|
|
3377
|
+
sourceType = awaited(sourceType);
|
|
3378
|
+
if (sourceType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) return { states: [], allAccountedFor: false };
|
|
3379
|
+
if (sourceType === target) return { states: [], allAccountedFor: true };
|
|
3380
|
+
const sId = sourceType.id;
|
|
3381
|
+
const tId = target.id;
|
|
3382
|
+
if (sId !== void 0 && tId !== void 0) {
|
|
3383
|
+
const pairKey = `${sId}:${tId}`;
|
|
3384
|
+
if (seen.has(pairKey)) return { states: [], allAccountedFor: true };
|
|
3385
|
+
seen.add(pairKey);
|
|
3386
|
+
}
|
|
3387
|
+
if (isPresentResult(target)) {
|
|
3388
|
+
if (stateInfo(target).stated) return { states: [], allAccountedFor: true };
|
|
3389
|
+
const info = stateInfo(sourceType);
|
|
3390
|
+
return { states: info.stated ? info.states : [], allAccountedFor: true };
|
|
3391
|
+
}
|
|
3392
|
+
const targetMembers = target.isUnion() ? target.types : [target];
|
|
3393
|
+
const sourceMembers = sourceType.isUnion() ? sourceType.types : [sourceType];
|
|
3394
|
+
if (targetMembers.length && targetMembers.some((tm) => checker.isTupleType(tm))) {
|
|
3395
|
+
const nonNullishTargets = targetMembers.filter((tm) => !(tm.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Void)));
|
|
3396
|
+
if (nonNullishTargets.length && nonNullishTargets.every((tm) => checker.isTupleType(tm))) {
|
|
3397
|
+
const states = /* @__PURE__ */ new Set();
|
|
3398
|
+
let allAccountedFor = true;
|
|
3399
|
+
for (const sm of sourceMembers) {
|
|
3400
|
+
if (sm.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never | ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Void) || policy.resultVariant(sm) !== null) continue;
|
|
3401
|
+
const compatibleTargets = typeof checker.isTypeAssignableTo === "function" ? nonNullishTargets.filter((tm) => checker.isTypeAssignableTo(sm, tm)) : [];
|
|
3402
|
+
const activeTargets = compatibleTargets.length ? compatibleTargets : nonNullishTargets;
|
|
3403
|
+
if (checker.isTupleType(sm)) {
|
|
3404
|
+
const sRef = sm;
|
|
3405
|
+
const sFlags = sRef.target.elementFlags;
|
|
3406
|
+
const sElems = checker.getTypeArguments(sRef);
|
|
3407
|
+
const sHasVar = Boolean(sRef.target.combinedFlags & ts.ElementFlags.Variable);
|
|
3408
|
+
for (const tm of activeTargets) {
|
|
3409
|
+
const tRef = tm;
|
|
3410
|
+
const tFlags = tRef.target.elementFlags;
|
|
3411
|
+
const tElems = checker.getTypeArguments(tRef);
|
|
3412
|
+
const tVarIdx = tElems.findIndex((_, ti) => (tFlags[ti] & ts.ElementFlags.Variable) !== 0);
|
|
3413
|
+
const tSuffixCount = tVarIdx >= 0 ? tElems.length - 1 - tVarIdx : 0;
|
|
3414
|
+
for (let k = 0; k < sElems.length; k++) {
|
|
3415
|
+
const sIsVar = (sFlags[k] & ts.ElementFlags.Variable) !== 0;
|
|
3416
|
+
const sElem = sIsVar ? checker.getIndexTypeOfType(sElems[k], ts.IndexKind.Number) ?? sElems[k] : sElems[k];
|
|
3417
|
+
if (!stateInfo(awaited(sElem)).stated) continue;
|
|
3418
|
+
const applyTarget = (pt) => {
|
|
3419
|
+
if (!pt) {
|
|
3420
|
+
allAccountedFor = false;
|
|
3421
|
+
return;
|
|
3422
|
+
}
|
|
3423
|
+
const sub = erasedStatesFor(sElem, pt, seen);
|
|
3424
|
+
for (const st of sub.states) states.add(st);
|
|
3425
|
+
if (!sub.allAccountedFor) allAccountedFor = false;
|
|
3426
|
+
};
|
|
3427
|
+
if (sIsVar) {
|
|
3428
|
+
const sSuffixCount = sElems.length - 1 - k;
|
|
3429
|
+
if (tVarIdx >= 0) {
|
|
3430
|
+
applyTarget(checker.getIndexTypeOfType(tElems[tVarIdx], ts.IndexKind.Number) ?? tElems[tVarIdx]);
|
|
3431
|
+
for (let p = k; p < tVarIdx; p++) applyTarget(tElems[p]);
|
|
3432
|
+
const extraSuffix = tSuffixCount - sSuffixCount;
|
|
3433
|
+
for (let s = 0; s < extraSuffix; s++) applyTarget(tElems[tVarIdx + 1 + s]);
|
|
3434
|
+
} else {
|
|
3435
|
+
const end = Math.max(tElems.length - sSuffixCount, k);
|
|
3436
|
+
if (end <= k) allAccountedFor = false;
|
|
3437
|
+
for (let p = k; p < end; p++) applyTarget(tElems[p]);
|
|
3438
|
+
}
|
|
3439
|
+
} else {
|
|
3440
|
+
let pt;
|
|
3441
|
+
if (!sHasVar) {
|
|
3442
|
+
pt = tupleSlotAt(tRef, k, sElems.length);
|
|
3443
|
+
} else {
|
|
3444
|
+
const sVarIdx = sElems.findIndex((_, si) => (sFlags[si] & ts.ElementFlags.Variable) !== 0);
|
|
3445
|
+
if (k < sVarIdx) pt = tupleSlotAt(tRef, k);
|
|
3446
|
+
else {
|
|
3447
|
+
const offsetFromEnd = sElems.length - k;
|
|
3448
|
+
if (tVarIdx >= 0) {
|
|
3449
|
+
if (offsetFromEnd <= tSuffixCount) pt = tElems[tElems.length - offsetFromEnd];
|
|
3450
|
+
else pt = checker.getIndexTypeOfType(tElems[tVarIdx], ts.IndexKind.Number) ?? tElems[tVarIdx];
|
|
3451
|
+
} else {
|
|
3452
|
+
pt = tElems.length >= offsetFromEnd ? tElems[tElems.length - offsetFromEnd] : void 0;
|
|
3453
|
+
}
|
|
3454
|
+
}
|
|
3455
|
+
}
|
|
3456
|
+
applyTarget(pt);
|
|
3457
|
+
}
|
|
3458
|
+
}
|
|
3459
|
+
}
|
|
3460
|
+
} else {
|
|
3461
|
+
const sElem = checker.getIndexTypeOfType(sm, ts.IndexKind.Number);
|
|
3462
|
+
if (!sElem || !stateInfo(awaited(sElem)).stated) continue;
|
|
3463
|
+
for (const tm of activeTargets) {
|
|
3464
|
+
const tRef = tm;
|
|
3465
|
+
const tFlags = tRef.target.elementFlags;
|
|
3466
|
+
const tElems = checker.getTypeArguments(tRef);
|
|
3467
|
+
for (let p = 0; p < tElems.length; p++) {
|
|
3468
|
+
const pt = (tFlags[p] & ts.ElementFlags.Variable) !== 0 ? checker.getIndexTypeOfType(tElems[p], ts.IndexKind.Number) ?? tElems[p] : tElems[p];
|
|
3469
|
+
const sub = erasedStatesFor(sElem, pt, seen);
|
|
3470
|
+
for (const st of sub.states) states.add(st);
|
|
3471
|
+
if (!sub.allAccountedFor) allAccountedFor = false;
|
|
3472
|
+
}
|
|
3473
|
+
}
|
|
3474
|
+
}
|
|
2105
3475
|
}
|
|
3476
|
+
return { states: [...states].sort(), allAccountedFor };
|
|
2106
3477
|
}
|
|
2107
3478
|
}
|
|
3479
|
+
const erasedArrayStates = /* @__PURE__ */ new Set();
|
|
3480
|
+
let arrayHandled = false;
|
|
3481
|
+
let arrayAllAccounted = true;
|
|
3482
|
+
for (const sm of sourceMembers) {
|
|
3483
|
+
if (sm.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never | ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Void) || policy.resultVariant(sm) !== null) continue;
|
|
3484
|
+
const sInfo = arrayStateInfo(sm);
|
|
3485
|
+
if (!sInfo.stated) continue;
|
|
3486
|
+
arrayHandled = true;
|
|
3487
|
+
const compatibleTargets = typeof checker.isTypeAssignableTo === "function" ? targetMembers.filter((tm) => checker.isTypeAssignableTo(sm, tm)) : [];
|
|
3488
|
+
const activeTargets = compatibleTargets.length ? compatibleTargets : targetMembers.filter((tm) => !(tm.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Void)));
|
|
3489
|
+
if (!activeTargets.length) {
|
|
3490
|
+
arrayAllAccounted = false;
|
|
3491
|
+
continue;
|
|
3492
|
+
}
|
|
3493
|
+
for (const tm of activeTargets) {
|
|
3494
|
+
if (checker.isTupleType(tm)) {
|
|
3495
|
+
const sub = erasedStatesFor(sm, tm, seen);
|
|
3496
|
+
for (const st of sub.states) erasedArrayStates.add(st);
|
|
3497
|
+
if (!sub.allAccountedFor) arrayAllAccounted = false;
|
|
3498
|
+
} else if (isStatelessResultArray(tm)) {
|
|
3499
|
+
for (const st of sInfo.states) erasedArrayStates.add(st);
|
|
3500
|
+
} else if (!arrayStateInfo(tm).stated) {
|
|
3501
|
+
arrayAllAccounted = false;
|
|
3502
|
+
}
|
|
3503
|
+
}
|
|
3504
|
+
}
|
|
3505
|
+
if (arrayHandled) {
|
|
3506
|
+
return { states: [...erasedArrayStates].sort(), allAccountedFor: arrayAllAccounted };
|
|
3507
|
+
}
|
|
3508
|
+
return { states: [], allAccountedFor: false };
|
|
3509
|
+
};
|
|
3510
|
+
const erasure = (expr, target) => {
|
|
3511
|
+
const { states, allAccountedFor } = erasedStatesFor(checker.getTypeAtLocation(expr), target);
|
|
3512
|
+
if (states.length) {
|
|
3513
|
+
report(expr, "erased-state", { subject: subjectOf2(expr), states: formatStates(states) });
|
|
3514
|
+
if (allAccountedFor) recordErasedArg(expr);
|
|
3515
|
+
}
|
|
2108
3516
|
};
|
|
2109
3517
|
const visit = (node) => {
|
|
2110
3518
|
if (ts.isPropertyAccessExpression(node) && node.name.text === "value") valueRead(node.expression, node.name);
|
|
@@ -2118,6 +3526,24 @@ function trustedStatesIn(sourceFile, context) {
|
|
|
2118
3526
|
}
|
|
2119
3527
|
if ((ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node)) && node.type && node.initializer) erasure(node.initializer, checker.getTypeFromTypeNode(node.type));
|
|
2120
3528
|
if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) erasure(node.right, checker.getTypeAtLocation(node.left));
|
|
3529
|
+
if (ts.isYieldExpression(node) && node.expression && !node.asteriskToken) {
|
|
3530
|
+
const target = checker.getContextualType(node.expression);
|
|
3531
|
+
if (target) erasure(node.expression, target);
|
|
3532
|
+
}
|
|
3533
|
+
if (ts.isYieldExpression(node) && node.expression && node.asteriskToken) {
|
|
3534
|
+
let fn = node.parent;
|
|
3535
|
+
while (fn && !ts.isFunctionLike(fn)) fn = fn.parent;
|
|
3536
|
+
const declared = fn && ts.isFunctionLike(fn) && fn.type ? checker.getTypeFromTypeNode(fn.type) : void 0;
|
|
3537
|
+
const yielded = declared && declared.flags & ts.TypeFlags.Object && declared.objectFlags & ts.ObjectFlags.Reference ? checker.getTypeArguments(declared)[0] : void 0;
|
|
3538
|
+
const element = yielded && checker.getIndexTypeOfType(checker.getTypeAtLocation(node.expression), ts.IndexKind.Number);
|
|
3539
|
+
if (yielded && element) {
|
|
3540
|
+
const { states, allAccountedFor } = erasedStatesFor(element, yielded);
|
|
3541
|
+
if (states.length) {
|
|
3542
|
+
report(node.expression, "erased-state", { subject: subjectOf2(node.expression), states: formatStates(states) });
|
|
3543
|
+
if (allAccountedFor) recordErasedArg(node.expression);
|
|
3544
|
+
}
|
|
3545
|
+
}
|
|
3546
|
+
}
|
|
2121
3547
|
if (ts.isReturnStatement(node) && node.expression) {
|
|
2122
3548
|
let parent = node.parent;
|
|
2123
3549
|
while (parent && !ts.isFunctionLike(parent)) parent = parent.parent;
|
|
@@ -2129,14 +3555,228 @@ function trustedStatesIn(sourceFile, context) {
|
|
|
2129
3555
|
const file = resolved?.declaration.getSourceFile().fileName;
|
|
2130
3556
|
const signature = checker.getResolvedSignature(node);
|
|
2131
3557
|
if (file && !isTrustPackageFile(file) && policy.zones.zoneOf(file) === "checked" && signature) {
|
|
2132
|
-
|
|
2133
|
-
|
|
2134
|
-
|
|
2135
|
-
|
|
2136
|
-
|
|
2137
|
-
|
|
2138
|
-
|
|
2139
|
-
|
|
3558
|
+
const parameters = signature.parameters;
|
|
3559
|
+
const lastParam = parameters[parameters.length - 1];
|
|
3560
|
+
const lastDecl = lastParam?.valueDeclaration;
|
|
3561
|
+
const hasRestParam = Boolean(lastDecl && ts.isParameter(lastDecl) && lastDecl.dotDotDotToken);
|
|
3562
|
+
const exactArgCount = (() => {
|
|
3563
|
+
let total = 0;
|
|
3564
|
+
for (const a of node.arguments) {
|
|
3565
|
+
if (!ts.isSpreadElement(a)) {
|
|
3566
|
+
total += 1;
|
|
3567
|
+
continue;
|
|
3568
|
+
}
|
|
3569
|
+
const st = awaited(checker.getTypeAtLocation(a.expression));
|
|
3570
|
+
const sms = st.isUnion() ? st.types : [st];
|
|
3571
|
+
if (!sms.length || !sms.every((m) => checker.isTupleType(m))) return void 0;
|
|
3572
|
+
let len;
|
|
3573
|
+
for (const m of sms) {
|
|
3574
|
+
const r = m;
|
|
3575
|
+
if (r.target.combinedFlags & ts.ElementFlags.NonRequired) return void 0;
|
|
3576
|
+
const mLen = checker.getTypeArguments(r).length;
|
|
3577
|
+
if (len === void 0) len = mLen;
|
|
3578
|
+
else if (len !== mLen) return void 0;
|
|
3579
|
+
}
|
|
3580
|
+
total += len ?? 0;
|
|
3581
|
+
}
|
|
3582
|
+
return total;
|
|
3583
|
+
})();
|
|
3584
|
+
const restStart = parameters.length - 1;
|
|
3585
|
+
const totalRestArgs = hasRestParam && exactArgCount !== void 0 && exactArgCount >= restStart ? exactArgCount - restStart : void 0;
|
|
3586
|
+
const tupleSlotTypes = (type, offset, fromEndOffset, fullRestSpread) => {
|
|
3587
|
+
const unwrapped = awaited(type);
|
|
3588
|
+
const rawMs = unwrapped.isUnion() ? unwrapped.types : [unwrapped];
|
|
3589
|
+
const compatible = fullRestSpread && typeof checker.isTypeAssignableTo === "function" ? rawMs.filter((tm) => checker.isTypeAssignableTo(fullRestSpread, tm)) : rawMs.length > 1 && typeof checker.isTypeAssignableTo === "function" && !node.arguments.some(ts.isSpreadElement) ? rawMs.filter((tm) => {
|
|
3590
|
+
if (checker.isTupleType(tm)) {
|
|
3591
|
+
const tuple = tm.target;
|
|
3592
|
+
const count = node.arguments.length - restStart;
|
|
3593
|
+
if (count < tuple.minLength || !(tuple.combinedFlags & ts.ElementFlags.Variable) && count > tuple.elementFlags.length) return false;
|
|
3594
|
+
}
|
|
3595
|
+
return node.arguments.slice(restStart).every((a, i) => {
|
|
3596
|
+
const slot = checker.isTupleType(tm) ? tupleSlotAt(tm, i, totalRestArgs) : checker.getIndexTypeOfType(tm, ts.IndexKind.Number);
|
|
3597
|
+
return slot && checker.isTypeAssignableTo(checker.getTypeAtLocation(a), slot);
|
|
3598
|
+
});
|
|
3599
|
+
}) : [];
|
|
3600
|
+
const ms = compatible.length ? compatible : rawMs;
|
|
3601
|
+
const out = [];
|
|
3602
|
+
for (const m of ms) {
|
|
3603
|
+
if (checker.isTupleType(m)) {
|
|
3604
|
+
const ref = m;
|
|
3605
|
+
if (fromEndOffset !== void 0) {
|
|
3606
|
+
const flags = ref.target.elementFlags;
|
|
3607
|
+
const elems = checker.getTypeArguments(ref);
|
|
3608
|
+
const varIdx = elems.findIndex((_, ti) => (flags[ti] & ts.ElementFlags.Variable) !== 0);
|
|
3609
|
+
if (varIdx >= 0) {
|
|
3610
|
+
const suffixCount = elems.length - 1 - varIdx;
|
|
3611
|
+
if (fromEndOffset <= suffixCount) out.push(elems[elems.length - fromEndOffset]);
|
|
3612
|
+
else out.push(checker.getIndexTypeOfType(elems[varIdx], ts.IndexKind.Number) ?? elems[varIdx]);
|
|
3613
|
+
} else if (elems.length >= fromEndOffset) {
|
|
3614
|
+
out.push(elems[elems.length - fromEndOffset]);
|
|
3615
|
+
}
|
|
3616
|
+
} else {
|
|
3617
|
+
const slot = tupleSlotAt(ref, offset, totalRestArgs);
|
|
3618
|
+
if (slot) out.push(slot);
|
|
3619
|
+
}
|
|
3620
|
+
} else {
|
|
3621
|
+
const indexed = checker.getIndexTypeOfType(m, ts.IndexKind.Number);
|
|
3622
|
+
if (indexed) out.push(indexed);
|
|
3623
|
+
}
|
|
3624
|
+
}
|
|
3625
|
+
return out;
|
|
3626
|
+
};
|
|
3627
|
+
const paramElementTypesAt = (index, fromEndArgs, fullRestSpread) => {
|
|
3628
|
+
if (hasRestParam && index >= restStart) {
|
|
3629
|
+
const restType = checker.getTypeOfSymbolAtLocation(lastParam, node);
|
|
3630
|
+
return tupleSlotTypes(restType, index - restStart, fromEndArgs, fullRestSpread);
|
|
3631
|
+
}
|
|
3632
|
+
const param = parameters[index];
|
|
3633
|
+
return param ? [checker.getTypeOfSymbolAtLocation(param, node)] : [];
|
|
3634
|
+
};
|
|
3635
|
+
const effectiveParamCount = () => {
|
|
3636
|
+
if (!hasRestParam) return parameters.length;
|
|
3637
|
+
const restType = awaited(checker.getTypeOfSymbolAtLocation(lastParam, node));
|
|
3638
|
+
const ms = restType.isUnion() ? restType.types : [restType];
|
|
3639
|
+
let maxExtra = 1;
|
|
3640
|
+
for (const m of ms) {
|
|
3641
|
+
if (checker.isTupleType(m)) {
|
|
3642
|
+
maxExtra = Math.max(maxExtra, checker.getTypeArguments(m).length);
|
|
3643
|
+
}
|
|
3644
|
+
}
|
|
3645
|
+
return parameters.length - 1 + maxExtra;
|
|
3646
|
+
};
|
|
3647
|
+
const totalPositions = effectiveParamCount();
|
|
3648
|
+
let cursor = 0;
|
|
3649
|
+
let seenVariadic = false;
|
|
3650
|
+
for (let argIdx = 0; argIdx < node.arguments.length; argIdx++) {
|
|
3651
|
+
const arg = node.arguments[argIdx];
|
|
3652
|
+
const trailingFixedArgs = (() => {
|
|
3653
|
+
let count = 0;
|
|
3654
|
+
for (let j = argIdx + 1; j < node.arguments.length; j++) {
|
|
3655
|
+
const nextArg = node.arguments[j];
|
|
3656
|
+
if (!ts.isSpreadElement(nextArg)) {
|
|
3657
|
+
count += 1;
|
|
3658
|
+
continue;
|
|
3659
|
+
}
|
|
3660
|
+
const st = awaited(checker.getTypeAtLocation(nextArg.expression));
|
|
3661
|
+
const sms = st.isUnion() ? st.types : [st];
|
|
3662
|
+
if (!sms.length || !sms.every((m) => checker.isTupleType(m))) return void 0;
|
|
3663
|
+
let len;
|
|
3664
|
+
for (const m of sms) {
|
|
3665
|
+
const r = m;
|
|
3666
|
+
if (r.target.combinedFlags & ts.ElementFlags.NonRequired) return void 0;
|
|
3667
|
+
const mLen = checker.getTypeArguments(r).length;
|
|
3668
|
+
if (len === void 0) len = mLen;
|
|
3669
|
+
else if (len !== mLen) return void 0;
|
|
3670
|
+
}
|
|
3671
|
+
count += len ?? 0;
|
|
3672
|
+
}
|
|
3673
|
+
return count;
|
|
3674
|
+
})();
|
|
3675
|
+
if (!ts.isSpreadElement(arg)) {
|
|
3676
|
+
const fromEnd = seenVariadic && trailingFixedArgs !== void 0 ? trailingFixedArgs + 1 : void 0;
|
|
3677
|
+
const paramTypes = paramElementTypesAt(cursor, fromEnd);
|
|
3678
|
+
const states = /* @__PURE__ */ new Set();
|
|
3679
|
+
let allAccountedFor2 = paramTypes.length > 0;
|
|
3680
|
+
const argType = checker.getTypeAtLocation(arg);
|
|
3681
|
+
for (const pt of paramTypes) {
|
|
3682
|
+
const res = erasedStatesFor(argType, pt);
|
|
3683
|
+
for (const s of res.states) states.add(s);
|
|
3684
|
+
if (!res.allAccountedFor) allAccountedFor2 = false;
|
|
3685
|
+
}
|
|
3686
|
+
if (states.size) {
|
|
3687
|
+
report(arg, "erased-state", { subject: subjectOf2(arg), states: formatStates([...states].sort()) });
|
|
3688
|
+
if (allAccountedFor2) recordErasedArg(arg);
|
|
3689
|
+
}
|
|
3690
|
+
cursor += 1;
|
|
3691
|
+
continue;
|
|
3692
|
+
}
|
|
3693
|
+
const expr = arg.expression;
|
|
3694
|
+
const spreadType = awaited(checker.getTypeAtLocation(expr));
|
|
3695
|
+
const ms = spreadType.isUnion() ? spreadType.types : [spreadType];
|
|
3696
|
+
const erasedStates = /* @__PURE__ */ new Set();
|
|
3697
|
+
let allAccountedFor = true;
|
|
3698
|
+
const isSoleRestSpread = hasRestParam && cursor === restStart && !seenVariadic && argIdx === node.arguments.length - 1;
|
|
3699
|
+
const checkParamPos = (elemType, pos, fromEnd, fullRestSpread) => {
|
|
3700
|
+
const pts = paramElementTypesAt(pos, fromEnd, fullRestSpread);
|
|
3701
|
+
if (!pts.length) return false;
|
|
3702
|
+
let ok = true;
|
|
3703
|
+
for (const pt of pts) {
|
|
3704
|
+
const res = erasedStatesFor(elemType, pt);
|
|
3705
|
+
for (const s of res.states) erasedStates.add(s);
|
|
3706
|
+
if (!res.allAccountedFor) ok = false;
|
|
3707
|
+
}
|
|
3708
|
+
return ok;
|
|
3709
|
+
};
|
|
3710
|
+
if (ms.length && ms.every((m) => checker.isTupleType(m))) {
|
|
3711
|
+
for (const m of ms) {
|
|
3712
|
+
const fullRest = isSoleRestSpread ? m : void 0;
|
|
3713
|
+
const ref = m;
|
|
3714
|
+
const flags = ref.target.elementFlags;
|
|
3715
|
+
const elemTypes = checker.getTypeArguments(ref);
|
|
3716
|
+
const varIdx = elemTypes.findIndex((_, si) => (flags[si] & ts.ElementFlags.Variable) !== 0);
|
|
3717
|
+
for (let k = 0; k < elemTypes.length; k++) {
|
|
3718
|
+
const isVar = (flags[k] & ts.ElementFlags.Variable) !== 0;
|
|
3719
|
+
const elemType = isVar ? checker.getIndexTypeOfType(elemTypes[k], ts.IndexKind.Number) ?? elemTypes[k] : elemTypes[k];
|
|
3720
|
+
if (!stateInfo(awaited(elemType)).stated) continue;
|
|
3721
|
+
if (isVar) {
|
|
3722
|
+
const end = Math.max(totalPositions, cursor + k + 1);
|
|
3723
|
+
for (let p = cursor + k; p < end; p++) {
|
|
3724
|
+
if (!checkParamPos(elemType, p, void 0, fullRest)) allAccountedFor = false;
|
|
3725
|
+
}
|
|
3726
|
+
} else {
|
|
3727
|
+
const hasAfterVar = varIdx >= 0 && k > varIdx;
|
|
3728
|
+
const fromEnd = (seenVariadic || hasAfterVar) && trailingFixedArgs !== void 0 ? trailingFixedArgs + (elemTypes.length - k) : void 0;
|
|
3729
|
+
if (!checkParamPos(elemType, cursor + k, fromEnd, fullRest)) allAccountedFor = false;
|
|
3730
|
+
}
|
|
3731
|
+
}
|
|
3732
|
+
}
|
|
3733
|
+
if (ms.length === 1) {
|
|
3734
|
+
const ref = ms[0];
|
|
3735
|
+
if (!(ref.target.combinedFlags & ts.ElementFlags.NonRequired)) {
|
|
3736
|
+
cursor += checker.getTypeArguments(ref).length;
|
|
3737
|
+
} else {
|
|
3738
|
+
seenVariadic = true;
|
|
3739
|
+
cursor += 1;
|
|
3740
|
+
}
|
|
3741
|
+
} else {
|
|
3742
|
+
const allExactSameLen = ms.every((m) => !(m.target.combinedFlags & ts.ElementFlags.NonRequired)) && new Set(ms.map((m) => checker.getTypeArguments(m).length)).size === 1;
|
|
3743
|
+
if (allExactSameLen) cursor += checker.getTypeArguments(ms[0]).length;
|
|
3744
|
+
else {
|
|
3745
|
+
seenVariadic = true;
|
|
3746
|
+
cursor += 1;
|
|
3747
|
+
}
|
|
3748
|
+
}
|
|
3749
|
+
} else {
|
|
3750
|
+
seenVariadic = true;
|
|
3751
|
+
const elemInfo = arrayStateInfo(spreadType);
|
|
3752
|
+
if (elemInfo.stated) {
|
|
3753
|
+
const end = Math.max(totalPositions, cursor + 1);
|
|
3754
|
+
for (let p = cursor; p < end; p++) {
|
|
3755
|
+
const pts = paramElementTypesAt(p);
|
|
3756
|
+
if (!pts.length) {
|
|
3757
|
+
allAccountedFor = false;
|
|
3758
|
+
continue;
|
|
3759
|
+
}
|
|
3760
|
+
for (const pt of pts) {
|
|
3761
|
+
const unwrappedTarget = awaited(pt);
|
|
3762
|
+
if (!isPresentResult(unwrappedTarget)) {
|
|
3763
|
+
allAccountedFor = false;
|
|
3764
|
+
continue;
|
|
3765
|
+
}
|
|
3766
|
+
if (!stateInfo(unwrappedTarget).stated) {
|
|
3767
|
+
for (const s of elemInfo.states) erasedStates.add(s);
|
|
3768
|
+
}
|
|
3769
|
+
}
|
|
3770
|
+
}
|
|
3771
|
+
}
|
|
3772
|
+
cursor += 1;
|
|
3773
|
+
}
|
|
3774
|
+
if (erasedStates.size) {
|
|
3775
|
+
const sorted = [...erasedStates].sort();
|
|
3776
|
+
report(expr, "erased-state", { subject: subjectOf2(expr), states: formatStates(sorted) });
|
|
3777
|
+
if (allAccountedFor) recordErasedArg(expr);
|
|
3778
|
+
}
|
|
3779
|
+
}
|
|
2140
3780
|
}
|
|
2141
3781
|
}
|
|
2142
3782
|
if (ts.isFunctionLike(node) && "body" in node && node.body) {
|
|
@@ -2202,13 +3842,74 @@ function trustedStatesIn(sourceFile, context) {
|
|
|
2202
3842
|
const symbol = checker.getSymbolsInScope(at, ts.SymbolFlags.Variable).find((s) => s.name === flow.subject);
|
|
2203
3843
|
if (symbol && erasedArguments.get(symbol)?.some(({ after, exit }) => {
|
|
2204
3844
|
if (flow.start < after || flow.start > exit) return false;
|
|
2205
|
-
|
|
3845
|
+
const connectedSymbols = /* @__PURE__ */ new Set([symbol]);
|
|
3846
|
+
const collectAliases = (node) => {
|
|
3847
|
+
if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
|
|
3848
|
+
const rhs = unparen(ts, node.initializer);
|
|
3849
|
+
if (ts.isIdentifier(rhs)) {
|
|
3850
|
+
const lhsSym = checker.getSymbolAtLocation(node.name);
|
|
3851
|
+
const rhsSym = checker.getSymbolAtLocation(rhs);
|
|
3852
|
+
if (lhsSym && rhsSym && (connectedSymbols.has(lhsSym) || connectedSymbols.has(rhsSym))) {
|
|
3853
|
+
connectedSymbols.add(lhsSym);
|
|
3854
|
+
connectedSymbols.add(rhsSym);
|
|
3855
|
+
}
|
|
3856
|
+
}
|
|
3857
|
+
} else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
|
|
3858
|
+
const lhs = unparen(ts, node.left);
|
|
3859
|
+
const rhs = unparen(ts, node.right);
|
|
3860
|
+
if (ts.isIdentifier(lhs) && ts.isIdentifier(rhs)) {
|
|
3861
|
+
const lhsSym = checker.getSymbolAtLocation(lhs);
|
|
3862
|
+
const rhsSym = checker.getSymbolAtLocation(rhs);
|
|
3863
|
+
if (lhsSym && rhsSym && (connectedSymbols.has(lhsSym) || connectedSymbols.has(rhsSym))) {
|
|
3864
|
+
connectedSymbols.add(lhsSym);
|
|
3865
|
+
connectedSymbols.add(rhsSym);
|
|
3866
|
+
}
|
|
3867
|
+
}
|
|
3868
|
+
}
|
|
3869
|
+
ts.forEachChild(node, collectAliases);
|
|
3870
|
+
};
|
|
3871
|
+
collectAliases(sourceFile);
|
|
3872
|
+
const matchesSymbol = (expr) => {
|
|
3873
|
+
const inner = unparen(ts, expr);
|
|
3874
|
+
if (!ts.isIdentifier(inner)) return false;
|
|
3875
|
+
const s = checker.getSymbolAtLocation(inner);
|
|
3876
|
+
return Boolean(s && connectedSymbols.has(s));
|
|
3877
|
+
};
|
|
3878
|
+
const patternMentionsSymbol = (pat) => {
|
|
3879
|
+
const inner = unparen(ts, pat);
|
|
3880
|
+
if (ts.isIdentifier(inner)) return matchesSymbol(inner);
|
|
3881
|
+
if (ts.isArrayLiteralExpression(inner)) {
|
|
3882
|
+
return inner.elements.some((el) => {
|
|
3883
|
+
if (ts.isOmittedExpression(el)) return false;
|
|
3884
|
+
if (ts.isSpreadElement(el)) return patternMentionsSymbol(el.expression);
|
|
3885
|
+
if (ts.isBinaryExpression(el) && el.operatorToken.kind === ts.SyntaxKind.EqualsToken) return patternMentionsSymbol(el.left);
|
|
3886
|
+
return patternMentionsSymbol(el);
|
|
3887
|
+
});
|
|
3888
|
+
}
|
|
3889
|
+
return false;
|
|
3890
|
+
};
|
|
3891
|
+
let refreshed = false;
|
|
2206
3892
|
const writes = (node) => {
|
|
2207
|
-
|
|
3893
|
+
const pos = node.getStart(sourceFile);
|
|
3894
|
+
if (pos >= after && pos < flow.start) {
|
|
3895
|
+
if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) {
|
|
3896
|
+
const lhs = unparen(ts, node.left);
|
|
3897
|
+
if (patternMentionsSymbol(lhs)) refreshed = true;
|
|
3898
|
+
else if (ts.isElementAccessExpression(lhs) && matchesSymbol(lhs.expression)) refreshed = true;
|
|
3899
|
+
} else if ((ts.isForOfStatement(node) || ts.isForInStatement(node)) && !ts.isVariableDeclarationList(node.initializer) && patternMentionsSymbol(node.initializer)) {
|
|
3900
|
+
refreshed = true;
|
|
3901
|
+
} else if (ts.isCallExpression(node)) {
|
|
3902
|
+
const callee = unparen(ts, node.expression);
|
|
3903
|
+
const methodName = ts.isPropertyAccessExpression(callee) ? callee.name.text : ts.isElementAccessExpression(callee) && callee.argumentExpression && (ts.isStringLiteral(unparen(ts, callee.argumentExpression)) || ts.isNoSubstitutionTemplateLiteral(unparen(ts, callee.argumentExpression))) ? unparen(ts, callee.argumentExpression).text : void 0;
|
|
3904
|
+
if (methodName && ["push", "unshift", "splice", "fill", "copyWithin"].includes(methodName) && (ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee)) && matchesSymbol(callee.expression)) {
|
|
3905
|
+
refreshed = true;
|
|
3906
|
+
}
|
|
3907
|
+
}
|
|
3908
|
+
}
|
|
2208
3909
|
ts.forEachChild(node, writes);
|
|
2209
3910
|
};
|
|
2210
3911
|
writes(sourceFile);
|
|
2211
|
-
return !
|
|
3912
|
+
return !refreshed;
|
|
2212
3913
|
})) continue;
|
|
2213
3914
|
}
|
|
2214
3915
|
findings.push({ start: flow.start, origin: flow.origin, data: {
|
|
@@ -3697,4 +5398,4 @@ export {
|
|
|
3697
5398
|
checkSourceFile,
|
|
3698
5399
|
checkSourceFileWithAccepted
|
|
3699
5400
|
};
|
|
3700
|
-
//# sourceMappingURL=chunk-
|
|
5401
|
+
//# sourceMappingURL=chunk-QTS55J43.js.map
|