hylo-lang/hylo

Hylo is a systems programming language compiler that transforms source code into native machine code via an LLVM backend, while also providing an interpreter for execution. It features a comprehensive type system with ownership semantics, concurrency primitives, and a standard library supporting collections, threading, and memory management. The toolchain includes a command-line driver for controlling compilation phases, automated test generation, and utilities for symbol demangling and code formatting.

20 changes.

The project was rebranded to Hylo and rebuilt with a comprehensive CMake and Swift Package Manager infrastructure. This period focused on implementing the core compiler pipeline, including the lexer, parser, AST, type-checking constraint system, and IR generation modules.

25 changes.

This period focused on establishing the Hylo compiler's native code generation capabilities by introducing the LLVM backend and implementing symbol mangling infrastructure. Concurrently, the team built out the core standard library with essential types, traits, and memory management primitives, while significantly expanding test coverage across the lexer, parser, type checker, and end-to-end execution paths.

10 changes.

This period focused on expanding the language's runtime capabilities by introducing asynchronous concurrency primitives, low-level OS threading, and a new efficient string representation. Concurrently, significant internal refactoring standardized compile-time value handling and requirement rewriting, while establishing the core memory management and type layout infrastructure for the interpreter.

A new command-line interface has been added to the hylo-demangle module, allowing users to pass a mangled symbol name as an argument to receive its demangled form on standard output. The tool imports the IR module to perform the demangling and provides clear error messages for missing inputs or symbols that cannot be demangled. Additionally, the FullPathInFatalErrors.swift file in this location is now a symlink to the shared version in the parent directory, ensuring consistent error handling behavior across modules.

Sources/hylo-demangle · high confidence

The Float32 type in the standard library now supports standard arithmetic operations (addition, subtraction, multiplication, division, remainder) and comparison operators (less than, greater than, equality, etc.), along with compound assignment operators. It also includes a static \pi()\ constant and conforms to \ExpressibleByFloatLiteral\, \ExpressibleByIntegerLiteral\, \Deinitializable\, and \Copyable\. Note that division and remainder operations currently lack runtime checks for division by zero.

StandardLibrary/Sources/Core/Numbers/Floats · high confidence

This change introduces the initial implementation of threading capabilities in the Hylo standard library, providing a high-level API for creating and managing OS threads on Linux and macOS. Users can now spawn new threads using \spawn\_thread\, passing closures with or without arguments (including mutable references), and wait for their completion via \ThreadCompletion\. The implementation includes utilities to retrieve the current thread ID, yield execution time to the scheduler, and query the system's available parallelism. Under the hood, this is built on POSIX pthreads, exposing FFI bindings for thread creation, joining, and attribute management.

StandardLibrary/Sources/LowLevel · high confidence

The Examples directory now includes four new Hylo source files: \hello.hylo\ (a standard Hello World program), \fortytwo.hylo\ (a minimal program returning 42), \factorial.hylo\ (a recursive factorial implementation), and \concurrent\_greeting.hylo\ (demonstrating thread spawning and awaiting with the concore2full library). These files replace the previous \.val\ extensions and provide fresh starting points for users learning the language.

Examples · high confidence

The TestGeneratorPlugin now automatically generates XCTest cases from annotated .hylo files during the build process. By scanning the target's TestCases directory for .hylo files and invoking the GenerateHyloFileTests tool, the plugin produces a HyloFileTests.swift file, allowing developers to write tests in the .hylo format without manually maintaining corresponding XCTest boilerplate.

Plugins/TestGeneratorPlugin · high confidence

The FrontEnd module now includes foundational data structures for program analysis, including ASTProperty, DeclProperty, ExprProperty, and PatternProperty to map AST nodes to associated values, as well as AccessEffect and AccessEffectSet to track how values are accessed (e.g., immutable, mutable, consumed). It also adds Conformance and ConformanceOrigin to represent type conformances, Diagnostic and DiagnosticSet for error reporting, and BuiltinFunction to define built-in operations. Additionally, it introduces Program and ScopedProgram protocols for representing typed programs, ConditionalCompilationFactors for build configuration, and various predicate types (FloatingPointPredicate, IntegerPredicate) and utility structs (SemanticVersion, SourceFile, ScopedValue) to support the type-checking and compilation pipeline.

Sources/FrontEnd · high confidence

