Calculating the content hash of the module on creating of a QMN is actively hurting their usability in hot-paths. The content hash was not really used and only was left there because it seemed to prevent some strange behaviour of COM components. Testing, I did no longer run into the strange behaviour. So, I think it is prudent to remove the content hash.
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4418?src=pr&el=h1) Report > Merging [#4418](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4418?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/8d26793249e32cb20ae522815b0d14c713378be4?src=pr&el=desc) will **decrease** coverage by `3.55%`. > The diff coverage is `56.03%`.
#DidYouKnow Rubberduck is written with the latest version of #CSharp? ...and as of 5 minutes ago, uses the new .csproj format!
Massive props to @vogel612 for this beautiful #TechDebtPayment PR! #Kudos #OSS #Hacktoberfest
Do I use the VBAParserAnnotationFactory to create an instace of an IAnnotation which then lets me access the VBAParser.AnnotationContext Context property?
Hey @M.Doerner are you available to lend me a few breadcrumbs?
Hi all, I was the guy who sent Mat the email with the VBA issue on 64-bit hosts (compared to 32-bit hosts) regarding the class terminator. Just was looking here first time.
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4426?src=pr&el=h1) Report > Merging [#4426](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4426?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/8d26793249e32cb20ae522815b0d14c713378be4?src=pr&el=desc) will **decrease** coverage by `3.83%`. > The diff coverage is `n/a`.
It never really was anything more than a discussion, and it's a lot of work and Tim did it. I think we could (should?) integrate a UI client for it though.
Does anyone know where the default for log is stored? In the file or set via code or what? The GeneratlSettings doesn't seem to set any defaults beside CompileOnParse
Introduces new setting that isn't UI-visible, `UserEditedLogLevel` that allows us to ship Rubberduck with `Trace` as the default logging level. If the user do not edit it, at the shutdown of the Rubberduck, the log level will be changed to `None`.
with this code I add item/properties into my collection:
Public RateSTD as Collection
Public Sub mCaricaRateSTD()
On Error GoTo RigaErrore
Dim rng As Range
Dim c As Range
Dim newRate As ClsRate 'ClsRate are Class Module
If Not RateSTD Is Nothing Then
Set RateSTD = Nothi...
I have a colleague who thinks he knows everything better than me. Sure, he knows many things, but not everything. He knows quite some things better than me, but I also know other things better than him. Yet, he believes he knows everything better than me.
He pulls up my changes and starts critic...
#1, if it really is renaming Request to RequestClass, then that guy is both a bad programmer and a jerk.
#2 "professional, university-educated .NET developer who knows her stuff"--"university-educated" and "knows [] stuff" are almost entirely contradictory.
There are some devs who learn their stuff in university (Jeroen for one--he was taught by Harwell...), but the vast, vast majority "university-educated" devs are useless.
And, Jeroen did a TON of stuff outside university, and probably learned just as much that way.
Oh, when I was searching Harwell Jeroen developer, I found Sam Harwell's name accurately with Roslyn, though unless Jeroen Vanneval goes by Jeroen Wellen online, I found the wrong Jeroen in the same thread.
If you "transpose" over one dimension, you still get a single dimension. To conceptualize this, picture a line. Now attempt to rotate it in a way that a given point on the line has different degrees of freedom (i.e. can move in a different direction). — Comintern56 secs ago
I hope OP tries that. Hopefully it doesn't consume the rest of the day...
No, they are one of our senior guys, and they are pretty sharp. I think they might just be trying to hit a number on this one, though, because we want everything to be tested.
I'm not certain they evaluated what is really important to test, though...
Which might be a hint at the past, when management told them to stop testing because they spent as much time maintaining tests as they did on new code.
@Comintern I know it sounds terrible but have you thought of intentionally implementing a problem into code that's easily fixed? Then when code barfs you can subtly mention "Ya know... Unit tests would have caught this. I can't remember everything all the time."
@IvenBach If I could put a decent unit testing suite together, I could just run the unit tests instead of waiting on a 5 or 6 hour process to crash because I forgot to convert a field from unicode to ascii or something dumb like that.
The 2 minutes to fix, 5 hours to "test" development model leaves a lot to be desired.
@Comintern At least he's a bit nicer about that. ;) Seriously, that buy-in is a big challenge.
It shouldn't be but it is.
It's more pronounced when you're dealing with tightfisted clients who want to see results right now or yesterday.
The good thing is that we can and do tell them at the upfront that if they don't pay for testing, they have no guarantees whatsoever. They get exactly what they pay for.
Oh, our clients are like that. It's more a matter of "downtime" between client projects. That's part of the reason some of this steaming pile of codebase exists.
I estimate in "infrastructure improvement time" into my quotes.
Oh, I know the pain. We have a library of code that get re-used in various projects. Only that they get tweaked here and there and every project has a version X.Y.Z.A of the same thing. Drives me insane and I've been working at harnessing them.
but it's not a work done in a night. Maybe one day.
My philosophy is that if I'm charging you to reuse some hurried code for another client, you get a break on the upfront development time, but you also get to pay some of the tech debt.
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4441?src=pr&el=h1) Report > Merging [#4441](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4441?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/8d26793249e32cb20ae522815b0d14c713378be4?src=pr&el=desc) will **decrease** coverage by `<.01%`. > The diff coverage is `100%`.
@IvenBach you get it from the parser, and - oh look - the delegate argument is taking a VBAParser parameter, so you can do parser => parser.StartRule() (or call it p, or t, or whatever) and that returns a StartRuleContext : IParseTree
just call the stringparser.parse method. as you type the comma, watch intellisense telling you that the parameter is a delegate type. so you pass an anonymous function as a parameter, and that function has to have one parameter, of type VBAParser - because that's what the delegate type says the parameters are for that anonymous function - so you type the name of the parameter, followed by a lambda operator
it's completely identical to typing .Where( and then being told "I need a Predicate<Foo> parameter", so you type foo => and proceed to write a bool-returning expression that involves foo, which has to be of type Foo, because Predicate<Foo> says so. (Predicate<Foo> also dictates that the expression must return a bool)
so here it's the exact same thing, except instead of a Predicate<T> delegate you need a ParserStartRule delegate
and like Predicate<T> is a Func<T,bool>, a ParserStartRule is a Func<VBAParser,IParseTree>
the function you provide will be invoked further down the call stack, when needed
if it's less confusing you could even new up the ParserStartRule delegate, but then R# will tell you that that's redundant
High level I get the idea. Now just working through the actual usage in the code. Relating it to Predicate<Foo> helps me use something I'm somewhat comfortable with and apply it to a slightly different concept. Thank you very much.
How does the Parse method know that the t which is supplied as an anonymous function (delegate) is of type VBAParser?
public static (IParseTree parseTree, TokenStreamRewriter rewriter) Parse(string code, ParserStartRule startRule, ParserMode mode = ParserMode.Default) is the signature but I don't see where VBAParser is defined.
Remember, it's just a different way of referencing a function. Rather than referencing it by its name, you reference it by basically inlining the function body.
I've always just defined the delegate, then assigned it to some function definition. But then again, I'm pretty almost all of my uses of delegates has been with events.
@Comintern Ah. When I was learning, I was far too green to even have known of it (and didn't then take C# for a long while after that brief foray w/ 2.0)
@this what's this newing up? myObj.SomethingHappened += new MyEventHandler(HandleSomethingHappened);
@BKSpurgeon that's because they are "delegates that take on subscribers" - event is mere syntax sugar, nothing more. — Mathieu GuindonJun 29 '17 at 0:29
Within Parse it news up a SimpleVBAModuleTokenStreamProvider() which invokes the method public CommonTokenStream Tokens(string code). You provide code as the argument` and get back tokenStream of type CommonTokenStream.
yeah well that's just that parsing boilerplate details
the interesting part is that instead of invoking & returning the result of parser.startRule(), it invokes & returns the result of whatever ParserStartRule function you provided
Then tokenStream is provided as the argument for new VBAParser(tokenStream) which has the signature of public VBAParser(ITokenStream input) : base(input).
this ability is useful for e.g. block completion, when I'll want to get a parse tree for a generated For loop body, and retrieve the placeholder tokens - I know I want to parse a For loop, so I tell it to parse a forNextStmt (whatever it's called)
> Rubberduck's type library is late-bound, so RD is already not required for running non-test code paths. The advantage of using precompiler directives would be to enable early-binding (and thus intellisense) - but then if RD is early-bound, it needs to be referenced... and if RD isn't installed, then it becomes a missing reference, which breaks the "doesn't require Rubberduck to run" premise, because then the project won't be compilable/runnable.
with this code I add item/properties into my collection:
Public RateSTD as Collection
Public Sub mCaricaRateSTD()
On Error GoTo RigaErrore
Dim rng As Range
Dim c As Range
Dim newRate As ClsRate 'ClsRate are Class Module
If Not RateSTD Is Nothing Then
Set RateSTD = Nothi...
VBA Rubberducking
VBA Rubberducking