- Added support for inherited keyword
- Added support for type helpers
- Added support for inline variables
- Jump to declaration/implementation of methods in nested classes is now supported
- Improved code completion for Pas2Js files
After quite a long time there’s a new version available. There are two new features helping you to stay focused:
1. Symbol creation suggestions
Type the name of a new variable, field or method and use it would have already been declared. When you’re done place the cursor inside the name. OmniPascal will try to find possible declarations for the new symbol. You only need to pick one from the lightbulb.
2. Automatic uses suggestions
Type the name of the class or function you want to use. If the name can’t be resolved in the current scope a lightbulb pops up offering you to add the corresponding unit automatically. No need to add it manually or perform a global search just to find out where it is declared.
How does it work?
On startup the workspace will be indexed. OmniPascal (partially) will parse all pascal files and create an in-memory-index of all symbols in the global scope. With this index OmniPascal can provide uses suggestions almost instantly.
The first run may take longer as it creates a file cache so that future starts are faster.
You can choose whether you want to have indexed
– the workspace
– or the entire search path including system units.
As a side effect of the new symbol index the “Go to Symbol in Workspace”-feature has also been implemented with this release. You can jump to any indexed symbol by just typing its name.
– Automatic declaration of variables, fields and methods
– The new setting “omnipascal.symbolIndex” defines the locations to be indexed
– Implemented workspace symbol provider (working on the new symbol index)
– Automatic uses suggestion
– The new setting “omnipascal.usesListStyle” defines how new uses entries are being added to the uses sections (one item per line or multiple items per line)
– The new setting “omnipascal.namingConventionString” defines whether the String type is being offered as “String” or “string” in code completion and hints
– Code completion on type names offers static accessible symbols only
– Improved parser speed
– tasks.json generated when loading a project is now version 2.0.0
– Bugfix: Method calls with negative constant literals sometimes resolved to unsigned integer types instead of signed types
– Bugfix: Failed to load projects where a property was declared multiple times within the same property group
– Bugfix: Generated Lazarus build scripts contain workaround to nothing-to-do-bug
This release brings a lot of improvements regarding understanding of language features as well as bugfixes. Read the complete change log:
OmniPascal has finally arrived on Mac and Linux! All the features you know from the Windows version are now available also on Unix like operating systems. These are:
Please keep in mind that the built in Pascal parser has support for Delphi syntax only. So you won’t see great support for ObjectPascal source files using a different dialect. That may change in the future.
*Build scripts for Delphi projects work on Windows only
omnipascaland press install
Please ensure your system allows execution of software from any location!
If you have any problems getting started then please create a bug report, ask on StackOverflow or create a comment under this blog post.
Since this is the first release of OmniPascal for Mac and Linux it’d be a surprise if everything was working right from start.
Introducing automatic build script generation
You are now able to load a project file in Visual Studio Code. You can either click the new OmniPascal project indicator in the status bar or execute the new command
OmniPascal: Load project. Pick a
.lpk file to open it. When it’s done you will see the currently loaded project file in the status bar.
The search path will be adjusted automatically when you open a project file.
If the new setting
omnipascal.createBuildScripts is set to
false by default) then a
tasks.json file and a
.bat file will be generated as soon as a project is loaded or the currently loaded project file changes. The generated
tasks.json defines both a build task and a test task. The build task will simply compile the loaded project while the test task will start the compiled application with the run parameters defined in the
.lpi file. If there is no
.lpi file for the project then OmniPascal won’t create a build script. So there are no auto generated build scripts for old Delphi projects.
The generated build scripts rely on MSBuild for Delphi projects and LazBuild for Lazarus projects. OmniPascal needs to know the location of these applications in order to work properly.
The path to MSBuild is defined in the setting
omnipascal.msbuildPath. If no path is defined OmniPascal will try to find the path by itself.
The path to LazBuild is be defined in
Changes in the OmniPascal settings are not reflected on the fly. You need to restart Visual Studio Code or execute the command
Reload Window when you change settings!
– The settings namespace used for OmniPascal is no longer
objectpascal but it’s
omnipascal. You need to change the settings in Visual Studio Code. For example: The setting
objectpascal.delphiInstallationPath has to be changed to
– The path to the FreePascal source files is no longer stored in
objectpascal.delphiInstallationPath. It’s now stored in
– FreePascal users need to set
FreePascal. The default value is
– Ability to load a project file
– Automatically adjust search path when opening a project file (loaded from .dproj and .lpi files)
– Automatic creation of tasks.json and a build script when loading a project that has a corresponding .dproj or .lpi file
– If DelphiInstallationPath is not defined in the settings then OmniPascal looks for the most recent Delphi installation path itself
– Fixed visibility of symbols defined in System.pas
– Aliases of full qualified types are now handled properly
– Fixed possible stack overflow when working with a generic class defined in the implementation section
– Fixed random crashes
– Parameterless calls to WriteLn, Write, ReadLn and Read can now be resolved
– Outlining in files with syntax errors works better
– Hints for constants of empty strings are now correct
– Implementations of overloaded methods could not be found when an alias for a parameter type is used in the implementation while the declaration uses the original type name
– Fixed internal error when code completion was requested for objects of a type that could not be resolved
– Fixed broken syntax highlighting for
Result and some keywords.
Add unit to uses in order to add a unit to a uses clause without navigating to the top. Open the command palette (by pressing F1 or
CTRL+SHIFT+P) and type “Add unit to uses”. Select the uses clause and a list of all available units will appear. Select the one you want and press enter. The command is also bound to
– Automatic implementation of interfaces adds missing units to the uses clause
– Member of typed pointers can be resolved
– Creation of errors and warnings does no longer stop working after a while
– Constants in classes are now resolved properly
– Indexed access on constant resolves now to the definition of that constant / constant array
– Fixed random crashes
– General performance improvements. Especially startup and code completion are much faster.
– Members of type casted identifiers can be resolved
– Code completion works even when working with type casts
– Basic data types like Integer or String appear in code completion
– Added support for Delphi Intrinsic Routines for Windows 32 platform
– True, False and Nil now appear in code completion
– Added support for pointer types
– Names of nested types in generic classes couldn’t be resolved in method implementations
– Names of nested strict private types can be resolved
– Code completion list doesn’t grow anymore when triggered multiple times in classes which inherit from a specialized generic class
– Fixed occasional crashes of OmniPascalServer.exe when editing code with multiple cursors
– Calls to overloaded methods weren’t always resolved correctly based on the parameter count. (Resolving calls to overloaded methods still doesn’t work when multiple versions of a method accept the same amount of parameters)
– Members of items in generic arrays can be resolved
– Name resolving and code completion for symbols defined in the implementation section now works in initialization and finalization section
…as well as some speed improvements.
– The search path will be indexed on start up
– Code completion in uses sections suggests known unit names
– Support for full qualified names like System.Classes.TStringList
– Code completion only suggests types and namespaces when only a type name makes sense in the current context
– Code completion in interface declarations suggests a GUID
– An error is displayed when a unit name doesn’t match its file name
– An error is displayed for duplicate entries in uses section
– An error is displayed for unresolvable entries in uses sections
– A lightbulb appears on unresolvable uses entries which allows to create that file in the current folder
– Hints of hoverered unit names in uses sections look nicer
– Definitions of redeclared properties can be resolved and are part of code completion
– It’s possible to jump to the initial declaration of a redeclared property
– Support for hidden namespaces in uses section (for example “Classes” can be resolved to “System.Classes”)
– Code completion is disabled when defining a new symbol
– Code completion used the wrong scope from time to time especially when hitting the dot inside of if-statements or brackets.
– Signature help now highlights the current parameter as soon as the comma is entered
– Signature help didn’t work when used on a member’s method of an object like ObjectA.Member.Find()
– Warnings for incomplete method definitions in included files were created
– Go to a definition of a symbol which is defined in an included file no longer opens the including file but the include file
– Symbol definitions of included files were part of outlining
– No warnings have been created for missing implementations of overloaded methods if one of those methods already had an implementation
– UTF8 files with BOM header can be parsed now
– Protected symbols which should be invisible were part of code completion in special cases
– References to out parameters without type information (void types) can be found
– Quickinfo for variables of type “file” contained no type information
– Code completion showed empty suggestion item
– Code completion in specialized generic descendants didn’t include protected members of non generic base classes
– Parameterized type names in static method calls couldn’t be resolved
– Method names in static method calls on parameterized type names couldn’t be resolved
…as well as some speed improvements.
– Syntax errors are displayed in the editor
– Method definitions without implementations produce warnings
– Warnings for missing implementations provide a quickfix that creates an empty implementation stub for it. TIP: Open the lightbulb with
– Additional search paths can be defined in configuration file using the
"objectpascal.searchPath" parameter. Paths are separated by
"D:\\ThirdPartyComponents\\*" will add the folder
"D:\ThirdPartyComponents and all its subfolders recursively to the search path.
– DPR files have now support for code completion
– DPR files have now support for outlining
– Code completion cleaned up from internal compiler methods
– It was impossible to go to the declaration of a procedure that was not a class member
– Fixed undefined internal file state that occured from time to time
– Parameters were not always displayed correctly when hovering a method
– Toggle Method declaration/implementation has become more error tolerant
– Outlining huge files is >10 times faster now
– Create code completions in huge files is >20 times faster now
– OmniPascal generally runs faster and consumes less memory
– Some words like
div etc. are temporarily not displayed as operators (gray in dark default theme) but as keywords (blue). This change has become necassary as Visual Studio Code broke some details in syntax highlighting with the latest release. Probably operators will be displayed in gray again in the future.