realm/SwiftLint

This system is SwiftLint, a static analysis tool for Swift code that enforces style, performance, and accessibility conventions through a comprehensive suite of built-in and custom rules. It provides a command-line interface and integrates with development workflows via Swift Package Manager plugins, Bazel, and CI/CD reporters. The tool analyzes source files using SwiftSyntax to detect violations, supports automatic correction, and manages configuration inheritance and caching for efficient processing.

15 changes.

The project underwent a major architectural overhaul, migrating the CLI to swift-argument-parser and rewriting the core framework to support async/await and modern concurrency. This period also saw the removal of legacy build infrastructure, including Xcode project files and Carthage support, in favor of Swift Package Manager and updated dependency management for Swift 5.9.

24 changes.

This period focused on migrating SwiftLint from SourceKit to SwiftSyntax, restructuring the codebase into modular components like SwiftLintCore and SwiftLintBuiltInRules, and rewriting the CLI with swift-argument-parser. It also introduced extensive new linting rules, native Bazel build support, and comprehensive macro-based tooling for rule development and configuration.

17 changes.

This period focused on expanding SwiftLint's integration capabilities by introducing new SPM build and command plugins, while simultaneously refactoring the core configuration system for better performance and caching. The work also involved a comprehensive migration of the test suite to the Swift Testing framework and the addition of internal development tooling to streamline rule creation and maintenance.

The assets directory now includes a new Swift file, ScreenshotExample.swift, containing sample code with intentional style violations for demonstration purposes, and a new vector graphic, presentation.svg, which provides a high-resolution, scalable image for presentations.

assets · high confidence

Adds a new Swift Package Manager build tool plugin that automatically runs SwiftLint on Swift source files during the build process. The plugin locates the nearest \.swiftlint.yml\ configuration file to set the working directory, respects existing environment variables, and configures caching behavior (disabling it on Xcode Cloud). It also includes path helper utilities to validate that source files are within the expected project or package directories.

Plugins/SwiftLintBuildToolPlugin · high confidence

Adds a new command plugin that integrates SwiftLint directly into the build workflow for both Swift Package Manager and Xcode projects. The plugin automatically manages the cache directory, supports linting specific targets via the \--target\ option or provided file paths, and restricts Xcode target linting to Swift files only. It also prevents users from overriding the cache path and handles various SwiftLint subcommands (such as \version\ or \rules\) appropriately.

Plugins/SwiftLintCommandPlugin · high confidence

A new \SwiftLintBase\ module has been added to provide foundational utilities and infrastructure for the SwiftLint codebase, specifically to support macro implementations. This module includes a \CodeIndentingRewriter\ for handling syntax indentation and unindentation, thread-safe printing functions (\queuedPrint\, \queuedPrintError\, \queuedFatalError\) to manage concurrent output safely, and various string and URL extensions (such as \CurrentWorkingDirectory\ task-local support) to standardize common operations across the tool.

Source/SwiftLintBase · high confidence

This change adds the foundational data models for SwiftLint's core functionality, including \AccessControlLevel\ for representing Swift access modifiers, \Baseline\ for storing and filtering lint violations, \Command\ for parsing disable/enable comments, \Example\ for rule testing, \Issue\ for standardized error reporting, and \Location\/\Region\ for tracking code positions. These models provide the structured types required for rule configuration, violation tracking, and source code analysis within the SwiftLintCore module.

Source/SwiftLintCore/Models · high confidence

SwiftLint now supports user-defined custom rules via the \custom\_rules\ configuration, allowing users to define regex-based patterns with specific syntax kinds, severity levels, and messages, with execution modes defaulting to SwiftSyntax for performance but supporting SourceKit for complex cases. Additionally, the new \superfluous\_disable\_command\ rule warns when \swiftlint:disable\ comments are used for rules that would not have triggered a violation in the affected region, helping to clean up unnecessary linting directives.

Source/SwiftLintFramework/Rules · high confidence

A new internal \swiftlint-dev\ command-line tool is available to streamline SwiftLint development workflows. It provides subcommands to automatically register built-in rules and reporters by scanning source directories and updating the corresponding generated lists, and includes a \template\ command to scaffold new rule implementations with configurable options for severity, correctness, and testing.

Source/swiftlint-dev · high confidence

This change adds a complete Bazel build system for SwiftLint, enabling users to build and test the project using Bazel instead of Xcode. It includes BUILD files for the main target and all external dependencies (SwiftSyntax, SourceKitten, CryptoSwift, etc.), a dependency resolution module, and configuration for compiler options and concurrency strictness. The build system supports both traditional WORKSPACE-based builds and the newer bzlmod module system, ensuring compatibility with modern Bazel workflows.

bazel · high confidence

This change adds a comprehensive set of extension methods to the \SwiftLintCore\ module to support core linting operations and performance improvements. It introduces parallel execution helpers (\parallelMap\, \parallelFlatMap\, \parallelCompactMap\, \parallelFilterGroup\) for \Array\ and \Collection\ types, enabling faster processing of file contents. It also provides essential utility extensions for \NSRegularExpression\ (with caching), \SourceKittenDictionary\ (for parsing SourceKit structures), \SwiftLintFile\ (for caching syntax trees and managing regions), and type conversions between \SwiftSyntax\ and \SourceKitten\ models. Additionally, it includes a \Request\ extension to enforce SourceKit usage policies and a \Collection\ extension for sliding windows, forming the foundational infrastructure for the core linting engine.

Source/SwiftLintCore/Extensions · high confidence

SwiftLint introduces several new built-in rules to improve code quality and accessibility. The \accessibility\_label\_for\_image\ rule flags SwiftUI \Image\ views that lack an accessibility label or are not explicitly hidden from assistive technologies, helping prevent poor VoiceOver experiences. The \accessibility\_trait\_for\_button\ rule ensures that views with manual tap gestures include the \.isButton\ or \.isLink\ accessibility traits. Additionally, the \async\_without\_await\ rule detects and auto-corrects \async\ functions or closures that do not actually use \await\, promoting cleaner concurrency code. Other new rules include \array\_init\ (preferring \Array(seq)\ over \seq.map { $0 }\), \balanced\_xctest\_lifecycle\ (ensuring \setUp\/\tearDown\ balance in tests), and \blanket\_disable\_command\ (encouraging scoped lint disables).

Source/SwiftLintBuiltInRules/Rules/Lint · high confidence

The SwiftLint framework now includes a comprehensive set of reporters to support various development workflows. New reporters have been added to integrate with CI/CD platforms and modern tooling, including SARIF (for static analysis tools), SonarQube, Code Climate, GitHub Actions Logging, GitLab JUnit, and Markdown. Existing reporters have been updated or introduced to improve usability and compatibility: the HTML reporter now features a styled table with summary statistics, the JSON reporter outputs pretty-printed sorted keys, the CSV reporter properly escapes special characters, and the Emoji reporter displays rule identifiers. The Xcode reporter remains the default for IDE integration, while the Summary reporter provides a tabular overview of violations by rule.

Source/SwiftLintFramework/Reporters · high confidence

The \Source/SwiftLintCore/Visitors\ module now provides a set of reusable syntax visitors that standardize how SwiftLint analyzes code. This includes \BodyLengthVisitor\ for enforcing line-count thresholds, \CodeBlockVisitor\ for collecting violations across various code blocks (functions, closures, control flow), \CommandVisitor\ for parsing swiftlint comment directives, and specialized visitors like \CommentLinesVisitor\ and \EmptyLinesVisitor\ for detecting comment-only or blank lines. Additionally, \DeclaredIdentifiersTrackingVisitor\ enables rules to track variable scopes and declarations, while \EffectiveAccessControlSyntaxVisitor\ computes accurate access control levels for nested types. These components form the foundation for more consistent and powerful rule implementations.

Source/SwiftLintCore/Visitors · high confidence

