I’ve just moved some linter integration plugins to the KDE infrastructure (scratch repos), therefore making them generally available.
They are fairly simple plugins, all 3 of them are alike in that they just run an external tool, and bring the results (the issues found) into KDevelop’s GUI. The found issues then will be in the problems toolview, in their own separate tab. The tools can check either a single file or all files in the project. You can see the workflow and configuration options in the videos included. There are also user’s manuals and tech manuals in the docs directories of each repo.
This plugin integrates Clang’s static code analysis feature, providing C/C++ static code analysis.
This plugin integrates a linter called Pylint, and as the name suggests it’s a Python code analyzer.
As you all probably know CppCheck is static code analyzer tool for C and C++. KDevelop has a plugin that provides a front-end for it, and the plugin is called kdev-cppcheck.
The good news is I’ve updated it’s GUI and now it uses the KDevelop Problem Checker Framework.
In the past it used to have it’s own toolview, where it showed issues in different formats (flat issue list, grouped by files, grouped by issue severity), based on the settings set in a KCM module.
Here’s a screenshot showing and example of this
What I’ve done is break up that KCM module, and create a per project settings window, and a general global settings window. The global settings window allows you to set the location of the cppcheck tool
The per project settings window allows one to set the rest: parameters, and what should be checked
Also the results area now shown in the problems toolview, just like problems found by the background parser, in it’s own tab.
Here’s a video showing the workflow
First of all let me introduce some concepts for readers who are unfamilair with them.
What is krayz2?
What is kdev-krazy2?
kdev-krazy is a plugin for KDevelop, that provides a frontend for Krazy2, so it can be run directly from KDevelop. The resulting issues also show up in KDevelop.
Up until now the plugin had it’s own toolview. That’s where settings could be changed, analysis started, and that’s where the issues showed up. Let’s see some screenshots!
The first one shows the main KDevelop window, with the plugin loaded, showing the krazy2 toolview docked in the bottom (fairly large picture, feel free to click).
Clicking either the “Select paths” or “Select checkers” buttons shows settings dialogs, not surprisingly you can select paths and chekers in them. The next 2 screenshots shows those.
Finally the result of the analysis is shown in the toolview
All this was in the past. Now the settings can be changed in the per project settings window
The analysis can be started from the Run menu.
The results show up in the problems toolview, the same way that problems detected by the background parser, in a separate tab
Here’s a video showing how it all works
I’m pleased to announce that the KDevelop Checker Framework has been pushed to the KDevPlatform repository. Here are some details about it:
- Moved ProblemModel to shell
- Reworked the Problems toolview. Now it works like this:
- ProblemModels are added to ProblemModelSet.
- ProblemReporterFactory makes instances of ProblemsView.
- ProblemsView takes the models from ProblemModelSet (also subscribes for updates about them, so if one is added or removed it can add/remove their views) and it provides a tabbed widget where the views for them can be added. It creates instances of ProblemTreeView which show the problems in ProblemModel, and adds them to the tabs. Also the tabs shows the number of problems in the ProblemModels.
- The toolview will only add actions that are supported by the model (for example: filtering, grouping, reparsing, showing imports. Obviously reparsing doesn’t make sense for runtime problem checkers)
See the video:
- First it shows that the “old” problem reporter still works as intended (which also uses the new code now)
- Then from 1:07 onward it shows an example problem model/view working with randomly generated test data.
- It shows the features of the new model(s), that is filtering by files/project and issue severity.
- It also shows the grouping support (grouping by severity, and path.
- Broke up ProblemModel into 2 parts
- Base ProblemModel that provides the QAbstractItemModel interface for views and can use various ProblemStores to store problems. By default it uses FilteredProblemStore.
- ProblemReporterModel is basically the old ProblemModel that grabs problems from DUChain, it’s a subclass of ProblemModel.
- ProblemStore simply stores problems as a list (well technically it stores them in a tree, but it only has 1 level, so it’s a list). There’s no filtering, no grouping. It’s perfect for ProblemReporterModel since it does filtering itself when grabbing the problems from DUChain.
- FilteredProblemStore DOES filtering, and grouping itself. It stores problems in a tree (ProblemStoreNode subclasses). The tree structure depends on the grouping method, which is implemented with GroupingStrategy subclasses.
- Moved WatchedDocumentSet and it’s subclasses from ProblemModel to ProblemStore, as it is really a detail that the model itself doesn’t need, however ProblemStore which stores the problems needs it actually.
- Created a new Problem class, DetectedProblem and moved both this and the “old” Problem class in under the IProblem interface. The intent here was to create a class with a clear interface for problems, which ProblemStore can simply store. I wanted to eventually clear the problems out of DUChain and replace the “old” Problem class with it. However I realized that it’s not practical because of the “show imports” feature which shows the problems from imported contexts. Unfortunately DUChain is the class that knows those, and it’s way too much work to get it out from it. Not to mention it doesn’t even make sense, since it’s really something that logically belongs there.
Using this new system is fairly straightforward:
All one has to do is instantiate a model, add it to the model set:
KDevelop::ILanguageController *lc = KDevelop::ICore::self()->languageController();
KDevelop::ProblemModelSet *pms = lc->problemModelSet();
m_model = new KDevelop::ProblemModel(this);
Then later inject problems into it:
KDevelop::DetectedProblem *p = new KDevelop::DetectedProblem();
Here’s a class diagram about the relevant classes:
So I got a slot for GSOC2015 to implement a “Checker framework” for KDevelop, therefore I have been and I will be working on it during the summer.
The project has 3 phases
- Create a framework that problem checker plugin developers can push issues into, so that they don’t have to create their own infrastructure for it (like models, views, toolviews for the views, etc)
- Update some of the already existing plugins to use this framework (kdev-krazy, kdev-cppcheck, kdev-valgrind)
- Implement 2 new checker tools using the framework (clang-check, pylint).
A little bottom-line explanation:
This framework will basically mean a common (obviously subclassable) model that can be used for storing problems, some infrastructure for holding such models, and views. The model will be a refactored, cleaned up version of the current ProblemModel that is used by the problem reporter plugin. The toolview of that plugin will also be cleaned up and refactored, and provide a better view for the model(s).
Up to now I’ve been already working on creating this framework.
- Now it is a tabbed view, and the tabs show the number of problems in the currently shown view
- I’ve also created a class that holds problem models, and those models automatically get a view in a tab in the problem toolview
I am now in the process of refactoring the ProblemModel.
Here are two screenshots comparing the “old” toolview with the “new” one:
Let’s review what I’ve done to KDevelop’s kdev-cppcheck and kdev-valgrind plugins lately.
JSONized kdev-cppcheck and kdev-valgrind
This is fairly straightfoward: These plugins were still using the old .desktop plugin manifest files. Now they are using the embedded JSON manifests. This isn’t something user visible, but it’s needed as the old .desktop method is now deprecated.
Added the number of calls to the callgrind output of kdev-valgrind
Until now the callgrind output has only shown the IR and Inclusive IR fields. Now is shows the number of calls as well. Take a look at the pictures!
Reorganized the output of memcheck in kdev-valgrind
Until now kdev-valgrind’s memcheck output unfortunately didn’t show enough of the callstacks to be really useful. You couldn’t see where the problem exactly occured, or where it was stemming from! Now it shows the full backtrace + the auxilliary trace as well, so you can see what actually causes the problems. See the pictures!
While working on kdev-valgrind, I learned some debug lessons about them, and kinda made up a smaller checklist for problems I’ve encountered.
Problem: plugin doesn’t load
- Is the plugin installed to the right directory?
- Is the plugin path set correctly? ( QT_PLUGIN_PATH )
- Is the kdevelop version in the plugin manifest correct? ( .desktop file in KDE 4 style manifest )
Problem: when starting KDevelop KDE complains about missing .rc file for the plugin
- Is the .rc file installed to the right directory? ( e.g.: /usr/share/kxmgui5/plugin/plugin.rc )
- Is the .rc file named correctly and is it the same as set with setXMLFile in the plugin?
- Is the .rc file named the same as the plugin’s name in IPlugin’s constructor?
Problem: plugin menu items don’t show up
- Is the plugin loaded?
- Check the possible problems in the section above
I’ve started to upgrade KDevelop’s valgrind plugin ( kdev-valgrind ) to KF5 so that the KF5 version of KDevelop can use it.
In short ‘Valgrind’ is a dynamic analysis tool that allows you to check your programs for memory errors, threading errors in runtime. It also allows you to cache and call profile. So it’s very useful. Without such tools it would be almost impossible to detect and debug these kinds of errors. ( other than reading all the code and spotting it of course )
Kdev-valgrind is a plugin for KDevelop, that integrates some of this functionality into KDevelop. I did not create the plugin I am just merely updating it, because it is very very important to have!
It took me some time, but finally I can compile and load it as the screenshots below will show. All I had to do was basically update it’s cmake project file with the KF5 libraries instead of the KDE4 ones, change some class/call references ( ok, lots of them ), and move away from the deprecated KDE widgets, in favor of the Qt ones. Very soon I will test it througly and then submit my changes for review to the KDevelop guys.