core

type File interface {
	// The name of the file in the file system.
	// This is the path relative to the root of the file system
	// source defined by the file system.
	Name() string

	// Open the file for reading.
	Reader() (io.ReadCloser, error)

	// Flag to identify if the file is an application source file
	IsApp() bool

	// Flag to identify if the file is an import source file
	IsImport() bool
}

type FilePlugin interface {
	Plugin

	AnalyzeSource(context.Context, File) error
}

type FileSystem interface {
	// Enumerate the contents of the file system
	Enumerate(context.Context, func(File) error) error

	// Find a file by name in the file system
	// The name is a relative path to the root of the file system
	Find(context.Context, string) (File, error)
}

type ImportAwareFileSystem interface {
	// Base file system
	FileSystem

	// Enumerate application source files in the file system
	EnumerateApp(context.Context, func(File) error) error

	// Enumerate import source files in the file system
	EnumerateImports(context.Context, func(File) error) error
}

type Language interface {
	// Name returns the name of the language
	Meta() LanguageMeta

	// Tree Sitter Language
	Language() *sitter.Language

	// Get language specific resolvers
	Resolvers() LanguageResolvers
}

type LanguageCode string

type LanguageMeta struct {
	// Name of the language
	Name string

	// Code of the language, used for internal comparisons
	Code LanguageCode

	// Flag to indicate if the language is object oriented
	ObjectOriented bool

	// Supported file extensions
	SourceFileExtensions []string
}

type LanguageResolvers interface {
	// ResolveImports returns a list of import statements
	// identified from the parse tree
	ResolveImports(tree ParseTree) ([]*ast.ImportNode, error)

	// ResolveFunctions returns a list of function declarations
	// identified from the parse tree
	ResolveFunctions(tree ParseTree) ([]*ast.FunctionDeclarationNode, error)
}

type ObjectOrientedLanguageResolvers interface {

	// ResolveClasses returns a list of class declarations
	// identified from the parse tree
	ResolveClasses(tree ParseTree) ([]*ast.ClassDeclarationNode, error)

	// ResolveInheritance returns the inheritance graph
	// constructed from class definitions in the parse tree
	ResolveInheritance(tree ParseTree) (*ast.InheritanceGraph, error)
}

type ParseTree interface {
	// Tree returns the underlying TreeSitter tree
	Tree() *sitter.Tree

	// Data returns the raw data of the source file
	// from which the tree was created.
	Data() (*[]byte, error)

	// The file from which the tree was created
	File() (File, error)

	// The language used to parse the tree
	Language() (Language, error)
}

type Parser interface {
	Parse(context.Context, File) (ParseTree, error)
}

type Plugin interface {
	Name() string

	SupportedLanguages() []LanguageCode
}

type PluginCallback[T any] func(context.Context, T) error

type SourceVisitor interface {
	VisitFile(File) error
}

type SourceWalker interface {
	Walk(context.Context, ImportAwareFileSystem, SourceVisitor) error
}

type TreePlugin interface {
	Plugin

	AnalyzeTree(context.Context, ParseTree) error
}

type TreeVisitor interface {
	VisitTree(ParseTree) error
}

type TreeWalker interface {
	Walk(context.Context, ImportAwareFileSystem, TreeVisitor) error
}