The SwiftLintCore module now includes a new Macros.swift file defining several macros to simplify rule development: AutoConfigParser generates configuration parsing logic, SwiftSyntaxRule adds conformance to SwiftSyntaxRule and optional visitor/rewriter implementations, and example/correction macros (\#example, \#examples, \#corrections) allow for compiled, type-checked example code in rule descriptions. Additionally, a new Stack.swift helper provides a basic LIFO stack data structure, and SwiftSyntaxKindBridge.swift bridges SwiftSyntax classifications to SourceKitten syntax kinds, enabling SwiftSyntax-based custom rules to work with kind filtering without SourceKit calls.

Source/SwiftLintCore/Helpers · high confidence

This update introduces several new built-in rules to the Idiomatic category, including \anonymous\_argument\_in\_multiline\_closure\ (which flags anonymous arguments like \$0\ in multiline closures), \convenience\_type\ (which suggests using caseless enums for types with only static members), \discouraged\_assert\ (which prefers \assertionFailure\ over \assert(false)\), \discouraged\_none\_name\ (which warns against enum cases or static members named \none\), \discouraged\_object\_literal\ (which prefers initializers over \\#imageLiteral\/\\#colorLiteral\), \discouraged\_optional\_boolean\ (which flags optional booleans), and \discouraged\_optional\_collection\ (which flags optional arrays, dictionaries, or sets). These rules help enforce clearer, more modern Swift idioms.

Source/SwiftLintBuiltInRules/Rules/Idiomatic · high confidence

The \SwiftLintCoreMacros\ module introduces several new macros to streamline rule development and documentation. \@SwiftSyntaxRule\ automatically generates visitor and rewriter extensions based on attributes like \correctable\ or \optIn\, reducing boilerplate in rule implementations. \@AutoConfigParser\ and \@AcceptableByConfigurationElement\ generate configuration parsing logic for rule settings, allowing developers to define configurations with less manual code. Additionally, \\#example\, \\#examples\, and \\#corrections\ macros simplify the inclusion of code examples and corrections in rule descriptions by automatically capturing source locations and formatting.

Source/SwiftLintCoreMacros · high confidence

This update introduces a suite of new opt-in performance rules to SwiftLint, all located in the \Source/SwiftLintBuiltInRules/Rules/Performance\ directory. These rules encourage more efficient Swift code by flagging patterns such as using \filter(...).count\ or \filter(...).isEmpty\ instead of \contains\, replacing \sorted().first\/\last\ with \min()\/\max()\, preferring \isEmpty\ over comparing \count\ to zero or collections to empty literals, and using \reduce(into:\_:)\ for copy-on-write types. Specific rules include \contains\_over\_filter\_count\, \contains\_over\_filter\_is\_empty\, \contains\_over\_first\_not\_nil\, \contains\_over\_range\_nil\_comparison\, \empty\_collection\_literal\, \empty\_count\, \empty\_string\, \final\_test\_case\, \first\_where\, \flatmap\_over\_map\_reduce\, \last\_where\, \reduce\_boolean\, \reduce\_into\, and \sorted\_first\_last\. Most of these rules are opt-in and provide automatic corrections to refactor the flagged code into the recommended performance-friendly alternatives.

Source/SwiftLintBuiltInRules/Rules/Performance · high confidence

Users can now define custom linting rules using regular expressions via the new \RegexConfiguration\, which supports options for execution mode (SwiftSyntax or SourceKit), inclusion/exclusion patterns, and capture groups. Additionally, the \SeverityLevelsConfiguration\ allows rules to define specific thresholds for warning and error severities, enabling more granular control over violation reporting.

Source/SwiftLintCore/RuleConfigurations · high confidence

The \tools\ directory now includes a suite of new scripts to automate the release process and CI workflows. This includes \create-github-release.sh\ and \generate-release-notes.sh\ for building and publishing GitHub releases with artifacts for macOS, Linux, and Windows, alongside \add-new-changelog-section.sh\ to streamline changelog maintenance. Additional tools support Bazel integration (\update-artifact-bundle.sh\, \test-analyze.sh\), repository performance auditing (\oss-check\), GitHub issue lifecycle management (\stale-issues.rb\), and SourceKit loading verification (\verify-sourcekit-loading.sh\).

tools · high confidence

SwiftLint introduces several new style rules to enforce consistent formatting. The \attribute\_name\_spacing\ rule prevents spaces between attribute names and parentheses (e.g., \@MainActor\ vs \@ MainActor\) to ensure compatibility with Swift 6. The \attributes\ rule (opt-in) enforces that attributes are placed on their own lines for functions and types, but on the same line for variables and imports. Additionally, new rules \closing\_brace\, \closure\_end\_indentation\, \closure\_parameter\_position\, and \closure\_spacing\ enforce proper indentation and spacing for closures, including aligning closing braces with their opening lines and ensuring single spaces inside braces.

Source/SwiftLintBuiltInRules/Rules/Style · high confidence

SwiftLint now generates structured markdown documentation for its rule set, including a dedicated 'Swift Syntax Dashboard' that tracks the migration from SourceKit to SwiftSyntax. The generated 'Rule Directory' separates rules into Default, Opt-in, and Analyzer sections, while individual rule pages display identifiers, default status, autocorrection support, and rationale. This provides users with clearer visibility into which rules rely on SourceKit versus the faster SwiftSyntax backend.

Source/SwiftLintFramework/Documentation · high confidence

The SwiftLint Xcode project file (project.pbxproj) and its associated workspace configuration have been deleted. This change removes the legacy Xcode project structure and drops support for building SwiftLint via Carthage, shifting the project's build and dependency management away from these methods.

SwiftLint.xcodeproj · high confidence

The \script\ directory has been completely removed, deleting legacy utilities such as \bootstrap\, \cibuild\, \check-xcode-version\, and \extract-tool\, along with their associated \README.md\ and \LICENSE.md\ documentation. This eliminates the project's previous method for bootstrapping Objective-C dependencies, running continuous integration builds via \xctool\, and extracting CLI tools from application bundles, effectively ending support for these specific build workflows.

script · high confidence

The local Carthage dependency checkouts for Commandant, LlamaKit, SWXMLHash, SourceKitten, SwiftXPC, and xcconfigs have been removed from the repository.

Carthage · high confidence

The Xcode project file and its associated scheme definitions (SwiftLintFramework.xcscheme and swiftlint.xcscheme) have been deleted from the repository. This change removes the local Xcode build and test configurations, aligning with the removal of Carthage support and the project's shift away from maintaining an Xcode project structure.

SwiftLint.xcodeproj/xcshareddata · high confidence

The foundational protocols for SwiftLint rules—including \Rule\, \ASTRule\, \SwiftSyntaxRule\, \CollectingRule\, and \RuleConfiguration\—have been moved into the new \SwiftLintCore\ module. This structural change centralizes the core linting logic, establishing a cleaner separation between the rule definitions and the rest of the application, while introducing updated interfaces such as \SwiftSyntaxRule\ for rules backed by SwiftSyntax and \CollectingRule\ for rules requiring cross-file analysis.

Source/SwiftLintCore/Protocols · high confidence

The extra SwiftLint rules have been reorganized into a dedicated module (Source/SwiftLintExtraRules). This change introduces an Exports.swift file to manage module dependencies and an ExtraRules.swift file that provides a public extension point (extraRules()) for integrating custom native rules, specifically supporting Bazel builds.

Source/SwiftLintExtraRules · high confidence

The built-in linting rules have been moved into a new \SwiftLintBuiltInRules\ module. This change introduces an \Exports.swift\ file to re-export \SwiftLintCore\, a generated \BuiltInRules.swift\ file that registers all available rule types, and an \ImportUsage.swift\ model to handle import-related violations. For users, this represents an internal architectural reorganization that consolidates the rule definitions into a single, dedicated package without altering the linting behavior itself.

Source/SwiftLintBuiltInRules/Models · high confidence

The Bazel build configuration no longer treats compiler warnings as errors. A new patch file removes the \-warnings-as-errors\ flag from \bazel/copts.bzl\, allowing builds to complete even when warnings are generated, while retaining other upcoming features like \ConciseMagicFile\.

.bcr/patches · high confidence

SwiftLint now correctly honors exclusion rules for files located under directories symlinked to /private (such as CI workspaces or mktemp directories). The new FileManager extension bridges the gap between standardized URLs (which drop the /private prefix) and paths produced by the directory enumerator (which retain it), ensuring that exclusion patterns match correctly without incurring the performance cost of statting every file.

Source/SwiftLintFramework/Extensions · high confidence

The metrics rules in this module (including closure body length, cyclomatic complexity, enum case associated values, file length, function body length, function parameter count, large tuples, line length, nesting, and type body length) have been rewritten to use SwiftSyntax instead of SourceKit, providing more accurate and consistent analysis. Several rules now support new configuration options: the nesting rule can ignore typealiases and associated types, the line length rule can ignore multiline strings and regex literals, and the large tuple rule can ignore tuples inside regex types. Additionally, the cyclomatic complexity rule now supports ignoring case statements, and the function body length rule explicitly handles deinitializers, subscripts, and accessors.

Source/SwiftLintBuiltInRules/Rules/Metrics · high confidence

The \swiftlint\ module now includes new \LintOrAnalyzeArguments\ and \RulesFilterOptions\ structs in the \Common\ directory to centralize command-line argument definitions. \LintOrAnalyzeArguments\ consolidates shared flags such as \--config\, \--fix\, \--format\, \--leniency\, \--only-rule\, and \--baseline\, while \RulesFilterOptions\ provides flags like \--enabled\, \--disabled\, and \--correctable\ to filter which rules are displayed or processed. These changes refactor argument parsing into reusable components, improving consistency across lint and analyze commands.

Source/swiftlint/Common · high confidence

The file-matching logic has been extracted into a dedicated \Glob\ struct to support recursive globstar patterns and native Windows path resolution, replacing the previous inline implementation. Additionally, a new \ExecutableInfo\ helper has been added to macOS to retrieve a stable build identifier from the Mach-O header UUID, which can be used for caching or identification purposes.

Source/SwiftLintFramework/Helpers · high confidence

The SwiftLint.xcworkspace file has been deleted, removing the Xcode project reference and all associated Carthage checkout dependencies (SourceKitten, SwiftXPC, Commandant, LlamaKit, SWXMLHash). This change effectively drops Carthage support for the project, as the workspace that coordinated these dependencies no longer exists.

SwiftLint.xcworkspace · high confidence

The \Info.plist\ file and the \LinterTests.swift\ integration test suite have been removed from the SwiftLintFrameworkTests target. This cleanup eliminates the previous monolithic test structure that relied on a generic \violations\ helper, streamlining the test suite as new, specific rule tests (such as those for type names, line lengths, and trailing newlines) are introduced in their place.

Source/SwiftLintFrameworkTests · high confidence

The configuration logic in SwiftLintFramework has been reorganized into focused extensions to improve performance and maintainability. A new caching system (Configuration+Cache) stores parsed configurations in memory and on disk to avoid redundant parsing, while a file graph (Configuration+FileGraph) manages the inheritance tree of nested configuration files, supporting both local and remote YAML sources with timeout-based fetching and local caching. Configuration merging (Configuration+Merging) now explicitly handles the precedence of child over parent settings for included/excluded paths and rule modes. Additionally, lintable file discovery (Configuration+LintableFiles) uses parallel processing for speed, and global settings like indentation are now accessible to rules via a dedicated global configuration object.

Source/SwiftLintFramework/Configuration · high confidence

On macOS, the application now includes a workaround to suppress runtime dyld warnings caused by duplicate Objective-C class symbols from SwiftSyntax. This change adds a new C source file and header that define hidden duplicate class entries for specific SwiftSyntax types (such as SyntaxArena, SyntaxVisitor, and SyntaxRewriter), ensuring a cleaner console output without affecting functionality.

Source/DyldWarningWorkaround · high confidence

This entry covers the release of SwiftLint version 0.11.2. The release includes fixes for missing documentation in rule configurations, corrections for multi-byte character handling, and various test fixes.

(repo-wide) · high confidence

This release updates the framework version to 0.65.1 and introduces several internal improvements. The caching mechanism has been refactored to use a split read/write cache structure with file modification dates instead of hashing, ensuring cache invalidation when the Swift version changes. A new \CustomRuleTimer\ utility allows for thread-safe benchmarking of custom rule execution times. Additionally, the YAML parser now supports environment variable expansion in configuration files, and the linter logic has been updated to better handle SourceKit failures and superfluous disable commands.

Source/SwiftLintFramework/Models · high confidence

The SwiftLint command-line interface has been refactored to replace the legacy Commandant framework with swift-argument-parser. This change removes the old command registration structure (including the previous \lint\ and \version\ command implementations) and updates the underlying argument parsing logic, which may affect how CLI arguments are processed and how help or error messages are displayed to users.

Source/swiftlint · high confidence

The command-line interface has been migrated from the legacy Commandant library to Apple's swift-argument-parser, introducing a new command structure with dedicated subcommands for linting, analyzing, rule management, documentation, and baseline operations. This rewrite adds several new capabilities: a \baseline\ command to report and compare violation baselines, a \reporters\ command to list available output formats, and a \docs\ command to open rule documentation in a browser. The \rules\ command now supports filtering by configuration and displaying detailed rule descriptions with rationales. Additionally, the CLI now includes an automatic update checker accessible via the \version\ command, and the \lint\ command gains options to silence deprecation warnings, disable SourceKit, and enable all rules regardless of configuration. The tool now requires Swift 5.9 or later.

Source/swiftlint/Commands · high confidence

The SwiftLintFramework module has been significantly refactored to support modern concurrency and improved build integration. The core linting engine now uses async/await, enabling parallel file processing and progress reporting via a new ProgressBar. A new Benchmark module allows users to measure linting performance. The framework now supports extracting compiler arguments from Xcode build logs and compilation databases (including SwiftPM YAML) to enable more accurate analysis, handled by CompilerArgumentsExtractor and LintableFilesVisitor. Rule registration is centralized in Exports.swift, importing built-in, core, and extra rules. Additionally, the framework now detects Xcode Cloud environments and includes an UpdateChecker to notify users of new versions.

Source/SwiftLintFramework · high confidence

The configuration models for built-in SwiftLint rules have been moved into the new \SwiftLintBuiltInRules\ module and rewritten to use the \@AutoConfigParser\ macro and \SeverityBasedRuleConfiguration\ protocol. This change standardizes how rule options (such as severity levels, thresholds, and exclusion lists) are defined and parsed, providing a consistent and declarative configuration structure for users across all built-in rules.

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations · high confidence

The Windows installer has been updated to automatically add the SwiftLint installation directory to the system or user PATH environment variable during installation. This allows users to run the \swiftlint\ command from any location in the command line without needing to manually configure their environment variables.

Platforms · high confidence

Added CoreTests module with Swift Testing suite; Added integration test fixtures for configuration inheritance and file exclusion; Added integration tests for configuration path resolution and self-hosting linting; Added new test module for file system access scenarios; Added test suite for extra rules; Added tests for SwiftLint core macros and configuration parsing; Added tests for built-in rules using Swift Testing; Added tests for code indentation rewriting and string utilities; Generated tests for SwiftLint rules now use the Swift Testing framework; New TestHelpers module for Swift Testing integration; New test fixtures for file-system-dependent reporter and configuration validation; New test suite for the SwiftLint framework internals.

This release updates the SwiftLint build system and dependencies to support the latest tooling. The Swift Package Manager configuration now targets macOS 13 and Swift 5.9, enabling upcoming language features like ExistentialAny and InferIsolatedConformances, while adopting strict concurrency checking. Key dependencies have been upgraded, including SwiftSyntax to the 605.0.0 prerelease (2026-06-26), SourceKitten to 0.38.0, and Yams to 6.2.2. The CocoaPods distribution has been updated to version 0.65.1 with adjusted deployment targets (iOS 12.0, macOS 10.13, tvOS 12.0, watchOS 7.0), and the Ruby development environment now includes Danger 9.6.1 and Jazzy 0.15.4.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 45 → 51 (+5.4)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 99 (-1.2)
• Architecture 95 (new)
• Maturity 61 → 78 (+17.9)
• Readiness 30 → 71 (+40.8)
• Security 48 → 65 (+17.4)
• Accessibility 26 (new)

• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 10 more

• Change coupling: Analyze.swift ↔ Lint.swift (Source/swiftlint/Commands/Analyze.swift)
• Change coupling: SeverityConfiguration.swift ↔ SeverityLevelsConfiguration.swift (Source/SwiftLintCore/Models/SeverityConfiguration.swift)
• Coverage not measured — Swift suite
• Duplicated block (10–11 lines × 2) (Source/SwiftLintCore/Models/Example.swift)
• Duplicated block (10–12 lines × 2) (Source/SwiftLintBuiltInRules/Rules/Lint/CommentSpacingRule.swift)
• Duplicated block (11 lines × 2) (Source/SwiftLintCore/Visitors/CommentLinesVisitor.swift)
• Duplicated block (12 lines × 2) (Source/SwiftLintFramework/Configuration/Configuration.swift)
• Duplicated block (12–13 lines × 2) (Source/SwiftLintFramework/Configuration/Configuration.swift)
• Duplicated block (13 lines × 2) (Source/SwiftLintBuiltInRules/Rules/Lint/AccessibilityLabelForImageRule.swift)
• Duplicated block (17 lines × 2) (Source/SwiftLintFramework/Signposts.swift)
• Duplicated block (7 lines × 2) (Source/SwiftLintFramework/Reporters/CSVReporter.swift)
• Duplicated block (9 lines × 2) (Source/SwiftLintBuiltInRules/Rules/Lint/CommentSpacingRule.swift)
• FixmeComment (Tests/BuiltInRulesTests/TodoRuleTests.swift)
• FixmeComment (Tests/BuiltInRulesTests/TodoRuleTests.swift)
• Further sole-owners (lower concentration)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 557 more

• 30 commits — 28 feature/other, 2 fixes

• (root) — 12 commits
• .github/workflows — 8 commits
• .github/actions — 4 commits
• Source/SwiftLintBuiltInRules — 2 commits
• Source/SwiftLintBase — 1 commit
• Source/SwiftLintCoreMacros — 1 commit
• Source/SwiftLintFramework — 1 commit
• tools/oss-check — 1 commit

• fix: Fix legacy_swiftui_aspect_ratio to preserve whitespace (#6885)
• fix: Fix orphaned_doc_comment for current doc comment attachment (#6904)
• change: Add Brigade to the oss-check repositories (#6866)
• change: Add #example macro allowing for compiled example code (#6893)
• change: Add auto-correction, and multi-violation support to multiline_call_arguments (#6745)
• change: Add new changelog section
• change: Avoid recomputing the rule identifier in performLint (#6864)
• change: Bump DavidAnson/markdownlint-cli2-action from 24.1.0 to 24.2.0 (#6860)
• change: Bump apple_support from 2.8.0 to 2.8.1 (#6898)
• change: Bump apple_support from 2.8.1 to 2.8.3 (#6911)
• change: Bump bazel-contrib/publish-to-bcr from 1.4.2 to 1.5.0 (#6878)
• change: Bump danger from 9.6.0 to 9.6.1 (#6859)
• change: Bump docker/build-push-action from 7.3.0 to 7.4.0 (#6917)
• change: Bump docker/login-action from 4.5.2 to 4.6.0 (#6861)
• change: Bump docker/login-action from 4.5.2 to 4.6.0 (#6862)
• change: Bump docker/setup-buildx-action (#6880)
• change: Bump docker/setup-buildx-action from 4.2.0 to 4.3.0 (#6879)
• change: Bump docker/setup-buildx-action from 4.3.0 to 4.4.0 (#6918)
• change: Bump docker/setup-buildx-action from 4.3.0 to 4.4.1 (#6915)
• change: Bump ruby/setup-ruby from 1.321.0 to 1.323.0 (#6916)
• …and 10 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

realm/SwiftLint was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.