@suss/resolution 0.28.0 → 0.30.0

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   calleeOutcomeOf: () => calleeOutcomeOf,
   calleeOutcomes: () => calleeOutcomes,
   checkFactContract: () => checkFactContract,
+  couldBeSettled: () => couldBeSettled,
   explainResolutionProof: () => explainResolutionProof,
   explainResolvedKey: () => explainResolvedKey,
   joinMountedPath: () => joinMountedPath,
@@ -152,6 +153,9 @@ function askAboutSources(db, keys, program) {
     wave = next;
   }
 }
+function couldBeSettled(db, key) {
+  return db.has("func", [key]) || db.has("objectValue", [key]) || sourcesOf(db, key).length > 0;
+}
 function sourcesOf(db, key) {
   const base = db.lookup("readsProperty", 0, key)[0];
   if (base !== void 0) {
@@ -584,6 +588,38 @@ var DEFAULT_PHRASES = {
       ]
     };
   },
+  "declared finder": ({ tuple, premises, describe }) => {
+    const method = String(premises[1].tuple[2]);
+    const base = String(premises[4].tuple[0]);
+    return {
+      reason: `${describe(tuple[0])} calls ${method} on ${describe(tuple[1])}, which gives back one of it`,
+      assumptions: [
+        `a pack declares that ${method} on a class extending ${base} gives back one of that class`
+      ]
+    };
+  },
+  "declared argument finder": ({ tuple, premises, describe }) => {
+    const method = String(premises[1].tuple[2]);
+    const position = String(premises[2].tuple[1]);
+    const base = String(premises[3].tuple[0]);
+    return {
+      reason: `${describe(tuple[0])} calls ${method} with ${describe(tuple[1])} at argument ${position}, which gives back one of it`,
+      assumptions: [
+        `a pack declares that ${method} with a class extending ${base} at argument ${position} gives back one of that class`
+      ]
+    };
+  },
+  "declared import finder": ({ tuple, premises, describe }) => {
+    const module2 = String(premises[1].tuple[1]);
+    const name = String(premises[1].tuple[2]);
+    const position = String(premises[2].tuple[2]);
+    return {
+      reason: `${describe(tuple[0])} calls ${name} from ${module2} with ${describe(tuple[1])} at argument ${position}, which gives back one of it`,
+      assumptions: [
+        `a pack declares that ${name} from ${module2} gives back one of the class at argument ${position}`
+      ]
+    };
+  },
   "call result": ({ tuple, premises, describe, inline }) => {
     const invokes = premises[0];
     const invoked = invokes.tuple[1];
@@ -1070,6 +1106,57 @@ var RESOLUTION_RULES = [
     ],
     "class instance"
   ),
