VBA Rubberducking

Duga

00:01

RELOAD!

[FreezePhoenix/Angels-And-Demons] 1 commit. 247 additions. 40688 deletions.

[FreezePhoenix/XtraUtils] 2 commits. 2732 additions. 374 deletions.

[rubberduck-vba/Rubberduck] 2 opened issues. 12 issue comments.

IvenBach

#TIL Insert>Procedure>Type: Property

Wish I knew about that years ago :sadface:

ThunderFrame

@this thanks, I'll have a play with that. What happens if code is Ended without the value releasing?

IvenBach

Home Time.

this

00:36

@ThunderFrame You'd have springed a leak.

ThunderFrame

Thought so. A leaky vault.

this

that's what you get for playing outside the VB sandbox.

pretty sure it won't go away until you shut down the host and you can't deallocate if you lose the address.

ThunderFrame

Which OleWoo fork do you use? leibnitz27/olewoo or ydanila/OleWoo?

this

leibnitz27

that's the original author

note that the version we are using for our build is further downstream, though. There's an open PR currently.

ThunderFrame

@this is it effectively doing the same thing as .NET's SecureString?

@this oh, it seemed like ydanila was the original, and leibnitz27 was the forker

this

00:41

@ThunderFrame Not sure about the internal implementation of SecureString, but functionally, it should be the same -- no unwanted access from outside the environment. Meaning that if you tried to do a memory dump, you wouldn't be able to read it. Only in-process code can do that (and only after having made the necessary changes to locks). Note that's a different thing from encryption.

@ThunderFrame yeah I had to do my research first to make sure I forked off the author.

ThunderFrame

I still don't understand how @CallumDA was able to access an instance using the class name as if it were predeclared. Maybe someone wrote a really weird VBE rootkit that makes all of your class modules predeclared.

this

it might be that he declared a variable Dim class1 As class1

Comintern

01:23

Was #4091 the first issue opened for COM collector issues?

ThunderFrame

@Comintern there have been a few dupes, but that's the main one. I think there's. A linked issue there too.

Comintern

OK, that'll be a good start.

Assuming that I didn't just screw up my VS2017 install... Grrrrrr

ThunderFrame

@Comintern I think you need a certain release/update level, but if you downloaded latest, you should be OK.

Comintern

Yeah, I had apparently installed it at some point, but the updater just failed.

ThunderFrame

If it were up to @Hosch250 we'd all be running VS 2019 Alpha.

this

01:29

this may be relevant: 4045 and 3995

Comintern

I think #4174 might also be a dup based on the log file.

@Comintern needs food, badly.

ThunderFrame