Introduces the LLVM code generation backend for the Hylo compiler, enabling the transpilation of Hylo Intermediate Representation (IR) into LLVM IR. This change adds the core infrastructure for compiling Hylo programs to native machine code, including type lowering for built-in types, product types, tuples, unions, and buffers; code generation for functions, subscripts, and global static storage; and the ability to emit object files. It also establishes the \SwiftyLLVM\ module integration and provides optimization passes.

Sources/CodeGen/LLVM · high confidence

The integer types (Int, Int8, Int32, Int64, UInt, UInt8, UInt32, UInt64) now conform to a full hierarchy of standard library traits including AdditiveArithmetic, Numeric, BinaryInteger, FixedWidthInteger, Hashable, and Comparable. This enables users to perform standard arithmetic, bitwise operations, comparisons, and hashing on all integer sizes, while also providing specific capabilities like overflow reporting, bit-width queries, and power-of-two rounding.

StandardLibrary/Sources/Core/Numbers/Integers · high confidence

This change adds the foundational Abstract Syntax Tree (AST) node definitions for various statement types within the new Sources/FrontEnd/AST/Stmt directory. Users can now expect the compiler to recognize and process standard control-flow structures including assignments, blocks, loops (for, while, do-while), conditionals (if/else), and flow-control statements (break, continue, return, yield, discard). The diff also introduces specific support for conditional compilation directives (allowing checks against OS, architecture, features, and compiler versions) and conditional bindings, establishing the structural backbone for the merged FrontEnd module's parsing and semantic analysis capabilities.

Sources/FrontEnd/AST/Stmt · high confidence

The IR module now includes a complete system for generating and parsing unique, assembly-safe identifiers for compiler symbols. This adds support for mangling declarations (functions, types, bindings), generic parameters, and complex types (tuples, unions, buffers, associated types). The implementation uses a Base64 encoding scheme to ensure all generated symbols are valid LLVM assembly identifiers, enabling the compiler to correctly reference and resolve internal entities during code generation.

Sources/IR/Mangling · high confidence

