« first day (1535 days earlier)      last day (1645 days later) » 

Duga
Duga
12:01 AM
RELOAD!
[banane-io/PDB] 1 commit. 657 additions. 631 deletions.
[Hosch250/CheckersWebsite] 2 commits. 15 additions. 1 deletion.
[rubberduck-vba/Rubberduck] 5 issue comments.
 
 
11 hours later…
Duga
Duga
10:51 AM
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4285?src=pr&el=h1) Report
> Merging [#4285](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4285?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/055d9110421e53908807d8aac9348209f4af3b55?src=pr&el=desc) will **decrease** coverage by `<.01%`.
> The diff coverage is `n/a`.


```diff
@@ Coverage Diff @@
## next #4285 +/- ##
============================
 
Duga
Duga
11:04 AM
[rubberduck-vba/Rubberduck] build for commit 7ebed463 on unknown branch: AppVeyor build succeeded
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4285?src=pr&el=h1) Report
> Merging [#4285](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4285?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/055d9110421e53908807d8aac9348209f4af3b55?src=pr&el=desc) will **decrease** coverage by `<.01%`.
> The diff coverage is `n/a`.


```diff
@@ Coverage Diff @@
## next #4285 +/- ##
============================
[rubberduck-vba/Rubberduck] build for commit 7ebed463 on unknown branch: 52.3% (target 0%)
 
M.Doerner
M.Doerner
12:00 PM
I just realized that the AttributesListener currently puts all module variable member attributes on the scope of the module.
I wanted to correct that, but now I have a question.
Can you put attributes on lists of variable declarations and if yes, which ones are actually affected?
Moreover, looking at the grammar, I am wondering whether it is possible to put module attributes between subs.
 
Duga
Duga
12:15 PM
[rubberduck-vba/Rubberduck] MDoerner pushed commit acd485f8 to next: Catching InvalidCastExceptions when getting the host application in order to not blow up.
[rubberduck-vba/Rubberduck] MDoerner pushed commit 7ebed463 to next: Even more catching and logging
Merge pull request #4285 from MDoerner/DirtyHackToNotBlowUpForStrangeHostSetups

Dirty hack to not blow up for hosts with unexpected COM setups
 
Duga
Duga
12:27 PM
[rubberduck-vba/Rubberduck] build for commit 00e0c4fc on next: AppVeyor build succeeded
[rubberduck-vba/Rubberduck] build for commit 00e0c4fc on next: 52.3% (target 0%)
 
M.Doerner
M.Doerner
12:44 PM
@DisplayName You might want to try the latest prerelease of RD.
 
this
this
1:22 PM
@M.Doerner On one hand, I don't think I ever saw an attribute on a variable; only on a module or a procedure. On the other hand, I have never seen an exhaustive list of attributes. I imagine the VB6 help files would be the place to have such listing.... If it did.
 
M.Doerner
M.Doerner
1:44 PM
We have an issue in which @ThunderFrame demonstrates that module level variables can have VB_Descriptin attributes.
Moreover, the list was not about the wttributes, but the variables.
Public foo As Long, bar As Long
Attribute VB_Description = "WhichOne"
Ah, now I understand what you meant.
I also have no idea which attributes actually exist apart from the usual ones.
 
this
this
For procedure attribute, don't you normally prefix them?
@M.Doerner When I test that, the description get applied on the module. 
Public foo As Integer, bar As Integer
Attribute foo.VB_Description = "WhichOne"
This imports but does nothing
Interesting; for a given procedure named Foo, Attribute VB_Description = "foo" will not work. It must be Attribute Foo.VB_Description = "foo" and be located within the procedure. If the Attribute Foo.VB_Description = "foo" is declared in the module header, it is simply ignored. Seems to me that prefixing only works for procedure attributes.
Not finding the issue by ThunderFrame....
I see now - without the prefix, the attribute seems to always apply to the module, no matter where the attribute is positioned within the module. Thus, Attribute VB_Description = "Foo" inside a Foo procedure will end up decorating the module's description property instead of the Foo procedure. Prefixing helps avoid that but it must be within the procedure's body for it to work, apparently.
 
M.Doerner
M.Doerner
2:21 PM
It must be within the procedures body or immediately following it.
You can find a few on the following line in vbWatchdog.
 
this
this
Yes I remember that issue
 
DisplayName
DisplayName
@M.Doerner done. And I don't get any error! Thanks: I'll be testing it in near future
 
this
this
@DisplayName that's great news! When you do get back to it, please make sure to check the unit testing module and make sure it still works.
 
Duga
Duga
[rubberduck-vba/Rubberduck] mansellan pushed commit 7afb435d to next: Closes #4280.
Merge pull request #4284 from mansellan/4280

Quick hack to fix VB6 crash on certain project types
 
M.Doerner
M.Doerner
@this This issue #1683 has the attributes.
Apparently, I have to disect the list according to the variable names in the attributes. Fun!
 
DisplayName
DisplayName
2:31 PM
@this er... I don't know how to check the unit testing module (yet?)
 
this
this
@M.Doerner I'm confused. This seems to be about annotations, not the attributes as defined by VB*.
@DisplayName No worries. Just keep it simple: 1) in a blank project; load Rubberduck. 2) via Rubberduck's menu, Unit Tests -> Add Test Module, then again to Add Test Method, then Run All Tests. By default, you should get a single result with a yellow icon (e.g. inconclusive result). If you got that far with no error, then we know it's working fine.
 
