Type Inference in code AI is the task of automatically predicting the data types of variables, function parameters, and return values in dynamically typed programming languages — applying machine learning to the types that static type checkers like mypy (Python) and TypeScript's tsc would assign, enabling gradual typing adoption, reducing runtime type errors, and improving IDE tooling in languages like Python, JavaScript, and Ruby where types are optional.

What Is Type Inference as a Code AI Task?

• Context: Statically typed languages (Java, C#, Rust) require explicit type declarations; compilers infer or enforce types. Dynamically typed languages (Python, JavaScript, Ruby) allow running code without type declarations — making type errors runtime failures instead of compile-time failures.
• Task Definition: Given source code without type annotations, predict the most appropriate type annotation for each variable, parameter, and return value.
• Key Benchmarks: TypeWriter (Pradel et al.), PyCraft, ManyTypes4Py (869K typed Python functions), TypeWeaver, InferPy (parameter type prediction).
• Output Format: Python type hints (PEP 484): def calculate_price(quantity: int, unit_price: float) -> float:.

The Type Annotation Gap

Despite Python's PEP 484 type hints being available since 2014:

• Only ~25% of PyPI packages have any type annotations.
• Only ~6% have comprehensive type annotations.
• GitHub Python codebase analysis: ~85% of function parameters have no type annotation.

This gap means:

• PyCharm, VS Code, and mypy cannot provide accurate type-checking for most Python code.
• Refactoring with confidence requires manual type investigation.
• LLM code completion context is degraded without type information.

Why Type Inference Is Hard for ML Models

Polymorphism: Function process(data) might accept List[str], Dict[str, Any], or pd.DataFrame depending on the call site — type depends on how the function is used, not just how it's implemented.

Library-Dependent Types: result = pd.read_csv(path) → return type is pd.DataFrame — requires knowing that pd.read_csv returns a DataFrame, which demands library-specific type knowledge.

Optional and Union Types: user_id: Optional[str] vs. user_id: str vs. user_id: Union[str, int] — the correct annotation depends on whether None is a valid value, which requires data flow analysis.

Generic Types: def first(lst: List[T]) -> T — correctly inferring generic parameterized types requires understanding covariance and contravariance.

Technical Approaches

Type4Py (Neural Type Inference):

• Bi-directional LSTM + attention over identifiers, comments, and usage patterns.
• Leverages similarity to annotated functions from the type database (ManyTypes4Py).
• Top-1 accuracy: ~68% (exact match) on ManyTypes4Py test set.

TypeBERT / CodeBERT fine-tuned:

• Fine-tuned on (unannotated function, annotated function) pairs.
• Top-1 accuracy: ~72% for parameter types, ~74% for return types.

LLM-Based (GPT-4, Claude):

• Given function + context, prompt: "Add appropriate Python type hints."
• High accuracy for common patterns (~85%+); lower for complex generic types.
• Used in GitHub Copilot type annotation suggestions.

Probabilistic Type Inference:

• Output probability distribution over type vocabulary, not just top-1 prediction.
• Enables "type annotation with confidence" — annotate when P(type) > 0.8, suggest review otherwise.

Performance Results (ManyTypes4Py)

Why Type Inference Matters

• Python Ecosystem Quality: Automatically annotating the ~75% of PyPI that lacks types would enable mypy type checking across the entire Python ecosystem — dramatically improving code reliability.
• TypeScript Migration: Migrating JavaScript codebases to TypeScript requires inferring types for JavaScript variables. AI type inference generates initial .ts declarations that developers then refine.
• IDE Intelligence: VS Code, PyCharm, and other IDEs provide better autocomplete, refactoring, and inline documentation when type information is available. AI-inferred types extend this intelligence to unannotated code.
• LLM Code Completion Quality: Research shows that type-annotated code context improves GPT-4 and Copilot code completion accuracy by 15-20% — AI type inference enriches the context for all downstream code AI.
• Bug Prevention: MyPy with comprehensive type annotations catches 15-20% of bugs before runtime in production Python codebases. Automated type inference makes this bug-catching regime feasible without manual annotation effort.

Type Inference is the type safety automation layer for dynamic languages — applying machine learning to automatically annotate the vast majority of Python, JavaScript, and Ruby code that currently runs without type safety, enabling the full power of static type checking and IDE intelligence tools to apply to dynamically typed codebases without requiring developer annotation effort.