@codeperfect/eslint-plugin 1.0.0 → 2.1.0

package/dist/domain/testing/enforce-aaa-phase-purity/pattern-identifiers.js

@@ -0,0 +1,134 @@
+/**
+ * Collects identifiers from an array pattern.
+ * @param pattern Array pattern to inspect.
+ * @param identifiers Identifier set updated in place.
+ * @example
+ * ```typescript
+ * collectArrayPatternIdentifiers({ elements: [], type: "ArrayPattern" }, new Set<string>());
+ * ```
+ */
+function collectArrayPatternIdentifiers(pattern, identifiers) {
+    const elements = pattern.elements;
+    for (const element of elements) {
+        if (element !== null && element !== void 0) {
+            collectPatternIdentifiers(element, identifiers);
+        }
+    }
+}
+/**
+ * Collects identifiers from an assignment pattern.
+ * @param pattern Assignment pattern to inspect.
+ * @param identifiers Identifier set updated in place.
+ * @example
+ * ```typescript
+ * collectAssignmentPatternIdentifiers({ left: { name: "value", type: "Identifier" }, right: { name: "fallback", type: "Identifier" }, type: "AssignmentPattern" } as ESTree.AssignmentPattern, new Set<string>());
+ * ```
+ */
+function collectAssignmentPatternIdentifiers(pattern, identifiers) {
+    collectPatternIdentifiers(pattern.left, identifiers);
+}
+/**
+ * Collects identifiers from a plain identifier pattern.
+ * @param pattern Identifier pattern to inspect.
+ * @param identifiers Identifier set updated in place.
+ * @example
+ * ```typescript
+ * collectIdentifierPatternIdentifiers({ name: "value", type: "Identifier" }, new Set<string>());
+ * ```
+ */
+function collectIdentifierPatternIdentifiers(pattern, identifiers) {
+    identifiers.add(pattern.name);
+}
+/**
+ * Collects identifiers from an object pattern.
+ * @param pattern Object pattern to inspect.
+ * @param identifiers Identifier set updated in place.
+ * @example
+ * ```typescript
+ * collectObjectPatternIdentifiers({ properties: [], type: "ObjectPattern" }, new Set<string>());
+ * ```
+ */
+function collectObjectPatternIdentifiers(pattern, identifiers) {
+    for (const property of pattern.properties) {
+        if (property.type === "Property") {
+            collectPatternIdentifiers(property.value, identifiers);
+        }
+        else {
+            collectPatternIdentifiers(property.argument, identifiers);
+        }
+    }
+}
+/**
+ * Collects all identifier names declared by a destructuring or identifier pattern.
+ * @param pattern Pattern node to inspect.
+ * @param identifiers Identifier set updated in place.
+ * @example
+ * ```typescript
+ * collectPatternIdentifiers({ name: "value", type: "Identifier" }, new Set<string>());
+ * ```
+ */
+function collectPatternIdentifiers(pattern, identifiers) {
+    getPatternIdentifierCollector(pattern)(pattern, identifiers);
+}
+/**
+ * Collects identifiers from a rest element pattern.
+ * @param pattern Rest element to inspect.
+ * @param identifiers Identifier set updated in place.
+ * @example
+ * ```typescript
+ * collectRestPatternIdentifiers({ argument: { name: "value", type: "Identifier" }, type: "RestElement" }, new Set<string>());
+ * ```
+ */
+function collectRestPatternIdentifiers(pattern, identifiers) {
+    collectPatternIdentifiers(pattern.argument, identifiers);
+}
+/**
+ * Ignores pattern kinds that do not declare identifiers.
+ * @param pattern Pattern to ignore.
+ * @param identifiers Identifier set left unchanged.
+ * @example
+ * ```typescript
+ * collectUnsupportedPatternIdentifiers({ object: { name: "value", type: "Identifier" }, property: { name: "member", type: "Identifier" }, computed: false, optional: false, type: "MemberExpression" }, new Set<string>());
+ * ```
+ */
+function collectUnsupportedPatternIdentifiers(pattern, identifiers) {
+    void pattern;
+    void identifiers;
+}
+/**
+ * Gets the identifier collector for one supported pattern kind.
+ * @param pattern Pattern whose collector is needed.
+ * @returns Collector for the pattern, when one exists.
+ * @example
+ * ```typescript
+ * const collector = getPatternIdentifierCollector({ name: "value", type: "Identifier" });
+ * void collector;
+ * ```
+ */
+function getPatternIdentifierCollector(pattern) {
+    switch (pattern.type) {
+        case "ArrayPattern": {
+            return collectArrayPatternIdentifiers;
+        }
+        case "AssignmentPattern": {
+            return collectAssignmentPatternIdentifiers;
+        }
+        case "Identifier": {
+            return collectIdentifierPatternIdentifiers;
+        }
+        case "MemberExpression": {
+            return collectUnsupportedPatternIdentifiers;
+        }
+        case "ObjectPattern": {
+            return collectObjectPatternIdentifiers;
+        }
+        case "RestElement": {
+            return collectRestPatternIdentifiers;
+        }
+        default: {
+            return collectUnsupportedPatternIdentifiers;
+        }
+    }
+}
+export { collectPatternIdentifiers };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pattern-identifiers.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/pattern-identifiers.ts"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH,SAAS,8BAA8B,CACrC,OAAuB,EACvB,WAAwB;IAExB,MAAM,QAAQ,GAAI,OAA+B,CAAC,QAI/C,CAAC;IAEJ,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,CAAC,EAAE,CAAC;YAC3C,yBAAyB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,mCAAmC,CAC1C,OAAuB,EACvB,WAAwB;IAExB,yBAAyB,CACtB,OAAoC,CAAC,IAAI,EAC1C,WAAW,CACZ,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,mCAAmC,CAC1C,OAAuB,EACvB,WAAwB;IAExB,WAAW,CAAC,GAAG,CAAE,OAA6B,CAAC,IAAI,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,+BAA+B,CACtC,OAAuB,EACvB,WAAwB;IAExB,KAAK,MAAM,QAAQ,IAAK,OAAgC,CAAC,UAAU,EAAE,CAAC;QACpE,IAAI,QAAQ,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YACjC,yBAAyB,CAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QACzD,CAAC;aAAM,CAAC;YACN,yBAAyB,CAAC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,yBAAyB,CAChC,OAAuB,EACvB,WAAwB;IAExB,6BAA6B,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,6BAA6B,CACpC,OAAuB,EACvB,WAAwB;IAExB,yBAAyB,CACtB,OAA8B,CAAC,QAAQ,EACxC,WAAW,CACZ,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,oCAAoC,CAC3C,OAAuB,EACvB,WAAwB;IAExB,KAAK,OAAO,CAAC;IACb,KAAK,WAAW,CAAC;AACnB,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,6BAA6B,CACpC,OAAuB;IAEvB,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;QACrB,KAAK,cAAc,CAAC,CAAC,CAAC;YACpB,OAAO,8BAA8B,CAAC;QACxC,CAAC;QACD,KAAK,mBAAmB,CAAC,CAAC,CAAC;YACzB,OAAO,mCAAmC,CAAC;QAC7C,CAAC;QACD,KAAK,YAAY,CAAC,CAAC,CAAC;YAClB,OAAO,mCAAmC,CAAC;QAC7C,CAAC;QACD,KAAK,kBAAkB,CAAC,CAAC,CAAC;YACxB,OAAO,oCAAoC,CAAC;QAC9C,CAAC;QACD,KAAK,eAAe,CAAC,CAAC,CAAC;YACrB,OAAO,+BAA+B,CAAC;QACzC,CAAC;QACD,KAAK,aAAa,CAAC,CAAC,CAAC;YACnB,OAAO,6BAA6B,CAAC;QACvC,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACR,OAAO,oCAAoC,CAAC;QAC9C,CAAC;IACH,CAAC;AACH,CAAC;AAED,OAAO,EAAE,yBAAyB,EAAE,CAAC","sourcesContent":["import type * as ESTree from \"estree\";\r\n\r\n/** Function signature for pattern identifier collectors. */\r\ntype PatternIdentifierCollector = (\r\n  pattern: ESTree.Pattern,\r\n  identifiers: Set<string>,\r\n) => void;\r\n\r\n/**\r\n * Collects identifiers from an array pattern.\r\n * @param pattern Array pattern to inspect.\r\n * @param identifiers Identifier set updated in place.\r\n * @example\r\n * ```typescript\r\n * collectArrayPatternIdentifiers({ elements: [], type: \"ArrayPattern\" }, new Set<string>());\r\n * ```\r\n */\r\nfunction collectArrayPatternIdentifiers(\r\n  pattern: ESTree.Pattern,\r\n  identifiers: Set<string>,\r\n): void {\r\n  const elements = (pattern as ESTree.ArrayPattern).elements as (\r\n    | ESTree.Pattern\r\n    | null\r\n    | undefined\r\n  )[];\r\n\r\n  for (const element of elements) {\r\n    if (element !== null && element !== void 0) {\r\n      collectPatternIdentifiers(element, identifiers);\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Collects identifiers from an assignment pattern.\r\n * @param pattern Assignment pattern to inspect.\r\n * @param identifiers Identifier set updated in place.\r\n * @example\r\n * ```typescript\r\n * collectAssignmentPatternIdentifiers({ left: { name: \"value\", type: \"Identifier\" }, right: { name: \"fallback\", type: \"Identifier\" }, type: \"AssignmentPattern\" } as ESTree.AssignmentPattern, new Set<string>());\r\n * ```\r\n */\r\nfunction collectAssignmentPatternIdentifiers(\r\n  pattern: ESTree.Pattern,\r\n  identifiers: Set<string>,\r\n): void {\r\n  collectPatternIdentifiers(\r\n    (pattern as ESTree.AssignmentPattern).left,\r\n    identifiers,\r\n  );\r\n}\r\n\r\n/**\r\n * Collects identifiers from a plain identifier pattern.\r\n * @param pattern Identifier pattern to inspect.\r\n * @param identifiers Identifier set updated in place.\r\n * @example\r\n * ```typescript\r\n * collectIdentifierPatternIdentifiers({ name: \"value\", type: \"Identifier\" }, new Set<string>());\r\n * ```\r\n */\r\nfunction collectIdentifierPatternIdentifiers(\r\n  pattern: ESTree.Pattern,\r\n  identifiers: Set<string>,\r\n): void {\r\n  identifiers.add((pattern as ESTree.Identifier).name);\r\n}\r\n\r\n/**\r\n * Collects identifiers from an object pattern.\r\n * @param pattern Object pattern to inspect.\r\n * @param identifiers Identifier set updated in place.\r\n * @example\r\n * ```typescript\r\n * collectObjectPatternIdentifiers({ properties: [], type: \"ObjectPattern\" }, new Set<string>());\r\n * ```\r\n */\r\nfunction collectObjectPatternIdentifiers(\r\n  pattern: ESTree.Pattern,\r\n  identifiers: Set<string>,\r\n): void {\r\n  for (const property of (pattern as ESTree.ObjectPattern).properties) {\r\n    if (property.type === \"Property\") {\r\n      collectPatternIdentifiers(property.value, identifiers);\r\n    } else {\r\n      collectPatternIdentifiers(property.argument, identifiers);\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Collects all identifier names declared by a destructuring or identifier pattern.\r\n * @param pattern Pattern node to inspect.\r\n * @param identifiers Identifier set updated in place.\r\n * @example\r\n * ```typescript\r\n * collectPatternIdentifiers({ name: \"value\", type: \"Identifier\" }, new Set<string>());\r\n * ```\r\n */\r\nfunction collectPatternIdentifiers(\r\n  pattern: ESTree.Pattern,\r\n  identifiers: Set<string>,\r\n): void {\r\n  getPatternIdentifierCollector(pattern)(pattern, identifiers);\r\n}\r\n\r\n/**\r\n * Collects identifiers from a rest element pattern.\r\n * @param pattern Rest element to inspect.\r\n * @param identifiers Identifier set updated in place.\r\n * @example\r\n * ```typescript\r\n * collectRestPatternIdentifiers({ argument: { name: \"value\", type: \"Identifier\" }, type: \"RestElement\" }, new Set<string>());\r\n * ```\r\n */\r\nfunction collectRestPatternIdentifiers(\r\n  pattern: ESTree.Pattern,\r\n  identifiers: Set<string>,\r\n): void {\r\n  collectPatternIdentifiers(\r\n    (pattern as ESTree.RestElement).argument,\r\n    identifiers,\r\n  );\r\n}\r\n\r\n/**\r\n * Ignores pattern kinds that do not declare identifiers.\r\n * @param pattern Pattern to ignore.\r\n * @param identifiers Identifier set left unchanged.\r\n * @example\r\n * ```typescript\r\n * collectUnsupportedPatternIdentifiers({ object: { name: \"value\", type: \"Identifier\" }, property: { name: \"member\", type: \"Identifier\" }, computed: false, optional: false, type: \"MemberExpression\" }, new Set<string>());\r\n * ```\r\n */\r\nfunction collectUnsupportedPatternIdentifiers(\r\n  pattern: ESTree.Pattern,\r\n  identifiers: Set<string>,\r\n): void {\r\n  void pattern;\r\n  void identifiers;\r\n}\r\n\r\n/**\r\n * Gets the identifier collector for one supported pattern kind.\r\n * @param pattern Pattern whose collector is needed.\r\n * @returns Collector for the pattern, when one exists.\r\n * @example\r\n * ```typescript\r\n * const collector = getPatternIdentifierCollector({ name: \"value\", type: \"Identifier\" });\r\n * void collector;\r\n * ```\r\n */\r\nfunction getPatternIdentifierCollector(\r\n  pattern: ESTree.Pattern,\r\n): PatternIdentifierCollector {\r\n  switch (pattern.type) {\r\n    case \"ArrayPattern\": {\r\n      return collectArrayPatternIdentifiers;\r\n    }\r\n    case \"AssignmentPattern\": {\r\n      return collectAssignmentPatternIdentifiers;\r\n    }\r\n    case \"Identifier\": {\r\n      return collectIdentifierPatternIdentifiers;\r\n    }\r\n    case \"MemberExpression\": {\r\n      return collectUnsupportedPatternIdentifiers;\r\n    }\r\n    case \"ObjectPattern\": {\r\n      return collectObjectPatternIdentifiers;\r\n    }\r\n    case \"RestElement\": {\r\n      return collectRestPatternIdentifiers;\r\n    }\r\n    default: {\r\n      return collectUnsupportedPatternIdentifiers;\r\n    }\r\n  }\r\n}\r\n\r\nexport { collectPatternIdentifiers };\r\n"]}

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-identifiers.d.ts