@Comintern I deduced the other day, and Wayne confirmed, that certain Functions (like Array, Left$ and Left) and statements (like Mid and `Mid$) have internal, optimized implementations, so the like-named counterparts in the VBA library are only called if you qualify them with the library name.

In most cases, there's no difference, other than speed optimizations, with the exception of Array and VBA.Array, where the default lower bound differs according to the qualification, and your Option Base settings. I have a list somewhere, of the functions I suspect are internal (as they all show up in the identifiers table for an otherwise blank project)

I wonder whether we should let the resolver distinguish between internal and VBA usages

Comintern

@ThunderFrame Interesting... I knew there were multiple entry points for them in the the vbe dll. So they're handled entirely outside of the library?

this

01:45

Jul 5 at 14:03, by WaynePhillipsEA

There are many execode opcodes that handle these optimized conversions, and also LBound/UBound

^ this suggests to me that those simply get inlined.

#ReadFail, right above that quote, Wayne does say they get inlined, so yeah.

ThunderFrame

@Comintern it's one of the reasons you get a compile/syntax error if you try using CLng on LHS as CLng 1, but not as VBA.CLng 1

Comintern

LBound and UBound are trivial with SafeArrays - they're literally stored in the struct.

Means hooking them is probably out of the question...

Although why you would ever need to spoof a UBound call is beyond me ATM.

Mathieu Guindon

@this I'm resuming work on test-friendly block completion. I'm merging #4153

this

go for it. I'm a bit fuzzy how we will further refactor it anyway.

Mathieu Guindon

:+1:

this

01:57

Just Make It Better™ and I Won't Complain®.

Duga

[rubberduck-vba/Rubberduck] retailcoder merged pull request #4153: Introduce CodeStringParser from bclothier/Rubberduck/CodeStringParser into rubberduck-vba/Rubberduck/next

[rubberduck-vba/Rubberduck] bclothier pushed commit af66193a to next: Introduce CodeStringParser

Mathieu Guindon

I'll probably have to make a few changes to it anyway

Duga

[rubberduck-vba/Rubberduck] bclothier pushed commit e7197bd7 to next: Enable explicit mode selection and some refactoring

[rubberduck-vba/Rubberduck] bclothier pushed commit 294ab90f to next: Remove the superficial private constructor and create a separate method to parse. Update tests.

[rubberduck-vba/Rubberduck] web-flow pushed commit abe03b04 to next

Merge pull request #4153 from bclothier/CodeStringParser

Introducing ability to parse out-of-context code strings

Comintern

:needs to find VB6 disc:

:probably under the VHS tapes:

3

Duga

[rubberduck-vba/Rubberduck] retailcoder published prerelease Rubberduck-v2.2.0.3484

[rubberduck-vba/Rubberduck] retailcoder created tag Rubberduck-v2.2.0.3484

[rubberduck-vba/Rubberduck] build for commit abe03b04 on next: AppVeyor build succeeded

[rubberduck-vba/Rubberduck] build for commit abe03b04 on next: 52.48% (target 0%)

Comintern

02:14

Does RD add the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VBA\Vbe71DllPath key? I don't remember ever seeing that before.

Mathieu Guindon

hmm, not that I know of, but then I haven't looked there in a while, and @this did make rather significant changes to deployment and registration..

you'll want to make Rubberduck.Deployment your startup project BTW

Comintern

Yep, @this tipped me to that this morning.

mansellan

@this this PR was the small fix for KnownTypes csching: github.com/rubberduck-vba/Rubberduck/pull/4040

Comintern

Need to look at it in the IDE, but wouldn't that prevent any caching? That shouldn't matter though - I just put that in for performance.

Finally hitting <kbd>F5</kbd>

Mathieu Guindon

02:31

Jun 29 at 4:58, by WaynePhillipsEA

OMG, @MathieuGuindon what have you done to the VBE?!!

@Comintern go on, give autocompletion a shot :)

(couple of bugs though, and an off-by-one will crash the IDE if you do msgbox(

Comintern

Looking forward to it. :-)

Currently sitting at a breakpoint though. HTH I could boot RD straight into a debugging session before checking out all the bells and whistles is beyond even me.

stdole looks fine...

mso.dll is looking good.

excel.exe looks OK.

Well there's the problem...

It never even loads vbe7.dll.

Looking at you, suspicious new registry key...

this

02:52

@Comintern hmm, is it literally that? I'm pretty sure we shouldn't be adding a 71 anything.

Comintern

I'm checking back through the call stack, but IIR we explicity load the vbe dll because it isn't really a "reference".

this

uh, isn't it the first reference?

Comintern

Going to find out shortly. Just need to move my breakpoint back a bit.

this

and I just verified - we definitely don't have a symbol for Vbe71DllPath anywhere in the RD solution, so whatever that key is from, it's not from the Deployment, I think.

Comintern

I wonder if that's specific to a 64bit Office install. I was running 32bit in my last VM.

this

02:58

.....

let me see...

Comintern

...and not having VS Professional is already driving me up the wall. May have to fix that at work tomorrow.

this

just for my reference, are you building w/ MIDL or using tlexp?

Comintern

Whatever the default is. :-D

this

it depends on your VS configuration....

if you have C++ build tools, then it'll try to compile using MIDL

otherwise it falls back to tlbexp

you can tell from the build output -- if it uses MIDL you will see all the MIDL messages

Peter M Taylor

@this got a screen shot for reference regarding MIDL messages so I can recognise them in future.

this

03:06

@PeterMTaylor from line 645 to line 881

Comintern

@this I didn't check the build output, but I don't have the MFC toolchain installed.

OK, WTF? That time it found it.

Why are we using the references object from the VBE on multiple threads?

this

for a debug build, we are using this script... that's the closest we get to the VBA branch....

@Comintern link to the code?

Comintern

COMReferenceSynchronizer.LoadReferences, starting at line 26.

this

VS says that it was last touched by @M.Doerner 450+ days ago... One'd think that the problems would have manifested long ago if that was at that.

Comintern

Unless a Windows change manifested itself in a different way between then and now.

Or a change to the runtime wrapper.

Those calls should ultimately be sorted out at the STA boundary and stacked, but that's dangerous in that it relies on the OLE subsystems to make sure that the accesses are thread safe.

this

03:21

re: that bogus registry key - maybe try and delete. If it re-appears after re-building, then that would confirm it is coming from the deployment project. I don't see any evidence that the scripts will build that funky key but who knows....

Comintern

OK. I'm thinking it was something with an Office update?

We definitely try to load it (sometimes). The first time through, the debugger was telling me that there were 3 references. This time it's saying 4 (both with empty Workbooks).

this

hmmm.... this is a wild guess but one change was to have Excel auto-parse on startup for small enough workbook. That might be failing, since VBE isn't necessarily ready?

Mind, that change was made long while ago... I want to say almost a year now

Comintern

OMG, autocomplete.

6

this

?!? it can do that?

(one'd hope that listening for keyboard events would be benign....)

Comintern

Int -> Tab = Integer

@this LOL - nothing to do with reading the TLB. That was my first VBA autocomplete ever.

:savors moment:

Hmmm... What's the best way to test this in the VBE. The status bar isn't behaving like I remembered.

IvenBach

03:32

@MathieuGuindon methinks @Comintern is enjoying his first taste of autocomplete in VBA.

this

@Comintern whew! Glad you like it! I think Mat really did a great job there.

2

Comintern

My VBA productivity seriously just tripled, at least.

this

given that he's using subclassing, I jumped to totally wrong conclusion. :D

IvenBach

There is something very satisfying about it. I’m looking forward to when our BDFL gets around to putting in foo ++ —> foo = foo + 1

Comintern

I need an XML prettifier to verify, but the serialized declarations look just fine. Something is definately screwed up though, because this time I only got vbe and stdole loaded.

@IvenBach ὸ.ό HERESY!

I'm getting better results with this change:

foreach (var reference in referencesToLoad.ToList())

It's still occasionally missing though.

Comintern

03:59

@M.Doerner I'm thinking that the main performance reason to multi-thread the COM collection is due to the TLB reads. Those are all native calls that can safely run concurrently. At that point in execution, we can assume that references are static (the UI isn't blocking, but I dare you to add a reference fast enough to trip it up...). Any downside to copying the members we need from the VBE reference objects to a managed IReference and then loading those concurrently?

Mathieu Guindon

...some load, some don't?

Comintern

Yep. It's different with every run.

Mathieu Guindon

that does explain a lot of things

Comintern

Looks like either thread contention or what @this mentioned, we're loading too fast.

The debugger itself gives a good clue - the count changes if you set a breakpoint before the loading loop and force it to enumerate the IEnumerable<IReference>. I'm getting all the references consistently that way.

Duga

04:18

[rubberduck-vba/Rubberduck] comintern created comment on issue #4045: COM resolver issues

> See [this in chat](https://chat.stackexchange.com/transcript/message/45603555#45603555).
Ref also #4045, #4091, and #4174.

Duga

04:31

[rubberduck-vba/Rubberduck] comintern created comment on issue #3201: Smart Indenter doesn't use changed/current Tab Width setting

> The corollary to this is that if you change the indentation level in _settings_, it doesn't update the registry setting either. I'm not sure it's feasible to keep the two in synch. IIR, the rationale behind keeping the two settings distinct was to allow for the future possibility of loading settings on a per-project level. In that use case, you _don't_ want the project's tab width to persist, because "don't mess with my IDE, project author".

I'm leaning toward by-design, but I'd be happy t

Comintern

@Duga This is the use case for symbolic links in the Windows registry.

Mathieu Guindon

04:54

TTGTB

Duga

[rubberduck-vba/Rubberduck] comintern created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> Clarification for my own sanity. The compiler is treating 10 as a line number here, but the IDE is as confused as I am by this syntax - it doesn't follow its formatting rule of pinning the line number to the left margin.

I can't even figure out how this is compiling by stepping through it with the debugger:
```
foo _
: Beep
```
By my read, `foo` should be a recursive call to `Sub foo()` (followed by a Beep after the line combining `:`) and this should never exit.

It seems t

Duga

05:35

[rubberduck-vba/Rubberduck] Vogel612 added label bug to issue #4174: False Positives for Builtin Functions and Constants

[rubberduck-vba/Rubberduck] Vogel612 added label resolver to issue #4174: False Positives for Builtin Functions and Constants

this

06:41

@Comintern It might be worthwhile to check out this particular feature of typelib API: GetReferenceInfo, ReferencesCollection,

and TypeInfoReference. This has the added advantage of providing you with the info even for a broken reference as well.

Duga

07:22

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #3201: Smart Indenter doesn't use changed/current Tab Width setting

> Since raising this issue I've learnt that the VBA SDK allows a host to define a key for host-specific settings. If the host doesn't specify the key, as none of the Office hosts seem to do, then the settings are stored in the `Common` key and are common to all hosts that share that key.

Currently, we don't have any way of determining whether a host is defining a host-specific key, so trying to use `Common` mightn't actually be the correct settings, for some hosts.

I'm inclined to close th

[rubberduck-vba/Rubberduck] ThunderFrame edited comment on issue #3201: Smart Indenter doesn't use changed/current Tab Width setting

> Since raising this issue I've learnt that the VBA SDK allows a host to define a key for host-specific settings. If the host doesn't specify the key, as none of the Office hosts seem to do, then the settings are stored in the `Common` key and are common to all hosts that share that key.

Currently, we don't have any way of determining whether a host is defining a host-specific key, so trying to use `Common` mightn't actually be the correct settings, for some hosts.

I'm inclined to close th

Duga

08:04

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> No, `foo` is a line label on the line after the line number, then an instruction separator, then the beep statement. i.e. statements with line-numbers 10 and 20 are identical, and should be read as:

```vb
Sub foo()
10 foo: Beep
20 bar: Beep
End Sub
```

[rubberduck-vba/Rubberduck] ThunderFrame added label parse-tree-processing to issue #3210: Indenter indents line numbers/labels that include line continuations

ThunderFrame

@M.Doerner ^ - adding parser to that issue, rather than opening a duplicate with a different tag..

Duga

09:41

[rubberduck-vba/Rubberduck] ThunderFrame edited comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> No, `foo` is a line label on the line after the line number, ---then an instruction separator--- then the label termination colon is on the next line, then the beep statement. i.e. statements with line-numbers 10 and 20 are identical, and should be read as:

```vb
Sub foo()
10 foo: Beep
20 bar: Beep
End Sub
```

[rubberduck-vba/Rubberduck] ThunderFrame edited comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> No, `foo` is a line label on the line after the line number, <s>then an instruction separator</s> then the label termination colon is on the next line, then the beep statement. i.e. statements with line-numbers 10 and 20 are identical, and should be read as:

```vb
Sub foo()
10 foo: Beep
20 bar: Beep
End Sub
```

Duga

11:15

[rubberduck-vba/Rubberduck] WaynePhillipsEA created pull request #4175: Add user defined compilation arguments to the preprocessor (WIP) to merge WaynePhillipsEA/Rubberduck/next into rubberduck-vba/Rubberduck/next

> This PR pushes user defined compilation arguments (from the VBE) into the preprocessor.

TODO: read the arguments once at the start of parsing, rather than have each parse thread grab its own version (as it requires a context switch to the main thread, which is relatively slow).

TODO: before starting to parse, check if the arguments have changed, and force a parse of all modules in order to avoid caching issues.

[rubberduck-vba/Rubberduck] build for commit f4ba846a on unknown branch: AppVeyor build failed

BUILD FAILURE!

WaynePhillipsEA

@Duga huh? builds here. what have I done now

Duga

11:44

[rubberduck-vba/Rubberduck] WaynePhillipsEA synchronized pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

Duga

11:56

[rubberduck-vba/Rubberduck] build for commit fe6a5009 on unknown branch: AppVeyor build failed

BUILD FAILURE!

M.Doerner

Thinking about it, could the change in managing the IVBE instance passed to us on startup have started the issues with the references?

Duga

[rubberduck-vba/Rubberduck] MDoerner created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> I have no idea how the compiler interprets the code example. Per spec, line labels must be at the start of the logical line.

[rubberduck-vba/Rubberduck] Stevefb opened issue #4176: Rubberduck ate my code, spit it out ....

> ### Steps to reproduce:
- Put comments from line 1 to line 3
- Add a Sub at line 4
- Put cursor in front of Sub (line 4, col 0)
- Press enter (additional comment lines are automatically added)
- Move cursor to the line JUST ABOVE Sub …
- Select the PARAGRAPH corresponding to the comma
- Press delete
Result looks like:

![image](https://user-images.githubusercontent.com/9349975/42631922-eed437ee-861e-11e8-95ae-c379c19deec1.png)

### Now press the DOWN ARROW...

![image]

[rubberduck-vba/Rubberduck] Stevefb edited issue #4176: Something ~Rubberduck~ ate my code, spit it out ....

[rubberduck-vba/Rubberduck] WaynePhillipsEA synchronized pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

WaynePhillipsEA

@Duga if that doesn't fix the broken tests, I'll have to ask one of you to take a look, as I don't know how to run them locally and debug them so I'm shooting in the dark

@M.Doerner if you could spare a few minutes to look over my PR I'd be grateful. In particular, the use of the task with your pimped UiDispatcher

Duga

12:12

[rubberduck-vba/Rubberduck] Stevefb edited issue #4176: Something ~Rubberduck~ ate my code, spit it out ....

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> IIUC, when determining the logical line, the VBE treats the physical line continuation as if it is:

`" *_ *\n *"`

and then treats line-continuations as if they don't exist, so, to the VBE, the line number _looks_ like it **is** at the start of the logical line.

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) created comment on pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=h1) Report
> Merging [#4175](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/abe03b04767868cce2672bff8c9289d0e1bbf2ad?src=pr&el=desc) will **decrease** coverage by `0.01%`.
> The diff coverage is `42.11%`.

```diff
@@ Coverage Diff @@
## next #4175 +/- ##
=======================

[rubberduck-vba/Rubberduck] build for commit ca7cd95f on unknown branch: 52.47% (target 0%)

[rubberduck-vba/Rubberduck] build for commit ca7cd95f on unknown branch: AppVeyor build succeeded

Duga

12:40

[rubberduck-vba/Rubberduck] MDoerner commented on Rubberduck.Parsing/VBA/AttributeParser.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] MDoerner commented on Rubberduck.Parsing/Preprocessing/VBAPreprocessor.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] MDoerner commented on Rubberduck.Parsing/VBA/ComponentParseTask.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] MDoerner commented on Rubberduck.Parsing/Preprocessing/VBAPreprocessor.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