Duga
Duga
 
M.Doerner
M.Doerner
@this I have no idea what went wrong there. #1683
I did copy from the address field of the browser.
And got the wrong URL.
 
this
this
Huh. I did that and that didn't work. Let me try using his code.
@Duga Poor wording on my part - I wasn't referring to the Rubberduck API but rather that the serialization is a part of the Rubberduck.Parsing and thus is available to any other assemblies that depends on that project.
ahh I see why
 
Duga
Duga
 
this
this
2:39 PM
it's VB_VarDescription, not VB_Description
 
M.Doerner
M.Doerner
The desciption attribute is different.
 
Duga
Duga
 
this
this
Yes.
 
M.Doerner
M.Doerner
^
 
Duga
Duga
[rubberduck-vba/Rubberduck] build for commit bfd6a950 on next: AppVeyor build succeeded
 
this
this
2:40 PM
That is rather.... intuitive.
 
Duga
Duga
[rubberduck-vba/Rubberduck] build for commit bfd6a950 on next: 52.3% (target 0%)
 
M.Doerner
M.Doerner
Does it work if you do something like
Public foo, bar
Attribute foo.VB_VarDescription = "something"
Attribute bar.VB_VarDescription = "somethingElse"
 
this
this
Yes.
they get assigned correctly
 
M.Doerner
M.Doerner
On one hand, that is reasuring; on the other hand, that is really annoying when collecting the attributes.
 
this
this
As matter of fact the position does not matter
I can put it anywhere else in the module
 
DisplayName
DisplayName
2:44 PM
@this Done: all steps and feedback as per your description and no error!
 
this
this
Well, not exactly; it has to come after. Can't be prior the declaration
but I can put it to the end of the module and it will get applied still
@DisplayName Awesome!
Glad to know that it was an easy fix!
 
DisplayName
DisplayName
@this thank you all again. Is it time to close the issue?
 
M.Doerner
M.Doerner
@this What happens when you export? Are the attributes still at a random place?
 
this
this
Yes, @DisplayName
@M.Doerner given this input: 
VERSION 1.0 CLASS
BEGIN
  MultiUse = -1  'True
END
Attribute VB_Name = "TestClass"
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = False
Attribute VB_PredeclaredId = True
Attribute VB_Exposed = False
Option Compare Database
Option Explicit




Public foo, bar

Public MyVar As String

Public Sub doit()
    Debug.Print "OK!"
End Sub

Public Sub Foo()

End Sub

Attribute VB_Description = "WhichOne"
Attribute bar.VB_VarDescription = "somethingElse"
Attribute foo.VB_VarDescription = "something"
 
Duga
Duga
> Rubberduck v2.2.0.3684-pre solved it!
Thanks you all!
 
this
this
2:53 PM
This is what VBA exports: 
VERSION 1.0 CLASS
BEGIN
  MultiUse = -1  'True
END
Attribute VB_Name = "TestClass15"
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = False
Attribute VB_PredeclaredId = True
Attribute VB_Exposed = False
Attribute VB_Description = "WhichOne"
Option Compare Database
Option Explicit