The \Sources/FrontEnd/Parse\ module now provides the core lexical and syntactic analysis for the Hylo language. The new \Lexer\ handles tokenization, including support for conditional compilation keywords (\\#if\, \\#else\, \\#elseif\, \\#endif\), pragmas, and numeric literals with exponents. The \Parser\ constructs the Abstract Syntax Tree (AST) from these tokens, implementing parsing for declarations, expressions, and control flow, while \ParserState\ manages the parsing context and error reporting via a new \DiagnosticSet\ system.

Sources/FrontEnd/Parse · high confidence

The IR analysis module now includes a reusable abstract interpretation framework (AbstractContext, AbstractDomain, AbstractInterpreter) and foundational data structures for control-flow (ControlFlowGraph) and dominance (DominatorTree) analysis. This enables new optimization and checking passes, specifically frame reification for projection callers, access reification to narrow memory access capabilities, and yield coherence checking for subscripts.

Sources/IR/Analysis · high confidence

The standard library now includes foundational collection types: \Array\ (a dynamic, random-access collection with methods like \append\, \insert\, \remove\, and \pop\_last\), \BoundedArray\ (a fixed-capacity collection suitable for non-movable elements), and \BitArray\ (a space-efficient array of bits). Additionally, the library provides \DynamicBuffer\ for contiguous memory storage, low-level memory allocation via \hylo\_aligned\_alloc\/\hylo\_aligned\_free\, and basic I/O utilities in \Print\ for writing to standard output.

StandardLibrary/Sources · high confidence

The interpreter now includes core runtime components to manage execution state and memory. A new \BuiltinValue\ enum handles integer values (i1 through i128) derived from IR constants. \TypeLayout\ and \TypeLayoutCache\ provide memoized calculation of memory layouts for types, including support for unions with discriminators. The \Memory\ struct manages allocations, ensuring proper alignment and bounds checking, while \TargetABI\ (specifically \UnrealABI\) defines the layout rules for builtin types. These changes establish the foundation for the interpreter to correctly handle variable storage and type representation during execution.

Sources/Interpreter · high confidence

The IR now includes a comprehensive set of new instructions to handle memory management, control flow, and advanced language features. Memory operations include \Access\ (replacing previous borrow models), \AllocStack\/\DeallocStack\, \Load\/\Store\, \MarkState\, \MemoryCopy\, and \Move\. Control flow is handled by \Branch\, \CondBranch\, and \Return\. The IR also supports complex type interactions through \OpenUnion\/\CloseUnion\ for union payloads, \Project\/\EndProject\ for value projections, and \ProjectBundle\/\CallBundle\ for subscript and method bundles. Additional instructions like \CaptureIn\/\ReleaseCaptures\ manage remote value lifetimes, while \AdvancedByBytes\/\AdvancedByStrides\ and \PlaceToPointer\/\PointerToPlace\ handle low-level address arithmetic and conversions. \ConstantString\ and \GenericParameter\ provide support for literals and generics, and \CallFFI\ enables foreign function interface calls.

Sources/IR/Operands/Instruction · high confidence

The standard library now includes \Future\ and \EscapingFuture\ types, along with \spawn\_\ and \escaping\spawn\\ functions, enabling users to spawn asynchronous computations and await their results. \Future\ is designed for local scope usage, while \EscapingFuture\ allows the result handle to be passed across scope boundaries, with both types integrating with the underlying \concore2full\ runtime via \SpawnFrame\ and \SpawnFrameBase\ structures.

StandardLibrary/Sources/Concurrency · high confidence

The compiler now exposes a unified command-line interface via the 'hc' executable, built on ArgumentParser. Users can control the compilation pipeline using the --last-phase flag to stop after type-checking, lowering, or emitting, and can inspect intermediate outputs (raw AST, IR, LLVM IR, assembly) via the --emit flag. Diagnostics are now rendered with optional ANSI styling for better readability, and subprocess errors provide detailed output including standard output and error streams. The driver also supports parallel type-checking as an experimental feature and allows linking against native libraries.

Sources/Driver · high confidence

The type-checking module now includes new foundational types to support the constraint-based solver: \ConstraintSystem\ manages the solving of type and name constraints, \Solution\ represents the resulting substitutions and diagnostics, and \SubstitutionMap\ handles variable assignments. Supporting structures like \ProofObligations\ define the constraints to be solved, while \NameResolutionResult\ and \ArgumentResolutionResult\ model the outcomes of name lookup and argument matching. New enums such as \NameUse\ and \BindingDeclUse\ track how names and bindings are utilized, and \RefinementClosure\/\RefinementSequence\ manage trait refinement relationships.

Sources/FrontEnd/TypeChecking · high confidence

The core library now includes a new \UTF8Array\ type that manages UTF-8 code units using an optimized inline storage strategy for short strings (up to 7 units) and out-of-line heap allocation for longer content. This change provides users with a more efficient underlying representation for string data, automatically handling memory management and null-terminated buffer projections for interoperability.

StandardLibrary/Sources/Core/String · high confidence

The compiler now includes a dedicated IR (Intermediate Representation) module that transforms typed ASTs into a form suitable for flow-sensitive analysis and code generation. This change introduces the core IR data structures, including \Function\, \Block\, \Instruction\, and their respective IDs, along with an \Emitter\ responsible for lowering declarations and synthesized code. It also adds support for representing type layouts, conformance witnesses, and method bundle references, establishing the foundational infrastructure for subsequent IR passes and LLVM code generation.

Sources/IR · high confidence

The \Sources/FrontEnd/AST/Decl\ directory now contains the foundational Abstract Syntax Tree (AST) structures for the compiler's FrontEnd module. This change introduces new types for core language constructs, including \FunctionDecl\, \MethodDecl\, \SubscriptDecl\, \TraitDecl\, \ProductTypeDecl\, and \ConformanceDecl\, alongside supporting structures for generics (\GenericClause\, \GenericParameterDecl\), access control (\AccessModifier\), and capture semantics (\CapturingDecl\, \ImplicitCapture\). It also adds models for module organization (\ModuleDecl\, \TranslationUnit\, \NamespaceDecl\) and synthesized code generation (\SynthesizedFunctionDecl\), establishing the data structures required to represent and validate source code declarations.

Sources/FrontEnd/AST/Decl · high confidence

The FrontEnd module now includes a comprehensive set of Abstract Syntax Tree (AST) nodes for expressions and declaration modifiers. This adds support for access and member modifiers (private, internal, public, static), as well as a wide range of expression types including literals (boolean, integer, float, string, unicode, buffer, map), control flow (conditional, match), function calls, lambdas, captures, casts, and sequence operations. These new types form the structural foundation for parsing and representing source code within the renamed FrontEnd compiler target.

Sources/FrontEnd/AST/DeclModifiers, Sources/FrontEnd/AST/Expr · high confidence

A new \TestUtils\ module has been added to provide shared infrastructure for testing the Hylo compiler. This includes \HyloTestCase\ for managing a shared, type-checked standard library instance across tests, \AnnotatedHyloFileTest\ for parsing and validating \//!\ source annotations (such as expected diagnostics), and \ProgramInstances\ for convenient compilation and interpretation of test files. The module also provides XCTest compatibility shims for non-Apple platforms and helper functions for checking errors and diagnostics.

Sources/TestUtils · high confidence

The Tools directory now includes scripts and templates to support documentation extraction and code formatting. A new \doc-index.html.gyb\ template generates an index page for implementation documentation, while \gyb.py\ provides the underlying template engine. The \run-swift-format.sh\ script automates linting and fixing of Swift source code, and \set-hc-version.sh\ manages the compiler version string. Additionally, \retry-once\ is added to handle spurious failures in CI environments.

Tools · high confidence

Introduces the GenerateHyloFileTests command-line tool, which automatically generates XCTest cases from annotated .hylo source files to streamline the testing of Hylo programs. The tool supports various test types including compilation, type checking, and parsing, and now includes support for generating tests that apply optimizations. Additionally, a shared FullPathInFatalErrors.swift file is symlinked into the test module to ensure consistent error reporting across tests.

Sources/GenerateHyloFileTests · high confidence

This change introduces a comprehensive suite of new utility types and algorithms to the \Sources/Utils\ module. Key additions include concurrency-safe wrappers like \AnyHashableAndSendable\ and \SharedMutable\, lazy evaluation types (\Lazy\, \LazyThrowing\), and a \BitArray\ for efficient bit manipulation. The update also adds data structures such as \DirectedGraph\ (with BFS and reachability support), \DoublyLinkedList\, \CustomWitnessedSet\, and \DistinctNameGenerator\. Furthermore, it extends standard library types with new methods on \Collection\, \Sequence\, \Dictionary\, and \Optional\, alongside helper protocols like \HashableWitness\ and \EquatableWitness\ for custom conformance.

Sources/Utils · high confidence

The project has been renamed from Val to Hylo, reflected in the repository name, documentation, and the compiler executable name (hc). A CMake build system has been added alongside the existing Swift Package Manager support, allowing users to build the compiler using CMake and Ninja or Xcode. The repository now requires LLVM 20 and Swift 6.2 or higher, and includes configuration files for editor consistency, linting, and CI integration.

(repo-wide) · high confidence

The StandardLibrary/Sources/Core module now provides the foundational building blocks for the language, including core traits like Collection, Hashable, Equatable, and Comparable, as well as essential types such as Optional, Range, Pointer, and String. This update adds standard collection algorithms (count, contains, reduce, rotate), memory management utilities (MemoryLayout, unsafe\_bitcast), and assertion handling with stacktrace support, establishing the base API for data structures and runtime behavior.

StandardLibrary/Sources/Core · high confidence

The \Sources/FrontEnd/Types\ directory now contains the complete type system implementation for the compiler's front end, consolidating type definitions into a new module. This includes the \AnyType\ type-erased container, the \TypeProtocol\ for type operations, and specific types for functions (\ArrowType\, \MethodType\), generics (\BoundGenericType\, \GenericTypeParameterType\), and built-ins (\BuiltinType\). The change also introduces \ValueFlags\ to track structural properties and \GenericEnvironment\ to manage constraint solving, effectively replacing the previous scattered type definitions with a cohesive, modular structure.

Sources/FrontEnd/Types · high confidence

A new dummy target has been added to support building with SPM\_BUILD\_TOOL\_SUPPORT\_NO\_REENTRANT\_BUILD=1 on Windows. This change allows build tool plugins to be built by requesting a single target, avoiding the creation of a separate product for each executable target.

Sources/BuildToolDependencies · high confidence

The Sources/hc module now deduplicates the FullPathInFatalErrors.swift file by replacing the source file with a symlink to the shared version, and the main entry point has been simplified to import and invoke Driver.main(), centralizing the CLI execution logic.

Sources/hc · high confidence

The AST implementation has been reorganized into the \Sources/FrontEnd/AST\ directory, merging previously separate Core and FrontEnd modules into a unified structure. This change introduces a \CoreEntities\ system that provides structured access to standard library traits (such as \Collection\, \Equatable\, and \Copyable\) and renames the module loading entry point from \makeModule\ to \loadModule\ for consistency. Additionally, the language now supports parsing and type-checking of option patterns (e.g., \if let\), and the \ConditionalBindingStmt\ node has been renamed to \ConditionalBindingStmt\ to improve naming clarity.

Sources/FrontEnd/AST · high confidence

The Terms module has been restructured to support a new compile-time value representation. A new \AnyTerm\ type-erased container now wraps term instances, providing a unified way to handle different term types while preserving equality and hashing semantics. Several new concrete term types have been added: \ConcreteTerm\ for wrapping hashable and sendable values, \ErrorTerm\ to represent type-checking errors, \GenericTermParameter\ for generic type parameters (skolems), and \TermVariable\ for variable references. These changes introduce new flags in \ValueFlags\ (such as \.hasError\, \.hasSkolem\, \.hasVariable\) to distinguish term behaviors at compile time, enabling more precise tracking of term states during compilation.

Sources/FrontEnd/Terms · high confidence

The FrontEnd AST now uses a new, type-safe identity system for all Abstract Syntax Tree nodes. This change introduces a \NodeIDProtocol\ hierarchy with specific ID types for declarations (\DeclID\), expressions (\ExprID\), statements (\StmtID\), patterns (\PatternID\), and scopes (\ScopeID\), along with type-erased wrappers like \AnyNodeID\ and \AnyDeclID\. Node identities are now backed by a \NodeRawIdentity\ struct that encodes base and offset bits, enabling efficient hashing and comparison. A centralized \NodeKind\ enum explicitly lists all supported node types (declarations, expressions, patterns, statements) and supports serialization/deserialization, ensuring that node types are consistently identified and tracked throughout the compiler's front-end processing.

Sources/FrontEnd/AST/NodeIDs · high confidence

The IR now exposes a dedicated \Constant\ protocol and a set of concrete constant types (FloatingPointConstant, IntegerConstant, WordConstant, FunctionReference, VoidConstant, MetatypeType, and WitnessTable) within the \Sources/IR/Operands/Constant\ module. This change replaces ad-hoc constant handling with a unified, type-safe representation for values like floats, integers, function references, and witness tables, ensuring that constants carry explicit IR types and support canonicalization and hashing.

Sources/IR/Operands/Constant · high confidence

The IR operand representation has been refactored to replace the previous \Constant\ enum with an existential \any Constant\ type, allowing for more flexible constant handling. The \Operand\ type now exposes public properties for accessing the instruction ID, the constant payload, and a boolean flag indicating if the operand is a constant. New convenience methods have been added to create built-in Boolean (\i1\) and machine-word-sized integer (\word\) constants, alongside an existing void constant. The operand's description format has been simplified, and the type now conforms to \Equatable\ and \Hashable\ based on its underlying values.

Sources/IR/Operands · high confidence

The requirement rewriting logic in the type checker has been restructured to use a more abstract, equatable, and testable \RewritingSystem\ and \RewritingRule\ architecture. This change introduces a dedicated \RequirementPrinter\ to generate clearer textual descriptions of requirement rules and terms, aiding in debugging and understanding the rewriting process. The underlying data structures for terms and rules are now more explicitly defined and conform to standard protocols, facilitating better integration with testing and future enhancements to the completion procedures.

Sources/FrontEnd/TypeChecking/Rewriting · high confidence

The type-checking constraint system in the FrontEnd module has been refactored to improve diagnostic accuracy and internal structure. Call constraints now track the specific source location of the callee expression (renamed from 'site' to 'valueSite') and account for mutation markers, while member constraints explicitly record the purpose of name usage. A new ConstraintOrigin structure categorizes the reason for each constraint (e.g., annotations, arguments, where clauses), enabling more precise error reporting for issues like where clause violations. The system also introduces methods to collect open variables and supports parallel type checking through these updated constraint definitions.

Sources/FrontEnd/TypeChecking/Constraints · high confidence

The internal representation of compile-time values has been restructured to introduce a new \CompileTimeValue\ enum that unifies type and term handling, along with a dedicated \ValueFlags\ struct to track properties such as errors, type variables, and canonicality. This change ensures that function IDs and type representations are maintained in canonical form, improving consistency during specialization and generic argument resolution.

Sources/FrontEnd/CompileTimeValues · medium confidence

Users can now control how the standard library sources are located by setting the \HYLO\_USE\_BUILTIN\_STDLIB\ environment variable. When enabled, the compiler loads sources directly from the source tree (\Sources\ directory), ensuring that diagnostics point to original files and edits fix issues; otherwise, it falls back to bundled resources. This change also introduces a \pthreadVCE3.lib\ polyfill for Windows to provide threading and basic LibC functions, and refactors the AST initialization to use \loadModule\ and \compilationConditions\ for clearer conditional compilation handling.

StandardLibrary · high confidence

Added driver and source-line parsing tests; Added end-to-end execution tests; Added end-to-end tests for concurrency features; Added end-to-end tests for projection and subscript mechanics; Added interpreter test suite for memory, type layout, and execution; Added standard library test suite for core types and concurrency; Added tests for assembly sanitization, Base64VarUInt encoding, and symbol mangling; Added unit tests for Utils library components; Expanded end-to-end test coverage for Hylo language features; Expanded lowering test coverage for Hylo; Expanded parser test coverage for Hylo language constructs; Expanded type-checking test coverage for the Hylo compiler; Initial test suite for Hylo compiler components; Test infrastructure setup and deduplication via symlinks.

The project is now distributed as a Swift Package, defining the 'Hylo' package with a minimum deployment target of macOS 15 and Swift tools version 6.2. This configuration establishes the core build structure, including executable products 'hc' and 'hylo-demangle', and library targets such as 'FrontEnd', 'IR', 'CodeGenLLVM', 'Interpreter', and 'StandardLibrary'. It introduces dependencies on Apple's standard libraries (swift-argument-parser, swift-collections, swift-algorithms, swift-format, swift-syntax, swift-numerics, swift-tools-support-core) and third-party packages (BigInt, Durian, SPIManifest, Yams), alongside the internal 'Swifty-LLVM' dependency, to support the compiler's frontend, intermediate representation, LLVM code generation, and interpretation capabilities.

(dependencies) · high confidence

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

• CAI 56 → 49 (-7.2)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 85 → 85 (-0.3)
• Architecture 91 → 83 (-8.2)
• Maturity 72 → 72 (-0.1)
• Readiness 61 → 41 (-19.7)
• Security 40 → 40 (+0.0)
• Performance 63 (new)

• Dependency hygiene PARTLY measured — SwiftPM pinning read, dependency currency NOT established
• Documentation: hard to navigate (Docs/Compiler/MetatypeLowering.md)
• Documentation: no contributor guidance (README.md)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2

• Ambiguous overload resolution for name(of:). Two methods share the same name and parameter signature (ID), differing only in return type (Name? vs Name). This forces callers to rely on context or explicit casting, which is error-prone and violates the principle of least surprise.
• BuiltinFunction.description (cognitive 29) (Sources/FrontEnd/BuiltinFunction.swift)
• BuiltinFunction.description (cyclomatic 178) (Sources/FrontEnd/BuiltinFunction.swift)
• Coverage not measured — Swift suite
• Documentation: no architecture or design documentation (Docs/Compiler/MetatypeLowering.md)
• Documentation: no installation or build instructions (Docs/Compiler/CLI.md)
• Duplicated block (10 lines × 2) (Sources/IR/Module.swift)
• Duplicated block (11 lines × 2) (Sources/FrontEnd/TypeChecking/TypeChecker.swift)
• Duplicated block (12 lines × 2) (Sources/FrontEnd/Terms/GenericTermParameter.swift)
• Duplicated block (17 lines × 2) (Sources/FrontEnd/Terms/TermVariable.swift)
• Duplicated block (5 lines × 2) (Sources/FrontEnd/TypeChecking/TypeChecker.swift)
• Duplicated block (6 lines × 2) (Sources/FrontEnd/AST/AST.swift)
• Duplicated block (6 lines × 2) (Sources/IR/Module.swift)
• Duplicated block (7 lines × 2) (Sources/FrontEnd/Assertions.swift)
• Duplicated block (7 lines × 2) (Sources/FrontEnd/Terms/TermProtocol.swift)
• Duplicated block (7 lines × 2) (Sources/FrontEnd/TypeChecking/TypeChecker.swift)
• Duplicated block (7 lines × 2) (Sources/FrontEnd/Types/CallableTypeParameter.swift)
• Duplicated block (7 lines × 9) (Sources/CodeGen/FullPathInFatalErrors.swift)
• Duplicated block (7 lines × 9) (Sources/CodeGen/FullPathInFatalErrors.swift)
• Duplicated block (7 lines × 9) (Sources/CodeGen/FullPathInFatalErrors.swift)
• …and 16 more

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

hylo-lang/hylo 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.