Hosch250

@Duga Is that an auto-complete bug?

It shouldn't be considering it is unloaded, but...

Duga

[rubberduck-vba/Rubberduck] WaynePhillipsEA created comment on pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

> Thanks @MDoerner. With regards to the step before parsing: I fully agree, and I said as much in the description of this WIP PR.

M.Doerner

@WaynePhillipsEA @Duga I think we can postpone the refactoring of how the preprocessor is organized to when we refactor the parser. My current plan is to do that next month when I have a bit more time again.

Duga

[rubberduck-vba/Rubberduck] comintern created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> I'm still not exactly clear on why the `foo:` label is on line 10.

This outputs 10, but I'm not sure if that's because of the behavior of `Erl` (it always just returns the last number encountered) or the compile itself:

```
Sub foo()
On Error GoTo bar
_
10
_
foo _
: Debug.Print 1 / 0

20 bar: Debug.Print Erl
End Sub
```
This also outputs 10:
```
Sub test()
On Error GoTo label
10
Debug.Print 1 / 0
label:
Debug.Print Erl
End Sub
```
Do we think t

[rubberduck-vba/Rubberduck] bclothier created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> I'm not so sure.

There is a missing line continuation for the line where `10` is.

This works:

```
Sub foo()
_
10 _
_
foo _
: Beep

20 bar: Beep
End Sub
```