@@ -0,0 +1,25 @@
+import type * as ESTree from "estree";
+import type { TestBlockAnalysis } from "../aaa/index.js";
+/**
+ * Collects all identifiers referenced from the Assert phase.
+ * @param analysis Parsed test-block analysis.
+ * @returns Referenced identifier names from Assert statements.
+ * @example
+ * ```typescript
+ * getAssertReferencedIdentifiers({ statements: [] } as never);
+ * ```
+ */
+declare function getAssertReferencedIdentifiers(analysis: TestBlockAnalysis): Set<string>;
+/**
+ * Checks whether an Act-phase declaration is later referenced from Assert.
+ * @param assertReferencedIdentifiers Referenced identifiers collected from Assert.
+ * @param statement Statement to inspect.
+ * @returns True when one declared identifier is asserted later.
+ * @example
+ * ```typescript
+ * isActResultAsserted(new Set<string>(), { type: "ExpressionStatement" } as never);
+ * ```
+ */
+declare function isActResultAsserted(assertReferencedIdentifiers: Set<string>, statement: ESTree.Statement): boolean;
+export { getAssertReferencedIdentifiers, isActResultAsserted };
+//# sourceMappingURL=phase-purity-identifiers.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-identifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-purity-identifiers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/phase-purity-identifiers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAsHhD;;;;;;;;GAQG;AACH,iBAAS,8BAA8B,CACrC,QAAQ,EAAE,iBAAiB,GAC1B,GAAG,CAAC,MAAM,CAAC,CAQb;AAED;;;;;;;;;GASG;AACH,iBAAS,mBAAmB,CAC1B,2BAA2B,EAAE,GAAG,CAAC,MAAM,CAAC,EACxC,SAAS,EAAE,MAAM,CAAC,SAAS,GAC1B,OAAO,CAQT;AAoBD,OAAO,EAAE,8BAA8B,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-identifiers.js

@@ -0,0 +1,138 @@
+import { collectPatternIdentifiers } from "./pattern-identifiers.js";
+/**
+ * Collects referenced identifiers from one Assert-phase statement.
+ * @param statement Statement to inspect.
+ * @param identifiers Identifier set updated in place.
+ * @example
+ * ```typescript
+ * collectAssertStatementIdentifiers({ type: "ExpressionStatement" } as never, new Set<string>());
+ * ```
+ */
+function collectAssertStatementIdentifiers(statement, identifiers) {
+    if (!statement.phases.includes("Assert")) {
+        return;
+    }
+    if (statement.node.type !== "VariableDeclaration") {
+        collectReferencedIdentifiers(statement.node, identifiers);
+        return;
+    }
+    for (const declaration of statement.node.declarations) {
+        if (declaration.init !== null && declaration.init !== void 0) {
+            collectReferencedIdentifiers(declaration.init, identifiers);
+        }
+    }
+}
+/**
+ * Collects referenced identifier names from an ESTree node.
+ * @param node Node to inspect.
+ * @param identifiers Identifier set updated in place.
+ * @example
+ * ```typescript
+ * collectReferencedIdentifiers({ name: "value", type: "Identifier" }, new Set<string>());
+ * ```
+ */
+function collectReferencedIdentifiers(node, identifiers) {
+    if (node.type === "Identifier") {
+        identifiers.add(node.name);
+        return;
+    }
+    for (const [key, value] of Object.entries(node)) {
+        collectReferencedValue(key, value, identifiers);
+    }
+}
+/**
+ * Collects referenced identifiers from one object entry on an ESTree node.
+ * @param key Entry key being inspected.
+ * @param value Entry value being inspected.
+ * @param identifiers Identifier set updated in place.
+ * @example
+ * ```typescript
+ * collectReferencedValue("type", "Identifier", new Set<string>());
+ * ```
+ */
+function collectReferencedValue(key, value, identifiers) {
+    if (key === "parent") {
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (isNode(item)) {
+                collectReferencedIdentifiers(item, identifiers);
+            }
+        }
+        return;
+    }
+    if (isNode(value)) {
+        collectReferencedIdentifiers(value, identifiers);
+    }
+}
+/**
+ * Gets identifiers declared by an Act-phase variable declaration.
+ * @param statement Statement to inspect.
+ * @returns Declared identifier names.
+ * @example
+ * ```typescript
+ * getActDeclaredIdentifiers({ declarations: [], kind: "const", type: "VariableDeclaration" } as never);
+ * ```
+ */
+function getActDeclaredIdentifiers(statement) {
+    const identifiers = new Set();
+    if (statement.type !== "VariableDeclaration") {
+        return identifiers;
+    }
+    for (const declaration of statement.declarations) {
+        collectPatternIdentifiers(declaration.id, identifiers);
+    }
+    return identifiers;
+}
+/**
+ * Collects all identifiers referenced from the Assert phase.
+ * @param analysis Parsed test-block analysis.
+ * @returns Referenced identifier names from Assert statements.
+ * @example
+ * ```typescript
+ * getAssertReferencedIdentifiers({ statements: [] } as never);
+ * ```
+ */
+function getAssertReferencedIdentifiers(analysis) {
+    const identifiers = new Set();
+    for (const statement of analysis.statements) {
+        collectAssertStatementIdentifiers(statement, identifiers);
+    }
+    return identifiers;
+}
+/**
+ * Checks whether an Act-phase declaration is later referenced from Assert.
+ * @param assertReferencedIdentifiers Referenced identifiers collected from Assert.
+ * @param statement Statement to inspect.
+ * @returns True when one declared identifier is asserted later.
+ * @example
+ * ```typescript
+ * isActResultAsserted(new Set<string>(), { type: "ExpressionStatement" } as never);
+ * ```
+ */
+function isActResultAsserted(assertReferencedIdentifiers, statement) {
+    for (const identifier of getActDeclaredIdentifiers(statement)) {
+        if (assertReferencedIdentifiers.has(identifier)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Checks whether an unknown value is an ESTree node.
+ * @param value Unknown value to inspect.
+ * @returns True when the value has the shape of an ESTree node.
+ * @example
+ * ```typescript
+ * isNode({ type: "Identifier" });
+ * ```
+ */
+function isNode(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "type" in value &&
+        typeof value.type === "string");
+}
+export { getAssertReferencedIdentifiers, isActResultAsserted };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"phase-purity-identifiers.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/phase-purity-identifiers.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as ESTree from \"estree\";\r\n\r\nimport type { TestBlockAnalysis } from \"../aaa\";\r\n\r\nimport { collectPatternIdentifiers } from \"./pattern-identifiers\";\r\n\r\n/** Type definition for rule data. */\r\ninterface NodeCandidate {\r\n  /** Optional ESTree node type marker. */\r\n  type?: unknown;\r\n}\r\n\r\n/**\r\n * Collects referenced identifiers from one Assert-phase statement.\r\n * @param statement Statement to inspect.\r\n * @param identifiers Identifier set updated in place.\r\n * @example\r\n * ```typescript\r\n * collectAssertStatementIdentifiers({ type: \"ExpressionStatement\" } as never, new Set<string>());\r\n * ```\r\n */\r\nfunction collectAssertStatementIdentifiers(\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  identifiers: Set<string>,\r\n): void {\r\n  if (!statement.phases.includes(\"Assert\")) {\r\n    return;\r\n  }\r\n\r\n  if (statement.node.type !== \"VariableDeclaration\") {\r\n    collectReferencedIdentifiers(statement.node, identifiers);\r\n    return;\r\n  }\r\n\r\n  for (const declaration of statement.node.declarations) {\r\n    if (declaration.init !== null && declaration.init !== void 0) {\r\n      collectReferencedIdentifiers(declaration.init, identifiers);\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Collects referenced identifier names from an ESTree node.\r\n * @param node Node to inspect.\r\n * @param identifiers Identifier set updated in place.\r\n * @example\r\n * ```typescript\r\n * collectReferencedIdentifiers({ name: \"value\", type: \"Identifier\" }, new Set<string>());\r\n * ```\r\n */\r\nfunction collectReferencedIdentifiers(\r\n  node: ESTree.Node,\r\n  identifiers: Set<string>,\r\n): void {\r\n  if (node.type === \"Identifier\") {\r\n    identifiers.add(node.name);\r\n    return;\r\n  }\r\n\r\n  for (const [key, value] of Object.entries(node)) {\r\n    collectReferencedValue(key, value, identifiers);\r\n  }\r\n}\r\n\r\n/**\r\n * Collects referenced identifiers from one object entry on an ESTree node.\r\n * @param key Entry key being inspected.\r\n * @param value Entry value being inspected.\r\n * @param identifiers Identifier set updated in place.\r\n * @example\r\n * ```typescript\r\n * collectReferencedValue(\"type\", \"Identifier\", new Set<string>());\r\n * ```\r\n */\r\nfunction collectReferencedValue(\r\n  key: string,\r\n  value: unknown,\r\n  identifiers: Set<string>,\r\n): void {\r\n  if (key === \"parent\") {\r\n    return;\r\n  }\r\n\r\n  if (Array.isArray(value)) {\r\n    for (const item of value) {\r\n      if (isNode(item)) {\r\n        collectReferencedIdentifiers(item, identifiers);\r\n      }\r\n    }\r\n    return;\r\n  }\r\n\r\n  if (isNode(value)) {\r\n    collectReferencedIdentifiers(value, identifiers);\r\n  }\r\n}\r\n\r\n/**\r\n * Gets identifiers declared by an Act-phase variable declaration.\r\n * @param statement Statement to inspect.\r\n * @returns Declared identifier names.\r\n * @example\r\n * ```typescript\r\n * getActDeclaredIdentifiers({ declarations: [], kind: \"const\", type: \"VariableDeclaration\" } as never);\r\n * ```\r\n */\r\nfunction getActDeclaredIdentifiers(statement: ESTree.Statement): Set<string> {\r\n  const identifiers = new Set<string>();\r\n\r\n  if (statement.type !== \"VariableDeclaration\") {\r\n    return identifiers;\r\n  }\r\n\r\n  for (const declaration of statement.declarations) {\r\n    collectPatternIdentifiers(declaration.id, identifiers);\r\n  }\r\n\r\n  return identifiers;\r\n}\r\n\r\n/**\r\n * Collects all identifiers referenced from the Assert phase.\r\n * @param analysis Parsed test-block analysis.\r\n * @returns Referenced identifier names from Assert statements.\r\n * @example\r\n * ```typescript\r\n * getAssertReferencedIdentifiers({ statements: [] } as never);\r\n * ```\r\n */\r\nfunction getAssertReferencedIdentifiers(\r\n  analysis: TestBlockAnalysis,\r\n): Set<string> {\r\n  const identifiers = new Set<string>();\r\n\r\n  for (const statement of analysis.statements) {\r\n    collectAssertStatementIdentifiers(statement, identifiers);\r\n  }\r\n\r\n  return identifiers;\r\n}\r\n\r\n/**\r\n * Checks whether an Act-phase declaration is later referenced from Assert.\r\n * @param assertReferencedIdentifiers Referenced identifiers collected from Assert.\r\n * @param statement Statement to inspect.\r\n * @returns True when one declared identifier is asserted later.\r\n * @example\r\n * ```typescript\r\n * isActResultAsserted(new Set<string>(), { type: \"ExpressionStatement\" } as never);\r\n * ```\r\n */\r\nfunction isActResultAsserted(\r\n  assertReferencedIdentifiers: Set<string>,\r\n  statement: ESTree.Statement,\r\n): boolean {\r\n  for (const identifier of getActDeclaredIdentifiers(statement)) {\r\n    if (assertReferencedIdentifiers.has(identifier)) {\r\n      return true;\r\n    }\r\n  }\r\n\r\n  return false;\r\n}\r\n\r\n/**\r\n * Checks whether an unknown value is an ESTree node.\r\n * @param value Unknown value to inspect.\r\n * @returns True when the value has the shape of an ESTree node.\r\n * @example\r\n * ```typescript\r\n * isNode({ type: \"Identifier\" });\r\n * ```\r\n */\r\nfunction isNode(value: unknown): value is ESTree.Node {\r\n  return (\r\n    typeof value === \"object\" &&\r\n    value !== null &&\r\n    \"type\" in value &&\r\n    typeof (value as NodeCandidate).type === \"string\"\r\n  );\r\n}\r\n\r\nexport { getAssertReferencedIdentifiers, isActResultAsserted };\r\n"]}

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.combined.d.ts

