LuaLS/lua-language-server

Features

• Lua IDE Integrations - Integrates autocompletion, go-to-definition, and real-time error checking for Lua within various code editors.
• Semantic Code Analyzers - Provides real-time diagnostics and error detection through semantic analysis of the Lua source code.
• Code Completion - Suggests variable names and code snippets during typing to accelerate the development process.
• Code Symbol Navigators - Enables jumping to symbol definitions and locating all references of a specific element across the project.
• Implementation Navigations - Allows developers to jump from a function call directly to its underlying source code implementation.
• Language Server Protocol Implementations - Implements the Language Server Protocol to provide editor intelligence and formatting for Lua.
• Real-time Code Autocompletes - Provides real-time code autocompletion and predictive suggestions for variables and functions during typing.
• Real-Time Code Diagnostics - Provides real-time visual feedback on syntax mistakes and type errors during the editing process.
• Static Code Analysis - Scans Lua source code for linting violations, syntax errors, and logic flaws without execution.
• Symbol Information Providers - Displays detailed information and function signatures for code elements when hovering over them in the editor.
• Context-Aware Suggestions - Recommends functions and variables based on current semantic context and type annotations.
• Static Type Annotations - Allows assigning types or generics to variables and function arguments to enable static analysis.
• LSP Server Implementations - Implements the server-side logic of the Language Server Protocol using JSON-RPC for IDE communication.
• Function Signatures - Enables explicit definition of input parameters and return types for functions, including support for overloads.
• Module Resolvers - Implements configurable lookup engines to resolve custom search paths and library directories for external modules.
• External Library Definitions - Loads external definition files to provide type intelligence for third-party libraries and APIs.
• Type Safety - Detects type mismatches in assignments and function signatures to ensure codebase-wide type safety.
• Lua Static Analysis Tools - Identifies type mismatches, unused variables, and logic errors in Lua code before execution.
• Lua Type Checkers - Defines custom types and annotations to enforce type safety and improve code predictability in Lua.
• Type Inference Support - Deduces variable types by analyzing assignments and return values to enforce type safety during static analysis.
• Symbol Definition Resolution - Enables locating the original declaration of variables, classes, or functions across the project workspace.
• Type Annotations - Provides a system for defining and enforcing types through inline annotations and meta files for static analysis.
• Type Inference Engines - Implements an inference-based type system that automatically deduces variable types from assignments and return values.
• Language Grammar Validation - Identifies violations of Lua language grammar to prevent runtime failures.
• User-Defined Types - Allows the definition of custom type aliases, enums, and class structures to enforce type safety.
• Lua Type Checkers - Infers variable types and enforces type safety using optional annotations and meta files.
• Static Type Checking - Analyzes variable and function types to detect potential mismatches before the code is executed.
• Static Analysis AST Parsing - Parses source code into abstract syntax trees to detect structural errors and identify unused code.
• Source Code Formatters - Includes a built-in formatter that automatically adjusts indentation and style to maintain consistent visual structure.
• Code-to-Documentation Extractors - Extracts docstrings and symbols from source code to generate technical reference documentation.
• Document Exporting - Generates project documentation in Markdown and JSON formats using defined filtering rules.
• API Documentation Generators - Extracts codebase information to automatically generate documentation in Markdown and JSON formats.
• Code Refactoring Tools - Provides project-wide symbol renaming and automatic source code formatting to maintain style consistency.
• Definition-Only Files - Supports meta files that provide type definitions for other files without affecting functional analysis.
• Symbol-Based Documentation Generators - Exports project symbols and annotations into JSON or Markdown files via a command-line interface.
• Hover Information Displays - Displays detailed information and documentation comments in popups when hovering over symbols.
• Project Workspaces - Isolates environments for different project roots to maintain independent global variables and settings.
• API Documentation Generators - Extracts symbols and annotations from source code to generate structured technical API documentation.
• Cross-Module Symbol Linking - Implements mechanisms for linking symbols across different modules to enable hyperlinked navigation in documentation.
• Workspace Library Scopes - Includes external library implementation code and definition files in the project scope for better context.
• Language Version Targeting - Allows restricting functions or classes to specific language versions to ensure static analysis compatibility.
• Module Path Resolution - Translates module requests into specific filesystem paths to locate external libraries and dependencies.
• Runtime Environment Configuration - Defines the language version and available libraries to match the target execution environment.
• Third-Party Extension Installation - Enables the installation of external library definitions to provide intelligence for third-party frameworks.
• Type Casting - Overrides inferred types using inline annotations to resolve complex type scenarios.
• Lua Library Type Declarations - Provides the ability to describe external library signatures using meta files for accurate autocompletion.
• Member Visibility Control - Supports restricting access to functions and fields through private, protected, and package-level scopes.
• Member Access Verification - Blocks access to private class members from unauthorized scopes and flags deprecated variables.
• Code Style Formatting - Standardizes code layout and enforces a consistent style guide across the codebase.
• Dead Code Detectors - Highlights variables, functions, and arguments that are defined but never referenced across the project.
• Lua API Documentation Generation - Extracts symbols and annotations from Lua source code to generate structured Markdown and JSON documentation.
• Workspace Isolation - Maintains separate global variables and settings for different project roots to prevent cross-project interference.
• AST Modification Plugins - Integrates custom scripts to modify ASTs, intercept text changes, and alter compilation behavior.
• Server Capability Extenders - Allows adding custom API definitions and plugins to extend the server's knowledge of specific frameworks.
• LSP Plugin Extensions - Supports third-party plugins that can hook into internal interfaces to modify the AST or resolve calls.
• Static Logic Analyzers - Detects potential runtime risks and logic errors such as infinite loops and indexing nil objects.
• Symbol Renamers - Allows for project-wide symbol renaming while automatically updating all references to the changed symbol.

Star-Verlauf