and adding that one changes how debugger will highlight the lines. That one is more like the

```
Sub foo()
10 foo: Beep
20 bar: Beep
End Sub
```

because in both cases, the yellow highlight starts from `10` to the `beep` in the logical line `10 foo: Beep`.

In contrast, the following

[rubberduck-vba/Rubberduck] bclothier edited comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> I'm not so sure.

There is a missing line continuation for the line where `10` is.

This works:

```
Sub foo()
_
10 _
_
foo _
: Beep

20 bar: Beep
End Sub
```

and adding that one changes how debugger will highlight the lines. That one is more like the

```
Sub foo()
10 foo: Beep
20 bar: Beep
End Sub
```

because in both cases, the yellow highlight starts from `10` to the `beep` in the logical line `10 foo: Beep`.

In contrast, the following

[rubberduck-vba/Rubberduck] MDoerner created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> I think I have an idea how to fix the parser to accept the line continuations in front of the line number. However, I will have to test whether that brakes something else.

this

13:10

@WaynePhillipsEA am I to understand that the value for a compilation argument is a short? Why would this compile? #Const Test = &HFFFFFFFF?

Duga

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> I'm convinced it's a single logical line, but it seems like a little tool called vbWatchdog might be of use here, or even a p-code analysis. I'm AFK. Maybe @WaynePhillipsEA can help determine the lines are a single logical line?