@@ -0,0 +1,4 @@
+/** Companion module for combined-section phase purity behavior spec coverage. */
+declare const phasePurityReportingBehaviorCombinedCompanion: true;
+export { phasePurityReportingBehaviorCombinedCompanion };
+//# sourceMappingURL=phase-purity-reporting.behavior.combined.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.combined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-purity-reporting.behavior.combined.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.combined.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,QAAA,MAAM,6CAA6C,EAAG,IAAa,CAAC;AAEpE,OAAO,EAAE,6CAA6C,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.combined.js

@@ -0,0 +1,4 @@
+/** Companion module for combined-section phase purity behavior spec coverage. */
+const phasePurityReportingBehaviorCombinedCompanion = true;
+export { phasePurityReportingBehaviorCombinedCompanion };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhhc2UtcHVyaXR5LXJlcG9ydGluZy5iZWhhdmlvci5jb21iaW5lZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vdGVzdGluZy9lbmZvcmNlLWFhYS1waGFzZS1wdXJpdHkvcGhhc2UtcHVyaXR5LXJlcG9ydGluZy5iZWhhdmlvci5jb21iaW5lZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxpRkFBaUY7QUFDakYsTUFBTSw2Q0FBNkMsR0FBRyxJQUFhLENBQUM7QUFFcEUsT0FBTyxFQUFFLDZDQUE2QyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQ29tcGFuaW9uIG1vZHVsZSBmb3IgY29tYmluZWQtc2VjdGlvbiBwaGFzZSBwdXJpdHkgYmVoYXZpb3Igc3BlYyBjb3ZlcmFnZS4gKi9cclxuY29uc3QgcGhhc2VQdXJpdHlSZXBvcnRpbmdCZWhhdmlvckNvbWJpbmVkQ29tcGFuaW9uID0gdHJ1ZSBhcyBjb25zdDtcclxuXHJcbmV4cG9ydCB7IHBoYXNlUHVyaXR5UmVwb3J0aW5nQmVoYXZpb3JDb21iaW5lZENvbXBhbmlvbiB9O1xyXG4iXX0=

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.companion.d.ts