Public Foo, bar
Attribute Foo.VB_VarDescription = "something"
Attribute bar.VB_VarDescription = "somethingElse"

Public MyVar As String
Attribute MyVar.VB_VarUserMemId = 256
Attribute MyVar.VB_VarHelpID = 4
Note that the procedure attribute get lost since I declared them outside the procedure body. Module and variable attributes did not.
Note #2: the code is also technically un-compilable, due to duplicate declaration of Foo. That did not stop VBE from parsing the attributes, apparently.
 
M.Doerner
M.Doerner
So, variable attributes can be declared anywehere but get exported to right after the declaration.
I'll come up with something that handles the attributes correctly.
 
this
this
Anywhere after the declaration
if it's prior, it will get lost, too
 
M.Doerner
M.Doerner
It still seems to make sense to add member attributes for variables right after the declaration.
 
this
this
I agree that is the sensible expectation but VBE is.... loose.
 
M.Doerner
M.Doerner
Ah, ok, makes it even more fun.
 
this
this
3:03 PM
module attributes apparently don't have that problem because technically they can be put at the first line of the module and will still work, so it can be literally anywhere.
Hmm. I wonder.
 
M.Doerner
M.Doerner
Actually, that makes it easier to handle with the listener.
I think they really can be anywhere, which is really annoying.
Can you have module attributes withing procedures?
If yes, we are doing it wrong atm.
 
this
this
Apparently, we can.
for some reason, it strikes me that VBE is doing multiples passes; resolving the members, then resolving the attributes, then resolving the content last.
 
M.Doerner
M.Doerner
Then the AttributesListsner needs a conceptual rework.
 
this
this
or more likely just 2 passes; 1 pass to resolve both the member and attributes... which would be why the attributes can be only declared after but not prior.
 
M.Doerner
M.Doerner
You only need one pass.
 
this
this
3:08 PM
and it's probably using scoping rules which would be why the procedure attributes cannot work anywhere outside the procedure's body.
 
M.Doerner
M.Doerner
I mean, to get the attributes.
 
this
this
My thought is that if it's own pass, VBE would be able to pick up the procedure attributes anywhere as it did with the module and variable attributes, and you would be able to declare attributes prior to the declaration it refers to.
But it's very like C/C++; you can't refer to a member that has not been declared already.
 
M.Doerner
M.Doerner
I think it is the other way around: with two passes, you can get all, but not in one.
 
Duga
Duga
> PR #4284 disabled the RD context menu from being attached to the MS Forms designer to solve an AV issue with certain VB6 project types described in #4280.

To reinstate this context menu, we will need a way of observing the initial load of the MS Forms designer (which may not occur at IDE startup), and attach the menu after it has loaded.
 
this
this
@M.Doerner That's what I was saying only in different terms - it could have only gotten them all if there were a prior pass to resolve all member names.
 
M.Doerner
M.Doerner
3:12 PM
Ah, OK. I was getting the entirely opposite impression.
 
this
this
Sorry. Anyway, that's why I think VBE is likely doing both the member resolution and attribute together in the one pass considering the scoping rules, which gives that behavior we observe.
 
M.Doerner
M.Doerner
That makes sense.
We actually try to something similar.
However, we neglect outer scopes.
 
this
this
I just tried applying attributes on a variable declared inside a procedure. That imports but exports did not have the attributes. I don't think it is possible to decorate a privately declared variable anyway. It also means that procedure attributes might be the only one that has additional scoping consideration.
Interestingly, a private module level variable persists the attributes. I didn't expect that.
Actually that makes sense - the variable still shows up in the OB so it should be able to persist the attributes.
The OB will never show the procedure level variables, so I don't think there's a chance of saving any additional attributes to a variable declared in a procedure....
Yeah, parameters don't get their attributes persisted, either.
Unless @ThunderFrame can show otherwise w/ his ThunderCode ;-) , I think procedure attributes are the only one that has scoping rules to consider.
 
ThunderFrame
ThunderFrame
3:34 PM
@this I think you're right, if you want to attribute data to a procedure-level variable, you need to use Attribute VB_Ext_Key and your own key/value naming convention.
 
this
this
and have you ever seen a official list of attributes?
I was thinking that if it was ever officially listed, it'd be probably hidden away in a page of the VB6 help tome.
 
M.Doerner
M.Doerner
I would consider that a module attribute.
 