ThunderFrame

@this I thought code-defined arguments could be any type?

#Const fooo = "abc"

#If fooo = "abc" Then
    Const x = "strings allowed"
#Else
    Const x = "not allowed"
#End If

@this - ^ that should compile and return strings allowed

Comintern

@ThunderFrame Even Object apparently

`Sub WTF()
#Const foo = Application
#If foo.ScreenUpdating Then
Debug.Print "True"
#Else
Debug.Print "False"
#End If
End Sub`

ThunderFrame

that looks like it's asking for trouble

Comintern

That's an "invalid use of object" on the #If line.

@ThunderFrame I demand trouble.

5

ThunderFrame

13:22

@this - huh, there are imposters:

and there's even a this.foo:

this

13:34

@ThunderFrame how do you impose a pronoun? Of course you gonna get different answer since it's all about context, baby!

ThunderFrame

@this I assumed one of those thises has a trailing space, so if I watch that user, I'll be watching this space?

@Comintern When you have a moment, you may want to review some recent, unresolved chats about how to treat <globals> and appobjects (see(4164) and how to get the IControl members for a control (see 2592)

this

@ThunderFrame That's what I thought but it might be that I did not understand the PR changing from string to short. That's why I asked.

@ThunderFrame IDK. It might be even legal to have duplicates.

ThunderFrame

@this or, it's a coding error at SO, where sombody accidentally treated a this variable as a string literal... A bit like Jennifer Null having trouble when booking travel.

this

I doubt it. If you try a common name... say Paul, you get a lot of dupes. And if you look carefully - when you select a choice it changes to user ID. Thus the names are not necessarily unique in SO.

mansellan

Gah... I think I may have misdirected on the com collector... I had a dirty local, having reset to vanilla next, the collector seems OK. There still appears to be a problem with events from COM controls though, investigating.

this

13:48

@Comintern it might be that it's doing a crappy job of validating the validity. Change the line to #If foo Is Application Then then you get a different compile error: Constant expression required which is more expected.

WaynePhillipsEA

14:29

@this project-level compilation arguments are always shorts. Even the built-in ones.

this

@WaynePhillipsEA ooh. that's new to me! Yeah I can confirm that.

bar = 1 : foo = bar and foo = 32678 both result in error.

But gee whiz, consistency isn't their strong suit; one'd expect the module-level constants to have similar behavior.

WaynePhillipsEA

The handling of the builtin constants VBA7 etc is wrong in the preprocessor actually. I might just fix it in my PR.

Problem is, the preprocessor is a bit of a mess. e.g. It should have separate integer types, not just Bool / Byte / Decimal

this

IDK if you saw but there is a open issue to build a proper expression engine

right now we have 2 versions of expression engine. :(

WaynePhillipsEA

ah right, well that explains it. no missed that

this

That's why Max would like to merge them and ensure that they follow the VBA spec

WaynePhillipsEA

14:35

I see, sounds like a good idea

vbWatchdog has a built in preprocessor evaluation engine, so if I can assist, just let me know

this

github.com/rubberduck-vba/Rubberduck/issues/3969

This is the issue

I also wonder if we need to be importing the functions from the oleaut32 DLL so that we use exact same functions that VBA internally uses for comparison/conversions/parsing of various types.

WaynePhillipsEA

pssst.... you're on the right track

6

this

Unfortunately, the p/invoke site only has one function from that DLL. The rest will have to be crafted by hand. x_x

WaynePhillipsEA

Well, let's just say, that's how vbWatchdog does it. Everything goes through the appropriate OLE functions.

this

Makes complete sense. Good to know that I'm not wrong all the time!

Duga

14:42

[rubberduck-vba/Rubberduck] mansellan edited comment on issue #4045: COM resolver issues

> ~~Removing VB6-specific tag, as it also applies in VBA:

1. Add a Common Dialog control to a user form
2. Add some code to access common dialog
3. Parse

Yields a resolver error.~~

Sorry, this was a *complete* red herring (I had some debug cruft in my local causing this). There seems to still be an issue with resolution of events on COM controls, but that's a separate issue.

[rubberduck-vba/Rubberduck] mansellan edited comment on issue #4045: COM resolver issues

> ~~Removing VB6-specific tag, as it also applies in VBA:~~

~~1. Add a Common Dialog control to a user form~~
~~2. Add some code to access common dialog~~
~~3. Parse~~

~~Yields a resolver error.~~

Sorry, this was a *complete* red herring (I had some debug cruft in my local causing this). There seems to still be an issue with resolution of events on COM controls, but that's a separate issue.

[rubberduck-vba/Rubberduck] mansellan created comment on issue #4045: COM resolver issues

> OK, so this is `vb6-specific` after all.

It seems that the References collection of VBProject (sometimes?) returns the [OCA](https://stackoverflow.com/a/4055171/8658841) file rather than the OCX. These then fail to collect properly with COMExceptions on certain calls to ITypeInfo::GetDocumentation.

[rubberduck-vba/Rubberduck] mansellan added label vb6-specific to issue #4045: COM resolver issues

this

@Duga #TIL RE: OCA. I wonder if that's the same thing that we get via the typelib API (e.g. strings like

*\G{000204EF-0000-0000-C000-000000000046}#4.1#9#C:\PROGRA~2\COMMON~1\MICROS~1\V‌BA\VBA7\VBE7.DLL#Visual Basic For Applications"

Duga

[rubberduck-vba/Rubberduck] WaynePhillipsEA commented on Rubberduck.Parsing/VBA/ComponentParseTask.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

this

@Duga we really need that code analyzer for dangerous access to com wrapper. @Hosch250 do you think you might be able to whip it up quickly?

Duga

[rubberduck-vba/Rubberduck] WaynePhillipsEA commented on Rubberduck.Parsing/Preprocessing/VBAPreprocessor.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

Hosch250

@this Which one?

The chained access one?

Maybe.

this

14:57

yes

for any types deriving from ~~ComSafeWrapper~~ SafeComWrapper

Hosch250

I guess I could take a stab at it this weekend.

Mathieu Guindon

@this SafeComWrapper

the COM "safe" is another thing :)

this

Well, they do recommend wrapping your safe to keep it warm.

Especially during the winter.

Duga

[rubberduck-vba/Rubberduck] WaynePhillipsEA synchronized pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] WaynePhillipsEA created comment on pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

> as per chat, I'll leave it to @MDoerner to refactor the code to grab the argument values only once before parse when he does his larger scope PR for the preprocessor.

mansellan

@Duga I could understand it if the .VBP or .FRM files (for some reason) referenced the .OCA. But tracing through all the GUIDs leads to the OCX, not the OCA...

So the References collection is lying

WaynePhillipsEA

15:10

@mansellan you could always use the TypeLib API instead, as I've exposed the ITypeLib for each reference, which is the exact ITypeLib that VBE is itself using internally.

ThunderFrame

@this IIRC, those # delimiters and reference strings are the same format used in the binary vbProject files, and are documented in the [OVBA] specification.

mansellan

@WaynePhillipsEA sounds like the way forward

chores, bbl

this

@ThunderFrame hm. If it's in the .vbp then I guess I don't understand the use of OCA file.

@mansellan This may help, too:

9 hours ago, by this

@Comintern It might be worthwhile to check out this particular feature of typelib API: GetReferenceInfo, ReferencesCollection,

ThunderFrame

@this I forget what the OCA files are?

this

@ThunderFrame it's linked in the issue: stackoverflow.com/questions/4050078/…

Duga

15:18

[rubberduck-vba/Rubberduck] bclothier created comment on issue #3969: Unify expression evaluation back-ends for Unreachable case and the preprocessor

> Just to record for posterity, the new unified expression engine should ideally make use of the functions imported from the oleaut32 DLL. The functions are described here. The engine should invoke those functions to get the same behavior as we observe with VBA for parsing, conversion and casting of the expressions and its types.

ThunderFrame

@this yeah, thought they sounded familiar. Are they the files that you sometimes need to delete to get userforms to work? I had thought they had a different extension and related to the form, or maybe they're in addition to the OCA files?

@Duga didn't @Comintern use some of those for the Fakes?

this

@ThunderFrame only to load the type lib: github.com/rubberduck-vba/Rubberduck/blob/…

we also have another import for clearing the variant: github.com/rubberduck-vba/Rubberduck/blob/…

Duga

[rubberduck-vba/Rubberduck] build for commit 5c6bfc64 on unknown branch: AppVeyor build succeeded

this

only 2 functions --- we're missing only few. ;-)

Duga

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=h1) Report
> Merging [#4175](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/abe03b04767868cce2672bff8c9289d0e1bbf2ad?src=pr&el=desc) will **decrease** coverage by `0.01%`.
> The diff coverage is `41.67%`.

```diff
@@ Coverage Diff @@
## next #4175 +/- ##
=======================

[rubberduck-vba/Rubberduck] build for commit 5c6bfc64 on unknown branch: 52.47% (target 0%)

Comintern

15:22

@ThunderFrame I'd have to check to make sure, but I don't think so. It probably needs to in order to be stable. I was starting to run into issues with memory management of Variants that were being used as return values IIR.

ThunderFrame

> twiddled type library: A modified Automation type library in which all controls are marked as extensible. A twiddled type library is generated automatically by the Visual Basic Editor when a user adds one or more controls to a document.

this

@Comintern that's the thing about imported functions - you've left the sandbox. It may be necessary to use IntPtrs and only cast to object when actually needed or something like that.

WaynePhillipsEA

@Comintern... that's a name I've haerd a lot around here

Comintern

@this Oh, you can't even see the sandbox from the Fakes.

WaynePhillipsEA

Nice to virtually meet you @Comintern

Comintern

15:26

Likewise, @WaynePhillipsEA

ThunderFrame

> from [MS-OVBA]:

2.1.1.8 LibidReference
Specifies the identifier of an Automation type library.
ABNF syntax:
LibidReference = "*\" LibidReferenceKind LibidGuid
"#" LibidMajorVersion "." LibidMinorVersion
"#" LibidLcid
"#" LibidPath
"#" LibidRegName

WaynePhillipsEA

^ see constructor for TypeInfoReference, as the parser for that string format already exists.

Duga

[rubberduck-vba/Rubberduck] WaynePhillipsEA edited pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] bclothier created comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> I think this is a ore-existing leak that also needs to be plugged?

https://github.com/rubberduck-vba/Rubberduck/pull/4175/files#diff-aae74206ac3d07c402d95c4dac6ae8edR39

[rubberduck-vba/Rubberduck] bclothier edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> I think this is a pre-existing leak that also needs to be plugged?

https://github.com/rubberduck-vba/Rubberduck/pull/4175/files#diff-aae74206ac3d07c402d95c4dac6ae8edR39

[rubberduck-vba/Rubberduck] bclothier edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> I think this is a pre-existing leak that also needs to be plugged?

https://github.com/rubberduck-vba/Rubberduck/pull/4175/files#diff-aae74206ac3d07c402d95c4dac6ae8edR39

and possibly also this:

https://github.com/rubberduck-vba/Rubberduck/pull/4175/files#diff-43f39201f2d65b267b80dcf1db408767R173

[rubberduck-vba/Rubberduck] WaynePhillipsEA created comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> @bclothier they looks like they are cached? I can't see that they are getting new wrappers, so they should be OK.

[rubberduck-vba/Rubberduck] WaynePhillipsEA edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> @bclothier they looks like they are cached? I can't see that they are getting new wrappers, so they should be OK.

ParentProject returns a new wrapper each time, and we are responsible for disposing.

[rubberduck-vba/Rubberduck] WaynePhillipsEA synchronized pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=h1) Report
> Merging [#4175](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/abe03b04767868cce2672bff8c9289d0e1bbf2ad?src=pr&el=desc) will **decrease** coverage by `0.01%`.
> The diff coverage is `41.67%`.

```diff
@@ Coverage Diff @@
## next #4175 +/- ##
=======================

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=h1) Report
> Merging [#4175](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/abe03b04767868cce2672bff8c9289d0e1bbf2ad?src=pr&el=desc) will **decrease** coverage by `0.01%`.
> The diff coverage is `41.67%`.

```diff
@@ Coverage Diff @@
## next #4175 +/- ##
=======================

[rubberduck-vba/Rubberduck] WaynePhillipsEA created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> Line labels are lost at the excode level, but it basically gets compiled to:
```
Sub foo()
10 Beep
20 Beep
End Sub
```

[rubberduck-vba/Rubberduck] WaynePhillipsEA created comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> ^ whilst I was in here, I thought I may as well correct some errors with the handling of builtin constants (VBE7, VBE6, Win64 etc).

[rubberduck-vba/Rubberduck] build for commit 18af41aa on unknown branch: AppVeyor build failed

BUILD FAILURE!

Duga

16:27

[rubberduck-vba/Rubberduck] bclothier edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> ~I think this is a pre-existing leak that also needs to be plugged?~

~https://github.com/rubberduck-vba/Rubberduck/pull/4175/files#diff-aae74206ac3d07c402d95c4dac6ae8edR39~

~and possibly also this:~

~https://github.com/rubberduck-vba/Rubberduck/pull/4175/files#diff-43f39201f2d65b267b80dcf1db408767R173~

Disregard - those from a provider doesn't need to be handled.

this

@Duga that's yet another reason why we really need the code analyzer. I can't trust my own eyeballing to catch the possible leaks.

Malachi

you all help me with an excel formula?

> ISNUMBER(SEARCH("%",B12))

if I have 5% in B12, why does it give me a Falsey value?

Mathieu Guindon

SEARCH returns an index, and that index will always be a number..

@Malachi because SEARCH is expecting a string, not a number. 5% is really 0.05.

Malachi

16:42

hmmm....

makes sense for Excel.....

Mathieu Guindon

SEARCH("%",TEXT(B12,"0%"))

Malachi

I am trying to set up discount calculation where I can input either a dollar amount or a percentage

Mathieu Guindon

@Malachi makes sense period: B12 doesn't contain "5%", it contains 0.05 and then it has a NumberFormat that makes its text representation be 5%.

Malachi

@MathieuGuindon very true

where is that one post by SO Guru about Excel and the Cell Names.... do you know what I am talking about?

maybe it was a youtube video

Mathieu Guindon

no idea

Malachi

16:45

Jon Skeet I think....

Mathieu Guindon

Jon Skeet, Excel guru?

Malachi

the fancy A1 style cell naming is not what the cell names really are.

Mathieu Guindon

not names, addresses

and yes, they're that. you can use either A1 or R1C1 addressing.

Malachi

who are the other Top Names in SO

it wasn't skeet

Mathieu Guindon

Spolsky?

Malachi

16:47

yeah ~~maybe~~ actually

Mathieu Guindon

(SE's CEO BTW)

Malachi

You Suck at Excel with Joel Spolsky

►

Mathieu Guindon

he worked on the Excel team and designed the VBA spec

Malachi

that is exactly the one I was looking for

Mathieu Guindon

I don't need to compare each individual value in the arrays, but rather the value of the entire 2D variant arrays. — Kwon Black 13 mins ago

Duga

16:50

[rubberduck-vba/Rubberduck] WaynePhillipsEA synchronized pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=h1) Report
> Merging [#4175](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/abe03b04767868cce2672bff8c9289d0e1bbf2ad?src=pr&el=desc) will **decrease** coverage by `0.01%`.
> The diff coverage is `41.67%`.

```diff
@@ Coverage Diff @@
## next #4175 +/- ##
=======================

Malachi

@MathieuGuindon that gives a value of 2? is that truthy for excel?

it's a very good video IIRC

Mathieu Guindon

index is 1-based

Malachi

oh I get it

duh LOL

Duga

17:04

[rubberduck-vba/Rubberduck] build for commit e6da06f9 on unknown branch: AppVeyor build succeeded

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=h1) Report
> Merging [#4175](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4175?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/abe03b04767868cce2672bff8c9289d0e1bbf2ad?src=pr&el=desc) will **decrease** coverage by `0.01%`.
> The diff coverage is `57.58%`.

```diff
@@ Coverage Diff @@
## next #4175 +/- ##
=======================

WaynePhillipsEA

@Duga just a note to whoever wrote the preprocessor unit tests... "#If Not VBA7 Then" does not do what you think it does, since the VBA7 constant is only either 1 or 0 (not True/-1 as you may expect)

Duga

[rubberduck-vba/Rubberduck] build for commit e6da06f9 on unknown branch: 52.47% (target 0%)

Malachi

@MathieuGuindon, Thank you for your help.

ThunderFrame

@WaynePhillipsEA thanks for that. Looks like that might need to be an inspection too.

WaynePhillipsEA

good idea

Duga

17:09

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> @WaynePhillipsEA - Thanks for the confirmation.

this

Not only that but also for incorrect ordering (e.g. #If VBA6 Then .... #ElseIf VBA7 Then....) --- the VBA7 branch would be basically unreachable.

WaynePhillipsEA

^ definitely

BTW guys, how do you run the tests locally?

Tweeting Duck

17:28

Is your working #Excel #VBA code just waiting to blow up with a "type mismatch" error? https://stackoverflow.com/a/51290589/1188513

Tweeted by rubberduckvba on July 12, 2018 at 5:24 PM

this

@WaynePhillipsEA can you open up Test Explorer?

it's under the Test -> Windows menu

WaynePhillipsEA

ahah.... got it, thanks

this

one more FYI -

if you go to any unit test procedure

you can right-click somewhere inside and choose Debug Tets / Run Test from the context menu

WaynePhillipsEA

brilliant, thanks.

Malachi

17:49

I am on Windows 10 and Can't find Excel in the folder structure to have it open an ODS file, any thoughts?

nevermind

Duga

18:44

[rubberduck-vba/Rubberduck] schifazl starred us

4

Mathieu Guindon

19:01

@Jeeped it's a member of the Dictionary class. If every member of every object in every referenced type library is forbidden to use for anything, we're all in trouble! ;-) ...that said, keys is indeed a confusing name to use for a 2D array, as is keyArray. — Mathieu Guindon 1 min ago

ugh. folks, member names aren't reserved keywords

Comintern

I think a lot of VBA coders avoid them as if they were though because the VBE screws up the casing everywhere. It's an OCD thing that I'm guilty of.

Definitely not "reserved" though. Nothing a reference to Excel would compile...

Mathieu Guindon

I've gotten to the point where I truly don't care for casing of referenced libraries anymore. If I need a value parameter, I'm not calling it pValue just to keep Range.Value uppercase.

Comintern

19:27

I'd probably grab a thesaurus and end up with something like quantity or something stupid like that.

I think it mainly has to do with working in so many case-sensitive languages - it requires concentration to not assume that Value and value are distinct.

FreeMan

OMG!!! @Comintern is ALIVE!!!!! / late to the party / story of my life

welcome back.

Duga

[rubberduck-vba/Rubberduck] DudePascalou starred us

4

Comintern

19:45

@FreeMan Thanks!

Transcript for