typescript

This study addresses the limited systematic understanding of real-world defects in the TypeScript ecosystem, particularly the lack of empirical evidence on how the type system influences fault distribution. Through a large-scale analysis of 633 defect reports from 16 prominent open-source projects, we develop a fine-grained defect taxonomy and employ statistical methods to examine its relationship with project size, domain, and dependency structure. Our findings reveal that faults in TypeScript projects predominantly stem from toolchain issues, configuration errors, API misuse, and asynchronous error handling—rather than traditional logic or syntax bugs. While static typing significantly suppresses runtime and type-related errors, the locus of failures has shifted toward build systems and integration boundaries, highlighting toolchain complexity and dependency management as key drivers of modern software faults.

This study investigates whether developers actually use type annotations as inline documentation during code comprehension and debugging. Through an eye-tracking experiment with 26 undergraduate participants performing code summarization and bug localization tasks on TypeScript code, the research examines visual attention to type-annotated lines. As the first empirical study employing eye tracking to assess developers’ engagement with static type information, the findings reveal that participants did not significantly fixate more on code lines containing type annotations, thereby challenging the widely held assumption that type annotations inherently serve as effective documentation. These results carry important implications for the design of programming tools and the pedagogy of type systems.

This work addresses the challenge of executing Q# quantum programs directly in web environments. Methodologically, we design and implement the first TypeScript-based compiler toolchain that translates Q# to QASM 3.0, featuring a complete lexer and an LL(1) parser supporting a core subset of Q# syntax, along with a lightweight, structured JSON intermediate representation (IR) that preserves semantics across platforms and enables portable code generation. Our key contributions are: (1) the first browser-native Q# compilation capability, substantially improving accessibility for quantum programming; and (2) a modular JSON IR design that enhances extensibility and interoperability across heterogeneous platforms. Experimental evaluation demonstrates correct compilation and semantic fidelity for representative Q# programs, with performance comparable to mainstream Q# compilers.

This work addresses the inefficiency of modern JavaScript compilers, which often waste substantial computational resources by indiscriminately applying all downlevel transformations regardless of the actual language features used. To mitigate this, the authors propose a conditional transpilation mechanism that precisely detects and dynamically tracks the set of language features employed at the script level, triggering transformations only for those features that require them. Implemented within the Google Closure Compiler, the approach integrates feature set construction, strategic pass ordering, and post-transpilation feature validation to significantly reduce unnecessary abstract syntax tree (AST) traversals. Empirical evaluation on large-scale production codebases demonstrates that the proposed method effectively decreases compilation time while reducing both memory consumption and computational overhead.

This work addresses the performance bottlenecks of existing Language Server Protocol (LSP)-based code parsing approaches in large-scale TypeScript projects, where frequent symbol queries hinder efficient function-level indexing. To overcome this limitation, we propose abcoder-ts-parser, which uniquely integrates the native capabilities of the TypeScript Compiler API directly into the indexing pipeline. By leveraging the compiler’s abstract syntax tree (AST), semantic information, and module resolution logic, our method constructs a graph-structured index—UniAST—that preserves call chains and dependency relationships. Experimental evaluation on three open-source projects, including one with up to 1.2 million lines of code, demonstrates that abcoder-ts-parser substantially outperforms conventional LSP-based architectures, achieving significant improvements in both indexing efficiency and reliability.

This work addresses the limitations of existing static type inference approaches for Python—particularly their low accuracy, poor scalability, and weak interpretability when applied to codebases lacking or partially equipped with type annotations. To overcome these challenges, the authors propose a lightweight, usage-driven static analysis method that innovatively integrates execution-aware dependency graph traversal, symbolic execution, iterative fixed-point analysis, and context-aware matching retrieval. Notably, this approach achieves high-precision type inference without relying on deep learning or large-scale datasets. Empirical evaluation demonstrates that the method significantly outperforms data-driven models such as Type4Py and HiTyper, as well as industrial tools like Pyre, on real-world benchmarks including ManyTypes4Py and Typilus, while maintaining both computational efficiency and strong interpretability.

This work addresses runtime errors in Java applications caused by type mismatches between SQL and Java types in JDBC database access. By extending the Java compiler with the Checker Framework, the authors present the first static analysis technique capable of enforcing JDBC type safety across method boundaries. The approach requires no source code modifications and leverages optional annotations to enhance type inference, enabling static verification of Java type correctness during both PreparedStatement parameter setting and ResultSet value retrieval. A fallback checking mode is also provided for legacy systems. Experimental evaluation demonstrates that the technique effectively detects real-world type mismatch bugs, prevents runtime exceptions, and incurs acceptable compilation overhead, achieving a practical balance between soundness and usability.

This work addresses the erosion of TypeScript’s static guarantees caused by the pervasive use of the `any` type in function decorators within dynamic languages. We propose the F<:DR calculus, which introduces domain (Dom(T)) and range (Range(T)) projection types to enable precise type checking for arbitrary function calls while preserving compatibility with System F<:. The approach supports lightweight parametric polymorphism, allowing safe expression of higher-order function patterns without resorting to unsafe `any` types. Leveraging logical relations and a path-selection mechanism, we formalize and prove the semantic type safety of F<:DR in Rocq. Moreover, the design naturally extends to other projection scenarios, such as product types.

This work addresses the challenge of formally modeling the interplay among structural subtyping, generics, and non-uniform runtime representations in the Go programming language. To this end, it introduces WG, a core calculus that, for the first time, unifies these three mechanisms within a single formal framework. The approach employs a type-directed compilation strategy to translate high-level types—including type unions and generic methods—into a lower-level LWG language. By incorporating runtime type conversions and adapter methods, the scheme enables efficient compilation without requiring runtime code generation while remaining compatible with separate compilation. This research thus provides both a precise formal foundation and a practical implementation pathway for key Go language features.