Inspector that flags lack of explicit Let or Set in an assignment
**Why** Although use of Let is obsolete (which is already detected by an inspector), I always use Let or Set to make it clear in the code, especially when default members are involved, and would love it if Rubberduck could tell me where I have forgotten to do so (much as it warns me of implicit ByRef arguments)
**Example** This code should trigger the inspection:
> We already have an inspection for an assignment to an Object variable without the `Set` keyword. To avoid duplicate results, this should only flag assignments to value types as missing the `Let` keyword.
The code already written for recognizing missing `Set` keywords should possibly be reused for this inspection. The two inspections should be separate, though. This is necessary for the inspection system to allow ignoring this inspection when the user doesn't want to explicitly qualify al
@KySoto remember the issue with OASIS and that DLL? He thinks it might be out of date and apparently it's a redistributable. Here's a link to one: docwiki.embarcadero.com/RADStudio/Rio/en/OpenSSL
@this Frankly, the difference between Set xlApp = New Excel.Application and i = 10 is far more noticeable than Let i = 10. If you've got a bunch of assignments all left-aligned, lines starting with Set stick out from those that _don't` better than having Let, Set, Let, Let, Let, Set...
> We've written inspections we don't personally agree with before (e.g. missing `Step` keyword, redundant `ByRef` modifier, etc.), so I don't see an inspection that flags "missing" `Let` keywords completely out of place. It *would* be disabled by default though, so as to not fix an "obsolete `Let` keyword" result only to get a "missing `Let` keyword" result, but I don't have a problem with such an inspection being implemented.
That said the `Set` keyword inspection has a number of false posit
or, enabling "missing Let keyword inspection" automatically forces explicit Call statements, line numbers everywhere in increments of 10 and in jumps of 1000 per procedure, single-letter variable names declared and referred to with a type hint, SysHungarian prefixes enforced by Def[Type] statements, implicit access modifiers, and implicit ByRef parameters. Oh and Do...While is forbidden.
#WellYouAskedForIt
no wait, the type hints defeat the Def[Type] statements
Easter egg idea: pop the original 1981 pac-man playable in a modal dialog, when RD parses a module that contains a single scope with line numbers and GoSub/Return statements instead of procedures, and explicit Let statements, single-letter variable names declared with type hints.
just got a handful of higher-priority issues to address first :)
At my job, there's absolutely no code review, no testing, no version control, no organization of software architecture, no concept of "test vs production servers", no code commenting. In fact, all of this is explicitly banned and I often get "in trouble" for writing comments or using small modula...
> I agree that default members are dangerous and confusing. The main reason I use them despite that is to make debugging easier: if they return a string, that string shows when you roll-over the variable in code, or have a watch on a variable. That way you can see the value of complex objects when debugging without having to look at their individual attributes, and you can control how they are displayed in the debugger. Additionally, I have built wrapper classes for VBA simple types (e.g. Intege
> I'm new to Rubberduck and am very impressed by the product and the programming philosophy that underpins it. I have many, many gripes with VBA as a language, but I'm forced to use it for my work, and Rubberduck makes working with VBA that much more satisfying.
Thank you for the insight. This is definitely the type of information I can't find anywhere no matter how much I search and it's also more interesting than most things in the documentation. — user739397311 mins ago
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/5044?src=pr&el=h1) Report > Merging [#5044](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/5044?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/bdaf6d7be446e9ca2814b1fdf2503143f6dafe38?src=pr&el=desc) will **increase** coverage by `0.14%`. > The diff coverage is `28.21%`.
Duck check: I'm pushing to repos to delete theme. Works great. When I have a web page open such as github.com/rubberduck-vba/Rubberduck/pull/5039 that allows for me to click a button and delete it, how does it know to refresh when I do a CLI push that deletes the branch?
Frankly, if they're anything like me, they'll be too busy trying to parse what that icon actually is and what it means to remember to launch their apocalypse.
> News organizations across the globe are reporting the Robo-Pocalypse was thwarted by horribly written and inefficient code. Canadian expert and #IndustryDisruptor Mathieu Guindon testified before Parliament that there were too many Let statements and the code was too large to successfully be parsed.
> Looks like a woopsie submission that accidentally went through - feel free to edit as needed (we'll close this issue in the meantime, feel free to reopen when it's fleshed out)
there's an official position in Ottawa whose role is to "represent the Queen" and basically rubberstamp the laws that the senate rubberstamped after the legislative/executive (the separation is annoyingly blurry) passed them
@IvenBach somewhat unrelatedly: the German head of state is Frank Walter Steinmeier. The French Monsieur Le Presidente is Emmanuel Macron and the EU is a royal fuckfest of compenency overlaps and bureaucratic nightmare so I have no idea who's actually in charge over there
@MichaelHarvey Over Soviet Russia, alcohol drinks you! Or did the space stations qualify as sovereign territory? I've never been quite up on all those rules and rgulations. — Cort Ammonyesterday
@this can you confirm that an Access form has a Print method? I'm writing up an issue on the vba-docs repo and I can't seem to be able to write any code that makes this a true statement:
> The object is required if the method is used outside a module having a default display space. For example, an error occurs if the method is called in a standard module without specifying an object, but if called in a form module, outputlist is displayed on the form.
as far as I can tell, that's demonstrably false
(throws error 438 on a userform)
I'm sure I read it in the chat transcript a (quite a long) while ago, but I can't find it :(
Private Sub Report_Load()
Me.Print "test"; "ac"
End Sub
will give an error:
> 2158 Application-defined or object-defined error You can use the Print method and the report graphics methods (Circle, Line, PSet, and Scale) only in an event procedure or a macro set to the OnPrint, the OnFormat, or the OnPage event property.@@@1@1@10129@1
yeah, i tried to test for IVBPrint and I think I failed
?typeof Report_Report1 is IVBPrint => Compile error: User-defined type not defined
Hmm. I thought IUnknown would always work but apparently not if the OLE library isn't referenced. So I guess I must reference whatever library contains the IVBPrint interface.
@this Err is browsable though; it's a function in the VBA.Information module
Debug gets keyword syntax-highlighting, which ...is rather puzzling
I'm thinking it's some kind of macro. Like, it tells VBA "you know this hidden object that implements IVBPrint there? dereference it, we've got a member call here"
it's basically "here's a module, gimme the rewriter for it" then you tell the rewriter what tokens to rewrite, and you can chain up as many operations as you need, nothing actually happens until you tell the rewriter to go ahead and rewrite the module
You can actually insert at each token index as many times as you want. The restriction on only one operation is only there for deleting and replacing tokens.
Btw, if you want to add an annotation, you might want to use the AnnotationUpdater.
@IvenBach a rewriter works with the token stream - the very same lexer output that's given to the parser (lexer tokenizes the input string, parser makes a parse tree out of the stream of tokens), and lets you manipulate the tokens, e.g. replace token #374 with the string "foo", then replace everything between tokens #643 and #822 with some other string, and then proceed to physically rewrite the actual module with the new rewritten token stream.
The rewriter API provides a number of methods and overloads to make it easy to work with IParseTree objects (e.g. a CallStmtContext, or other parse tree nodes)
private void ExecuteIgnoreTestAnnotationCommand(object parameter)
{
var foo = SelectedItem;
var testMethod = ((TestMethodViewModel)SelectedItem).Method;
//testMethod.IsEnabled = !testMethod.IsEnabled;
var result = Rubberduck.Parsing.VBA.Parsing.VBACodeStringParser.Parse(testMethod.TestCode, x => x.annotationList());
var annotations = testMethod.Declaration.Annotations;
}
That's what I've tried so far but can't make progress on result.rewriter. Again I feel like I'm missing the forest that's right in front of me.
VBA Rubberducking
VBA Rubberducking