ThunderFrame
ThunderFrame
There's a list, and a good example in 1683
 
this
this
@ThunderFrame I saw that but you got it by peeking in the memory dump; I was referring to the official documentation
 
ThunderFrame
ThunderFrame
@this there's scant VB6 documentation left. The best sources are RubberduckVBA or Chris Mclelland (@rubberduck203)
 
this
this
3:40 PM
Yes. I was thinking more of the old VB6 help files.. you know those that came with the CD?
(they did come with it, right?)
 
mansellan
mansellan
@this they came on the MSDN CD yes
I don't have a copy to hand atm :-(
 
this
this
The earliest I can get is MSDN from Oct 2001 but it's 1.2 GB compressed....
 
mansellan
mansellan
oh it's still on there?
 
this
this
only if you're a subscriber.
Whether that is the one with VB6 documentation.... IDK.
 
ThunderFrame
ThunderFrame
guess what happens if you press help?
 
mansellan
mansellan
3:43 PM
hmm - found a link that still works
 
this
this
@ThunderFrame Ironic considering that VB6 was aimed at .... nonprogrammer. .
 
ThunderFrame
ThunderFrame
@this Windows 10 doesn't support .hlp files
 
this
this
Hmm OK but it doesn't seems to be searchable
 
ThunderFrame
ThunderFrame
there's a hack somewhere that involves copying the help provider from XP to Win10, but I haven't got around to it yet.
I only installed the bare minimum for VB6 - didn't install the MSDN disks.
 
this
this
I thought the MSDN disks were the VB6's disc #2
apparently not.
 
ThunderFrame
ThunderFrame
3:47 PM
also, I found this KBARCHIVE on github the other day - it's not a complete set of articles, but it's pretty good..... until it gets taken down.
@this I have VisualStudio6, it's 2 CDs of MSDN content, IIRC
 
this
this
I think there's also 1 or 2 other sites that does same thing
 
ThunderFrame
ThunderFrame
@this none that make it quite so easy to clone
 
this
this
@ThunderFrame I see, so for a total of 4 CDs? 2 CDs of VB6 and 2 CDs of MSDN?
 
M.Doerner
M.Doerner
Hm, we do not really save everything about attributes.
 
this
this
Via the MSDN, the Oct-2001 one is 3 CDs.
 
M.Doerner
M.Doerner
3:49 PM
In particular, we only save the first context.
 
ThunderFrame
ThunderFrame
@this Installing VB was a single CD requirement, IIRC. C++, JVM and extra controls were probably another 1-3CDs, plus the MSDN of 2 CDs
 
mansellan
mansellan
@ThunderFrame cloned :-)
 
this
this
@ThunderFrame Gotcha. The MSDN had VB6 on its won and that was the one I grabbed.
 
ThunderFrame
ThunderFrame
it really irritates me that .hlp files don't work in Win10. MS spends so, much time and resource ensuring old software works on every new OS, but they can't ensure the help works?
 
this
this
probably a subtle disincentive to stop developing old software?
 
ThunderFrame
ThunderFrame
3:55 PM
@this sure, in this case it's help for old development tools, but help for end-user apps is the same.
it's not like they make a huge amount out of CHM authoring software (although I'm staggered at the cost of third party help authoring tools)
 
this
this
Yeah, the help file authoring and installer authoring tools are uniformly overpriced
 
ThunderFrame
ThunderFrame
 
this
this
Checking, VB6 was distributed with VS6?
 
ThunderFrame
ThunderFrame
@this yep
and VB5 in VS97
 
this
this
not available via the MSDN, AFAICS
the earliest i can go is VS 2005
maybe VS6 got taken down due to the java lawsuit?
there's a huge gap between roughly 1996-2002 because of that.
 
ThunderFrame
ThunderFrame
3:59 PM
@this I have discs and key, but the ISOs are on betaarchive
 
mansellan
mansellan
October 2001 is the best set to use, it was the last release before they removed Vs6 entries
 
M.Doerner
M.Doerner
Can you have multi-part identifiers in attributes?
 
ThunderFrame
ThunderFrame
and the product keys were pretty trivial back then - the first part must be a number modulo 1, and the second part must be a number modulo 7, so 111-777777 would seem to work
 
this
this
@mansellan how do you know that?
 