@@ -0,0 +1,4 @@
+/** Companion module for phase purity reporting companion marker spec coverage. */
+declare const phasePurityReportingBehaviorCompanionCompanion: true;
+export { phasePurityReportingBehaviorCompanionCompanion };
+//# sourceMappingURL=phase-purity-reporting.behavior.companion.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.companion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-purity-reporting.behavior.companion.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.companion.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,QAAA,MAAM,8CAA8C,EAAG,IAAa,CAAC;AAErE,OAAO,EAAE,8CAA8C,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.companion.js

@@ -0,0 +1,4 @@
+/** Companion module for phase purity reporting companion marker spec coverage. */
+const phasePurityReportingBehaviorCompanionCompanion = true;
+export { phasePurityReportingBehaviorCompanionCompanion };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhhc2UtcHVyaXR5LXJlcG9ydGluZy5iZWhhdmlvci5jb21wYW5pb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvZW5mb3JjZS1hYWEtcGhhc2UtcHVyaXR5L3BoYXNlLXB1cml0eS1yZXBvcnRpbmcuYmVoYXZpb3IuY29tcGFuaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGtGQUFrRjtBQUNsRixNQUFNLDhDQUE4QyxHQUFHLElBQWEsQ0FBQztBQUVyRSxPQUFPLEVBQUUsOENBQThDLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBDb21wYW5pb24gbW9kdWxlIGZvciBwaGFzZSBwdXJpdHkgcmVwb3J0aW5nIGNvbXBhbmlvbiBtYXJrZXIgc3BlYyBjb3ZlcmFnZS4gKi9cclxuY29uc3QgcGhhc2VQdXJpdHlSZXBvcnRpbmdCZWhhdmlvckNvbXBhbmlvbkNvbXBhbmlvbiA9IHRydWUgYXMgY29uc3Q7XHJcblxyXG5leHBvcnQgeyBwaGFzZVB1cml0eVJlcG9ydGluZ0JlaGF2aW9yQ29tcGFuaW9uQ29tcGFuaW9uIH07XHJcbiJdfQ==

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.d.ts

