Prevent mlint warning for onCleanup like return value

Question

tommsch 2024-7-2

0
链接

此问题的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/2133706-prevent-mlint-warning-for-oncleanup-like-return-value

编辑： Steven Lord about 21 hours 前

I wrote a function, similar to onCleanup. I noticed that Matlab does not give a mlint warning for the following code.

dummy = onCleanup( @() some_func );

But for my own function

dummy = MyOwnCleanup( @() some_func );

I get the warning Value assigned to variable might be unused, which I need to silence with %#ok<NASGU>. Obviously, Matlab recognizes the onCleanup call and does not emit a warning. How can I acchieve similar behaviour for my own MyOwnCleanup function?

5 个评论
显示 3更早的评论隐藏 3更早的评论

Umar 2024-8-16，1:32

Hi @tommsch,

It is quite interesting that MATLAB issues warnings for potentially unused variables as a way to help developers maintain clean and efficient code while the `onCleanup` function which is a built-in feature designed specifically for cleanup tasks, recognized by MATLAB for its intended usage does not generate a warning when it's used. In contrast, your custom function `MyOwnCleanup` does not have this built-in recognition. Consequently, when you assign it to a variable without further use, MATLAB issues a warning indicating that the variable might be unused. Now, achieving similar behavior, as mentioned in comments by @Rik , would be using overload for the existing `onCleanup` function but he also mentioned not to recommend using it and I do agree with his comments due to its potential conflicts and unexpected behavior in other parts of your code or MATLAB itself. My suggestion would of trying to trick MATLAB into recognizing your function like it does with `onCleanup`, consider modifying your implementation of “MyOwnCleanup” which you could implement it in such a way that it either always returns an object that would need to be stored or making sure that its functionality is always invoked when necessary. Now, if you still wish to use your current implementation without modifying it extensively, using %#ok<NASGU> is a valid approach because it does inform MATLAB's linting system to ignore this specific warning for that line of code. Here’s an example of how you could structure “MyOwnCleanup”

   classdef MyOwnCleanup

       properties

           CleanupFunction

end

       methods

           function obj = MyOwnCleanup(func)

               obj.CleanupFunction = func;

               % Register cleanup on object destruction

               cleanupObj = onCleanup(@() obj.execute());

end

           function execute(obj)

               feval(obj.CleanupFunction);

end

end

end

So, in this example, when an instance of `MyOwnCleanup` goes out of scope or is destroyed, it will execute the cleanup function passed during its creation. Please note that you will still need to store the object (e.g., dummy = MyOwnCleanup(@() some_func);) for the cleanup functionality to work properly.

Hope this helps. Please let me know if you have any further questions.

tommsch 2024-8-23，19:50

What is the worth of that answer. You just repeated my question and all the stuff I know. Are you a ChatGPT bot? You may consider to delete your answer to reduce spam - I will delete my reply then too.

Umar 2024-8-24，4:05

Hi @ tommsch,

You mentioned,” You just repeated my question and *all the stuff I know* “

Now, in your posted comments, you mentioned,

“I wrote a function, similar to onCleanup. I noticed that Matlab does not give a mlint warning for the following code. dummy = onCleanup( @() some_func );”

Could you please click the mathworks mlint documentation link below and tell me what does it say about mlint

https://www.mathworks.com/help/matlab/ref/checkcode.html

请先登录，再进行评论。

请先登录，再回答此问题。

Answer 1

Steven Lord 2024-8-23，20:52

0
链接

此回答的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/2133706-prevent-mlint-warning-for-oncleanup-like-return-value#answer_1504434

编辑：Steven Lord about 21 hours 前

在 MATLAB Online 中打开

So I wrote a cleanup function which accepts parameters, so you can write

cleandir = onCleanup_lazy( @(x) cd( x ), pwd );

Be careful with how you implement this if some of the parameters are state-dependent. What you've written here is fine, as pwd will be evaluated when onCleanup_lazy is called and the value returned by that function is what would be captured. I assume onCleanup_lazy is implemented something like:

function oc = onCleanup_lazy(fh, varargin)
fh2 = @() fh(varargin{:});
oc = onCleanup(fh2);
end

But consider if you'd written your onCleanup_lazy call slightly differently.

cleandir = onCleanup_lazy( @() cd(pwd));

This wouldn't do what you wanted, as pwd would only get called when the onCleanup object returned by onCleanup_lazy was being destroyed. This is likely well after you changed away from the directory that was pwd when you called onCleanup_lazy, and so that onCleanup object would have done nothing.

Getting back to your original question, I believe onCleanup is handled specially by Code Analyzer. Code Analyzer "knows" (aka we told Code Analyzer) that onCleanup objects generally aren't going to be interacted with in code after they were created. [Occasionally, if you want to control exactly when their tasks are executed, you may want to delete them, but that's about it.] Therefore we exempted it from the "This variable may be unused" check. I don't believe there is a way for users to instruct Code Analyzer that it should exempt their objects from this check as well. You could contact Technical Support and request a way to specify in the definition of a function or class that uses/instances of this function or class should not issue this Code Analyzer warning.