mansellan
mansellan
seen it mentioned in the past too
 
ThunderFrame
ThunderFrame
4:02 PM
oops, Correction:
Jul 28 '16 at 0:19, by ThunderFrame
@Comintern - No, VB6 was still before Bill's internet epiphany. The key just needs to have sum of first 3 digits mod 3 = 0, and sum of last 7 digits mod 7 = 0.
@mansellan ditto
 
this
this
Hmm, Ok.
@ThunderFrame that's .... terrifying stupid.
"Nobody can possibly crack it!"
esp. considering that VS6 wasn't exactly cheap
 
ThunderFrame
ThunderFrame
@M.Doerner there was a bug when parsing Wayne's code, where a procedure was defined in a single line, like Sub PlaceHolder1():End Sub and the attribute was on the next line. It's since been fixed, but might be worth considering in any changes.
@this that was around the time of Balmer's "Developer, Developer, Developer" rant, so I guess they saw VS as a loss-leader.
 
this
this
@ThunderFrame they could have just gave it away for free, you know....
 
M.Doerner
M.Doerner
That is no problem.
 
ThunderFrame
ThunderFrame
@this like they do now
 
this
this
4:07 PM
Yes. They're just slightly slow on the uptake.
 
M.Doerner
M.Doerner
The main problem is the correct identification for attributes that can be defined anywhere.
 
this
this
Max, how would there be a multi-part identifier within a single scope, though?
 
ThunderFrame
ThunderFrame
@M.Doerner IIRC, if a module level attribute isn't defined in the declarations section, then it doesn't stick. But the way the VBE identifies the Declarations section isn't completely straight forward - for one thing, a line-continued comment changes the length of the declarations section.
 
M.Doerner
M.Doerner
As far as I understood @this, it sticks from everywhere.
It just gets moved on the next export.
 
ThunderFrame
ThunderFrame
@M.Doerner oh, well it might stick on import, but I assume the next export would have it in the declarations section
snap
 
M.Doerner
M.Doerner
4:13 PM
I guess in a VB6 file it will probably just stay where it is.
 
ThunderFrame
ThunderFrame
I'd want to check that - I suspect it might get moved. but TTGTB
 
this
this
4:46 PM
@M.Doerner tried this: 
Public MyVar As String
Attribute VB_Description = "WhichOne"
Attribute TestClass.MyVar.VB_VarUserMemId = 256
Attribute TestClass.MyVar.VB_VarHelpID = 4
Attribute TestClass.MyVar.VB_VarDescription = "The MyVar description"
That did not work.
So, no, I don't think an attribute can have a multiple part name applied.
 
mansellan
mansellan
5:01 PM
oh wait
I was wrong
 
M.Doerner
M.Doerner
@this That is reassuring. Then my identification scheme should work.
 
M.Doerner
M.Doerner
5:34 PM
Is there a specific reason why we read in attribute values in two different ways, depending whether we add further values to an attribute or not?
_values = context?.attributeValue().Select(a => a.GetText()).ToList() ?? new List<string>();
vs
var values = context.attributeValue().Select(e => e.GetText().Replace("\"", string.Empty)).ToList();
 
Duga
Duga
5:54 PM
> This PR introduces a new field AttributesPassContext on the Declaration holding the context from the attributes pass for all declarations allowing attributes. I would like to have added this only to a more specific type. However, that would have required some rework on the declaration type hierarchy since we have no ModuleVariableDeclaration. (That is something for another PR at some time in the furture.) The membersAllowingAttributes are acquired along with the attributes and...
stored in an analogous way. In addition, this PR fixed the key assigned to attributes for module variables and for module attributes inside procedures, functions and properties. This PR should provide the necessary foundation for an AddAttributeCommand. This PR is still WIP because the modified AttributeListener needs quite a few new unit tests.
 
M.Doerner
M.Doerner
Oh, apparently we have no tests at all for the attributes.
 
