bidirectional type inference

Existing bidirectional type-checking approaches for System F with context-free session types require explicit type annotations at polymorphic applications, compromising expressiveness and usability. Method: We propose the first bidirectional type-checking system supporting fully local type inference for System F extended with context-free session types. Our approach embeds context-free grammars directly into the type system and integrates bidirectional checking, type equivalence checking, and extensions of System F to jointly infer sequence composition, first-class polymorphism, and session structure. Contributions/Results: (1) The first fully local type inference mechanism within a context-free session typing framework; (2) elimination of all manual annotations at type applications; (3) strict preservation of type safety while significantly improving programmer experience and inference precision. Our system enables concise, annotation-free programming of complex session-typed protocols without sacrificing formal guarantees.

This paper addresses functional programs featuring atomic operations and pattern matching, proposing the first dually typed system supporting **unified verification of both correctness and incorrectness**. Methodologically, it defines types as sets of normal forms and introduces, for the first time in a type system, a **complement operator dual to co-implication** to model logical negation, thereby embedding multiple refutation principles. Subtyping is axiomatized to govern the complement operator, and bidirectional inference rules—combined with a decidable subtyping algorithm—guarantee both **soundness and completeness** with respect to normal forms. The system has been successfully applied to verify runtime errors in several Erlang-like programs. Its contributions include: (i) a theoretically grounded, bidirectional type-theoretic framework for simultaneous proof and refutation; and (ii) a practical, implementable methodology for error detection in functional programs.

Deep subtyping—where subtyping judgments require complex, nested derivations—compromises both theoretical tractability and practical understandability in type systems. Method: This paper proposes a systematic replacement of deep subtyping inference with η-expansion as a foundational design principle. Building on Barendregt et al. (1983), we recast η-expansion as a universal paradigm for type design and integrate it with intersection types and a precisely defined subtyping relation to construct a shallow subtyping system. Contribution/Results: We formally prove that, under η-expansion, the shallow system is expressively and decidably equivalent to its deep counterpart; all key lemmas are complete and all derivations are mechanically verifiable. Our approach reduces type-checking complexity significantly, enhances formal verifiability, and improves engineering applicability. It establishes a novel, principled paradigm for type system design that reconciles high expressive power with conceptual simplicity and syntactic clarity.

To address the high manual annotation cost of pluggable type systems (e.g., NullAway) in legacy Java codebases, this paper proposes an automated type qualifier inference method. Our approach introduces NaP-AST—a lightweight program representation that explicitly encodes data-flow semantics as structural hints. We conduct the first systematic empirical comparison of graph transformation networks (GTNs), graph convolutional networks (GCNs), and large language models (LLMs) for this task, demonstrating that GTNs achieve superior performance. Evaluated on 12 open-source Java projects, our GTN-based method attains 0.89 recall and 0.60 precision, significantly reducing spurious type warnings. We further identify a performance inflection point at approximately 16K Java classes, beyond which model accuracy stabilizes. This work establishes a scalable, high-precision paradigm for static-analysis-driven type enhancement in industrial Java ecosystems.

Traditional refinement type systems are difficult to adopt in mainstream languages due to their heavy annotation overhead, particularly when handling common properties such as integer ranges, which often require extensive manual annotations. This work proposes Ranger, a bidirectional type system for integer range refinements that integrates type inference with lightweight, flow-sensitive static analysis. Ranger supports imperative constructs—including variables and loops—while substantially reducing the annotation burden on users. Experimental evaluation using the Licorne language demonstrates that Ranger can concisely verify properties beyond the reach of standard type systems, such as index safety, and achieves greater annotation succinctness compared to both the Java Checker Framework and Liquid Java.

This work addresses the challenge in dynamic languages where heterogeneous type evidence for function parameters—such as internal assignments, explicit declarations, contextual requirements, and structural operations—often leads to conflicts or redundancy when processed jointly. The paper proposes a Generalized Constraint Projection (GCP) framework that separates these four evidence sources into monotonic slots at definition time and validates arguments via fresh projection sessions at call time, simultaneously specializing return types. A key innovation is the introduction of Outline Equational Matching (OEM), a structure that integrates preorder relations with a future-this receiver mechanism, enabling—for the first time—annotation-free, modular, and convergent type inference. Implemented in the Outline language, the approach accurately reconstructs PEP 484 type annotations from unannotated Python code, supports downstream compilation, and formally guarantees convergence, type preservation, and projection–evaluation consistency.

Existing languages typically relegate refinement types to secondary annotations or separate specifications, hindering seamless integration with core language features such as subtyping, type inference, and pattern matching, thereby limiting their practical utility. This work presents the first integration of refinement types as first-class citizens in Scala 3, leveraging dependent function types, bounded polymorphism, recursion, and union/intersection types to deeply embed logical predicates into the type system. Building upon a partial correctness semantics, we develop a fuel-bounded semantic type system, formalize a core calculus, and prove its type safety. Furthermore, we implement a prototype extension of the Scala 3 compiler that combines Rocq-based verification with a lightweight e-graph-based predicate solver, enabling practical and scalable lightweight program verification.

Existing development tools can report the types of expressions but cannot explain how those types arise. This work proposes a theory of bidirectional type slicing, extending type slicing for the first time to bidirectional type systems, thereby unifying type synthesis and contextual expectation. The approach supports complete, incomplete, and erroneous programs. Built upon a core calculus featuring holes, products, sums, and explicit polymorphism, and leveraging a precision order and static gradual guarantee, we formalize the theory in Agda, proving the existence of minimal slices and their monotonic contraction under query refinement. Furthermore, we implement a linear-time approximation algorithm in the Hazel environment.