@@ -0,0 +1,4 @@
+/** Companion marker for the phase-purity reporting behavior tests. */
+declare const phasePurityReportingBehaviorCompanion = true;
+export { phasePurityReportingBehaviorCompanion };
+//# sourceMappingURL=phase-purity-reporting.behavior.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-purity-reporting.behavior.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,QAAA,MAAM,qCAAqC,OAAO,CAAC;AAEnD,OAAO,EAAE,qCAAqC,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.behavior.js

@@ -0,0 +1,4 @@
+/** Companion marker for the phase-purity reporting behavior tests. */
+const phasePurityReportingBehaviorCompanion = true;
+export { phasePurityReportingBehaviorCompanion };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhhc2UtcHVyaXR5LXJlcG9ydGluZy5iZWhhdmlvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vdGVzdGluZy9lbmZvcmNlLWFhYS1waGFzZS1wdXJpdHkvcGhhc2UtcHVyaXR5LXJlcG9ydGluZy5iZWhhdmlvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxzRUFBc0U7QUFDdEUsTUFBTSxxQ0FBcUMsR0FBRyxJQUFJLENBQUM7QUFFbkQsT0FBTyxFQUFFLHFDQUFxQyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQ29tcGFuaW9uIG1hcmtlciBmb3IgdGhlIHBoYXNlLXB1cml0eSByZXBvcnRpbmcgYmVoYXZpb3IgdGVzdHMuICovXHJcbmNvbnN0IHBoYXNlUHVyaXR5UmVwb3J0aW5nQmVoYXZpb3JDb21wYW5pb24gPSB0cnVlO1xyXG5cclxuZXhwb3J0IHsgcGhhc2VQdXJpdHlSZXBvcnRpbmdCZWhhdmlvckNvbXBhbmlvbiB9O1xyXG4iXX0=

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.d.ts

@@ -0,0 +1,14 @@
+import type { Rule } from "eslint";
+import type { TestBlockAnalysis } from "../aaa/index.js";
+/**
+ * Reports all enforce-aaa-phase-purity violations for one test block.
+ * @param context ESLint rule context.
+ * @param analysis Parsed test-block analysis.
+ * @example
+ * ```typescript
+ * reportPhasePurityViolations({ report() {} } as never, { sectionComments: [], statements: [] } as never);
+ * ```
+ */
+declare function reportPhasePurityViolations(context: Rule.RuleContext, analysis: TestBlockAnalysis): void;
+export { reportPhasePurityViolations };
+//# sourceMappingURL=phase-purity-reporting.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-purity-reporting.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAqNhD;;;;;;;;GAQG;AACH,iBAAS,2BAA2B,CAClC,OAAO,EAAE,IAAI,CAAC,WAAW,EACzB,QAAQ,EAAE,iBAAiB,GAC1B,IAAI,CAyBN;AAgCD,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.js