Duga
Duga
6:06 PM
[rubberduck-vba/Rubberduck] build for commit 7ceeb295 on unknown branch: AppVeyor build succeeded
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4287?src=pr&el=h1) Report
> Merging [#4287](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4287?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/bfd6a95059fdeed531194e6bd29a6ef683512c2d?src=pr&el=desc) will **increase** coverage by `0.18%`.
> The diff coverage is `90.88%`.


```diff
@@ Coverage Diff @@
## next #4287 +/- ##
=========================
[rubberduck-vba/Rubberduck] build for commit 7ceeb295 on unknown branch: 52.47% (target 0%)
 
Duga
Duga
6:31 PM
 
ThunderFrame
ThunderFrame
7:20 PM
@this does it work if you omit the module name?
 
this
this
7:34 PM
@ThunderFrame that was originally from your sample and it did work until I added the module name then it fizzled.
 
ThunderFrame
ThunderFrame
7:45 PM
@this there's a fine line between thundercode and fizzle, fo shizzle.
Reads Windows Search SDK interoperability.... This can't be too hard.... Reads "due to potential CLR versioning issues with the process that multiple add-ins run in, filters, property handlers, and protocol handlers must be written in native code." Closes page
 
this
this
IDK if they still have it in windows 10 but in windows 7, you could use ADO + SQL
 
ThunderFrame
ThunderFrame
@this yep, there's an OLE DB provider, but doesn't help you with searching content that isn't already indexed.
 
this
this
Right, yes. IIRC, it was a simple setting in the filesystem (making it a library) which fortunately happened to be sufficient when I last used that.
 
ThunderFrame
ThunderFrame
Sounds like Windows Search SDK is a bit like OLE DB Provider and DDK work. A fine idea, but a lot more effort than you could have ever anticipated.
 
Duga
Duga
 
 
1 hour later…
Peter M Taylor
Peter M Taylor
9:25 PM
@this @Comintern @mansellan would the consensus of VS developers helping Winforms and WPF framework for Win 10 on desktop help RD in that direction? infoq.com/news/2018/08/Modern-Desktop-Applications
 
Duga
Duga
9:49 PM
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4287?src=pr&el=h1) Report
> Merging [#4287](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4287?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/bfd6a95059fdeed531194e6bd29a6ef683512c2d?src=pr&el=desc) will **increase** coverage by `0.18%`.
> The diff coverage is `90.88%`.


```diff
@@ Coverage Diff @@
## next #4287 +/- ##
=========================
 
this
this
@PeterMTaylor Frankly I find it unsettling that they are talking about providing compatibility for a third UI framework with both existing frameworks (WinForm and WPF). That can only mean more problems and we know that the WinForm & WPF don't always play together nice. Now they want to bring a 3rd framework in the play?
 
Duga
Duga
 
Peter M Taylor
Peter M Taylor
So it’s a heads up on our radar in the long term then....
 
this
this
we aren't using UWP (thankfully) ATM. I don't think we'll ever. At least not unless MS decides that "WPF and Winform is dead! Long live UWP!" (which will only happen in 20 years hence at a minimum.
 
Duga
Duga
[rubberduck-vba/Rubberduck] build for commit fa62a554 on unknown branch: AppVeyor build succeeded
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4287?src=pr&el=h1) Report
> Merging [#4287](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4287?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/bfd6a95059fdeed531194e6bd29a6ef683512c2d?src=pr&el=desc) will **increase** coverage by `0.18%`.
> The diff coverage is `90.83%`.


```diff
@@ Coverage Diff @@
## next #4287 +/- ##
=========================
[rubberduck-vba/Rubberduck] build for commit fa62a554 on unknown branch: 52.47% (target 0%)
 
Peter M Taylor
Peter M Taylor
10:04 PM
@ThunderFrame is it hard to access by discovery the Win 10 search SDK instead if this was included?
 
Comintern
Comintern
10:53 PM
I think this is wrong:
private const string MemberBody = " Err.Raise 5 'TODO implement interface member";
Shouldn't this be:
private const string MemberBody = " Err.Raise &H80004001 'TODO implement interface member";
That's the standard hresult for that - E_NOTIMPL.
 
this
this
I don't see the point - it's still in a string.... #ReadingFail
 
Comintern
Comintern
That's what the implement interface refactoring puts in for the body.
 
this
this
Yes, realized it too late
 
Comintern
Comintern
I actually don't like either of them being a magic number TBH.
Not sure how I feel about introducing a const though.
Probably not a good idea.
 
this
this
 
Comintern
Comintern
10:59 PM
445 then.
 
this
this
hmm
 
Comintern
Comintern
Maybe pass the description explicitly though? That would make it obvious what the error was.
Although it wouldn't be localized...
 
this
this
yes, agreed RE: description
Just checked in Access; same thing
(I was never sure whether hosts handle the HRESULTs the same way)
 
Comintern
Comintern
Guessing that's coming from VBA not the host?
 
this
this
IIRC, VBA errors are all <1000
so mostly likely yes
 
Comintern
Comintern
11:02 PM
"doesn't support this action" is kind of dumbed down. No respect for the VBA...
 
this
this
would have been nice to be able to create a temporary project reference.
that way the consts could be housed in a different DLL
though that might break if the file is distributed to a PC w/o RD
(in which case, I say serves them right for not reading the manual)
 
Comintern
Comintern
lol
 
this
this
oh, btw, what's stopping you from using a resx?
private static string MemberBody = $" Err.Raise 445 '{Rubberduck.SomeResource.SomeLocalizedString}";
 
Comintern
Comintern
Nothing, but that would only support RD localization. I also don't really want to duplicate all the VBA error descriptions that we would possibly put into TODOs.
Although I really don't have a problem with just the one.
#4178 turned into kind of a PITA. RD's entire infrastructure for interfaces and implementations is handled entirely by inlined code, extension methods, and the declaration finder. It's a bit of a horror show.
 
this
this
Back in the day, whoever wrote that said, "meh, good enough."
 
Comintern
Comintern
11:09 PM
Doing some refactoring...
You know of the top of your head if there's such a thing as a Friend interface?
 
this
this
uh, good question. I don't know for a fact.
I would think yes?
 
Comintern
Comintern
Was hoping to not have to fire up VB6. I should check though.
 
this
this
well in VBA, it won't show up
 
Comintern
Comintern
I didn't even realize VBA supported Friend accessibility. TIL.
 
this
this
a bit hard to use if all you ever have is a single VBA project.
 
Comintern
Comintern
11:14 PM
Some of this interface handing stuff is horribly inefficient - even with the caching.
Think it must pre-date the SuperTypes and SubTypes.
 
this
this
TBH I don't think most of refactorings were updated for a while
 
Comintern
Comintern
It's not so much the refactorings as the infrastructure underneath it.
Outside of tests, this is looking like a sharply negative line count ATM...
WTH does PropertyLetDeclaration have this? 
public override bool IsObject =>
    base.IsObject || (Parameters.OrderBy(p => p.Selection).LastOrDefault()?.IsObject ?? false);
Shouldn't that be public override bool IsObject => false;?
 
this
this
you can define a property let on an object
 
Comintern
Comintern
Property Let Foo(bar as Object) ?
 
this
this
yeah
 
Comintern
Comintern
11:24 PM
OK apparently so, that's messed up...
 
this
this
fyi ADO abuses that
 
Comintern
Comintern
Does that bypass Set semantics?
 
this
this
well, not exactly
you still have to do Set in the body.
but it lets you do stuff like cmd.ActiveConnection = con and Set cmd.ActiveConnection = con
 
Comintern
Comintern
Right, of the property. I was curious about the caller.
 
this
this
in the above set, Let works just like Set.
 
Comintern
Comintern
11:25 PM
Interesting. Worthy of an inspection?
 
this
this
i would think so. it's .... weird.
but then on the other hand, VB.NET did away with the Set semantics, didn't they?
 
Comintern
Comintern
True.
Huh. The Set and Let types don't even have to match.
 
this
this
Yep
I think compiler will only enforce the Get and Let
and probably Get and Set if there are no Let
but if there's all 3, bets' off
Fun, ain't it?
 
Comintern
Comintern
Think Set needs to be a reference type.
 
this
this
yeah 
---------------------------
Microsoft Visual Basic for Applications
---------------------------
Compile error:

Definitions of property procedures for the same property are inconsistent, or property procedure has an optional parameter, a ParamArray, or an invalid Set final parameter
---------------------------
OK   Help
---------------------------
I would bet you that the invalid Set final parameter would have been very confusing to poor kids using the language.
 
Comintern
Comintern
11:33 PM
I would bet that having properties would have been very confusing to poor kids using the language.
 
this
this
hmm. Maybe. I got it when I first learnt it, though.
 
Comintern
Comintern
Same here. Learned mainly from O’Reilly's VB & VBA in a Nutshell.
 

« first day (1535 days earlier)      last day (1645 days later) »