+  // A finder the library declares, keyed on the base a pack named so a
+  // project class with a method of the same name on another hierarchy is
+  // left alone. The DESIGN says what a chain of them composes into.
+  (0, import_datalog4.rule)(
+    "stepsTo",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), VALUE_STEP],
+    [
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("m")),
+      (0, import_datalog4.lit)("objectOf", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("cls")),
+      // Before `libraryBase`, so the demand rewrite asks it with the base
+      // bound and walks an ancestry only for a method a pack declared.
+      (0, import_datalog4.lit)("givesBackOne", (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m")),
+      (0, import_datalog4.lit)("libraryBase", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"))
+    ],
+    "declared finder"
+  ),
+  // The same word, for a library that takes the class as an argument
+  // instead of as the receiver. The argument having to reach the base a
+  // pack named is what keeps an unrelated `get` out.
+  (0, import_datalog4.rule)(
+    "stepsTo",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), VALUE_STEP],
+    [
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("m")),
+      (0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("a")),
+      // Before `libraryBase`, so the demand rewrite asks it with the base
+      // bound and walks an ancestry only for a method a pack declared.
+      (0, import_datalog4.lit)("givesBackOneOfArgument", (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("k")),
+      (0, import_datalog4.lit)("objectOf", (0, import_datalog4.variable)("a"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("libraryBase", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"))
+    ],
+    "declared argument finder"
+  ),
+  // The same again for a function called on its own rather than read off
+  // anything, keyed on the module it was imported from so a project
+  // function spelled the same way is not mistaken for it.
+  (0, import_datalog4.rule)(
+    "stepsTo",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), VALUE_STEP],
+    [
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("comesFrom", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("mod"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("givesBackOneOfImport", (0, import_datalog4.variable)("mod"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("k")),
+      (0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("a")),
+      (0, import_datalog4.lit)("objectOf", (0, import_datalog4.variable)("a"), (0, import_datalog4.variable)("cls"))
+    ],
+    "declared import finder"
+  ),
   // Wrapper transparency, derived: calling a factory that returns a
   // function which calls its parameter k steps to argument k.
   (0, import_datalog4.rule)(
@@ -1343,6 +1430,54 @@ var RESOLUTION_RULES = [
       (0, import_datalog4.lit)("contains", (0, import_datalog4.variable)("baseCls"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held"))
     ]
   ),
+  // An association is read off an instance as a property, and stating
+  // it as `contains` is what puts it on the ancestry rule, so a concern
+  // or a base class can be the one that declares it.
+  (0, import_datalog4.rule)(
+    "contains",
+    [(0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("t")],
+    [(0, import_datalog4.lit)("declaresAssociation", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("t"))],
+    "declared association"
+  ),
+  // The same, for a language that buries the declaration in an ordinary
+  // assignment. Keying on the module the callable came from is what
+  // keeps a project function spelled the same way out.
+  (0, import_datalog4.rule)(
+    "contains",
+    [(0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("t")],
+    [
+      (0, import_datalog4.lit)("fieldCall", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("t")),
+      (0, import_datalog4.lit)("comesFrom", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("name")),
+      (0, import_datalog4.lit)("associationConstructor", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("name"))
+    ],
+    "constructed association"
+  ),
+  // The library base a class's ancestry arrives at, however many of a
+  // project's own classes sit in between. A base the run declares has a
+  // node to keep walking from; one it does not has only a name.
+  (0, import_datalog4.rule)("libraryBase", [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")], [(0, import_datalog4.lit)("extendsNamed", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n"))]),
+  (0, import_datalog4.rule)(
+    "libraryBase",
+    [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")],
+    [
+      (0, import_datalog4.lit)("extends", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("x")),
+      (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("b")),
+      (0, import_datalog4.lit)("libraryBase", (0, import_datalog4.variable)("b"), (0, import_datalog4.variable)("n"))
+    ]
+  ),
+  // A base a library hands back from a call rather than exporting as a
+  // class, SQLAlchemy's `Base = declarative_base()`. The walk stops at
+  // the call, so the function it called is the name to match on.
+  (0, import_datalog4.rule)(
+    "libraryBase",
+    [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")],
+    [
+      (0, import_datalog4.lit)("extends", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("x")),
+      (0, import_datalog4.lit)("isWrittenAs", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("r")),
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cc")),
+      (0, import_datalog4.lit)("comesFrom", (0, import_datalog4.variable)("cc"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))
+    ]
+  ),
   // Which function a factory returns, and which of its parameters that
   // function calls: together they are what makes it a wrapper.
   (0, import_datalog4.rule)(
@@ -1691,6 +1826,25 @@ var RESOLUTION_QUESTIONS = [
     [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")],
     [(0, import_datalog4.lit)("ancestryChain", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("b")), (0, import_datalog4.lit)("extendsNamed", (0, import_datalog4.variable)("b"), (0, import_datalog4.variable)("n"))]
   ),
+  // Each method the same chain declares, so a caller that settled a
+  // receiver on a class can tell a method the project writes itself
+  // from one only the library provides.
+  (0, import_datalog4.rule)(
+    "wantedDeclaredName",
+    [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")],
+    [
+      (0, import_datalog4.lit)("ancestryChain", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("b")),
+      (0, import_datalog4.lit)("holdsProperty", (0, import_datalog4.variable)("b"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held"))
+    ]
+  ),
+  // A method the class gets under a name the source computes rather than
+  // writes out. The adapter settles the name against the same facts and
+  // says so, and the chain reports it beside the ones written out.
+  (0, import_datalog4.rule)(
+    "wantedDeclaredName",
+    [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")],
+    [(0, import_datalog4.lit)("ancestryChain", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("b")), (0, import_datalog4.lit)("declaresName", (0, import_datalog4.variable)("b"), (0, import_datalog4.variable)("n"))]
+  ),
   (0, import_datalog4.rule)("anchorChain", [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("wantedAnchor", (0, import_datalog4.variable)("x"))]),
   (0, import_datalog4.rule)(
     "anchorChain",
@@ -1754,6 +1908,7 @@ var ANSWER_RELATIONS = [
   calleeOutcomeOf,
   calleeOutcomes,
   checkFactContract,
+  couldBeSettled,
   explainResolutionProof,
   explainResolvedKey,
   joinMountedPath,

package/dist/index.d.cts

@@ -58,6 +58,14 @@ type CalleeOutcome =
 declare function calleeOutcomes(db: Database, keys: readonly string[], program?: OnDemandRules): Map<string, CalleeOutcome>;
 /** What one callee is, for a caller with a single key in hand. */
 declare function calleeOutcomeOf(db: Database, key: string, program?: OnDemandRules): CalleeOutcome;
+/**
+ * Whether this run says anything at all about the key: it is a value
+ * itself, or something built it. A key that fails this settles on
+ * nothing, and asking anyway adds a `wanted` fact that every later
+ * question has to derive over, so a caller with a batch of keys and a
+ * cheap question about each one puts this in front of the batch.
+ */
+declare function couldBeSettled(db: Database, key: string): boolean;
 declare function writtenSourcesOf(db: Database, key: string): string[];
 
 /** The tuples of one relation, as strings, which is all a case compares. */
@@ -531,4 +539,4 @@ declare const RESOLUTION_QUESTIONS: _suss_datalog.Rule[];
 /** The relations `RESOLUTION_QUESTIONS` answers into. */
 declare const ANSWER_RELATIONS: string[];
 
-export { ANSWER_RELATIONS, ASKING_RELATIONS, type CalleeOutcome, type CaseFiles, type ChainReads, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, type ExplainResolvedKeyOptions, type ExplainStats, FACT_CONTRACT_CASES, type FactsOf, type MountEdge, type MountEdges, NAMESPACE_IMPORT, NAMESPACE_IMPORT_NAME, type NameReads, type NameWrite, type OrderedWrite, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ReadNode, type ResolutionExplanation, type ResolutionStep, type SpannedNode, type StepContext, type StepPhrase, VALUE_STEP, type ValueLocation, type WhyExplained, agreedMountPrefix, askResolution, calleeOutcomeOf, calleeOutcomes, checkFactContract, explainResolutionProof, explainResolvedKey, joinMountedPath, mountPathsOf, nodeOfKey, placeholderValues, queryFacts, renderExplanation, resolutionProgram, singleAnswers, startsAtName, valueLeftByWrites, writesRunInOrder, writtenSourcesOf, writtenValueOf };
+export { ANSWER_RELATIONS, ASKING_RELATIONS, type CalleeOutcome, type CaseFiles, type ChainReads, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, type ExplainResolvedKeyOptions, type ExplainStats, FACT_CONTRACT_CASES, type FactsOf, type MountEdge, type MountEdges, NAMESPACE_IMPORT, NAMESPACE_IMPORT_NAME, type NameReads, type NameWrite, type OrderedWrite, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ReadNode, type ResolutionExplanation, type ResolutionStep, type SpannedNode, type StepContext, type StepPhrase, VALUE_STEP, type ValueLocation, type WhyExplained, agreedMountPrefix, askResolution, calleeOutcomeOf, calleeOutcomes, checkFactContract, couldBeSettled, explainResolutionProof, explainResolvedKey, joinMountedPath, mountPathsOf, nodeOfKey, placeholderValues, queryFacts, renderExplanation, resolutionProgram, singleAnswers, startsAtName, valueLeftByWrites, writesRunInOrder, writtenSourcesOf, writtenValueOf };

package/dist/index.d.ts

@@ -58,6 +58,14 @@ type CalleeOutcome =
 declare function calleeOutcomes(db: Database, keys: readonly string[], program?: OnDemandRules): Map<string, CalleeOutcome>;
 /** What one callee is, for a caller with a single key in hand. */
 declare function calleeOutcomeOf(db: Database, key: string, program?: OnDemandRules): CalleeOutcome;
+/**
+ * Whether this run says anything at all about the key: it is a value
+ * itself, or something built it. A key that fails this settles on
+ * nothing, and asking anyway adds a `wanted` fact that every later
+ * question has to derive over, so a caller with a batch of keys and a
+ * cheap question about each one puts this in front of the batch.
+ */
+declare function couldBeSettled(db: Database, key: string): boolean;
 declare function writtenSourcesOf(db: Database, key: string): string[];
 
 /** The tuples of one relation, as strings, which is all a case compares. */
@@ -531,4 +539,4 @@ declare const RESOLUTION_QUESTIONS: _suss_datalog.Rule[];
 /** The relations `RESOLUTION_QUESTIONS` answers into. */
 declare const ANSWER_RELATIONS: string[];
 
-export { ANSWER_RELATIONS, ASKING_RELATIONS, type CalleeOutcome, type CaseFiles, type ChainReads, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, type ExplainResolvedKeyOptions, type ExplainStats, FACT_CONTRACT_CASES, type FactsOf, type MountEdge, type MountEdges, NAMESPACE_IMPORT, NAMESPACE_IMPORT_NAME, type NameReads, type NameWrite, type OrderedWrite, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ReadNode, type ResolutionExplanation, type ResolutionStep, type SpannedNode, type StepContext, type StepPhrase, VALUE_STEP, type ValueLocation, type WhyExplained, agreedMountPrefix, askResolution, calleeOutcomeOf, calleeOutcomes, checkFactContract, explainResolutionProof, explainResolvedKey, joinMountedPath, mountPathsOf, nodeOfKey, placeholderValues, queryFacts, renderExplanation, resolutionProgram, singleAnswers, startsAtName, valueLeftByWrites, writesRunInOrder, writtenSourcesOf, writtenValueOf };
+export { ANSWER_RELATIONS, ASKING_RELATIONS, type CalleeOutcome, type CaseFiles, type ChainReads, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, type ExplainResolvedKeyOptions, type ExplainStats, FACT_CONTRACT_CASES, type FactsOf, type MountEdge, type MountEdges, NAMESPACE_IMPORT, NAMESPACE_IMPORT_NAME, type NameReads, type NameWrite, type OrderedWrite, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ReadNode, type ResolutionExplanation, type ResolutionStep, type SpannedNode, type StepContext, type StepPhrase, VALUE_STEP, type ValueLocation, type WhyExplained, agreedMountPrefix, askResolution, calleeOutcomeOf, calleeOutcomes, checkFactContract, couldBeSettled, explainResolutionProof, explainResolvedKey, joinMountedPath, mountPathsOf, nodeOfKey, placeholderValues, queryFacts, renderExplanation, resolutionProgram, singleAnswers, startsAtName, valueLeftByWrites, writesRunInOrder, writtenSourcesOf, writtenValueOf };

package/dist/index.js

@@ -98,6 +98,9 @@ function askAboutSources(db, keys, program) {
     wave = next;
   }
 }
+function couldBeSettled(db, key) {
+  return db.has("func", [key]) || db.has("objectValue", [key]) || sourcesOf(db, key).length > 0;
+}
 function sourcesOf(db, key) {
   const base = db.lookup("readsProperty", 0, key)[0];
   if (base !== void 0) {
@@ -530,6 +533,38 @@ var DEFAULT_PHRASES = {
       ]
     };
   },
+  "declared finder": ({ tuple, premises, describe }) => {
+    const method = String(premises[1].tuple[2]);
+    const base = String(premises[4].tuple[0]);
+    return {
+      reason: `${describe(tuple[0])} calls ${method} on ${describe(tuple[1])}, which gives back one of it`,
+      assumptions: [
+        `a pack declares that ${method} on a class extending ${base} gives back one of that class`
+      ]
+    };
+  },
+  "declared argument finder": ({ tuple, premises, describe }) => {
+    const method = String(premises[1].tuple[2]);
+    const position = String(premises[2].tuple[1]);
+    const base = String(premises[3].tuple[0]);
+    return {
+      reason: `${describe(tuple[0])} calls ${method} with ${describe(tuple[1])} at argument ${position}, which gives back one of it`,
+      assumptions: [
+        `a pack declares that ${method} with a class extending ${base} at argument ${position} gives back one of that class`
+      ]
+    };
+  },
+  "declared import finder": ({ tuple, premises, describe }) => {
+    const module = String(premises[1].tuple[1]);
+    const name = String(premises[1].tuple[2]);
+    const position = String(premises[2].tuple[2]);
+    return {
+      reason: `${describe(tuple[0])} calls ${name} from ${module} with ${describe(tuple[1])} at argument ${position}, which gives back one of it`,
+      assumptions: [
+        `a pack declares that ${name} from ${module} gives back one of the class at argument ${position}`
+      ]
+    };
+  },
   "call result": ({ tuple, premises, describe, inline }) => {
     const invokes = premises[0];
     const invoked = invokes.tuple[1];
@@ -1016,6 +1051,57 @@ var RESOLUTION_RULES = [
     ],
     "class instance"
   ),
+  // A finder the library declares, keyed on the base a pack named so a
+  // project class with a method of the same name on another hierarchy is
+  // left alone. The DESIGN says what a chain of them composes into.
+  rule(
+    "stepsTo",
+    [v("r"), v("cls"), VALUE_STEP],
+    [
+      lit("call", v("r"), v("c")),
+      lit("readsProperty", v("c"), v("o"), v("m")),
+      lit("objectOf", v("o"), v("cls")),
+      lit("objectValue", v("cls")),
+      // Before `libraryBase`, so the demand rewrite asks it with the base
+      // bound and walks an ancestry only for a method a pack declared.
+      lit("givesBackOne", v("n"), v("m")),
+      lit("libraryBase", v("cls"), v("n"))
+    ],
+    "declared finder"
+  ),
+  // The same word, for a library that takes the class as an argument
+  // instead of as the receiver. The argument having to reach the base a
+  // pack named is what keeps an unrelated `get` out.
+  rule(
+    "stepsTo",
+    [v("r"), v("cls"), VALUE_STEP],
+    [
+      lit("call", v("r"), v("c")),
+      lit("readsProperty", v("c"), v("o"), v("m")),
+      lit("callArg", v("r"), v("k"), v("a")),
+      // Before `libraryBase`, so the demand rewrite asks it with the base
+      // bound and walks an ancestry only for a method a pack declared.
+      lit("givesBackOneOfArgument", v("n"), v("m"), v("k")),
+      lit("objectOf", v("a"), v("cls")),
+      lit("libraryBase", v("cls"), v("n"))
+    ],
+    "declared argument finder"
+  ),
+  // The same again for a function called on its own rather than read off
+  // anything, keyed on the module it was imported from so a project
+  // function spelled the same way is not mistaken for it.
+  rule(
+    "stepsTo",
+    [v("r"), v("cls"), VALUE_STEP],
+    [
+      lit("call", v("r"), v("c")),
+      lit("comesFrom", v("c"), v("mod"), v("n")),
+      lit("givesBackOneOfImport", v("mod"), v("n"), v("k")),
+      lit("callArg", v("r"), v("k"), v("a")),
+      lit("objectOf", v("a"), v("cls"))
+    ],
+    "declared import finder"
+  ),
   // Wrapper transparency, derived: calling a factory that returns a
   // function which calls its parameter k steps to argument k.
   rule(
@@ -1289,6 +1375,54 @@ var RESOLUTION_RULES = [
       lit("contains", v("baseCls"), v("n"), v("held"))
     ]
   ),
+  // An association is read off an instance as a property, and stating
+  // it as `contains` is what puts it on the ancestry rule, so a concern
+  // or a base class can be the one that declares it.
+  rule(
+    "contains",
+    [v("cls"), v("n"), v("t")],
+    [lit("declaresAssociation", v("cls"), v("n"), v("t"))],
+    "declared association"
+  ),
+  // The same, for a language that buries the declaration in an ordinary
+  // assignment. Keying on the module the callable came from is what
+  // keeps a project function spelled the same way out.
+  rule(
+    "contains",
+    [v("cls"), v("n"), v("t")],
+    [
+      lit("fieldCall", v("cls"), v("n"), v("c"), v("t")),
+      lit("comesFrom", v("c"), v("m"), v("name")),
+      lit("associationConstructor", v("m"), v("name"))
+    ],
+    "constructed association"
+  ),
+  // The library base a class's ancestry arrives at, however many of a
+  // project's own classes sit in between. A base the run declares has a
+  // node to keep walking from; one it does not has only a name.
+  rule("libraryBase", [v("c"), v("n")], [lit("extendsNamed", v("c"), v("n"))]),
+  rule(
+    "libraryBase",
+    [v("c"), v("n")],
+    [
+      lit("extends", v("c"), v("x")),
+      lit("comesTo", v("x"), v("b")),
+      lit("libraryBase", v("b"), v("n"))
+    ]
+  ),
+  // A base a library hands back from a call rather than exporting as a
+  // class, SQLAlchemy's `Base = declarative_base()`. The walk stops at
+  // the call, so the function it called is the name to match on.
+  rule(
+    "libraryBase",
+    [v("c"), v("n")],
+    [
+      lit("extends", v("c"), v("x")),
+      lit("isWrittenAs", v("x"), v("r")),
+      lit("call", v("r"), v("cc")),
+      lit("comesFrom", v("cc"), v("m"), v("n"))
+    ]
+  ),
   // Which function a factory returns, and which of its parameters that
   // function calls: together they are what makes it a wrapper.
   rule(
@@ -1637,6 +1771,25 @@ var RESOLUTION_QUESTIONS = [
     [v("c"), v("n")],
     [lit("ancestryChain", v("c"), v("b")), lit("extendsNamed", v("b"), v("n"))]
   ),
+  // Each method the same chain declares, so a caller that settled a
+  // receiver on a class can tell a method the project writes itself
+  // from one only the library provides.
+  rule(
+    "wantedDeclaredName",
+    [v("c"), v("n")],
+    [
+      lit("ancestryChain", v("c"), v("b")),
+      lit("holdsProperty", v("b"), v("n"), v("held"))
+    ]
+  ),
+  // A method the class gets under a name the source computes rather than
+  // writes out. The adapter settles the name against the same facts and
+  // says so, and the chain reports it beside the ones written out.
+  rule(
+    "wantedDeclaredName",
+    [v("c"), v("n")],
+    [lit("ancestryChain", v("c"), v("b")), lit("declaresName", v("b"), v("n"))]
+  ),
   rule("anchorChain", [v("x"), v("x")], [lit("wantedAnchor", v("x"))]),
   rule(
     "anchorChain",
@@ -1699,6 +1852,7 @@ export {
   calleeOutcomeOf,
   calleeOutcomes,
   checkFactContract,
+  couldBeSettled,
   explainResolutionProof,
   explainResolvedKey,
   joinMountedPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/resolution",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "type": "module",
   "description": "The rules suss uses to follow a name in TypeScript, Python or Ruby to the function it comes down to.",
   "keywords": [
@@ -56,6 +56,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@suss/datalog": "0.28.0"
+    "@suss/datalog": "0.30.0"
   }
 }