@@ -0,0 +1,180 @@
+import { hasAssertion, hasAsyncLogic, hasAwait, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, } from "../aaa/index.js";
+import { getAssertReferencedIdentifiers, isActResultAsserted, } from "./phase-purity-identifiers.js";
+/**
+ * Collects the phase-purity state for one analyzed statement.
+ * @param assertReferencedIdentifiers Referenced identifiers collected from Assert.
+ * @param statement Statement entry to classify.
+ * @returns Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * const state = getStatementPurityState(new Set<string>(), { node: { type: "ExpressionStatement" } as never, phases: [] });
+ * void state;
+ * ```
+ */
+function getStatementPurityState(assertReferencedIdentifiers, statement) {
+    const allowsArrange = statement.phases.includes("Arrange");
+    const allowsAct = statement.phases.includes("Act");
+    const allowsAssert = statement.phases.includes("Assert");
+    const containsAssertion = hasAssertion(statement.node);
+    const containsAsyncLogic = hasAsyncLogic(statement.node);
+    const containsAwait = hasAwait(statement.node);
+    const containsMutation = hasMutation(statement.node);
+    const isMeaningfulAct = isMeaningfulActStatement(statement.node);
+    const isMeaningfulActContent = isMeaningfulAct ||
+        hasCapturableActResult(statement.node) ||
+        isActResultAsserted(assertReferencedIdentifiers, statement.node);
+    return {
+        allowsAct,
+        allowsArrange,
+        allowsAssert,
+        containsAssertion,
+        containsAsyncLogic,
+        containsAwait,
+        containsMutation,
+        isMeaningfulAct,
+        isMeaningfulActContent,
+        isSetupLike: isSetupLikeStatement(statement.node),
+        isValidAssert: isValidAssertStatement(statement.node),
+    };
+}
+/**
+ * Checks whether the analyzed test block declares all AAA section comments.
+ * @param analysis Parsed test-block analysis.
+ * @returns True when Arrange, Act, and Assert are all present.
+ * @example
+ * ```typescript
+ * const complete = hasAllAaaSections({ sectionComments: [] } as never);
+ * void complete;
+ * ```
+ */
+function hasAllAaaSections(analysis) {
+    return ["Arrange", "Act", "Assert"].every((phase) => analysis.sectionComments.some((sectionComment) => sectionComment.phases.includes(phase)));
+}
+/**
+ * Reports Act-only phase violations for one statement.
+ * @param context ESLint rule context.
+ * @param statement Statement entry to report against.
+ * @param purityState Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * reportActOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);
+ * ```
+ */
+function reportActOnlyStatement(context, statement, purityState) {
+    if (purityState.containsAssertion && !purityState.allowsAssert) {
+        context.report({
+            messageId: "assertionOutsideAssert",
+            node: statement.node,
+        });
+    }
+    if (purityState.allowsAssert &&
+        purityState.containsAssertion &&
+        !purityState.isValidAssert) {
+        context.report({ messageId: "nonAssertionInAssert", node: statement.node });
+    }
+    if (purityState.isSetupLike && !purityState.isMeaningfulActContent) {
+        context.report({ messageId: "setupAfterAct", node: statement.node });
+    }
+}
+/**
+ * Reports Arrange-only phase violations for one statement.
+ * @param context ESLint rule context.
+ * @param statement Statement entry to report against.
+ * @param purityState Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * reportArrangeOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);
+ * ```
+ */
+function reportArrangeOnlyStatement(context, statement, purityState) {
+    if (purityState.containsAssertion && !purityState.allowsAssert) {
+        context.report({
+            messageId: "assertionOutsideAssert",
+            node: statement.node,
+        });
+    }
+    if (purityState.containsAwait) {
+        context.report({ messageId: "awaitOutsideAct", node: statement.node });
+    }
+    if (purityState.containsAsyncLogic) {
+        context.report({ messageId: "asyncInArrange", node: statement.node });
+    }
+    if (purityState.isMeaningfulAct) {
+        context.report({ messageId: "actionInArrange", node: statement.node });
+    }
+}
+/**
+ * Reports Assert-only phase violations for one statement.
+ * @param context ESLint rule context.
+ * @param statement Statement entry to report against.
+ * @param purityState Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * reportAssertOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);
+ * ```
+ */
+function reportAssertOnlyStatement(context, statement, purityState) {
+    if (purityState.containsAwait) {
+        context.report({ messageId: "awaitOutsideAct", node: statement.node });
+    }
+    if (purityState.containsMutation) {
+        context.report({ messageId: "mutationAfterAct", node: statement.node });
+        return;
+    }
+    if (!purityState.isValidAssert) {
+        context.report({ messageId: "nonAssertionInAssert", node: statement.node });
+    }
+}
+/**
+ * Reports all enforce-aaa-phase-purity violations for one test block.
+ * @param context ESLint rule context.
+ * @param analysis Parsed test-block analysis.
+ * @example
+ * ```typescript
+ * reportPhasePurityViolations({ report() {} } as never, { sectionComments: [], statements: [] } as never);
+ * ```
+ */
+function reportPhasePurityViolations(context, analysis) {
+    if (!hasAllAaaSections(analysis)) {
+        return;
+    }
+    let hasMeaningfulAct = false;
+    const assertReferencedIdentifiers = getAssertReferencedIdentifiers(analysis);
+    for (const statement of analysis.statements) {
+        const purityState = getStatementPurityState(assertReferencedIdentifiers, statement);
+        hasMeaningfulAct ||=
+            purityState.allowsAct && purityState.isMeaningfulActContent;
+        reportStatementViolations(context, statement, purityState);
+    }
+    if (!hasMeaningfulAct) {
+        context.report({
+            messageId: "missingMeaningfulAct",
+            node: analysis.callExpression,
+        });
+    }
+}
+/**
+ * Reports any phase-purity violations for one statement.
+ * @param context ESLint rule context.
+ * @param statement Statement entry to report against.
+ * @param purityState Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * reportStatementViolations({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);
+ * ```
+ */
+function reportStatementViolations(context, statement, purityState) {
+    if (purityState.allowsArrange && !purityState.allowsAct) {
+        reportArrangeOnlyStatement(context, statement, purityState);
+        return;
+    }
+    if (purityState.allowsAct && !purityState.allowsArrange) {
+        reportActOnlyStatement(context, statement, purityState);
+        return;
+    }
+    if (purityState.allowsAssert && !purityState.allowsAct) {
+        reportAssertOnlyStatement(context, statement, purityState);
+    }
+}
+export { reportPhasePurityViolations };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"phase-purity-reporting.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\nimport type { TestBlockAnalysis } from \"../aaa\";\r\n\r\nimport {\r\n  hasAssertion,\r\n  hasAsyncLogic,\r\n  hasAwait,\r\n  hasCapturableActResult,\r\n  hasMutation,\r\n  isMeaningfulActStatement,\r\n  isSetupLikeStatement,\r\n  isValidAssertStatement,\r\n} from \"../aaa\";\r\nimport {\r\n  getAssertReferencedIdentifiers,\r\n  isActResultAsserted,\r\n} from \"./phase-purity-identifiers\";\r\n\r\n/** Type definition for rule data. */\r\ninterface StatementPurityState {\r\n  /** Whether the statement belongs to Act. */\r\n  allowsAct: boolean;\r\n\r\n  /** Whether the statement belongs to Arrange. */\r\n  allowsArrange: boolean;\r\n\r\n  /** Whether the statement belongs to Assert. */\r\n  allowsAssert: boolean;\r\n\r\n  /** Whether the statement contains an assertion. */\r\n  containsAssertion: boolean;\r\n\r\n  /** Whether the statement contains async logic. */\r\n  containsAsyncLogic: boolean;\r\n\r\n  /** Whether the statement contains an await expression. */\r\n  containsAwait: boolean;\r\n\r\n  /** Whether the statement mutates state. */\r\n  containsMutation: boolean;\r\n\r\n  /** Whether the statement performs meaningful Act work. */\r\n  isMeaningfulAct: boolean;\r\n\r\n  /** Whether the statement counts as meaningful Act content overall. */\r\n  isMeaningfulActContent: boolean;\r\n\r\n  /** Whether the statement looks like setup. */\r\n  isSetupLike: boolean;\r\n\r\n  /** Whether the statement is a valid assert-phase statement. */\r\n  isValidAssert: boolean;\r\n}\r\n\r\n/**\r\n * Collects the phase-purity state for one analyzed statement.\r\n * @param assertReferencedIdentifiers Referenced identifiers collected from Assert.\r\n * @param statement Statement entry to classify.\r\n * @returns Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * const state = getStatementPurityState(new Set<string>(), { node: { type: \"ExpressionStatement\" } as never, phases: [] });\r\n * void state;\r\n * ```\r\n */\r\nfunction getStatementPurityState(\r\n  assertReferencedIdentifiers: Set<string>,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n): StatementPurityState {\r\n  const allowsArrange = statement.phases.includes(\"Arrange\");\r\n  const allowsAct = statement.phases.includes(\"Act\");\r\n  const allowsAssert = statement.phases.includes(\"Assert\");\r\n  const containsAssertion = hasAssertion(statement.node);\r\n  const containsAsyncLogic = hasAsyncLogic(statement.node);\r\n  const containsAwait = hasAwait(statement.node);\r\n  const containsMutation = hasMutation(statement.node);\r\n  const isMeaningfulAct = isMeaningfulActStatement(statement.node);\r\n  const isMeaningfulActContent =\r\n    isMeaningfulAct ||\r\n    hasCapturableActResult(statement.node) ||\r\n    isActResultAsserted(assertReferencedIdentifiers, statement.node);\r\n\r\n  return {\r\n    allowsAct,\r\n    allowsArrange,\r\n    allowsAssert,\r\n    containsAssertion,\r\n    containsAsyncLogic,\r\n    containsAwait,\r\n    containsMutation,\r\n    isMeaningfulAct,\r\n    isMeaningfulActContent,\r\n    isSetupLike: isSetupLikeStatement(statement.node),\r\n    isValidAssert: isValidAssertStatement(statement.node),\r\n  };\r\n}\r\n\r\n/**\r\n * Checks whether the analyzed test block declares all AAA section comments.\r\n * @param analysis Parsed test-block analysis.\r\n * @returns True when Arrange, Act, and Assert are all present.\r\n * @example\r\n * ```typescript\r\n * const complete = hasAllAaaSections({ sectionComments: [] } as never);\r\n * void complete;\r\n * ```\r\n */\r\nfunction hasAllAaaSections(analysis: TestBlockAnalysis): boolean {\r\n  return [\"Arrange\", \"Act\", \"Assert\"].every((phase) =>\r\n    analysis.sectionComments.some((sectionComment) =>\r\n      sectionComment.phases.includes(phase as never),\r\n    ),\r\n  );\r\n}\r\n\r\n/**\r\n * Reports Act-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportActOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportActOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAssertion && !purityState.allowsAssert) {\r\n    context.report({\r\n      messageId: \"assertionOutsideAssert\",\r\n      node: statement.node,\r\n    });\r\n  }\r\n\r\n  if (\r\n    purityState.allowsAssert &&\r\n    purityState.containsAssertion &&\r\n    !purityState.isValidAssert\r\n  ) {\r\n    context.report({ messageId: \"nonAssertionInAssert\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.isSetupLike && !purityState.isMeaningfulActContent) {\r\n    context.report({ messageId: \"setupAfterAct\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports Arrange-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportArrangeOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportArrangeOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAssertion && !purityState.allowsAssert) {\r\n    context.report({\r\n      messageId: \"assertionOutsideAssert\",\r\n      node: statement.node,\r\n    });\r\n  }\r\n\r\n  if (purityState.containsAwait) {\r\n    context.report({ messageId: \"awaitOutsideAct\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.containsAsyncLogic) {\r\n    context.report({ messageId: \"asyncInArrange\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.isMeaningfulAct) {\r\n    context.report({ messageId: \"actionInArrange\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports Assert-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportAssertOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportAssertOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAwait) {\r\n    context.report({ messageId: \"awaitOutsideAct\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.containsMutation) {\r\n    context.report({ messageId: \"mutationAfterAct\", node: statement.node });\r\n    return;\r\n  }\r\n\r\n  if (!purityState.isValidAssert) {\r\n    context.report({ messageId: \"nonAssertionInAssert\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports all enforce-aaa-phase-purity violations for one test block.\r\n * @param context ESLint rule context.\r\n * @param analysis Parsed test-block analysis.\r\n * @example\r\n * ```typescript\r\n * reportPhasePurityViolations({ report() {} } as never, { sectionComments: [], statements: [] } as never);\r\n * ```\r\n */\r\nfunction reportPhasePurityViolations(\r\n  context: Rule.RuleContext,\r\n  analysis: TestBlockAnalysis,\r\n): void {\r\n  if (!hasAllAaaSections(analysis)) {\r\n    return;\r\n  }\r\n\r\n  let hasMeaningfulAct = false;\r\n  const assertReferencedIdentifiers = getAssertReferencedIdentifiers(analysis);\r\n\r\n  for (const statement of analysis.statements) {\r\n    const purityState = getStatementPurityState(\r\n      assertReferencedIdentifiers,\r\n      statement,\r\n    );\r\n\r\n    hasMeaningfulAct ||=\r\n      purityState.allowsAct && purityState.isMeaningfulActContent;\r\n    reportStatementViolations(context, statement, purityState);\r\n  }\r\n\r\n  if (!hasMeaningfulAct) {\r\n    context.report({\r\n      messageId: \"missingMeaningfulAct\",\r\n      node: analysis.callExpression,\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports any phase-purity violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportStatementViolations({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportStatementViolations(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.allowsArrange && !purityState.allowsAct) {\r\n    reportArrangeOnlyStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (purityState.allowsAct && !purityState.allowsArrange) {\r\n    reportActOnlyStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (purityState.allowsAssert && !purityState.allowsAct) {\r\n    reportAssertOnlyStatement(context, statement, purityState);\r\n  }\r\n}\r\n\r\nexport { reportPhasePurityViolations };\r\n"]}