Supported Languages

Coraline uses tree-sitter for parsing, enabling support for 33 programming languages with AST-level precision.

Language Support Table

Language Detection

Coraline detects languages by file extension:

Node Types by Language

Different languages produce different node kinds:

Object-Oriented (Java, C#, Swift, Kotlin)

• class
• interface
• method
• property
• field
• enum
• enum_member

Functional (Haskell, Scala, Elixir, Erlang)

• function
• module
• trait (Scala)
• type_alias
• constant

Systems (Rust, C, C++, Zig)

• struct
• function
• trait (Rust)
• enum
• type_alias
• module (Rust)

Scripting (Python, Ruby, PHP, Bash)

• function
• class
• method
• variable
• constant

Web Frontend (JavaScript, TypeScript, TSX, JSX)

• function
• class
• method
• component (React/JSX/TSX)
• interface (TypeScript)
• type_alias (TypeScript)

Markup (Markdown, YAML, TOML)

• module (file-level)
• constant (YAML/TOML keys)

Framework-Specific Features

Rust

• Crate-relative imports (crate::, super::, self::)
• Trait implementation tracking
• Macro detection
• Module tree resolution

React (JavaScript/TypeScript/JSX/TSX)

• Component detection (PascalCase)
• Hook tracking (use* functions)
• Relative imports (./, ../)
• Path aliases (@/)

Blazor (C# + Razor)

• Razor component detection (.razor files)
• Component parameter tracking
• .NET type resolution
• Dependency injection detection

Laravel (PHP)

• PSR-4 autoloading resolution
• Blade template tracking
• Facade detection
• Dot-notation view paths

Python

• Module imports (from ... import)
• Package structure
• Class/function decorators
• Django/Flask detection (future)

Others

• Swift/Kotlin: Protocol/interface conformance
• Elixir: Phoenix routing, Ecto schemas
• Java: Spring annotations, package resolution

Cross-Language Support

Coraline can index polyglot projects with multiple languages:

project/
├── backend/           (Rust)
├── frontend/          (TypeScript + React)
├── mobile/            (Swift, Kotlin)
└── scripts/           (Python, Bash)

All languages are indexed into a unified graph. Cross-language references (e.g., TypeScript calling Rust WASM) are tracked as unresolved edges unless framework resolvers are available.

Language-Specific Configuration

Customize indexing per language via config.toml:

[indexing]
include_patterns = [
  "src/**/*.rs",           # Rust source
  "lib/**/*.ts",           # TypeScript libraries
  "app/**/*.tsx",          # React components
  "**/*.py",               # Python anywhere
]
exclude_patterns = [
  "**/target/**",          # Rust builds
  "**/node_modules/**",    # JS/TS deps
  "**/__pycache__/**",     # Python cache
  "**/dist/**",            # Build outputs
]

Adding New Languages

Coraline can be extended with new tree-sitter grammars:

1. Add the grammar to Cargo.toml:

   tree-sitter-newlang = "0.1.0"
   

2. Register in extraction.rs:

   #![allow(unused)]
   fn main() {
   ".newlang" => tree_sitter_newlang::language(),
   }

3. Add extraction patterns for node/edge types

4. (Optional) Add framework resolver in resolution/frameworks/

See Development Guide for contribution instructions.

Language Limitations

Markdown

• Only headings and code blocks are indexed
• No inline link tracking

YAML/TOML

• Config keys indexed as constant nodes
• No deep structure analysis

Bash/PowerShell

• Function detection only
• Limited variable tracking

Future Enhancements

• SQL query extraction (embedded SQL strings)
• HTML/CSS parsing (currently ignored)
• GraphQL schema tracking
• Protocol Buffers support

Performance by Language

Parse speed varies by grammar complexity:

Actual impact on indexing is minimal (<5% variation) for most projects.

Testing Language Support

Verify language support for your project:

# Index and check stats
coraline init -i
coraline stats --json

# Check language breakdown
jq '.files_by_language' .coraline/stats.json

Output:

{
  "rust": 42,
  "typescript": 31,
  "python": 12,
  "markdown": 5
}

Search for language-specific symbols:

# Rust
coraline query "impl" --kind trait

# TypeScript
coraline query "interface" --kind interface

# Python
coraline query "def" --kind function

Requesting Language Support

To request a new language:

1. Check if a tree-sitter grammar exists at tree-sitter.github.io
2. Open an issue at github.com/greysquirr3l/coraline/issues
3. Include:
   • Language name and typical file extensions
   • Link to tree-sitter grammar
   • Example files for testing
   • (Optional) Framework-specific features needed

Next Steps

• Quick Start Guide - Start indexing your project
• Configuration Guide - Customize language filtering
• Architecture - How language parsing works
• Development Guide - Contribute new languages