language

package
v1.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jan 30, 2026 License: MIT Imports: 10 Imported by: 0

Documentation

Overview

Package language provides abstractions for multi-language code analysis.

This package defines the core interfaces that language-specific implementations must satisfy. Each supported language provides its own implementation of these interfaces, encapsulating language-specific parsing, detection, coverage, and dependency analysis.

The Language interface is the primary abstraction that orchestrates all language-specific components. Language providers are registered at init time and can be retrieved by name or auto-detected from project files.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Register

func Register(lang Language)

Register adds a language provider to the registry. This is typically called from init() functions in language packages. Panics if a language with the same name is already registered.

func SupportedLanguages

func SupportedLanguages() []string

SupportedLanguages returns the names of all registered languages.

Types

type CoverageRunner

type CoverageRunner interface {
	// RunCoverage runs test coverage analysis for the project.
	// Returns per-package coverage results or an error if coverage cannot be run.
	RunCoverage(projectPath string, excludePatterns []string) ([]*coverage.PackageCoverage, error)
}

CoverageRunner runs test coverage analysis for a specific language.

Each language has its own test framework and coverage tools. This interface abstracts the language-specific details of running coverage analysis.

type DependencyAnalyzer

type DependencyAnalyzer interface {
	// Analyze extracts and categorizes dependencies from parsed files.
	// Returns per-package dependency information.
	Analyze(files []*parser.FileMetrics) ([]*dependencies.PackageDependencies, error)

	// DetectCircularDependencies finds circular import chains.
	// Returns a list of detected cycles.
	DetectCircularDependencies(files []*parser.FileMetrics) ([]*dependencies.CircularDependency, error)
}

DependencyAnalyzer analyzes dependencies for a specific language.

Each language has its own module system and import conventions. This interface abstracts the language-specific details of dependency analysis.

type DetectorRunner

type DetectorRunner interface {
	// RunDetectors analyzes a file and returns any issues found by enabled detectors.
	// The implementation may re-parse the file to obtain language-specific AST.
	RunDetectors(cfg *config.AnalysisConfig, file *parser.FileMetrics) []*detectors.Issue
}

DetectorRunner runs anti-pattern detectors for a specific language.

This interface decouples the generic analyzer from language-specific AST types. Each language's implementation handles its own parsing and AST walking internally, returning generic Issue objects that the analyzer can process.

type Language

type Language interface {
	// Name returns the lowercase identifier for this language (e.g., "go", "python", "typescript").
	// This is used for CLI flags and configuration.
	Name() string

	// DisplayName returns the human-readable name (e.g., "Go", "Python", "TypeScript").
	// This is used in user-facing messages and reports.
	DisplayName() string

	// Extensions returns the file extensions for this language (e.g., [".go"], [".py"], [".ts", ".tsx"]).
	// Extensions should include the leading dot.
	Extensions() []string

	// DefaultExcludePatterns returns glob patterns to exclude by default for this language.
	// For example, Go excludes "vendor/**" and "**/*_test.go".
	DefaultExcludePatterns() []string

	// Parser returns a parser for this language's source files.
	Parser() parser.Parser

	// DetectorRunner returns a runner for anti-pattern detectors.
	// Each language handles its own AST internally - the analyzer never sees language-specific types.
	DetectorRunner(cfg *config.AnalysisConfig) DetectorRunner

	// CoverageRunner returns a runner for test coverage analysis.
	// Returns nil if coverage analysis is not supported for this language.
	CoverageRunner(cfg *config.AnalysisConfig, statusReporter status.Reporter) CoverageRunner

	// DependencyAnalyzer returns an analyzer for dependency analysis.
	// Returns nil if dependency analysis is not supported for this language.
	DependencyAnalyzer(projectPath string) (DependencyAnalyzer, error)
}

Language defines the interface for language-specific analysis components.

Each supported programming language implements this interface to provide its own parser, detectors, coverage runner, and dependency analyzer. Language providers are registered at init time and can be retrieved by name or auto-detected from project files.

func All

func All() []Language

All returns all registered language providers.

func DetectLanguage

func DetectLanguage(projectPath string) (Language, error)

DetectLanguage auto-detects the primary language of a project.

Detection is based on the presence of language-specific manifest files:

  • go.mod → Go
  • pyproject.toml, setup.py, requirements.txt → Python

Returns an error if no supported language can be detected.

func Get

func Get(name string) (Language, bool)

Get retrieves a language provider by name. Returns the language and true if found, or nil and false if not found.

Directories

Path Synopsis
Package golang provides Go language support for code analysis.
Package golang provides Go language support for code analysis.
Package python provides Python language support for code analysis.
Package python provides Python language support for code analysis.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL