pumuki 6.3.270 → 6.3.272

package/core/facts/detectors/text/ios.test.ts

@@ -14,12 +14,15 @@ import {
   collectSwiftXCTestAssertionLines,
   collectSwiftXCTUnwrapLines,
   collectSwiftAnyViewLines,
+  collectSwiftAnyTypeErasureLines,
   collectSwiftCallbackStyleSignatureLines,
   collectSwiftDispatchGroupLines,
   collectSwiftDispatchSemaphoreLines,
   hasSwiftAnyViewUsage,
+  hasSwiftAnyTypeErasureUsage,
   hasSwiftAsyncWithoutAwaitUsage,
   hasSwiftCallbackStyleSignature,
+  hasSwiftCombineSinkWithoutStoreUsage,
   hasSwiftCornerRadiusUsage,
   hasSwiftDispatchGroupUsage,
   collectSwiftDispatchQueueLines,
@@ -43,16 +46,23 @@ import {
   hasSwiftHardcodedSensitiveStringUsage,
   hasSwiftUnlocalizedDateFormatterUsage,
   hasSwiftIconOnlyControlWithoutAccessibilityLabelUsage,
+  collectSwiftInteractiveControlWithoutAccessibilityIdentifierLines,
+  hasSwiftInteractiveControlWithoutAccessibilityIdentifierUsage,
+  collectSwiftBindableMissingForObservableBindingUsageLines,
+  hasSwiftBindableMissingForObservableBindingUsage,
   hasSwiftLooseAssetResourceUsage,
   hasSwiftLegacyOnChangeUsage,
   hasSwiftLegacyExpectationDescriptionUsage,
+  hasSwiftLegacyPreviewProviderUsage,
   hasSwiftLegacySwiftUiObservableWrapperUsage,
+  hasSwiftLowContrastStaticColorPairUsage,
   hasSwiftMainThreadBlockingSleepUsage,
   hasSwiftMassiveViewControllerResponsibilityUsage,
   hasSwiftMagicNumberLayoutUsage,
   hasSwiftMixedTestingFrameworksUsage,
   hasSwiftLegacyXCTestImportUsage,
   hasSwiftModernizableXCTestSuiteUsage,
+  hasSwiftNestedIfPyramidUsage,
   hasSwiftNonLazyScrollForEachUsage,
   hasSwiftUiForEachConditionalViewCountUsage,
   hasSwiftViewBodyObjectCreationUsage,
@@ -71,6 +81,8 @@ import {
   hasSwiftNonIBOutletImplicitlyUnwrappedOptionalUsage,
   hasSwiftObservableObjectUsage,
   hasSwiftOnChangeTaskUsage,
+  collectSwiftOnChangeReadonlyVarLines,
+  hasSwiftOnChangeReadonlyVarUsage,
   hasSwiftOnAppearTaskUsage,
   hasSwiftOnTapGestureUsage,
   hasSwiftOperationQueueUsage,
@@ -79,7 +91,10 @@ import {
   hasSwiftPassedValueStateWrapperUsage,
   hasSwiftPhysicalTextAlignmentUsage,
   hasSwiftPreconcurrencyUsage,
+  hasSwiftProductionCommentUsage,
+  hasSwiftProductionTestDoubleUsage,
   hasSwiftQuickNimbleUsage,
+  hasSwiftTestDoubleWithoutProtocolConformanceUsage,
   hasSwiftSheetIsPresentedUsage,
   hasSwiftScrollViewShowsIndicatorsUsage,
   hasSwiftSensitiveLoggingUsage,
@@ -101,6 +116,7 @@ import {
   hasSwiftSwinjectUsage,
   hasSwiftTabItemUsage,
   hasSwiftTaskDetachedUsage,
+  hasSwiftUnownedSelfCaptureUsage,
   hasSwiftWaitForExpectationsUsage,
   hasSwiftUIScreenMainBoundsUsage,
   hasSwiftXCTestAssertionUsage,
@@ -142,6 +158,121 @@ if waitersByKey[key] != nil {
   assert.deepEqual(collectSwiftForceUnwrapLines(source), []);
 });
 
+test('hasSwiftUnownedSelfCaptureUsage detecta captures unowned y preserva weak', () => {
+  const source = `
+final class ProfileViewModel {
+  func bind() {
+    loader.load { [unowned self] value in
+      self.value = value
+    }
+    service.run { [unowned owner] in
+      owner.finish()
+    }
+  }
+}
+`;
+  const safe = `
+loader.load { [weak self] value in
+  self?.value = value
+}
+let ignored = "[unowned self]"
+// loader.load { [unowned self] in }
+`;
+
+  assert.equal(hasSwiftUnownedSelfCaptureUsage(source), true);
+  assert.equal(hasSwiftUnownedSelfCaptureUsage(safe), false);
+});
+
+test('hasSwiftNestedIfPyramidUsage detecta pyramid of doom y preserva guard clauses', () => {
+  const source = `
+func submit() {
+  if session.isValid {
+    if form.isValid {
+      if network.isReachable {
+        send()
+      }
+    }
+  }
+}
+`;
+  const safe = `
+func submit() {
+  guard session.isValid else { return }
+  guard form.isValid else { return }
+  if network.isReachable {
+    send()
+  }
+  let ignored = "if a { if b { if c { } } }"
+  // if a { if b { if c { } } }
+}
+`;
+
+  assert.equal(hasSwiftNestedIfPyramidUsage(source), true);
+  assert.equal(hasSwiftNestedIfPyramidUsage(safe), false);
+});
+
+test('hasSwiftProductionCommentUsage detecta comentarios Swift y preserva strings con URLs', () => {
+  const source = `
+func submit() {
+  // TODO: remove workaround
+  send()
+}
+`;
+  const blockSource = `
+func submit() {
+  /* legacy workaround */
+  send()
+}
+`;
+  const safe = `
+let endpoint = "https://api.example.com/v1/orders"
+let sample = "// not a comment"
+send()
+`;
+
+  assert.equal(hasSwiftProductionCommentUsage(source), true);
+  assert.equal(hasSwiftProductionCommentUsage(blockSource), true);
+  assert.equal(hasSwiftProductionCommentUsage(safe), false);
+});
+
+test('hasSwiftCombineSinkWithoutStoreUsage detecta sink sin store y preserva cancellables', () => {
+  const source = `
+publisher
+  .sink { value in
+    render(value)
+  }
+`;
+  const safe = `
+publisher
+  .sink { value in
+    render(value)
+  }
+  .store(in: &cancellables)
+let ignored = ".sink { value in }"
+// publisher.sink { value in }
+`;
+
+  assert.equal(hasSwiftCombineSinkWithoutStoreUsage(source), true);
+  assert.equal(hasSwiftCombineSinkWithoutStoreUsage(safe), false);
+});
+
+test('hasSwiftProductionTestDoubleUsage detecta mocks/spies productivos y preserva strings', () => {
+  const source = `
+final class MockOrdersRepository: OrdersRepository {
+  func fetch() async throws -> [Order] { [] }
+}
+let spy = SpyAnalytics()
+`;
+  const safe = `
+final class OrdersRepositoryImpl: OrdersRepository {}
+let ignored = "MockOrdersRepository()"
+// let spy = SpyAnalytics()
+`;
+
+  assert.equal(hasSwiftProductionTestDoubleUsage(source), true);
+  assert.equal(hasSwiftProductionTestDoubleUsage(safe), false);
+});
+
 test('hasSwiftAnyViewUsage detecta AnyView en codigo real', () => {
   const source = `
 func render() -> some View {
@@ -158,6 +289,30 @@ test('hasSwiftAnyViewUsage ignora comentarios, strings y coincidencias parciales
   assert.deepEqual(collectSwiftAnyViewLines(source), []);
 });
 
+test('hasSwiftAnyTypeErasureUsage detecta Any, AnyObject, AnyHashable y casts en codigo Swift', () => {
+  const source = `
+let payload: Any = value
+let cache: [String: Any] = [:]
+let items: [Any] = []
+let object: AnyObject = controller
+let key: AnyHashable = route
+let erased = value as Any
+`;
+  assert.equal(hasSwiftAnyTypeErasureUsage(source), true);
+  assert.deepEqual(collectSwiftAnyTypeErasureLines(source), [2, 3, 4, 5, 6, 7]);
+});
+
+test('hasSwiftAnyTypeErasureUsage ignora AnyView, comentarios y strings', () => {
+  const source = `
+let view = AnyView(Text("Title"))
+// let payload: Any = value
+let message = "let object: AnyObject = value"
+let title: String = "Any"
+`;
+  assert.equal(hasSwiftAnyTypeErasureUsage(source), false);
+  assert.deepEqual(collectSwiftAnyTypeErasureLines(source), []);
+});
+
 test('hasSwiftEmptyCatchUsage detecta catch vacio e ignora comentarios y strings', () => {
   const source = `
 do {
@@ -601,6 +756,45 @@ struct SearchView: View {
   assert.equal(hasSwiftOnChangeTaskUsage(safe), false);
 });
 
+test('hasSwiftOnChangeReadonlyVarUsage detecta var local dentro de onChange y preserva let', () => {
+  const source = `
+struct SearchView: View {
+  @State private var query = ""
+
+  var body: some View {
+    Text(query)
+      .onChange(of: query) { _, newValue in
+        var normalized = newValue.trimmingCharacters(in: .whitespaces)
+        search(normalized)
+      }
+  }
+}
+`;
+  const safe = `
+struct SearchView: View {
+  @State private var query = ""
+
+  var body: some View {
+    Text(query)
+      .onChange(of: query) { _, newValue in
+        let normalized = newValue.trimmingCharacters(in: .whitespaces)
+        search(normalized)
+      }
+      .onChange(of: query) { _, newValue in
+        mutate(newValue)
+      }
+  }
+}
+let ignored = ".onChange(of: query) { var normalized = query }"
+// .onChange(of: query) { var normalized = query }
+`;
+
+  assert.equal(hasSwiftOnChangeReadonlyVarUsage(source), true);
+  assert.deepEqual(collectSwiftOnChangeReadonlyVarLines(source), [8]);
+  assert.equal(hasSwiftOnChangeReadonlyVarUsage(safe), false);
+  assert.deepEqual(collectSwiftOnChangeReadonlyVarLines(safe), []);
+});
+
 test('hasSwiftStrongDelegateReferenceUsage detecta delegates fuertes y preserva weak delegates', () => {
   const positive = `
 final class CheckoutCoordinator {
@@ -1132,6 +1326,77 @@ struct ToolbarView: View {
   assert.equal(hasSwiftIconOnlyControlWithoutAccessibilityLabelUsage(ignored), false);
 });
 
+test('detector iOS de accesibilidad detecta controles interactivos sin accessibilityIdentifier', () => {
+  const source = `
+struct CheckoutView: View {
+  var body: some View {
+    VStack {
+      Button("Pay") { pay() }
+      TextField("Email", text: $email)
+      NavigationLink("Details", value: route)
+    }
+  }
+}
+`;
+  const safe = `
+struct CheckoutView: View {
+  var body: some View {
+    VStack {
+      Button("Pay") { pay() }
+        .accessibilityIdentifier("checkout.pay")
+      TextField("Email", text: $email)
+        .accessibilityIdentifier("checkout.email")
+      Toggle("Enabled", isOn: $enabled)
+        .accessibilityIdentifier("checkout.enabled")
+      let sample = "Button(\\"Pay\\")"
+      // Button("Ignored") { pay() }
+    }
+  }
+}
+`;
+
+  assert.equal(hasSwiftInteractiveControlWithoutAccessibilityIdentifierUsage(source), true);
+  assert.deepEqual(collectSwiftInteractiveControlWithoutAccessibilityIdentifierLines(source), [5, 6, 7]);
+  assert.equal(hasSwiftInteractiveControlWithoutAccessibilityIdentifierUsage(safe), false);
+  assert.deepEqual(collectSwiftInteractiveControlWithoutAccessibilityIdentifierLines(safe), []);
+});
+
+test('detector iOS de Bindable detecta Observable inyectado usado como binding sin @Bindable', () => {
+  const source = `
+@Observable
+final class CheckoutForm {
+  var email = ""
+}
+
+struct CheckoutView: View {
+  let form: CheckoutForm
+
+  var body: some View {
+    TextField("Email", text: $form.email)
+  }
+}
+`;
+  const safe = `
+@Observable
+final class CheckoutForm {
+  var email = ""
+}
+
+struct CheckoutView: View {
+  @Bindable var form: CheckoutForm
+
+  var body: some View {
+    TextField("Email", text: $form.email)
+  }
+}
+`;
+
+  assert.equal(hasSwiftBindableMissingForObservableBindingUsage(source), true);
+  assert.deepEqual(collectSwiftBindableMissingForObservableBindingUsageLines(source), [8]);
+  assert.equal(hasSwiftBindableMissingForObservableBindingUsage(safe), false);
+  assert.deepEqual(collectSwiftBindableMissingForObservableBindingUsageLines(safe), []);
+});
+
 test('hasSwiftUncheckedSendableUsage detecta @unchecked Sendable', () => {
   const source = `
 final class LegacyBox: @unchecked Sendable {}
@@ -1526,6 +1791,66 @@ struct ContentView: View {
   assert.equal(hasSwiftLegacySwiftUiObservableWrapperUsage(modernWrapper), false);
 });
 
+test('hasSwiftLegacyPreviewProviderUsage detecta PreviewProvider legacy y preserva #Preview', () => {
+  const legacyPreview = `
+struct CheckoutView_Previews: PreviewProvider {
+  static var previews: some View {
+    CheckoutView()
+  }
+}
+`;
+  const modernPreview = `
+#Preview {
+  CheckoutView()
+}
+`;
+
+  assert.equal(hasSwiftLegacyPreviewProviderUsage(legacyPreview), true);
+  assert.equal(hasSwiftLegacyPreviewProviderUsage(modernPreview), false);
+});
+
+test('hasSwiftTestDoubleWithoutProtocolConformanceUsage detecta mocks sin protocolo', () => {
+  const invalidMock = `
+final class MockOrdersRepository {
+  func fetch() async throws -> [Order] { [] }
+}
+`;
+  const validMock = `
+final class MockOrdersRepository: OrdersRepository {
+  func fetch() async throws -> [Order] { [] }
+}
+`;
+
+  assert.equal(hasSwiftTestDoubleWithoutProtocolConformanceUsage(invalidMock), true);
+  assert.equal(hasSwiftTestDoubleWithoutProtocolConformanceUsage(validMock), false);
+});
+
+test('hasSwiftLowContrastStaticColorPairUsage detecta pares de color estáticos de bajo contraste', () => {
+  const lowContrast = `
+struct WarningBadge: View {
+  var body: some View {
+    Text("Warning")
+      .foregroundStyle(.white)
+      .background(.yellow)
+  }
+}
+`;
+  const sameColor = `
+Text("Error")
+  .foregroundColor(Color.red)
+  .background(Color.red)
+`;
+  const acceptableContrast = `
+Text("Confirmed")
+  .foregroundStyle(.white)
+  .background(.black)
+`;
+
+  assert.equal(hasSwiftLowContrastStaticColorPairUsage(lowContrast), true);
+  assert.equal(hasSwiftLowContrastStaticColorPairUsage(sameColor), true);
+  assert.equal(hasSwiftLowContrastStaticColorPairUsage(acceptableContrast), false);
+});
+
 test('hasSwiftNonPrivateStateOwnershipUsage detecta @State y @StateObject no privados', () => {
   const source = `
 struct DashboardView: View {
@@ -1793,17 +2118,19 @@ wait(for: [expectation], timeout: 1)
 waitForExpectations(timeout: 1)
 self.wait(for: [expectation], timeout: 1)
 XCTWaiter.wait(for: [expectation], timeout: 1)
+app.buttons["Continue"].waitForExistence(timeout: 1)
 `;
   const modernWait = `
 let expectation = expectation(description: "Done")
 await fulfillment(of: [expectation], timeout: 1)
 let sample = "waitForExpectations(timeout: 1)"
 // wait(for: [expectation], timeout: 1)
+// app.buttons["Continue"].waitForExistence(timeout: 1)
 `;
 
   assert.equal(hasSwiftWaitForExpectationsUsage(legacyWait), true);
   assert.equal(hasSwiftWaitForExpectationsUsage(modernWait), false);
-  assert.deepEqual(collectSwiftWaitForExpectationsLines(legacyWait), [3, 4, 5, 6]);
+  assert.deepEqual(collectSwiftWaitForExpectationsLines(legacyWait), [3, 4, 5, 6, 7]);
   assert.deepEqual(collectSwiftWaitForExpectationsLines(modernWait), []);
 });
 

package/core/facts/detectors/text/ios.ts

@@ -98,6 +98,79 @@ const hasSwiftSanitizedRegexMatch = (source: string, regex: RegExp): boolean =>
   return regex.test(sanitizeSwiftSourceForMultilineRegex(source));
 };
 
+const stripSwiftStringLiterals = (line: string): string => {
+  return line.replace(/"(?:\\.|[^"\\])*"/g, '""');
+};
+
+export const hasSwiftProductionCommentUsage = (source: string): boolean => {
+  return source.split(/\r?\n/).some((rawLine) => {
+    const line = stripSwiftStringLiterals(rawLine);
+    return /(^|[^:])\/\/|\/\*/.test(line);
+  });
+};
+
+export const hasSwiftCombineSinkWithoutStoreUsage = (source: string): boolean => {
+  const lines = source.split(/\r?\n/);
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = stripSwiftLineForSemanticScan(lines[index] ?? '');
+    if (!/\.sink\s*(?:\(|\{)/.test(line)) {
+      continue;
+    }
+
+    const chain = lines
+      .slice(index, Math.min(lines.length, index + 8))
+      .map((candidate) => stripSwiftLineForSemanticScan(candidate))
+      .join('\n');
+
+    if (!/\.store\s*\(\s*in\s*:\s*&[A-Za-z_][A-Za-z0-9_]*\s*\)/.test(chain)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+export const hasSwiftProductionTestDoubleUsage = (source: string): boolean => {
+  return hasSwiftSanitizedRegexMatch(
+    source,
+    /\b(?:class|struct|enum|actor)\s+(?:Mock|Fake|Spy|Stub)[A-Za-z0-9_]*\b|\b(?:Mock|Fake|Spy|Stub)[A-Za-z0-9_]*\s*\(/g
+  );
+};
+
+export const hasSwiftUnownedSelfCaptureUsage = (source: string): boolean => {
+  return hasSwiftSanitizedRegexMatch(
+    source,
+    /\[\s*unowned\s+(?:self|[A-Za-z_][A-Za-z0-9_]*)\s*\]/g
+  );
+};
+
+export const hasSwiftNestedIfPyramidUsage = (source: string): boolean => {
+  const lines = source.split(/\r?\n/);
+  const ifBraceDepths: number[] = [];
+  let braceDepth = 0;
+
+  for (const rawLine of lines) {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    const ifMatches = Array.from(line.matchAll(/\bif\b[^{]*\{/g));
+    for (const _match of ifMatches) {
+      if (ifBraceDepths.length >= 2) {
+        return true;
+      }
+      ifBraceDepths.push(braceDepth + 1);
+    }
+
+    braceDepth += countTokenOccurrences(line, '{');
+    braceDepth -= countTokenOccurrences(line, '}');
+
+    while (ifBraceDepths.length > 0 && braceDepth < (ifBraceDepths[ifBraceDepths.length - 1] ?? 0)) {
+      ifBraceDepths.pop();
+    }
+  }
+
+  return false;
+};
+
 const hasSwiftUiModernizationSnapshotMatch = (source: string, entryId: string): boolean => {
   const entry = getIosSwiftUiModernizationEntry(entryId);
   if (!entry) {
@@ -398,6 +471,20 @@ export const collectSwiftAnyViewLines = (source: string): readonly number[] => {
   return sortedUniqueLines(collectSwiftRegexLines(source, /\bAnyView\b/));
 };
 
+export const hasSwiftAnyTypeErasureUsage = (source: string): boolean => {
+  return collectSwiftAnyTypeErasureLines(source).length > 0;
+};
+
+export const collectSwiftAnyTypeErasureLines = (source: string): readonly number[] => {
+  return sortedUniqueLines([
+    ...collectSwiftRegexLines(
+      source,
+      /:\s*(?:Any\b|AnyObject\b|AnyHashable\b|\[\s*Any\s*\]|\[[^\]\n]+:\s*Any\s*\]|Dictionary\s*<\s*[^,\n>]+,\s*Any\s*>)/
+    ),
+    ...collectSwiftRegexLines(source, /\bas\s+(?:Any|AnyObject|AnyHashable)\b/),
+  ]);
+};
+
 export const collectSwiftCallbackStyleSignatureLines = (source: string): readonly number[] => {
   return sortedUniqueLines(
     collectSwiftRegexLines(
@@ -574,6 +661,40 @@ export const hasSwiftOnChangeTaskUsage = (source: string): boolean => {
   );
 };
 
+export const collectSwiftOnChangeReadonlyVarLines = (source: string): readonly number[] => {
+  const lines: number[] = [];
+  let insideOnChange = false;
+  let braceDepth = 0;
+
+  source.split(/\r?\n/).forEach((line, index) => {
+    const sanitizedLine = stripSwiftLineForSemanticScan(line);
+
+    if (!insideOnChange && /\.onChange\s*\([^)]*\)\s*\{/.test(sanitizedLine)) {
+      insideOnChange = true;
+      braceDepth = 0;
+    }
+
+    if (insideOnChange && /\bvar\s+[A-Za-z_][A-Za-z0-9_]*\s*=/.test(sanitizedLine)) {
+      lines.push(index + 1);
+    }
+
+    if (insideOnChange) {
+      const opened = (sanitizedLine.match(/\{/g) ?? []).length;
+      const closed = (sanitizedLine.match(/\}/g) ?? []).length;
+      braceDepth += opened - closed;
+      if (braceDepth <= 0) {
+        insideOnChange = false;
+      }
+    }
+  });
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftOnChangeReadonlyVarUsage = (source: string): boolean => {
+  return collectSwiftOnChangeReadonlyVarLines(source).length > 0;
+};
+
 export const hasSwiftStrongDelegateReferenceUsage = (source: string): boolean => {
   const delegatePropertyPattern =
     /\b(?:var|let)\s+(?:[A-Za-z_][A-Za-z0-9_]*(?:Delegate|DataSource)|delegate|dataSource)\s*:\s*(?:any\s+)?[A-Za-z_][A-Za-z0-9_]*(?:Delegate|DataSource)\b/;
@@ -933,6 +1054,78 @@ export const hasSwiftIconOnlyControlWithoutAccessibilityLabelUsage = (source: st
   return false;
 };
 
+export const collectSwiftInteractiveControlWithoutAccessibilityIdentifierLines = (
+  source: string
+): readonly number[] => {
+  const lines = sanitizeSwiftSourceForMultilineRegex(source).split(/\r?\n/);
+  const matches: number[] = [];
+  const interactiveControlPattern =
+    /\b(?:Button|TextField|SecureField|Toggle|NavigationLink)\s*(?:<[^>]+>)?\s*\(/;
+
+  lines.forEach((line, index) => {
+    if (!interactiveControlPattern.test(line)) {
+      return;
+    }
+    const window = lines.slice(index, Math.min(lines.length, index + 7)).join('\n');
+    if (!/\.\s*accessibilityIdentifier\s*\(/.test(window)) {
+      matches.push(index + 1);
+    }
+  });
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftInteractiveControlWithoutAccessibilityIdentifierUsage = (
+  source: string
+): boolean => {
+  return collectSwiftInteractiveControlWithoutAccessibilityIdentifierLines(source).length > 0;
+};
+
+const collectSwiftBindableMissingForObservableBindingLines = (
+  source: string
+): readonly number[] => {
+  const sanitized = sanitizeSwiftSourceForMultilineRegex(source);
+  if (!/@\s*Observable\b/.test(sanitized)) {
+    return [];
+  }
+  const lines = sanitized.split(/\r?\n/);
+  const bindableDeclarations = new Set<string>();
+  const plainObservableCandidates = new Map<string, number>();
+
+  lines.forEach((line, index) => {
+    const bindableMatch = line.match(/@\s*Bindable\s+(?:private\s+)?var\s+([A-Za-z_][A-Za-z0-9_]*)\s*:/);
+    if (bindableMatch?.[1]) {
+      bindableDeclarations.add(bindableMatch[1]);
+    }
+    const plainMatch = line.match(/\b(?:let|var)\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*[A-Za-z_][A-Za-z0-9_]*/);
+    if (plainMatch?.[1] && !/@\s*Bindable\b/.test(line)) {
+      plainObservableCandidates.set(plainMatch[1], index + 1);
+    }
+  });
+
+  const matches: number[] = [];
+  for (const [name, line] of plainObservableCandidates) {
+    if (bindableDeclarations.has(name)) {
+      continue;
+    }
+    if (sanitized.includes(`$${name}.`)) {
+      matches.push(line);
+    }
+  }
+
+  return sortedUniqueLines(matches);
+};
+
+export const collectSwiftBindableMissingForObservableBindingUsageLines = (
+  source: string
+): readonly number[] => {
+  return collectSwiftBindableMissingForObservableBindingLines(source);
+};
+
+export const hasSwiftBindableMissingForObservableBindingUsage = (source: string): boolean => {
+  return collectSwiftBindableMissingForObservableBindingLines(source).length > 0;
+};
+
 export const hasSwiftUncheckedSendableUsage = (source: string): boolean => {
   return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
     if (current !== '@' || !swiftSource.startsWith('@unchecked', index)) {
@@ -966,6 +1159,53 @@ export const hasSwiftObservableObjectUsage = (source: string): boolean => {
   });
 };
 
+export const hasSwiftLegacyPreviewProviderUsage = (source: string): boolean => {
+  return hasSwiftSanitizedRegexMatch(
+    source,
+    /\b(?:struct|enum|final\s+class|class)\s+[A-Za-z_][A-Za-z0-9_]*\s*:\s*PreviewProvider\b/g
+  );
+};
+
+export const hasSwiftTestDoubleWithoutProtocolConformanceUsage = (source: string): boolean => {
+  return source.split(/\r?\n/).some((line) => {
+    const sanitizedLine = stripSwiftLineForSemanticScan(line);
+    return /\b(?:final\s+)?class\s+(?:Mock|Fake|Spy|Stub)[A-Za-z0-9_]*\s*\{/.test(
+      sanitizedLine
+    );
+  });
+};
+
+const extractSwiftColorToken = (value: string): string | null => {
+  const match = value.match(/\b(?:Color\s*\.\s*)?([A-Za-z][A-Za-z0-9_]*)\b/);
+  return match?.[1]?.toLowerCase() ?? null;
+};
+
+const isLowContrastSwiftColorPair = (foreground: string, background: string): boolean => {
+  if (foreground === background) {
+    return true;
+  }
+
+  const pair = `${foreground}:${background}`;
+  return new Set(['white:yellow', 'yellow:white', 'white:cyan', 'cyan:white']).has(pair);
+};
+
+export const hasSwiftLowContrastStaticColorPairUsage = (source: string): boolean => {
+  const sanitizedSource = sanitizeSwiftSourceForMultilineRegex(source);
+  const chainPattern =
+    /\.(?:foregroundStyle|foregroundColor)\s*\(([^)]{1,80})\)([\s\S]{0,300}?)(?:\.(?:background|fill)\s*\(([^)]{1,80})\))/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = chainPattern.exec(sanitizedSource)) !== null) {
+    const foreground = extractSwiftColorToken(match[1] ?? '');
+    const background = extractSwiftColorToken(match[3] ?? '');
+    if (foreground && background && isLowContrastSwiftColorPair(foreground, background)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
 export const hasSwiftForEachIndicesUsage = (source: string): boolean => {
   return hasSwiftSanitizedRegexMatch(
     source,
@@ -1459,6 +1699,7 @@ export const collectSwiftWaitForExpectationsLines = (source: string): readonly n
     ...collectSwiftRegexLines(source, /\b(?:self\s*\.\s*)?wait\s*\(\s*for\s*:/),
     ...collectSwiftRegexLines(source, /\bwaitForExpectations\s*\(/),
     ...collectSwiftRegexLines(source, /\bXCTWaiter\s*\.\s*wait\s*\(\s*for\s*:/),
+    ...collectSwiftRegexLines(source, /\bwaitForExistence\s*\(/),
   ]);
 };