pumuki 6.3.297 → 6.3.299

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

@@ -165,6 +165,110 @@ export const hasSwiftUnownedSelfCaptureUsage = (source: string): boolean => {
   );
 };
 
+export const collectSwiftManualMemoryManagementLines = (source: string): readonly number[] => {
+  return sortedUniqueLines([
+    ...collectSwiftRegexLines(source, /\bUnmanaged\s*</),
+    ...collectSwiftRegexLines(source, /\.(?:takeRetainedValue|takeUnretainedValue)\s*\(/),
+    ...collectSwiftRegexLines(source, /\b(?:CFRetain|CFRelease)\s*\(/),
+  ]);
+};
+
+export const hasSwiftManualMemoryManagementUsage = (source: string): boolean => {
+  return collectSwiftManualMemoryManagementLines(source).length > 0;
+};
+
+const swiftPascalCaseTypeNamePattern = /^[A-Z][A-Za-z0-9]*$/;
+
+export const collectSwiftNonPascalCaseTypeDeclarationLines = (source: string): readonly number[] => {
+  const matches: number[] = [];
+
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    const declarationMatches = line.matchAll(
+      /\b(?:class|struct|enum|actor|protocol)\s+([A-Za-z_][A-Za-z0-9_]*)\b/g
+    );
+
+    for (const match of declarationMatches) {
+      const typeName = match[1];
+      if (typeName && !swiftPascalCaseTypeNamePattern.test(typeName)) {
+        matches.push(index + 1);
+        break;
+      }
+    }
+  });
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftNonPascalCaseTypeDeclarationUsage = (source: string): boolean => {
+  return collectSwiftNonPascalCaseTypeDeclarationLines(source).length > 0;
+};
+
+const collectSwiftMethodBodyLines = (
+  source: string,
+  methodPattern: RegExp,
+  bodyMatcher: (line: string) => boolean
+): readonly number[] => {
+  const lines = source.split(/\r?\n/);
+  const matches: number[] = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const declarationLine = stripSwiftLineForSemanticScan(lines[index] ?? '');
+    methodPattern.lastIndex = 0;
+    if (!methodPattern.test(declarationLine)) {
+      continue;
+    }
+
+    let braceDepth =
+      countTokenOccurrences(declarationLine, '{') - countTokenOccurrences(declarationLine, '}');
+    const bodyStart = index + 1;
+    const bodyEnd = lines.length;
+    let hasReuse = /\.dequeueReusableCell\s*\(/.test(declarationLine);
+    const localMatches: number[] = [];
+
+    for (let cursor = bodyStart; cursor < bodyEnd; cursor += 1) {
+      const line = stripSwiftLineForSemanticScan(lines[cursor] ?? '');
+      if (/\.dequeueReusableCell\s*\(/.test(line)) {
+        hasReuse = true;
+      }
+      if (bodyMatcher(line)) {
+        localMatches.push(cursor + 1);
+      }
+
+      braceDepth += countTokenOccurrences(line, '{');
+      braceDepth -= countTokenOccurrences(line, '}');
+      if (braceDepth <= 0) {
+        break;
+      }
+    }
+
+    if (!hasReuse) {
+      matches.push(...localMatches);
+    }
+  }
+
+  return sortedUniqueLines(matches);
+};
+
+export const collectSwiftCellCreationWithoutReuseLines = (source: string): readonly number[] => {
+  return sortedUniqueLines([
+    ...collectSwiftMethodBodyLines(
+      source,
+      /\bfunc\s+tableView\s*\([^)]*\bcellForRowAt\b[^)]*\)\s*->\s*UITableViewCell\b/,
+      (line) => /\bUITableViewCell\s*\(/.test(line)
+    ),
+    ...collectSwiftMethodBodyLines(
+      source,
+      /\bfunc\s+collectionView\s*\([^)]*\bcellForItemAt\b[^)]*\)\s*->\s*UICollectionViewCell\b/,
+      (line) => /\bUICollectionViewCell\s*\(/.test(line)
+    ),
+  ]);
+};
+
+export const hasSwiftCellCreationWithoutReuseUsage = (source: string): boolean => {
+  return collectSwiftCellCreationWithoutReuseLines(source).length > 0;
+};
+
 export const hasSwiftNestedIfPyramidUsage = (source: string): boolean => {
   const lines = source.split(/\r?\n/);
   const ifBraceDepths: number[] = [];
@@ -565,6 +669,92 @@ export const hasSwiftUiImageDataDecodingUsage = (source: string): boolean => {
   return /\bUIImage\s*\(\s*data\s*:/.test(swiftSource);
 };
 
+export const collectSwiftUiManualRenderingWithoutImageRendererLines = (source: string): readonly number[] => {
+  const swiftSource = sanitizeSwiftSourceForMultilineRegex(source);
+  if (/\bImageRenderer\s*\(/.test(swiftSource)) {
+    return [];
+  }
+
+  const hasHostedSwiftUiView = /\bUIHostingController\s*\(\s*rootView\s*:/.test(swiftSource);
+  const hasManualRenderer =
+    /\bUIGraphicsImageRenderer\s*\(/.test(swiftSource) ||
+    /\.drawHierarchy\s*\(/.test(swiftSource) ||
+    /\.layer\s*\.\s*render\s*\(/.test(swiftSource);
+
+  if (!hasHostedSwiftUiView || !hasManualRenderer) {
+    return [];
+  }
+
+  return sortedUniqueLines([
+    ...collectSwiftRegexLines(source, /\bUIHostingController\s*\(\s*rootView\s*:/),
+    ...collectSwiftRegexLines(source, /\bUIGraphicsImageRenderer\s*\(/),
+    ...collectSwiftRegexLines(source, /\.drawHierarchy\s*\(/),
+    ...collectSwiftRegexLines(source, /\.layer\s*\.\s*render\s*\(/),
+  ]);
+};
+
+export const hasSwiftUiManualRenderingWithoutImageRendererUsage = (source: string): boolean => {
+  return collectSwiftUiManualRenderingWithoutImageRendererLines(source).length > 0;
+};
+
+export const collectSwiftLargeViewBuilderFunctionLines = (source: string): readonly number[] => {
+  const lines = source.split(/\r?\n/);
+  const matches: number[] = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const annotationLine = stripSwiftLineForSemanticScan(lines[index] ?? '');
+    if (!/@ViewBuilder\b/.test(annotationLine)) {
+      continue;
+    }
+
+    let functionLineIndex = -1;
+    for (let candidateIndex = index; candidateIndex < Math.min(lines.length, index + 4); candidateIndex += 1) {
+      const candidate = stripSwiftLineForSemanticScan(lines[candidateIndex] ?? '');
+      if (/\bfunc\s+[A-Za-z_][A-Za-z0-9_]*\s*\(/.test(candidate)) {
+        functionLineIndex = candidateIndex;
+        break;
+      }
+    }
+
+    if (functionLineIndex < 0) {
+      continue;
+    }
+
+    let braceDepth = 0;
+    let bodyStarted = false;
+    let bodyLineCount = 0;
+
+    for (let bodyIndex = functionLineIndex; bodyIndex < lines.length; bodyIndex += 1) {
+      const line = stripSwiftLineForSemanticScan(lines[bodyIndex] ?? '');
+      if (!bodyStarted && line.includes('{')) {
+        bodyStarted = true;
+      } else if (bodyStarted) {
+        const bodyOnly = line.replace(/[{}]/g, '').trim();
+        if (bodyOnly.length > 0) {
+          bodyLineCount += 1;
+        }
+      }
+
+      braceDepth += countTokenOccurrences(line, '{');
+      braceDepth -= countTokenOccurrences(line, '}');
+
+      if (bodyStarted && braceDepth <= 0) {
+        break;
+      }
+    }
+
+    if (bodyLineCount > 12) {
+      matches.push(index + 1, functionLineIndex + 1);
+    }
+  }
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftLargeViewBuilderFunctionUsage = (source: string): boolean => {
+  return collectSwiftLargeViewBuilderFunctionLines(source).length > 0;
+};
+
 export const hasSwiftUiInlineActionLogicUsage = (source: string): boolean => {
   const swiftSource = sanitizeSwiftSourceForMultilineRegex(source);
   const inlineButtonActionPattern =
@@ -575,6 +765,22 @@ export const hasSwiftUiInlineActionLogicUsage = (source: string): boolean => {
   return inlineButtonActionPattern.test(swiftSource) || inlineActionParameterPattern.test(swiftSource);
 };
 
+export const collectSwiftAnimationWithoutReduceMotionLines = (source: string): readonly number[] => {
+  const swiftSource = sanitizeSwiftSourceForMultilineRegex(source);
+  if (/\baccessibilityReduceMotion\b|\bUIAccessibility\s*\.\s*isReduceMotionEnabled\b/.test(swiftSource)) {
+    return [];
+  }
+
+  return sortedUniqueLines([
+    ...collectSwiftRegexLines(source, /\bwithAnimation\s*(?:\(|\{)/),
+    ...collectSwiftRegexLines(source, /\.animation\s*\(/),
+  ]);
+};
+
+export const hasSwiftAnimationWithoutReduceMotionUsage = (source: string): boolean => {
+  return collectSwiftAnimationWithoutReduceMotionLines(source).length > 0;
+};
+
 export const collectSwiftUiInlineActionLogicLines = (source: string): readonly number[] => {
   if (!hasSwiftUiInlineActionLogicUsage(source)) {
     return [];
@@ -723,6 +929,52 @@ export const hasSwiftPackageBranchDependencyUsage = (source: string): boolean =>
   return collectSwiftPackageBranchDependencyLines(source).length > 0;
 };
 
+export const collectSwiftPackageToolsVersionBelow62Lines = (source: string): readonly number[] => {
+  const lines: number[] = [];
+
+  source.split(/\r?\n/).forEach((line, index) => {
+    const match = line.match(/^\s*\/\/\s*swift-tools-version\s*:\s*(\d+)(?:\.(\d+))?/);
+    if (!match) {
+      return;
+    }
+
+    const major = Number.parseInt(match[1] ?? '0', 10);
+    const minor = Number.parseInt(match[2] ?? '0', 10);
+    if (major < 6 || (major === 6 && minor < 2)) {
+      lines.push(index + 1);
+    }
+  });
+
+  return lines;
+};
+
+export const hasSwiftPackageToolsVersionBelow62Usage = (source: string): boolean => {
+  return collectSwiftPackageToolsVersionBelow62Lines(source).length > 0;
+};
+
+export const collectSwiftStrictConcurrencyBelowCompleteLines = (source: string): readonly number[] => {
+  const lines: number[] = [];
+
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    const match = /\bSWIFT_STRICT_CONCURRENCY\s*=\s*([A-Za-z_][A-Za-z0-9_]*)\s*;?/.exec(line);
+    if (!match) {
+      return;
+    }
+
+    const value = (match[1] ?? '').trim().toLowerCase();
+    if (value === 'minimal' || value === 'targeted') {
+      lines.push(index + 1);
+    }
+  });
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftStrictConcurrencyBelowCompleteUsage = (source: string): boolean => {
+  return collectSwiftStrictConcurrencyBelowCompleteLines(source).length > 0;
+};
+
 export const hasSwiftOnAppearTaskUsage = (source: string): boolean => {
   return collectSwiftOnAppearTaskLines(source).length > 0;
 };
@@ -1751,6 +2003,42 @@ export const hasSwiftOnTapGestureUsage = (source: string): boolean => {
   });
 };
 
+export const collectSwiftOnTapGestureWithoutButtonTraitLines = (source: string): readonly number[] => {
+  const sanitizedLines = sanitizeSwiftSourceForMultilineRegex(source).split(/\r?\n/);
+  const originalLines = source.split(/\r?\n/);
+  const matches: number[] = [];
+
+  for (let index = 0; index < sanitizedLines.length; index += 1) {
+    if (!/\.onTapGesture\s*(?:\(|\{)/.test(sanitizedLines[index] ?? '')) {
+      continue;
+    }
+
+    const modifierWindow = sanitizedLines
+      .slice(index, Math.min(sanitizedLines.length, index + 8))
+      .join('\n');
+
+    if (/\.accessibilityAddTraits\s*\(\s*\.isButton\s*\)/.test(modifierWindow)) {
+      continue;
+    }
+
+    if (/\.accessibilityAddTraits\s*\(\s*AccessibilityTraits\s*\.\s*isButton\s*\)/.test(modifierWindow)) {
+      continue;
+    }
+
+    if (!/\.onTapGesture\s*(?:\(|\{)/.test(stripSwiftLineForSemanticScan(originalLines[index] ?? ''))) {
+      continue;
+    }
+
+    matches.push(index + 1);
+  }
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftOnTapGestureWithoutButtonTraitUsage = (source: string): boolean => {
+  return collectSwiftOnTapGestureWithoutButtonTraitLines(source).length > 0;
+};
+
 export const hasSwiftStringFormatUsage = (source: string): boolean => {
   return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
     if (current !== 'S' || !hasIdentifierAt(swiftSource, index, 'String')) {
@@ -1856,6 +2144,22 @@ export const hasSwiftMakeSUTWithoutMemoryTrackingUsage = (source: string): boole
   return collectSwiftMakeSUTWithoutMemoryTrackingLines(source).length > 0;
 };
 
+export const collectSwiftDirectSUTInstantiationWithoutMakeSUTLines = (source: string): readonly number[] => {
+  const sanitized = sanitizeSwiftSourceForMultilineRegex(source);
+  if (/\bmakeSUT\s*\(/.test(sanitized)) {
+    return [];
+  }
+
+  return collectSwiftRegexLines(
+    source,
+    /^\s*(?:let|var)\s+sut\s*=\s*[A-Z][A-Za-z0-9_]*(?:<[^>]+>)?\s*\(/g
+  );
+};
+
+export const hasSwiftDirectSUTInstantiationWithoutMakeSUTUsage = (source: string): boolean => {
+  return collectSwiftDirectSUTInstantiationWithoutMakeSUTLines(source).length > 0;
+};
+
 export const hasSwiftLegacyXCTestImportUsage = (source: string): boolean => {
   if (!hasSwiftXCTestImportUsage(source)) {
     return false;

package/core/facts/extractHeuristicFacts.ts

@@ -110,6 +110,11 @@ const isIOSSwiftPackageManifestPath = (path: string): boolean => {
   return path.replace(/\\/g, '/') === 'apps/ios/Package.swift';
 };
 
+const isIOSXcodeProjectFilePath = (path: string): boolean => {
+  const normalized = path.replace(/\\/g, '/');
+  return normalized.startsWith('apps/ios/') && normalized.endsWith('/project.pbxproj');
+};
+
 const isIOSPodfilePath = (path: string): boolean => {
   const normalized = path.replace(/\\/g, '/');
   return (
@@ -748,6 +753,10 @@ const textDetectorRegistry: ReadonlyArray<TextDetectorRegistryEntry> = [
   { platform: 'ios', pathCheck: isIOSPodfilePath, excludePaths: [], detect: detectsTrackedFilePresence, ruleId: 'heuristics.ios.dependencies.cocoapods.ast', code: 'HEURISTICS_IOS_DEPENDENCIES_COCOAPODS_AST', message: 'AST heuristic detected CocoaPods dependency files in an iOS project; Swift Package Manager remains the preferred baseline for new code.' },
   { platform: 'ios', pathCheck: isIOSCartfilePath, excludePaths: [], detect: detectsTrackedFilePresence, ruleId: 'heuristics.ios.dependencies.carthage.ast', code: 'HEURISTICS_IOS_DEPENDENCIES_CARTHAGE_AST', message: 'AST heuristic detected Carthage dependency files in an iOS project; Swift Package Manager remains the preferred baseline for new code.' },
   { platform: 'ios', pathCheck: isIOSSwiftPackageManifestPath, excludePaths: [], detect: TextIOS.hasSwiftPackageBranchDependencyUsage, locateLines: TextIOS.collectSwiftPackageBranchDependencyLines, primaryNode: (lines) => ({ kind: 'call', name: 'SwiftPM .package(..., branch: ...)', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: .package(..., exact:/from: version)', lines }], why: 'Branch-based SwiftPM dependencies drift over time and do not provide a reproducible iOS dependency graph.', impact: 'A consumer can build different code from the same commit when the remote branch moves, making production audits and regressions non-deterministic.', expected_fix: 'Pin the dependency to an exact version or an approved semantic version requirement in Package.swift; avoid branch-based dependencies outside explicitly approved experiments.', ruleId: 'heuristics.ios.dependencies.swiftpm-branch-dependency.ast', code: 'HEURISTICS_IOS_DEPENDENCIES_SWIFTPM_BRANCH_DEPENDENCY_AST', message: 'AST heuristic detected a branch-based SwiftPM dependency in iOS Package.swift; use specific versions for reproducible builds.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPackageManifestPath, excludePaths: [], detect: TextIOS.hasSwiftPackageToolsVersionBelow62Usage, locateLines: TextIOS.collectSwiftPackageToolsVersionBelow62Lines, primaryNode: (lines) => ({ kind: 'property', name: 'Package.swift swift-tools-version directive', lines }), relatedNodes: (lines) => [{ kind: 'property', name: 'replacement: // swift-tools-version: 6.2', lines }], why: 'An iOS Swift package manifest below Swift tools 6.2 cannot guarantee the current Swift 6.2 language baseline expected by the project skills.', impact: 'Consumers can compile with an older toolchain mode and miss concurrency or language diagnostics that Pumuki expects to enforce.', expected_fix: 'Update the Package.swift directive to // swift-tools-version: 6.2 and verify the package with the repository Xcode/Swift toolchain.', ruleId: 'heuristics.ios.dependencies.swift-tools-version-below-6-2.ast', code: 'HEURISTICS_IOS_DEPENDENCIES_SWIFT_TOOLS_VERSION_BELOW_6_2_AST', message: 'AST heuristic detected Package.swift using swift-tools-version below 6.2.' },
+  { platform: 'ios', pathCheck: isIOSXcodeProjectFilePath, excludePaths: [], detect: TextIOS.hasSwiftStrictConcurrencyBelowCompleteUsage, locateLines: TextIOS.collectSwiftStrictConcurrencyBelowCompleteLines, primaryNode: (lines) => ({ kind: 'property', name: 'SWIFT_STRICT_CONCURRENCY below complete', lines }), relatedNodes: (lines) => [{ kind: 'property', name: 'replacement: SWIFT_STRICT_CONCURRENCY = complete', lines }], why: 'The iOS skill contract requires Complete strict concurrency checking so unsafe actor/sendability issues cannot pass silently.', impact: 'Minimal or targeted strict concurrency leaves parts of the module below the Swift concurrency safety baseline and can hide data-race warnings.', expected_fix: 'Set SWIFT_STRICT_CONCURRENCY = complete for the affected iOS build configuration after addressing surfaced warnings.', ruleId: 'heuristics.ios.concurrency.strict-concurrency-below-complete.ast', code: 'HEURISTICS_IOS_CONCURRENCY_STRICT_CONCURRENCY_BELOW_COMPLETE_AST', message: 'AST heuristic detected SWIFT_STRICT_CONCURRENCY below complete in an iOS Xcode project.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftNonPascalCaseTypeDeclarationUsage, locateLines: TextIOS.collectSwiftNonPascalCaseTypeDeclarationLines, primaryNode: (lines) => ({ kind: 'class', name: 'Swift type declaration without PascalCase', lines }), relatedNodes: (lines) => [{ kind: 'class', name: 'replacement: PascalCase type name', lines }], why: 'Swift type declarations should use PascalCase so public and internal APIs remain idiomatic, searchable and reviewable.', impact: 'Non-PascalCase type names make ownership boundaries less consistent and weaken automated remediation because the gate cannot rely on the declaration node name.', expected_fix: 'Rename the Swift class, struct, enum, actor or protocol declaration to PascalCase and update its references in the same slice.', ruleId: 'heuristics.ios.naming.non-pascal-case-type.ast', code: 'HEURISTICS_IOS_NAMING_NON_PASCAL_CASE_TYPE_AST', message: 'AST heuristic detected Swift type declaration without PascalCase.' },
+  { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftCellCreationWithoutReuseUsage, locateLines: TextIOS.collectSwiftCellCreationWithoutReuseLines, primaryNode: (lines) => ({ kind: 'call', name: 'UIKit cell created without reuse in cell provider', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: dequeueReusableCell(withIdentifier:for:)', lines }], why: 'UITableView and UICollectionView cell providers must reuse cells instead of allocating a fresh cell for every item.', impact: 'Creating cells directly inside cellForRowAt or cellForItemAt degrades scrolling performance and bypasses UIKit reuse semantics.', expected_fix: 'Register the cell type or nib and return tableView/collectionView.dequeueReusableCell(withIdentifier:for:) from the cell provider.', ruleId: 'heuristics.ios.uikit.cell-without-reuse.ast', code: 'HEURISTICS_IOS_UIKIT_CELL_WITHOUT_REUSE_AST', message: 'AST heuristic detected UIKit cell provider creating cells without dequeueReusableCell.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftForceUnwrap, locateLines: TextIOS.collectSwiftForceUnwrapLines, primaryNode: (lines) => ({ kind: 'member', name: 'force unwrap postfix !', lines }), relatedNodes: (lines) => [{ kind: 'member', name: 'replacement: guarded optional binding or explicit failure path', lines }], why: 'Force unwrap turns optional handling into a runtime crash path instead of a checked domain, UI or infrastructure decision.', impact: 'A nil value can terminate the app outside the error boundary, making production behavior non-deterministic and hard to recover or test.', expected_fix: 'Replace postfix ! with guard let, if let, nil coalescing, throwing validation, or an explicit fallback. In modern Swift tests prefer #require when the unwrap is part of an assertion contract.', ruleId: 'heuristics.ios.force-unwrap.ast', code: 'HEURISTICS_IOS_FORCE_UNWRAP_AST', message: 'AST heuristic detected force unwrap usage.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftAnyViewUsage, locateLines: TextIOS.collectSwiftAnyViewLines, primaryNode: (lines) => ({ kind: 'call', name: 'type erasure wrapper AnyView', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: concrete View composition or @ViewBuilder branch', lines }], why: 'AnyView erases SwiftUI view identity and type information, hiding structural changes from the compiler and making diffing less predictable.', impact: 'SwiftUI may lose optimization opportunities, navigation/sheet branches become harder to reason about, and remediating UI regressions requires reading dynamic wrappers instead of concrete view composition.', expected_fix: 'Replace AnyView with concrete some View composition, @ViewBuilder branching, generic View parameters, or small extracted subviews that preserve static SwiftUI identity.', ruleId: 'heuristics.ios.anyview.ast', code: 'HEURISTICS_IOS_ANYVIEW_AST', message: 'AST heuristic detected AnyView usage.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftAnyTypeErasureUsage, locateLines: TextIOS.collectSwiftAnyTypeErasureLines, primaryNode: (lines) => ({ kind: 'property', name: 'Swift Any/AnyObject/AnyHashable type erasure', lines }), relatedNodes: (lines) => [{ kind: 'member', name: 'replacement: generics, associated types, protocol boundary or concrete domain type', lines }], why: 'General Swift type erasure hides domain contracts that should be expressed with generics, associated types or explicit protocol boundaries.', impact: 'Callers lose compile-time guarantees, invalid states travel through the codebase and remediation becomes runtime/debug driven instead of type-system driven.', expected_fix: 'Replace Any, AnyObject or AnyHashable usage with a generic parameter, associated type, concrete value object or narrow protocol boundary.', ruleId: 'heuristics.ios.type-erasure.any.ast', code: 'HEURISTICS_IOS_TYPE_ERASURE_ANY_AST', message: 'AST heuristic detected Swift Any/AnyObject/AnyHashable type erasure in production code.' },
@@ -770,6 +779,9 @@ const textDetectorRegistry: ReadonlyArray<TextDetectorRegistryEntry> = [
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftStrongDelegateReferenceUsage, ruleId: 'heuristics.ios.memory.strong-delegate.ast', code: 'HEURISTICS_IOS_MEMORY_STRONG_DELEGATE_AST', message: 'AST heuristic detected a strong delegate/dataSource reference; weak delegates remain the preferred baseline to avoid retain cycles.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftStrongSelfEscapingClosureUsage, ruleId: 'heuristics.ios.memory.strong-self-escaping-closure.ast', code: 'HEURISTICS_IOS_MEMORY_STRONG_SELF_ESCAPING_CLOSURE_AST', message: 'AST heuristic detected strong self capture in an escaping iOS closure; weak or unowned captures remain the preferred baseline when ownership is not explicit.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftUnownedSelfCaptureUsage, ruleId: 'heuristics.ios.memory.unowned-self-capture.ast', code: 'HEURISTICS_IOS_MEMORY_UNOWNED_SELF_CAPTURE_AST', message: 'AST heuristic detected unowned capture in an iOS closure; use weak capture unless lifetime is explicitly guaranteed.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftManualMemoryManagementUsage, locateLines: TextIOS.collectSwiftManualMemoryManagementLines, primaryNode: (lines) => ({ kind: 'call', name: 'manual ARC bypass / Core Foundation retain-release', lines }), relatedNodes: (lines) => [{ kind: 'class', name: 'replacement: ARC-owned Swift object lifetime', lines }], why: 'Manual Unmanaged or Core Foundation retain/release bypasses normal Swift ARC ownership and needs an explicit bridge boundary.', impact: 'Manual memory ownership can leak or over-release objects, and without line evidence the gate cannot identify the unsafe bridge call.', expected_fix: 'Prefer ARC-owned Swift references. If a Core Foundation bridge is unavoidable, isolate it in infrastructure with documented ownership invariants and typed wrappers.', ruleId: 'heuristics.ios.memory.manual-management.ast', code: 'HEURISTICS_IOS_MEMORY_MANUAL_MANAGEMENT_AST', message: 'AST heuristic detected manual memory management that bypasses Swift ARC.' },
+  { platform: 'ios', pathCheck: isSwiftTestPath, excludePaths: [], detect: TextIOS.hasSwiftDirectSUTInstantiationWithoutMakeSUTUsage, locateLines: TextIOS.collectSwiftDirectSUTInstantiationWithoutMakeSUTLines, primaryNode: (lines) => ({ kind: 'call', name: 'direct let sut = Type(...) instantiation', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: makeSUT() factory', lines }], why: 'iOS tests that instantiate the SUT inline duplicate setup and bypass the repository makeSUT factory contract.', impact: 'Test setup drifts across methods, memory tracking and dependency wiring become inconsistent, and later brownfield quality checks cannot rely on a single factory boundary.', expected_fix: 'Move direct SUT construction into a private makeSUT() helper and let test methods call let sut = makeSUT(). Add trackForMemoryLeaks(sut) inside the factory when the repository memory contract requires it.', ruleId: 'heuristics.ios.testing.direct-sut-instantiation-without-makesut.ast', code: 'HEURISTICS_IOS_TESTING_DIRECT_SUT_INSTANTIATION_WITHOUT_MAKESUT_AST', message: 'AST heuristic detected direct SUT instantiation in an iOS test without makeSUT().' },
+  { platform: 'ios', pathCheck: isSwiftTestPath, excludePaths: [], detect: TextIOS.hasSwiftMakeSUTWithoutMemoryTrackingUsage, locateLines: TextIOS.collectSwiftMakeSUTWithoutMemoryTrackingLines, primaryNode: (lines) => ({ kind: 'call', name: 'makeSUT() without trackForMemoryLeaks', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: trackForMemoryLeaks(sut)', lines }], why: 'A repository-specific XCTest quality contract that uses makeSUT must also register created SUT instances for memory-leak tracking.', impact: 'Tests can keep passing while leaked view models, views or controllers are introduced, weakening the brownfield XCTest quality baseline that Pumuki relies on.', expected_fix: 'Inside makeSUT(), assign the SUT to a local value, call trackForMemoryLeaks(sut), and then return the SUT. Preserve repository-specific makeSUT and memory tracking helpers when they are mandatory.', ruleId: 'heuristics.ios.testing.makesut-without-memory-tracking.ast', code: 'HEURISTICS_IOS_TESTING_MAKESUT_WITHOUT_MEMORY_TRACKING_AST', message: 'AST heuristic detected makeSUT() in an iOS test without trackForMemoryLeaks(sut).' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftNestedIfPyramidUsage, ruleId: 'heuristics.ios.maintainability.nested-if-pyramid.ast', code: 'HEURISTICS_IOS_MAINTAINABILITY_NESTED_IF_PYRAMID_AST', message: 'AST heuristic detected nested if pyramid in iOS code; prefer guard clauses and early returns.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftProductionCommentUsage, ruleId: 'heuristics.ios.maintainability.comment-trivia.ast', code: 'HEURISTICS_IOS_MAINTAINABILITY_COMMENT_TRIVIA_AST', message: 'AST heuristic detected source comments in iOS production code; prefer self-documenting names and extracted concepts.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftWarningSuppressionUsage, locateLines: TextIOS.collectSwiftWarningSuppressionLines, primaryNode: (lines) => ({ kind: 'member', name: 'Swift warning or lint suppression directive', lines }), relatedNodes: (lines) => [{ kind: 'member', name: 'replacement: fix the warned code or configure the exception centrally', lines }], why: 'Local warning and lint suppressions hide code-quality failures from the normal compiler/tooling feedback loop.', impact: 'Suppressed diagnostics can turn into future errors or let unsafe production code bypass Pumuki and repository skills without a visible remediation path.', expected_fix: 'Remove local swiftlint/swiftformat/periphery disable directives and #warning markers by fixing the underlying code, or move a justified project-wide exception into policy/config with traceability.', ruleId: 'heuristics.ios.maintainability.warning-suppression.ast', code: 'HEURISTICS_IOS_MAINTAINABILITY_WARNING_SUPPRESSION_AST', message: 'AST heuristic detected local warning/lint suppression in iOS production code; fix the underlying issue instead of hiding diagnostics.' },
@@ -827,6 +839,9 @@ const textDetectorRegistry: ReadonlyArray<TextDetectorRegistryEntry> = [
   { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftNonLazyScrollForEachUsage, locateLines: TextIOS.collectSwiftNonLazyScrollForEachLines, primaryNode: (lines) => ({ kind: 'call', name: 'ScrollView non-lazy stack with ForEach', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: LazyVStack or LazyHStack', lines }], why: 'A non-lazy stack inside ScrollView renders all rows eagerly instead of virtualizing collection content.', impact: 'Large lists can degrade performance and the gate must point to the ScrollView/ForEach pair, not the whole file.', expected_fix: 'Replace VStack/HStack under ScrollView with LazyVStack/LazyHStack when rendering collection rows.', ruleId: 'heuristics.ios.swiftui.non-lazy-scroll-foreach.ast', code: 'HEURISTICS_IOS_SWIFTUI_NON_LAZY_SCROLL_FOREACH_AST', message: 'AST heuristic detected ScrollView with a non-lazy stack feeding ForEach; LazyVStack/LazyHStack remain the preferred baseline for large scrollable collections.' },
   { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftViewBodyObjectCreationUsage, ruleId: 'heuristics.ios.swiftui.body-object-creation.ast', code: 'HEURISTICS_IOS_SWIFTUI_BODY_OBJECT_CREATION_AST', message: 'AST heuristic detected formatter object creation inside SwiftUI body; keep body simple and move expensive objects out of render paths.' },
   { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftUiImageDataDecodingUsage, ruleId: 'heuristics.ios.swiftui.image-data-decoding.ast', code: 'HEURISTICS_IOS_SWIFTUI_IMAGE_DATA_DECODING_AST', message: 'AST heuristic detected UIImage(data:) in SwiftUI presentation; downsample image data before rendering large images.' },
+  { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftUiManualRenderingWithoutImageRendererUsage, locateLines: TextIOS.collectSwiftUiManualRenderingWithoutImageRendererLines, primaryNode: (lines) => ({ kind: 'call', name: 'manual SwiftUI view rendering via UIHostingController', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: ImageRenderer(content:)', lines }], why: 'Manual UIHostingController plus UIGraphicsImageRenderer rendering snapshots SwiftUI imperatively instead of using the native ImageRenderer API.', impact: 'Rendering code becomes UIKit-bound, harder to test, and can drift from SwiftUI rendering semantics while the gate cannot point to the exact rendering node.', expected_fix: 'Replace manual UIHostingController/UIGraphicsImageRenderer/drawHierarchy rendering with ImageRenderer(content:) and read uiImage/cgImage from that renderer.', ruleId: 'heuristics.ios.swiftui.manual-rendering-without-imagerenderer.ast', code: 'HEURISTICS_IOS_SWIFTUI_MANUAL_RENDERING_WITHOUT_IMAGERENDERER_AST', message: 'AST heuristic detected manual SwiftUI view rendering without ImageRenderer.' },
+  { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftLargeViewBuilderFunctionUsage, locateLines: TextIOS.collectSwiftLargeViewBuilderFunctionLines, primaryNode: (lines) => ({ kind: 'call', name: 'large @ViewBuilder helper function', lines }), relatedNodes: (lines) => [{ kind: 'class', name: 'replacement: extracted SwiftUI subview', lines }], why: '@ViewBuilder helper functions are intended for small sections; large builders hide view structure inside a function body instead of explicit subviews.', impact: 'Large helper builders become hard to review, diff and test, and whole-file blocks are likely when the gate lacks the exact function node.', expected_fix: 'Extract the large @ViewBuilder function into one or more named SwiftUI subviews or reduce the helper to a small focused section.', ruleId: 'heuristics.ios.swiftui.large-viewbuilder-function.ast', code: 'HEURISTICS_IOS_SWIFTUI_LARGE_VIEWBUILDER_FUNCTION_AST', message: 'AST heuristic detected a large @ViewBuilder helper function; keep @ViewBuilder functions small and extract complex sections into subviews.' },
+  { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftAnimationWithoutReduceMotionUsage, locateLines: TextIOS.collectSwiftAnimationWithoutReduceMotionLines, primaryNode: (lines) => ({ kind: 'call', name: 'SwiftUI animation without reduce motion guard', lines }), relatedNodes: (lines) => [{ kind: 'property', name: 'replacement: accessibilityReduceMotion / UIAccessibility.isReduceMotionEnabled', lines }], why: 'SwiftUI animations must respect the system reduce motion preference.', impact: 'Users who reduce motion can still receive animated transitions, making the UI less accessible.', expected_fix: 'Read @Environment(\\.accessibilityReduceMotion) or UIAccessibility.isReduceMotionEnabled and disable or replace animations when reduce motion is enabled.', ruleId: 'heuristics.ios.accessibility.animation-without-reduce-motion.ast', code: 'HEURISTICS_IOS_ACCESSIBILITY_ANIMATION_WITHOUT_REDUCE_MOTION_AST', message: 'AST heuristic detected SwiftUI animation without reduce motion handling.' },
   { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftUiInlineActionLogicUsage, locateLines: TextIOS.collectSwiftUiInlineActionLogicLines, primaryNode: (lines) => ({ kind: 'call', name: 'SwiftUI Button action with inline logic', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: extracted action method', lines }], why: 'Inline branching or async work in a SwiftUI action makes the view declaration own behavior instead of delegating to a named action.', impact: 'Reviewers and agents cannot remediate a blocked view safely when the finding lacks the exact Button action node.', expected_fix: 'Extract the action body to a named method or view model command and reference that method from Button.', ruleId: 'heuristics.ios.swiftui.inline-action-logic.ast', code: 'HEURISTICS_IOS_SWIFTUI_INLINE_ACTION_LOGIC_AST', message: 'AST heuristic detected inline logic inside a SwiftUI action handler; action handlers should reference methods and keep view declarations focused.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftNavigationViewUsage, ruleId: 'heuristics.ios.navigation-view.ast', code: 'HEURISTICS_IOS_NAVIGATION_VIEW_AST', message: 'AST heuristic detected NavigationView usage.' },
   { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftUntypedNavigationLinkDestinationUsage, ruleId: 'heuristics.ios.swiftui.untyped-navigation-link-destination.ast', code: 'HEURISTICS_IOS_SWIFTUI_UNTYPED_NAVIGATION_LINK_DESTINATION_AST', message: 'AST heuristic detected untyped NavigationLink destination usage; prefer NavigationLink(value:) with navigationDestination(for:) for type-safe navigation.' },
@@ -834,6 +849,7 @@ const textDetectorRegistry: ReadonlyArray<TextDetectorRegistryEntry> = [
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftCornerRadiusUsage, locateLines: TextIOS.collectSwiftCornerRadiusLines, primaryNode: (lines) => ({ kind: 'call', name: 'SwiftUI cornerRadius modifier', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: clipShape with rounded rectangle style', lines }], why: 'cornerRadius is a legacy shape shortcut that hides the shape semantics used by modern SwiftUI styling.', impact: 'The fix is local, but without line evidence the gate forces unsafe file-wide remediation.', expected_fix: 'Replace .cornerRadius(...) with .clipShape(.rect(cornerRadius: ...)) or a named reusable shape/style token.', ruleId: 'heuristics.ios.corner-radius.ast', code: 'HEURISTICS_IOS_CORNER_RADIUS_AST', message: 'AST heuristic detected cornerRadius usage.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftTabItemUsage, ruleId: 'heuristics.ios.tab-item.ast', code: 'HEURISTICS_IOS_TAB_ITEM_AST', message: 'AST heuristic detected tabItem usage.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftOnTapGestureUsage, ruleId: 'heuristics.ios.on-tap-gesture.ast', code: 'HEURISTICS_IOS_ON_TAP_GESTURE_AST', message: 'AST heuristic detected onTapGesture usage where Button may be preferred.' },
+  { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftOnTapGestureWithoutButtonTraitUsage, locateLines: TextIOS.collectSwiftOnTapGestureWithoutButtonTraitLines, primaryNode: (lines) => ({ kind: 'call', name: 'SwiftUI onTapGesture without button accessibility trait', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: Button or accessibilityAddTraits(.isButton)', lines }], why: 'A tappable SwiftUI element that is not a Button must expose button semantics to assistive technologies.', impact: 'VoiceOver users can encounter an interactive element without the expected button trait, and the gate must point to the exact tap modifier.', expected_fix: 'Prefer Button for interactive controls. If onTapGesture is required, add .accessibilityAddTraits(.isButton) to the same element.', ruleId: 'heuristics.ios.accessibility.on-tap-without-button-trait.ast', code: 'HEURISTICS_IOS_ACCESSIBILITY_ON_TAP_WITHOUT_BUTTON_TRAIT_AST', message: 'AST heuristic detected onTapGesture without button accessibility trait.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftStringFormatUsage, ruleId: 'heuristics.ios.string-format.ast', code: 'HEURISTICS_IOS_STRING_FORMAT_AST', message: 'AST heuristic detected String(format:) usage.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftScrollViewShowsIndicatorsUsage, ruleId: 'heuristics.ios.scrollview-shows-indicators.ast', code: 'HEURISTICS_IOS_SCROLLVIEW_SHOWS_INDICATORS_AST', message: 'AST heuristic detected ScrollView(showsIndicators: false) usage.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftSheetIsPresentedUsage, ruleId: 'heuristics.ios.sheet-is-presented.ast', code: 'HEURISTICS_IOS_SHEET_IS_PRESENTED_AST', message: 'AST heuristic detected .sheet(isPresented:) usage where .sheet(item:) may be preferred.' },

package/core/rules/presets/heuristics/ios.test.ts

@@ -3,7 +3,7 @@ import test from 'node:test';
 import { iosRules } from './ios';
 
 test('iosRules define reglas heurísticas locked para plataforma ios', () => {
-  assert.equal(iosRules.length, 106);
+  assert.equal(iosRules.length, 117);
 
   const ids = iosRules.map((rule) => rule.id);
   assert.deepEqual(ids, [
@@ -28,6 +28,9 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     'heuristics.ios.memory.strong-delegate.ast',
     'heuristics.ios.memory.strong-self-escaping-closure.ast',
     'heuristics.ios.memory.unowned-self-capture.ast',
+    'heuristics.ios.memory.manual-management.ast',
+    'heuristics.ios.testing.makesut-without-memory-tracking.ast',
+    'heuristics.ios.testing.direct-sut-instantiation-without-makesut.ast',
     'heuristics.ios.maintainability.nested-if-pyramid.ast',
     'heuristics.ios.maintainability.comment-trivia.ast',
     'heuristics.ios.maintainability.warning-suppression.ast',
@@ -46,6 +49,10 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     'heuristics.ios.dependencies.cocoapods.ast',
     'heuristics.ios.dependencies.carthage.ast',
     'heuristics.ios.dependencies.swiftpm-branch-dependency.ast',
+    'heuristics.ios.dependencies.swift-tools-version-below-6-2.ast',
+    'heuristics.ios.concurrency.strict-concurrency-below-complete.ast',
+    'heuristics.ios.naming.non-pascal-case-type.ast',
+    'heuristics.ios.uikit.cell-without-reuse.ast',
     'heuristics.ios.security.userdefaults-sensitive-data.ast',
     'heuristics.ios.security.insecure-transport.ast',
     'heuristics.ios.localization.localizable-strings.ast',
@@ -88,6 +95,9 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     'heuristics.ios.swiftui.non-lazy-scroll-foreach.ast',
     'heuristics.ios.swiftui.body-object-creation.ast',
     'heuristics.ios.swiftui.image-data-decoding.ast',
+    'heuristics.ios.swiftui.manual-rendering-without-imagerenderer.ast',
+    'heuristics.ios.swiftui.large-viewbuilder-function.ast',
+    'heuristics.ios.accessibility.animation-without-reduce-motion.ast',
     'heuristics.ios.swiftui.inline-action-logic.ast',
     'heuristics.ios.navigation-view.ast',
     'heuristics.ios.swiftui.untyped-navigation-link-destination.ast',
@@ -95,6 +105,7 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     'heuristics.ios.corner-radius.ast',
     'heuristics.ios.tab-item.ast',
     'heuristics.ios.on-tap-gesture.ast',
+    'heuristics.ios.accessibility.on-tap-without-button-trait.ast',
     'heuristics.ios.string-format.ast',
     'heuristics.ios.scrollview-shows-indicators.ast',
     'heuristics.ios.sheet-is-presented.ast',
@@ -144,6 +155,50 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     byId.get('heuristics.ios.memory.unowned-self-capture.ast')?.then.code,
     'HEURISTICS_IOS_MEMORY_UNOWNED_SELF_CAPTURE_AST'
   );
+  assert.equal(
+    byId.get('heuristics.ios.memory.manual-management.ast')?.then.code,
+    'HEURISTICS_IOS_MEMORY_MANUAL_MANAGEMENT_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.dependencies.swift-tools-version-below-6-2.ast')?.then.code,
+    'HEURISTICS_IOS_DEPENDENCIES_SWIFT_TOOLS_VERSION_BELOW_6_2_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.concurrency.strict-concurrency-below-complete.ast')?.then.code,
+    'HEURISTICS_IOS_CONCURRENCY_STRICT_CONCURRENCY_BELOW_COMPLETE_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.naming.non-pascal-case-type.ast')?.then.code,
+    'HEURISTICS_IOS_NAMING_NON_PASCAL_CASE_TYPE_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.uikit.cell-without-reuse.ast')?.then.code,
+    'HEURISTICS_IOS_UIKIT_CELL_WITHOUT_REUSE_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.testing.makesut-without-memory-tracking.ast')?.then.code,
+    'HEURISTICS_IOS_TESTING_MAKESUT_WITHOUT_MEMORY_TRACKING_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.testing.direct-sut-instantiation-without-makesut.ast')?.then.code,
+    'HEURISTICS_IOS_TESTING_DIRECT_SUT_INSTANTIATION_WITHOUT_MAKESUT_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.swiftui.manual-rendering-without-imagerenderer.ast')?.then.code,
+    'HEURISTICS_IOS_SWIFTUI_MANUAL_RENDERING_WITHOUT_IMAGERENDERER_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.swiftui.large-viewbuilder-function.ast')?.then.code,
+    'HEURISTICS_IOS_SWIFTUI_LARGE_VIEWBUILDER_FUNCTION_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.accessibility.animation-without-reduce-motion.ast')?.then.code,
+    'HEURISTICS_IOS_ACCESSIBILITY_ANIMATION_WITHOUT_REDUCE_MOTION_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.accessibility.on-tap-without-button-trait.ast')?.then.code,
+    'HEURISTICS_IOS_ACCESSIBILITY_ON_TAP_WITHOUT_BUTTON_TRAIT_AST'
+  );
   assert.equal(
     byId.get('heuristics.ios.maintainability.nested-if-pyramid.ast')?.then.code,
     'HEURISTICS_IOS_MAINTAINABILITY_NESTED_IF_PYRAMID_AST'