FA-44081 / Borrow checking / Open access

A conditionally initialized field lacks its runtime drop flag obligation · case 01

A conditionally initialized field lacks its runtime drop flag obligation.

Verified by executionVariant 1 · 21 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

The static analyzer mishandles conditional drop flags: a conditionally initialized field lacks its runtime drop flag obligation.

VERIFIED REPAIR

Apply the specified transfer or inference rule at this site: if set(d['possibly_initialized'])!=set(d['drop_flags']): errors.append('conditional-drop-flags').

Unsuccessful approach: The partial repair uses if not set(d['drop_flags'])<=set(d['possibly_initialized']): errors.append('conditional-drop-flags'), which still violates the stipulated analysis contract.

Case contract

Check ownership lattice join certificates. Definitely initialized paths intersect predecessor sets; possibly moved paths union; unique capabilities survive only if same owner on all paths; returned paths excluded from continuing join; divergent predecessors contribute bottom; reference alternatives union origins; assignment on every path restores initialization; storage incarnations cannot merge by variable spelling; drop flags reflect possibly initialized fields; conditional ownership is not unconditional ownership. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

Why this case matters

A finite offline static-analysis model of ownership and borrowing; it does not execute the analyzed program.

1 / The failure

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(d):
    errors=[]
    if set(d['joined_initialized'])!=(set.intersection(*(set(x) for x in d['pred_initialized'])) if d['pred_initialized'] else set()): errors.append('definite-meet')
    if set(d['joined_moved'])!=set(x for xs in d['pred_moved'] for x in xs): errors.append('possible-move-union')
    if d['unique_retained'] and len(set(d['unique_owners']))!=1: errors.append('unique-owner-agreement')
    if bool(set(d['returned'])&set(d['included'])): errors.append('returned-path-exclusion')
    if bool(set(d['diverged'])&set(d['included'])): errors.append('divergent-bottom')
    if set(d['joined_origins'])!=set(x for xs in d['origin_sets'] for x in xs): errors.append('origin-alternative-union')
    if not set(d['assigned_everywhere'])<=set(d['restored']): errors.append('all-path-reinitialization')
    if d['merged_incarnation'] is not None and any(x!=d['merged_incarnation'] for x in d['incarnations']): errors.append('incarnation-separation')
    if False: errors.append('conditional-drop-flags')
    if bool(set(d['conditional'])&set(d['unconditional'])): errors.append('conditional-capability')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'pred_initialized': [], 'joined_initialized': [], 'pred_moved': [], 'joined_moved': [], 'unique_owners': [], 'unique_retained': False, 'returned': [], 'included': [], 'diverged': [], 'origin_sets': [], 'joined_origins': [], 'assigned_everywhere': [], 'restored': [], 'incarnations': [], 'merged_incarnation': None, 'possibly_initialized': [], 'drop_flags': [], 'conditional': [], 'unconditional': []}
