OmniPascal 0.9 – Namespaces and more

Features:
– 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

Bugfixes:
– 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.

OmniPascal 0.8.1 released

New features
– 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 CTRL+.
– Additional search paths can be defined in configuration file using the "objectpascal.searchPath" parameter. Paths are separated by ;. TIP: "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

Bug fixes
– 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

Changes
– 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 as, mod,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.

How to attach the build process to Visual Studio Code

A lot of people asked for a sample on how to compile a project from within Visual Studio Code and how to get nice formatted compiler messages. VSCode comes with a configurable interface that allows you to define

  • a general command to be executed on each build
  • parameters to that command to build the main project
  • parameters to that command to build and run the test project
  • and a problem matcher that extracts warnings and errors from the compiler output.

This configuration is stored in ${workspaceRoot}/.vscode/tasks.json where ${workspaceRoot} is the path of the folder opened in VSCode.

Technical overview

We create a batch file which accepts two different values as the first parameter – build and test. Depending on its value we execute the corresponding commands. We define a problem matcher in order to convert the compiler’s StdOut into displayable notifications, hints and errors.
After compiling the test command we call the test executable to see its result inside the editor.
Here are two sample configurations. Pick the one that helps you the most.

Configuration for a Delphi project using MSBuild

Compile.bat:

@echo off

SET MSBUILD="C:\Program Files (x86)\MSBuild\12.0\Bin\MSBuild.exe"
SET RSVARS="C:\Program Files (x86)\Embarcadero\Studio\16.0\bin\rsvars.bat"

if /i %1%==test (
  SET PROJECT=TestProject\UnitTests.dproj
) else (
  SET PROJECT=MainProject\AwesomeExe.dproj
) 

call %RSVARS%   
%MSBUILD% %PROJECT% "/t:Clean,Make" "/p:config=Debug" "/verbosity:minimal"

if %ERRORLEVEL% NEQ 0 GOTO END

echo. 
if /i %1%==test (
  TestProject\UnitTests.exe
)
:END

tasks.json:

{
    "version": "0.1.0",
    "windows": {
        "command": "${workspaceRoot}/Compile.bat"
    },
    "isShellCommand": true,
    "showOutput": "always",
    "tasks": [
        {
            "taskName": "build",
            "isBuildCommand": true,
            "problemMatcher": {
                "owner": "external",
                "fileLocation": ["relative", "${workspaceRoot}"],                        
                "pattern": {
                    "regexp": "((([A-Za-z]):\\\\(?:[^\\/:*?\\\"<>|\\r\\n]+\\\\)*)?[^\\/\\s\\(:*?\\\"<>|\\r\\n]*)\\((\\d+)\\):\\s.*(fatal|error|warning|hint)\\s(.*):\\s(.*)",
                    "file": 1, 
                    "line": 4,
                    "severity": 5,
                    "code": 6,
                    "message": 7
                }
            }                
        },
        {
            "taskName": "test",
            "isTestCommand": true,
            "problemMatcher": {
                "owner": "external",
                "fileLocation": ["relative", "${workspaceRoot}"],                        
                "pattern": {
                    "regexp": "((([A-Za-z]):\\\\(?:[^\\/:*?\\\"<>|\\r\\n]+\\\\)*)?[^\\/\\s\\(:*?\\\"<>|\\r\\n]*)\\((\\d+)\\):\\s.*(fatal|error|warning|hint)\\s(.*):\\s(.*)",
                    "file": 1, 
                    "line": 4,
                    "severity": 5,
                    "code": 6,
                    "message": 7
                }
            }               
        }                         
    ]
}   

Known issues

  • The Delphi compiler provides file name and line number but it doesn’t provide the column number where a message belongs to. VSCode has to guess the correct column. This can cause the error marks to appear in the wrong columns within the correct lines.

  • File names are reported with paths relative to the .dproj file when the file is part of the project. When a file is not part of the project but inside the search path the Delphi compiler uses the absolute path for that file. VSCode’s problem matcher currently can’t handle both types of file names at the same time. You need to decide via the fileLocation key which kind of file names you want to support. You can’t open messages with relative file names when you set "fileLocation": ["absolute"] and vice versa.

Configuration for a Lazarus project using lazbuild

Compile.bat:

@echo off

SET LAZBUILD=C:\development\lazarus\lazbuild.exe

if /i %1%==test (
  SET PROJECT=TestProject\UnitTests.lpi
) else (
  SET PROJECT=MainProject\AwesomeExe.lpi
) 

%LAZBUILD% %PROJECT% --verbose 

if %ERRORLEVEL% NEQ 0 GOTO END

echo. 
if /i %1%==test (
  TestProject\UnitTests.exe --format=plain -a
)
:END

tasks.json:

{
    "version": "0.1.0",
    "windows": {
        "command": "${workspaceRoot}/Compile.bat"
    },
    "isShellCommand": true,
    "showOutput": "always",
    "tasks": [
        {
            "taskName": "build",
            "isBuildCommand": true,
            "severity": "info",
            "problemMatcher": {
                "owner": "external",
                "fileLocation": ["absolute"],                        
                "pattern": {
                    "regexp": "(([A-Za-z]):\\\\(?:[^\\/:*?\"<>|\\r\\n]+\\\\)*[^\\/\\s\\(:*?\"<>|\\r\\n]*)\\((\\d+),(\\d+)\\)\\s.*(Fatal|Error|Warning|Hint|Note):\\s\\((\\d+)\\)\\s(.*)$",
                    "file": 1, 
                    "line": 3,
                    "column": 4,
                    "severity": 5,
                    "code": 6,
                    "message": 7
                }
            }                
        },
        {
            "taskName": "test",
            "isTestCommand": true,
            "severity": "info",
            "problemMatcher": {
                "owner": "external",
                "fileLocation": ["absolute"],                        
                "pattern": {
                    "regexp": "(([A-Za-z]):\\\\(?:[^\\/:*?\"<>|\\r\\n]+\\\\)*[^\\/\\s\\(:*?\"<>|\\r\\n]*)\\((\\d+),(\\d+)\\)\\s.*(Fatal|Error|Warning|Hint|Note):\\s\\((\\d+)\\)\\s(.*)$",
                    "file": 1, 
                    "line": 3,
                    "column": 4,
                    "severity": 5,
                    "code": 6,
                    "message": 7
                }
            }               
        }                         
    ]
}   

When it’s done

When everything works fine then you can

  • run the build command by pressing CTRL+SHIFT+B
  • run the test command by pressing CTRL+SHIFT+T
  • jump to the next compiler message in the current file with F8
  • jump to the previous compiler message in the current file with SHIFT+F8

Compiler messages

Learn more

Announcing OmniPascal – Open Preview

OmniPascal is the newest way to edit Delphi and Free Pascal code.  It’s going to support all language features Delphi knows. It will give you code completion, quick code navigation, great syntax highlighting and much more.

Today OmniPascal becomes available for open preview! The current version supports already a lot of useful features as you can see on www.omnipascal.com. And there is much more about to come in the future. OmniPascal aims to become the greatest code editing experience Delphi developers have ever seen.

You will find the latest news about the project always here on blog.omnipascal.com.

Share your thoughts about OmniPascal. Help us creating the best tool Delphi and Free Pascal developers deserve!