check('well formed empty obligations',solve(base),[])
check('definite-meet regression 0', solve(dict(base, **({'pred_initialized':[['a'],[]],'joined_initialized':['a']}))), ['definite-meet'])
check('definite-meet regression 1', solve(dict(base, **({'pred_initialized':[[N,N+1],[N]],'joined_initialized':[N,N+1]}))), ['definite-meet'])
check('possible-move-union regression 0', solve(dict(base, **({'pred_moved':[['a'],[]]}))), ['possible-move-union'])
check('possible-move-union regression 1', solve(dict(base, **({'pred_moved':[[N],[N+1]],'joined_moved':[N]}))), ['possible-move-union'])
check('unique-owner-agreement regression 0', solve(dict(base, **({'unique_retained':True,'unique_owners':['a','b']}))), ['unique-owner-agreement'])
check('unique-owner-agreement regression 1', solve(dict(base, **({'unique_retained':True,'unique_owners':[N,N+1]}))), ['unique-owner-agreement'])
check('returned-path-exclusion regression 0', solve(dict(base, **({'returned':['a'],'included':['a','b']}))), ['returned-path-exclusion'])
check('returned-path-exclusion regression 1', solve(dict(base, **({'returned':[N],'included':[N,N+1]}))), ['returned-path-exclusion'])
check('divergent-bottom regression 0', solve(dict(base, **({'diverged':['a'],'included':['a','b']}))), ['divergent-bottom'])
check('divergent-bottom regression 1', solve(dict(base, **({'diverged':[N],'included':[N,N+1]}))), ['divergent-bottom'])
check('origin-alternative-union regression 0', solve(dict(base, **({'origin_sets':[['a'],['b']],'joined_origins':['a']}))), ['origin-alternative-union'])
check('origin-alternative-union regression 1', solve(dict(base, **({'origin_sets':[[N],[N+1]],'joined_origins':[N]}))), ['origin-alternative-union'])
check('all-path-reinitialization regression 0', solve(dict(base, **({'assigned_everywhere':['a','b'],'restored':['a']}))), ['all-path-reinitialization'])
check('all-path-reinitialization regression 1', solve(dict(base, **({'assigned_everywhere':[N,N+1],'restored':[N]}))), ['all-path-reinitialization'])
check('incarnation-separation regression 0', solve(dict(base, **({'merged_incarnation':N,'incarnations':[N,N+1]}))), ['incarnation-separation'])
check('incarnation-separation regression 1', solve(dict(base, **({'merged_incarnation':'x1','incarnations':['x1','x2']}))), ['incarnation-separation'])
check('conditional-drop-flags regression 0', solve(dict(base, **({'possibly_initialized':['a']}))), ['conditional-drop-flags'])
check('conditional-drop-flags regression 1', solve(dict(base, **({'possibly_initialized':[N,N+1],'drop_flags':[N]}))), ['conditional-drop-flags'])
check('conditional-capability regression 0', solve(dict(base, **({'conditional':['r'],'unconditional':['r']}))), ['conditional-capability'])
check('conditional-capability regression 1', solve(dict(base, **({'conditional':[N],'unconditional':[N]}))), ['conditional-capability'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
well formed empty obligations	`[]`	`[]`	Passed
definite-meet regression 0	`['definite-meet']`	`['definite-meet']`	Passed
definite-meet regression 1	`['definite-meet']`	`['definite-meet']`	Passed
possible-move-union regression 0	`['possible-move-union']`	`['possible-move-union']`	Passed
possible-move-union regression 1	`['possible-move-union']`	`['possible-move-union']`	Passed
unique-owner-agreement regression 0	`['unique-owner-agreement']`	`['unique-owner-agreement']`	Passed
unique-owner-agreement regression 1	`['unique-owner-agreement']`	`['unique-owner-agreement']`	Passed
returned-path-exclusion regression 0	`['returned-path-exclusion']`	`['returned-path-exclusion']`	Passed
returned-path-exclusion regression 1	`['returned-path-exclusion']`	`['returned-path-exclusion']`	Passed
divergent-bottom regression 0	`['divergent-bottom']`	`['divergent-bottom']`	Passed
divergent-bottom regression 1	`['divergent-bottom']`	`['divergent-bottom']`	Passed
origin-alternative-union regression 0	`['origin-alternative-union']`	`['origin-alternative-union']`	Passed
origin-alternative-union regression 1	`['origin-alternative-union']`	`['origin-alternative-union']`	Passed
all-path-reinitialization regression 0	`['all-path-reinitialization']`	`['all-path-reinitialization']`	Passed
all-path-reinitialization regression 1	`['all-path-reinitialization']`	`['all-path-reinitialization']`	Passed
incarnation-separation regression 0	`['incarnation-separation']`	`['incarnation-separation']`	Passed
incarnation-separation regression 1	`['incarnation-separation']`	`['incarnation-separation']`	Passed
conditional-drop-flags regression 0	`[]`	`['conditional-drop-flags']`	Failed
conditional-drop-flags regression 1	`[]`	`['conditional-drop-flags']`	Failed
conditional-capability regression 0	`['conditional-capability']`	`['conditional-capability']`	Passed
conditional-capability regression 1	`['conditional-capability']`	`['conditional-capability']`	Passed

SHA-256 / daab0773d2b4e4c126fc06efe5be95e0879114dd637a272ac015dd1d756ca95a

2 / The unsuccessful fix

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(d):
    errors=[]
    if set(d['joined_initialized'])!=(set.intersection(*(set(x) for x in d['pred_initialized'])) if d['pred_initialized'] else set()): errors.append('definite-meet')
    if set(d['joined_moved'])!=set(x for xs in d['pred_moved'] for x in xs): errors.append('possible-move-union')
    if d['unique_retained'] and len(set(d['unique_owners']))!=1: errors.append('unique-owner-agreement')
    if bool(set(d['returned'])&set(d['included'])): errors.append('returned-path-exclusion')
    if bool(set(d['diverged'])&set(d['included'])): errors.append('divergent-bottom')
    if set(d['joined_origins'])!=set(x for xs in d['origin_sets'] for x in xs): errors.append('origin-alternative-union')
    if not set(d['assigned_everywhere'])<=set(d['restored']): errors.append('all-path-reinitialization')
    if d['merged_incarnation'] is not None and any(x!=d['merged_incarnation'] for x in d['incarnations']): errors.append('incarnation-separation')
    if not set(d['drop_flags'])<=set(d['possibly_initialized']): errors.append('conditional-drop-flags')
    if bool(set(d['conditional'])&set(d['unconditional'])): errors.append('conditional-capability')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'pred_initialized': [], 'joined_initialized': [], 'pred_moved': [], 'joined_moved': [], 'unique_owners': [], 'unique_retained': False, 'returned': [], 'included': [], 'diverged': [], 'origin_sets': [], 'joined_origins': [], 'assigned_everywhere': [], 'restored': [], 'incarnations': [], 'merged_incarnation': None, 'possibly_initialized': [], 'drop_flags': [], 'conditional': [], 'unconditional': []}
check('well formed empty obligations',solve(base),[])
check('definite-meet regression 0', solve(dict(base, **({'pred_initialized':[['a'],[]],'joined_initialized':['a']}))), ['definite-meet'])
check('definite-meet regression 1', solve(dict(base, **({'pred_initialized':[[N,N+1],[N]],'joined_initialized':[N,N+1]}))), ['definite-meet'])
check('possible-move-union regression 0', solve(dict(base, **({'pred_moved':[['a'],[]]}))), ['possible-move-union'])
check('possible-move-union regression 1', solve(dict(base, **({'pred_moved':[[N],[N+1]],'joined_moved':[N]}))), ['possible-move-union'])
check('unique-owner-agreement regression 0', solve(dict(base, **({'unique_retained':True,'unique_owners':['a','b']}))), ['unique-owner-agreement'])
check('unique-owner-agreement regression 1', solve(dict(base, **({'unique_retained':True,'unique_owners':[N,N+1]}))), ['unique-owner-agreement'])
check('returned-path-exclusion regression 0', solve(dict(base, **({'returned':['a'],'included':['a','b']}))), ['returned-path-exclusion'])
check('returned-path-exclusion regression 1', solve(dict(base, **({'returned':[N],'included':[N,N+1]}))), ['returned-path-exclusion'])
check('divergent-bottom regression 0', solve(dict(base, **({'diverged':['a'],'included':['a','b']}))), ['divergent-bottom'])
check('divergent-bottom regression 1', solve(dict(base, **({'diverged':[N],'included':[N,N+1]}))), ['divergent-bottom'])
check('origin-alternative-union regression 0', solve(dict(base, **({'origin_sets':[['a'],['b']],'joined_origins':['a']}))), ['origin-alternative-union'])
check('origin-alternative-union regression 1', solve(dict(base, **({'origin_sets':[[N],[N+1]],'joined_origins':[N]}))), ['origin-alternative-union'])
check('all-path-reinitialization regression 0', solve(dict(base, **({'assigned_everywhere':['a','b'],'restored':['a']}))), ['all-path-reinitialization'])
check('all-path-reinitialization regression 1', solve(dict(base, **({'assigned_everywhere':[N,N+1],'restored':[N]}))), ['all-path-reinitialization'])
check('incarnation-separation regression 0', solve(dict(base, **({'merged_incarnation':N,'incarnations':[N,N+1]}))), ['incarnation-separation'])
check('incarnation-separation regression 1', solve(dict(base, **({'merged_incarnation':'x1','incarnations':['x1','x2']}))), ['incarnation-separation'])
check('conditional-drop-flags regression 0', solve(dict(base, **({'possibly_initialized':['a']}))), ['conditional-drop-flags'])
check('conditional-drop-flags regression 1', solve(dict(base, **({'possibly_initialized':[N,N+1],'drop_flags':[N]}))), ['conditional-drop-flags'])
check('conditional-capability regression 0', solve(dict(base, **({'conditional':['r'],'unconditional':['r']}))), ['conditional-capability'])
check('conditional-capability regression 1', solve(dict(base, **({'conditional':[N],'unconditional':[N]}))), ['conditional-capability'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
well formed empty obligations	`[]`	`[]`	Passed
definite-meet regression 0	`['definite-meet']`	`['definite-meet']`	Passed
definite-meet regression 1	`['definite-meet']`	`['definite-meet']`	Passed
possible-move-union regression 0	`['possible-move-union']`	`['possible-move-union']`	Passed
possible-move-union regression 1	`['possible-move-union']`	`['possible-move-union']`	Passed
unique-owner-agreement regression 0	`['unique-owner-agreement']`	`['unique-owner-agreement']`	Passed
unique-owner-agreement regression 1	`['unique-owner-agreement']`	`['unique-owner-agreement']`	Passed
returned-path-exclusion regression 0	`['returned-path-exclusion']`	`['returned-path-exclusion']`	Passed
returned-path-exclusion regression 1	`['returned-path-exclusion']`	`['returned-path-exclusion']`	Passed
divergent-bottom regression 0	`['divergent-bottom']`	`['divergent-bottom']`	Passed
divergent-bottom regression 1	`['divergent-bottom']`	`['divergent-bottom']`	Passed
origin-alternative-union regression 0	`['origin-alternative-union']`	`['origin-alternative-union']`	Passed
origin-alternative-union regression 1	`['origin-alternative-union']`	`['origin-alternative-union']`	Passed
all-path-reinitialization regression 0	`['all-path-reinitialization']`	`['all-path-reinitialization']`	Passed
all-path-reinitialization regression 1	`['all-path-reinitialization']`	`['all-path-reinitialization']`	Passed
incarnation-separation regression 0	`['incarnation-separation']`	`['incarnation-separation']`	Passed
incarnation-separation regression 1	`['incarnation-separation']`	`['incarnation-separation']`	Passed
conditional-drop-flags regression 0	`[]`	`['conditional-drop-flags']`	Failed
conditional-drop-flags regression 1	`[]`	`['conditional-drop-flags']`	Failed
conditional-capability regression 0	`['conditional-capability']`	`['conditional-capability']`	Passed
conditional-capability regression 1	`['conditional-capability']`	`['conditional-capability']`	Passed

SHA-256 / d10a92ff3a5492d52137e74ef970547b88a061fd73b3f56c57e87aa4315528d5

3 / The verified repair

Exit 0

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(d):
    errors=[]
    if set(d['joined_initialized'])!=(set.intersection(*(set(x) for x in d['pred_initialized'])) if d['pred_initialized'] else set()): errors.append('definite-meet')
    if set(d['joined_moved'])!=set(x for xs in d['pred_moved'] for x in xs): errors.append('possible-move-union')
    if d['unique_retained'] and len(set(d['unique_owners']))!=1: errors.append('unique-owner-agreement')
    if bool(set(d['returned'])&set(d['included'])): errors.append('returned-path-exclusion')
    if bool(set(d['diverged'])&set(d['included'])): errors.append('divergent-bottom')
    if set(d['joined_origins'])!=set(x for xs in d['origin_sets'] for x in xs): errors.append('origin-alternative-union')
    if not set(d['assigned_everywhere'])<=set(d['restored']): errors.append('all-path-reinitialization')
    if d['merged_incarnation'] is not None and any(x!=d['merged_incarnation'] for x in d['incarnations']): errors.append('incarnation-separation')
    if set(d['possibly_initialized'])!=set(d['drop_flags']): errors.append('conditional-drop-flags')
    if bool(set(d['conditional'])&set(d['unconditional'])): errors.append('conditional-capability')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'pred_initialized': [], 'joined_initialized': [], 'pred_moved': [], 'joined_moved': [], 'unique_owners': [], 'unique_retained': False, 'returned': [], 'included': [], 'diverged': [], 'origin_sets': [], 'joined_origins': [], 'assigned_everywhere': [], 'restored': [], 'incarnations': [], 'merged_incarnation': None, 'possibly_initialized': [], 'drop_flags': [], 'conditional': [], 'unconditional': []}
check('well formed empty obligations',solve(base),[])
check('definite-meet regression 0', solve(dict(base, **({'pred_initialized':[['a'],[]],'joined_initialized':['a']}))), ['definite-meet'])
check('definite-meet regression 1', solve(dict(base, **({'pred_initialized':[[N,N+1],[N]],'joined_initialized':[N,N+1]}))), ['definite-meet'])
check('possible-move-union regression 0', solve(dict(base, **({'pred_moved':[['a'],[]]}))), ['possible-move-union'])
check('possible-move-union regression 1', solve(dict(base, **({'pred_moved':[[N],[N+1]],'joined_moved':[N]}))), ['possible-move-union'])
check('unique-owner-agreement regression 0', solve(dict(base, **({'unique_retained':True,'unique_owners':['a','b']}))), ['unique-owner-agreement'])
check('unique-owner-agreement regression 1', solve(dict(base, **({'unique_retained':True,'unique_owners':[N,N+1]}))), ['unique-owner-agreement'])
check('returned-path-exclusion regression 0', solve(dict(base, **({'returned':['a'],'included':['a','b']}))), ['returned-path-exclusion'])
check('returned-path-exclusion regression 1', solve(dict(base, **({'returned':[N],'included':[N,N+1]}))), ['returned-path-exclusion'])
check('divergent-bottom regression 0', solve(dict(base, **({'diverged':['a'],'included':['a','b']}))), ['divergent-bottom'])
check('divergent-bottom regression 1', solve(dict(base, **({'diverged':[N],'included':[N,N+1]}))), ['divergent-bottom'])
check('origin-alternative-union regression 0', solve(dict(base, **({'origin_sets':[['a'],['b']],'joined_origins':['a']}))), ['origin-alternative-union'])
check('origin-alternative-union regression 1', solve(dict(base, **({'origin_sets':[[N],[N+1]],'joined_origins':[N]}))), ['origin-alternative-union'])
check('all-path-reinitialization regression 0', solve(dict(base, **({'assigned_everywhere':['a','b'],'restored':['a']}))), ['all-path-reinitialization'])
check('all-path-reinitialization regression 1', solve(dict(base, **({'assigned_everywhere':[N,N+1],'restored':[N]}))), ['all-path-reinitialization'])
check('incarnation-separation regression 0', solve(dict(base, **({'merged_incarnation':N,'incarnations':[N,N+1]}))), ['incarnation-separation'])
check('incarnation-separation regression 1', solve(dict(base, **({'merged_incarnation':'x1','incarnations':['x1','x2']}))), ['incarnation-separation'])
check('conditional-drop-flags regression 0', solve(dict(base, **({'possibly_initialized':['a']}))), ['conditional-drop-flags'])
check('conditional-drop-flags regression 1', solve(dict(base, **({'possibly_initialized':[N,N+1],'drop_flags':[N]}))), ['conditional-drop-flags'])
check('conditional-capability regression 0', solve(dict(base, **({'conditional':['r'],'unconditional':['r']}))), ['conditional-capability'])
check('conditional-capability regression 1', solve(dict(base, **({'conditional':[N],'unconditional':[N]}))), ['conditional-capability'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
well formed empty obligations	`[]`	`[]`	Passed
definite-meet regression 0	`['definite-meet']`	`['definite-meet']`	Passed
definite-meet regression 1	`['definite-meet']`	`['definite-meet']`	Passed
possible-move-union regression 0	`['possible-move-union']`	`['possible-move-union']`	Passed
possible-move-union regression 1	`['possible-move-union']`	`['possible-move-union']`	Passed
unique-owner-agreement regression 0	`['unique-owner-agreement']`	`['unique-owner-agreement']`	Passed
unique-owner-agreement regression 1	`['unique-owner-agreement']`	`['unique-owner-agreement']`	Passed
returned-path-exclusion regression 0	`['returned-path-exclusion']`	`['returned-path-exclusion']`	Passed
returned-path-exclusion regression 1	`['returned-path-exclusion']`	`['returned-path-exclusion']`	Passed
divergent-bottom regression 0	`['divergent-bottom']`	`['divergent-bottom']`	Passed
divergent-bottom regression 1	`['divergent-bottom']`	`['divergent-bottom']`	Passed
origin-alternative-union regression 0	`['origin-alternative-union']`	`['origin-alternative-union']`	Passed
origin-alternative-union regression 1	`['origin-alternative-union']`	`['origin-alternative-union']`	Passed
all-path-reinitialization regression 0	`['all-path-reinitialization']`	`['all-path-reinitialization']`	Passed
all-path-reinitialization regression 1	`['all-path-reinitialization']`	`['all-path-reinitialization']`	Passed
incarnation-separation regression 0	`['incarnation-separation']`	`['incarnation-separation']`	Passed
incarnation-separation regression 1	`['incarnation-separation']`	`['incarnation-separation']`	Passed
conditional-drop-flags regression 0	`['conditional-drop-flags']`	`['conditional-drop-flags']`	Passed
conditional-drop-flags regression 1	`['conditional-drop-flags']`	`['conditional-drop-flags']`	Passed
conditional-capability regression 0	`['conditional-capability']`	`['conditional-capability']`	Passed
conditional-capability regression 1	`['conditional-capability']`	`['conditional-capability']`	Passed

SHA-256 / 5727fce25b41fc17e0d4a6591835f5020589530dc5ebd4682845d2d1c7f8b429

Verification & scope

The explicitly stated toy language is the complete scope; this is not a production compiler or a claim about Rust semantics. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:44:08.567282+00:00.

Case digest / b03818929bcff9a72ef1fb09f13a327382136160869702b4111320928df041e5