VBA Rubberducking

Vogel612

16:00

somewhat unrelatedly: I really need to stop RD.Parsing from always rebuilding

that should speed up running tests locally by a huge factor for satellite assemblies

this

hmm, not sure that's just parsing.

I've noticed that main likes to builds itself everytime, too

Vogel612

it's primarily parsing, because the ANTLR target doesn't do up-to-date checks

and Main is downstream from parsing, so it's most likely just cascading

this

yeah... I commented that because in my mocking PR where my main work is in the main, I don't see parsing rebuilding

Vogel612

interesting.

this

but I seem to remember that when working in refactoring, the core (not main, sorry, bad memory) always rebuilds even though nothing changed in the core.

23fc9a62-56de-47fb-97b4-737890

16:06

devblogs.microsoft.com/visualstudio/…

Mathieu Guindon

@Vogel612 could it be just Antlr rebuilding the grammar everytime, thus regenerating the lexer, parser, base listener, and all the generated code - prompting a rebuild of RD.Parsing?

Vogel612

yea, that's what I'm thinking

Mathieu Guindon

do we (/Antlr) define constants in RD.Parsing, that RD.Core is using? A const being rewritten would cause all referencing assemblies to rebuild

token IDs come to mind (or they're static readonly variables?)

IvenBach

:derp: Ctrl+R, Ctrl+R needs to be in RD for renaming variables.

Mathieu Guindon

nah, token IDs are static readonly

Vogel612

16:12

oohhhhh... I know why the test fails

because the annotation itself is never constructed

Mathieu Guindon

@IvenBach hotkey "chords" have been on the wishlist forever! :)

this

I suspect it'll get easier with custom code panes

then we wouldn't have to fight with VBIDE.... right?

Mathieu Guindon

15

Q: Step by Step, ooh HotKey

Still hooked on Windows, I refactored the hook into a number of interfaces, and I wanted to support 2-step hotkeys, so I started with defining an IHook that can be attached, detached, exposes a property that tells whether a hook is attached or not, and raises an event when the hook receives a mes...

IvenBach

As much as VS makes me feel dumb and makes me struggle to learn new things It's a whole lot better than the VBA IDE.

Mathieu Guindon

23fc9a62-56de-47fb-97b4-737890

16:14

TBH, I find VS has too much tooling. I only use a little bit of it.

Mathieu Guindon

it never really worked though, and then hotkeys were pretty much entirely rewritten

23fc9a62-56de-47fb-97b4-737890

I'm sure it's all used, but I basically use the watch, the locals, the source control, and the code panes

Mathieu Guindon

"Class View" baffles me. Why would I need that on top of the Solution Explorer?

this

because you love UML?

23fc9a62-56de-47fb-97b4-737890

It's basically the object explorer.

I actually didn't know about that one.

But it lets you see dependency structures.

Mathieu Guindon

16:16

well it's basically namespace-driven, whereas solution explorer is file-system driven

23fc9a62-56de-47fb-97b4-737890

Like, in the web app I'm in, I can drill in and see the ANTLR3 NuGet dependency's types.

this

i wonder if it's driven by the partial which would diverge from the filesystem?

23fc9a62-56de-47fb-97b4-737890

Double-clicking an item opens the object browser.

Mathieu Guindon

oh I get it - it's drilling into the inheritance hierarchy rather than the members

yeah it's like a mini-object browser

..which I suppose is useful when you're not familiar with a project

23fc9a62-56de-47fb-97b4-737890

Or if you are learning a new dependency.

Vogel612

16:22

Poke @M.Doerner the AttributeAnnotationProvider doesn't hit the Annotation Type's constructor when examining the Attribute Values

that's why the unit test you admonished fails

Mathieu Guindon

@IvenBach #FunFact that is exactly why the hotkey settings grid has a "Key1" heading; there's a hidden (or commented-out, I don't recall) "Key2" column that means to accept the 2nd key of a hotkey chord.

M.Doerner

@Vogel612 The AttributeAnnotationProvider is meant to provide tha data needed to construct a suitable annotation based on the attribute and attribute value.

The second parameter in the test actually has the wrong name.

It should be attributeValue not annotationValue.

Vogel612

uuuuuuhhhh... okay

but then it should be @"A\n14", ..., @"A\14", because we're not constructing the annotation itself...

right?

M.Doerner

So far, different values either translated to another annotation type or were passed on.

No

Vogel612

the method tested is only used in the annotation quickfixes

it doesn't test whether the annotation type itself does the transformation correctly..

IvenBach

16:31

@MathieuGuindon I know it's on the roadmap. Just wish it'd arrive sooner. Having them identical to VS would make coding so much easier.

M.Doerner

The correct annotation value to get the attribute value @"A\n14" is "A" .

The annotation does the reverse transformation.

Vogel612

but the annoation ctor is never hit on that codepath

testing for it there doesn't make sense

it only finds the annotation type that needs to be constructed, but never actually constructs it

M.Doerner

It provides the current type and argument in order to be used to update/create the annotation in the module.

Vogel612

yes, but the transformation happens in the associated class constructor, which is never called

at least for FlexibleValueAnnotations

M.Doerner

It has to provide the annotation value that will lead to the attribute value provided.

Vogel612

16:36

for FixedValueAnnotations, the value is relevant, for flexibles only the count is taken into consideration

but it doesn't... that's kinda the point

or rather... the provided value is passed through

because again: the constructor of the specific annotation class is never called on the codepath tested there

M.Doerner

As I said, so far only the count mattered since the attribute and annotation value were always identical.

Vogel612

yea, but the AttributeAnnotationProvider only returns the AnnotationType, not an instance of T : IAttributeAnnotation

M.Doerner

The new annotation is the first attribute annotation to do a transformation from the annotation value to the attribute value.

Vogel612

so far I'm with you

M.Doerner

Look at where it is used.

There is no need for the instance.

Vogel612

16:40

I still don't follow

M.Doerner

The instance is created on the next parse

Vogel612

where are we constructing annotation instances?

so the AttributeAnnotationProvider is not responsible for creating instances, right?

M.Doerner

Correct

Vogel612

Why are you expecting it to do that (for the value transformation) then?

Mathieu Guindon

would AttributeAnnotationTypeProvider be a better name for it then?

Vogel612

16:42

        [TestCase("VB_ProcData.VB_Invoke_Func", @"A\n14", AnnotationType.ExcelHotKey, @"A\n14")]
        // ^^ this test passes

@MathieuGuindon maybe, yes

M.Doerner

It has to provide the information required to insert code into the code pane that results in an attribute annotation corresponding to the attribute provided.

Vogel612

but Provider is not really a good name, considering it returns additional information (namely the number of annotation arguments to help annotation rewriting)

@M.Doerner so far nothing there says to me that it needs to instantiate the Annotation Type?

M.Doerner

It returns the values, not the count.

Vogel612

and it also doesn't imply that the AttributeAnnotationProvider needs to do that transformation

M.Doerner

Please have a look at where it is used.

If you use the AdjustAttributeAnnotationQuickFix, you will expect to get an annotation representing the attribute, right?

Vogel612

16:47

soo ... AttributeAnnotations don't expose enough information from what I can tell...

that's why there is this weird clunky provider workaround there that for some reason interferes with the responsibilities of the annotations themselves

which means.... I gotta do some refactoring, I guess...

because as it stands Annotations only expose the AttributeValues

23fc9a62-56de-47fb-97b4-737890

I've done 8 hours worth of work (based on estimates) in the last 2 hours.

I'm not sure what's more concerning.

M.Doerner

Please note that we have no annotation at the start, only the attribute.

23fc9a62-56de-47fb-97b4-737890

The fact that the estimate is that high, or the fact that I did it that fast.

Vogel612

notably AnnotationBase does not expose AnnotationValues (which would be more appropriately named AnnotationArguments)

@M.Doerner eww... that's kinda ugly

23fc9a62-56de-47fb-97b4-737890

I mean for the business--if I became unavailable for some reason...

M.Doerner

16:50

Why should it?

Vogel612

we're correlating Attributes to AnnotationTypes already, which implies we should be able to construct an instance of IAnnotation

M.Doerner

The job of the provider is to reverse engineer the annotation from the attribute.

Vogel612

tightly correlating the metainformation to a VBAParser context isn't correct here

M.Doerner

But we do not need an instance.

Vogel612

but that's where the value transformation is...

that's the whole point of this mess...

M.Doerner

16:52

But it is the reverse transformation we need.

Vogel612

We have an AnnotationType from the Provider, the transformation must not be it's responsibility though

because the AnnotationArg -> AttributeArg transformation is the job of the Annotation instance

M.Doerner

Yes

Vogel612

therefore it should also be responsible for the reverse transformation

M.Doerner

And the provider does the reverse transformation.

Vogel612

but it shouldn't

M.Doerner

16:53

Why?

Vogel612

and testing for it when it doesn't also makes no sense

because the transformation is domain specific logic for the annotation

and it can be different for each separate annotation

M.Doerner

It is also responsible for finding the right annotation based on the attribute in the first place.

Vogel612

we don't want to have a gigantic switch inside the provider to correlate annotation types to their backtransformations

@M.Doerner that's a different responsibility, though...

it's resolution / binding vs semantics

the provider binds the semantic holder to the parsed context

it's not responsible for the "runtime evaluation"

also, forgive my french, but provider is a shit name here

AttributeAnnotationTypeResolver would be more of a match to what it does right now, or am I misunderstanding again?

M.Doerner

It got its name from the perspective of the user.

Vogel612

the alternative would be to augment the FlexibleAttributeValueAnnotationAttribute with the necessary metainformation to enable value transformation

which should in turn make the ExcelHotKeyAnnotation class unnecessary and allow us to seal the FlexibelAttributeValueAnnotationBase

which should of course be renamed then ...

M.Doerner

17:00

I really don't like to put too much magic into the attribute.

Vogel612

well, we kinda need to put it somewhere....

the alternative would be to put it in the Annotation class itself.

but putting the backtransform and the transform into different places makes no sense

M.Doerner

So far, there was only a trivial backtransform. So I stopped at that points. The transformations of the annotation systems were already giving me enough headaches.

The question is how to put the information on the annotation

Vogel612

aight... Imma try digging around to find something that can simplify the overall process

the transformation stuff should probably fall in place then

M.Doerner

Please keep in mind that the actual annotations are created via reflection.

That is why they all have the same constructor parameters.

FreeMan

@23fc9a62-56de-47fb-97b4-737890 be wary of papers asking for signature and including prohibitions of crossing the street near bus stops.

23fc9a62-56de-47fb-97b4-737890

17:06

@FreeMan Ooops.

M.Doerner

Btw, at the end, we will still need a class that does exactly what the provider does right now.

Vogel612

@M.Doerner yea, I know.

@M.Doerner that class should probably do a few more things to simplify the overall process...

I think I'll look into moving away from our enum-based AnnotationType idea

Mathieu Guindon

that's quite a redesign though

Vogel612

the thing is: those enums are doing multiple things and we're like the third bolt-on in on how they work

Mathieu Guindon

but yeah I'm all for it - we'll be running out of int32 values with all these flags :)

@Vogel612 lol true

Vogel612

17:09

there's special enum values for where an annotation is allowed and the AttributeAnnotations have a C# Attribute tacked on dealing with the attribute transformations

I think I want to get to automatically discovering annotation types through CW and enriching them with information instead of correlating the types we rely on anyways with an enum value

Something like:

class ExcelHotKeyAnnotation : FlexibleAttributeAnnotation
{
    int Arguments { get; } => 1;
    AnnotationTarget Target { get; } => AnnotationTarget.Member;
    //....
}

of course doing something like that implies moving the magic in the annotation system from the AnnotationType enum into the class hierarchy, but it should work

most of that information should be statically available, though...

and that makes it a bit harder to enforce in the class hierarchy...

So the alternative would be:

[AnnotationTarget(AnnotationTarget.Member)]
[FlexibleAttributeAnnotation("VB_ProcData.VB_Invoke_Func", 1)]
class ExcelHotKeyAnnotation : FlexibleAttributeAnnotation
{
   //  ...
}

but then we just moved the magic ...

~sigh

hmm ... interesting ...

teh `VBAParserAnnotationFactory´ currently needs manual specification of the supported annotations and annotation types...

that'd fall away completely.

well, crap. now I'm knees deep in another large-scale refactoring :/

Okay, I'll just finish the ExcelHKAnnotation by bodging it in and then I'll do the refactor as a separate PR

this

@Vogel612 in soviet, the ducky refactors you. ;-)

23fc9a62-56de-47fb-97b4-737890

17:28

@Vogel612 Sounds good.

@this Soviet, umm, Canada?

That reminds me. Remember when Obama "programmed"?

M.Doerner

I would like to have everything in the class hierarchy, but how will we construct the annotations based on the name of the annotation?

23fc9a62-56de-47fb-97b4-737890

That was so funny. It was like watching him "weld" something.

M.Doerner

And where will we have an overview of which annotations and categories thereof exist?

Currently, the enum is such an overview.

Mathieu Guindon

presumably the namespace would become the overview, kind of like inspections.concrete?

FreeMan

17:44

Why, oh why is Step Into F8 in VBA, F11 in SSMS and F5 in VS?

Microsoft, consistency is thine name!

Duga

[rubberduck-vba/Rubberduck] MDoerner created comment on issue #2522: ReDim should be treated as a declaration

> Just to add a bit of complexity to the situation, ReDim allows to specify a type.

M.Doerner

It is F11 in VS.

F5 is start debugging.

Which is execute in SSMS

FreeMan

My point!!!

you're correct, of course...

Vogel612

@M.Doerner we could actually do some more documentation generation magic to find all annotations...

this

@23fc9a62-56de-47fb-97b4-737890 according to this metrics, Canada is quite prosperous.

Vogel612

17:50

@M.Doerner that's currently done in the VBAParserAnnotationFactory

the _creators there just need to be adapted to deal with annotation types that are injected

23fc9a62-56de-47fb-97b4-737890

@this Are they dead in the last panel?

this

i interpreted as close to dead

Vogel612

so instead of AnnotationType.[...].ToString().ToUpperInvariant() we get annotationType.Name.Substring(0, [...]).ToUpperInvariant()

M.Doerner

@Vogel612 ah ok

@Duga ReDim is strange.

It has an As clause, but that actually does not change the declared type.

IvenBach

@23fc9a62-56de-47fb-97b4-737890 Pineapple AHOY!

M.Doerner

17:57

Moreover, it can redimension a declared array before it is declared.

this

@M.Doerner that's why I understood that we'd need to do a separate pass to find all Redim-only variables

Mathieu Guindon

@M.Doerner it can literally act as / replace a Dim

@M.Doerner it can, if the array was first declared as a Variant

M.Doerner

We don't. We just need to evaluate whether our undeclared variables are in a ReDim.

Mathieu Guindon

Sub test()
    Dim foo As Variant

    ReDim foo(1 To 10) As Long
    Debug.Print TypeName(foo)

    Stop

    ReDim foo(1 To 20) As String
    Debug.Print TypeName(foo)

    Stop

End Sub

Vogel612

@MathieuGuindon that begs the question ... how do Ignore annotations handle it?

Mathieu Guindon

17:59

output is Long(), then String()

@Vogel612 handle what?

Vogel612

Dim foo As Long(10)
'@Ignore UnusedDeclaration
Redim foo As Long(15)

this

@MathieuGuindon that can only happen with Variant, though. I think even Variant() will fail to change type.

M.Doerner

According to the spec, the declared type stays Variant; only the runtime type changes.

Vogel612

currently we're ignoring all inspections mentioned in an @Ignore on the declaration

Mathieu Guindon

@this at compile-time, yes

23fc9a62-56de-47fb-97b4-737890

18:00

Found an interesting statement of ambiguous meaning: My sister and I are getting married.

Vogel612

if ReDim can act as a declaration, does RD need to account for that or are we saying [wontfix, edge-case]

23fc9a62-56de-47fb-97b4-737890

Of course, that means two marriages, but it could also imply marriage to each other.

this

we need to be able to account for it in order to whack people with cold fish

Vogel612

@23fc9a62-56de-47fb-97b4-737890 it wouldn't be ambiguous with "My sister and me", would it?

Mathieu Guindon

I wish it were an edge case, but basically when ReDim is declaring the variable, we treat it as undeclared

Vogel612

18:01

@this sounds like a [wontfix]

this

@Vogel612 I don't think that is grammatically correct.

23fc9a62-56de-47fb-97b4-737890

Me wouldn't work in this case, because you wouldn't say "Me is getting married."

this

^

Mathieu Guindon

@23fc9a62-56de-47fb-97b4-737890 "...are both getting married" wouldn't be ambiguous though, would it?

23fc9a62-56de-47fb-97b4-737890

You say "X happened to Joe and me", because it still makes sense without the "Joe and"

@MathieuGuindon Correct.

this

18:03

but saying "The marriage was conducted to my sister and me." is just.... weird

Mathieu Guindon

"oh, a Targaryen marriage!"

this

I almost said "consummated" but I couldn't use the "to"; only "between" which makes it unambiguous.

Mathieu Guindon

lol

23fc9a62-56de-47fb-97b4-737890

Well, you don't conduct a marriage to someone.

this

Yeah, that's my point. You can't marry passively.

(see what I did there)

23fc9a62-56de-47fb-97b4-737890

18:05

Sure you can.

The spouse can say "I do, and they do too."

this

Passive voice....

lol, no, never mind.

M.Doerner

You are aware that even I will marry you is ambiguous, right?

Mathieu Guindon

@23fc9a62-56de-47fb-97b4-737890 technically none of it matters until they sign the contract :)

this

I guess a valid passive voice form would have to be "The preacher married me and my sister."

23fc9a62-56de-47fb-97b4-737890

@M.Doerner If you can legally conduct a marriage, yes, it is.

@MathieuGuindon :D

this

18:07

but I don't htink you can passively marry without that 3rd person to conduct the marriage.

The point being, the verb "to marry" does not really lend itself very well to passive voice.

M.Doerner

Regarding ReDim, it is only a declaration if there is no other declaration for it. So, all we have to do to fix everything around it is to validate whether we are in a ReDim context when we find an undeclared variable and create a different declaration in that case.

this

but how do you guarantee that it's not declared somewhere else?

for example, you could be in a module A, hit the Redim foo, but there is a Public Foo() in module B which you have not yet parsed?

you'd need to enumerate all non-local variables in order to accurately determine that this particular Redim does not reference any one of those.

M.Doerner

We do this in the reference resolver.

this

Ok, cool. As long that is known, I don't think that'll be a problem.

M.Doerner

According to the spec, things are a bit more complicated though.

It states that it is a declaration if it does not resolve in the same module.

this

18:14

what?

so Redim Foo() in module A isn't same as Public Foo() in module B?

M.Doerner

docs.microsoft.com/en-us/office/vba/language/reference/…

This behaviour is really strange.

this

that paragraph doesn't really make sense, TBH

M.Doerner

Better test it before putting it into the resolver logic.

this

agreed. wouldn't be first time docs was wrong

IvenBach

pondCheck: Should unit tests contain the name of the unit they're testing? Current book suggests so but that doesn't seem right as it hinders renaming.

M.Doerner

18:28

I think it is sufficient if the unit under test is in the test fixture name.

IvenBach

Forgot to mention this is in VBA-landia.

M.Doerner

Whether you want to have it in the test name depends on your test framework.

If you can navigate from the result to the test, I do not think it is necessary.

However, if you can't and the fixture name also is not in the output, the name should be in there to aid finding the right test.

this

so I created 2 modules

the one module only has Public foo

the other module has:

Public Sub x()
    ReDim foo(0 To 1) As String

    foo(0) = "hello"
    foo(1) = "world"

    Debug.Print foo(0), foo(1)
End Sub

after running the procedure, ?typename(foo) returns String()

so I am not too convinced that the doc commenting that it only considers module variable is correct.

Re-reading the doc, I now see that "module level variables" could include the Public foo -- in actuality the doc should have had said "public module-level variables"

then the following sentence makes sense

If I modify the first module to following:

Private foo

Public Sub test()
    Debug.Print TypeName(foo)
End Sub

then the Redim no longer affects the foo, as expected.

IvenBach

@M.Doerner Module name is 'TestPurlinViabilityChecker'. The test method name is 'MinimizesPunchPattern_PanelsWide8_PanelsLong15_StringSize20_MinCant2Point5_MaxCant3Point5_PanelsBetweenColumns10_ReturnsTrue' which invokes the MinimizesPunchPattern on the System Under Test (SUT). I'm wondering if there's a more succinct way to name the test method.

I may just need to take a few deep breaths and accept the long names.

@IvenBach Breathe and get over it. SomeCodePaneOpen_ThrowsExceptionOnSelectionChange_TrySetActiveSelectionDoesNotChangeTheActiveCodePaneAndReturnsFalse_QualifiedModuleNameAndSelection is your proof.

this

18:44

IDK... feels like it's doing too much

Reading the code, it makes sense but from the name alone, it does give an impression that it's testing too many things.

In actuality, all we are doing is asserting that a failed selection doesn't alter the state. Thus ThrowsExecptionOnTrySetActiveSelection_DoesNotChangeTheActiveCodePane_ReturnsFalse would have been enough, IMO.

FreeMan

@this in many US states there is a Common Law Marriage which basically means that if you've lived together long enough you're considered married for things like wills. That could be considered being "passively married".

this

@FreeMan sigh.... #MassiveJokeFail

FreeMan

Just looking at the factual side of things. While I'm a native English speaker and my mother was an English major, things like "passive voice" aren't over my head, I just don't care enough to be bothered. I can speek it guud enough, so there you is

this

lol

Duga

[rubberduck-vba/Rubberduck] Vogel612 synchronized pull request #5101: Add Excel Hotkey Annotation, Closes #4959

FreeMan

18:56

^yay!

Is there nothing in a VBA .cls file that indicates what the name of the class is/should be?

I'm adding a new implementation so the easiest thing is copy/pasta the .cls file and load that - I pulled it up in N++ looking for an internal name to change and didn't fine one.

this

i thought it was dictated by an attribute?

FreeMan

Headers:

Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = False
Attribute VB_PredeclaredId = True
Attribute VB_Exposed = False
'@PredeclaredId
'@folder ("WebDriver.Implementations")
Option Compare Database
Option Explicit

I thought it woulda been in there, too...

this

I think it woudl have been VB_name, but - I don't think it's hard and fast either.

KySoto

man

that crap was nuts

0

A: I am trying to update the data source of an oledb data adapter and nothing happens

In the end a reddit user helped me figure it out, Their post was the thing that got everything rolling. What i needed to do was set the state of every datarow in my datatable to "Added" using the SetAdded method. Then i needed to set $DestCb.QuotePrefix = "[" and $DestCb.QuoteSuffix = "]" Then it...

FreeMan

Well, according to Vitosh Academy, not only is there a VB_name, but I'm missing some other headers, too:

VERSION 1.0 CLASS
BEGIN
  MultiUse = -1  'True
END
Attribute VB_Name = "CarWithDefaultProperty"

KySoto

19:03

how are you exporting?

i noticed that using the "proper" export it includes those lines

if you use SaveAsText it doesnt include them

FreeMan

interesting that Access.Application.SaveAsText acModule, ... doesn't seem to put the class header in there

KySoto

i had to quit using it because something was happening that was causing it to export import junk

this

Indeed. I did confirm that was the case.

KySoto

had to go back to the proper inport

FreeMan

My import routine (using Access.Application.LoadFromText acModule,) seems to work just fine when I've exported as above.

this

19:05

but somehow it automagically knew what to does to do with it.

KySoto

mine did too for like a month

FreeMan

I guess I'm about to find out how well Access likes importing a class w/o that little bit 'o header

KySoto

then it exploded and was dying importing a class module

there was nothing i could find wrong with the project either, everything compiled, RD was cool with it for the most part

FreeMan

I've added the VB_Name attribute, we'll see what happens.

saves, makes a backup, then attempts import

Mathieu Guindon

@FreeMan export document modules (forms, reports) with that; use the VBIDE API to export class modules (that includes userforms)

KySoto

19:06

oh by the way, it doesnt care what the name is on loadfromtext because you specify where it is going

FreeMan

@MathieuGuindon oy!

this

makes me wonders whether tools like OASIS uses VBIDE im/ex for VBE stuff. I know it must use the LoadFromText/SaveAsText for all others.

Mathieu Guindon

@IvenBach have a separate test module per SUT

FreeMan

This is good:

> 1 file changed, 5 insertions(+), 10 deletions(-)

Duga

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

BUILD FAILURE!

FreeMan

19:13

^ not my fault!!

interesting... I did a C&R in Access - RD started parsing as soon as it reopened the file. I ignored the spinning ducks and closed the DB - the duckies kept right on spinning... Kept spinning after opening the DB again...

I think I've got a clean parse, but I'm not sure...

Says it's Ready...

this

yes that's been reported before @FreeMan

FreeMan

parses again to be on the safe side.

this

In fact, you reported it. :)

FreeMan

I was about to say that it may have been me that reported it... :)

this

the issue is that you do have to do a manual reparse after loading the file

there is also something else weird that causes it to toggle on/off

that is, the 2nd file you end up seeing nothing.

Close 2nd and open 3rd, and you can see everything.

Close 3rd and open 4th, and you're back to nothing.

and to be honest with you I'm not sure I have a good fix for that issue because we get 3 unload events and 3 load events in rapid succession.

FreeMan

19:18

if when there's a good way to cancel the parse, I'm sure that will get resolved.

this

that is not the problem, I don't think.

we are cancelling parse at least 6 times because of those events firing

FreeMan

Well... I right-clicked the CE and selected Add... | Existing File and had it import my class w/o the class header lines and. (drum roll, please)

2019-08-22 15:16:46.7255;ERROR-2.4.1.4848;Rubberduck.Parsing.VBA.DeclarationResolving.DeclarationResolveRunnerBase;Exception thrown acquiring declarations for 'Quarterly Report.ApptPlusPatientWebDownloader' (thread 78).;System.InvalidCastException: Unable to cast object of type 'Rubberduck.Parsing.Symbols.ProceduralModuleDeclaration' to type 'Rubberduck.Parsing.Symbols.ClassModuleDeclaration'.
   at Rubberduck.Parsing.VBA.DeclarationResolving.DeclarationSymbolsListener.EnterImplementsStmt(ImplementsStmtContext context) in C:\projects\rubberduck\Rubberduck.Parsing\VBA\DeclarationResolving\De…

It seems the parser wasn't really happy with it.

this

did it compile?

FreeMan

the PE doesn't show the module under either Modules or Classes and it doesn't show in the CE (due to the resolver error, obvs...)

this

what was it originally?

it's just a class or standard module, right?

FreeMan

19:21

Oh, nope, my bad, it does show under Modules in the PE. and it won't compile because you can't Implements in a standard module

it was originally a class.

And... this is what backups are for! :)

this

yeah that's bad

FreeMan

closed w/o saving. Added Version 1.0 Class header lines to .cls file. Opened the DB, imported via CE, hmmmm.....

The first time I tried that, Existing File was the only option enabled under Add. Now they're all available.

I wonder if the CE wasn't in a good state when I tried it the first time. (despite the manual parse)

not shocking... with the Class header lines, it shows up instantly in the PE under Class Modules and, once the parse is complete it shows up in the CE as expected.

Guess I'll need to tweak my export routine. However, for git usage, it seems to work just fine - when I import them, it seems to understand that they're classes even w/o the header.

(at least according to my faulty memory - will have to investigate further, but not today)

Mathieu Guindon

@FreeMan it seems to understand that they're classes even w/o the header - I'd be surprised if that were the case

Something needs to tell the VBE it's looking at a class, and it's not the file extension.

FreeMan

I've been doing about 99% exporting lately as I've been adding some new functionality, but I did test importing, and I'm pretty darn sure it worked since my code didn't implode most gracelessly... but, I'll do some additional testing to see what's what.

Vogel612

@Duga ~sigh. I'm an idiot

Mathieu Guindon

19:38

Jun 11 at 14:13, by this

oh you're right. I'm an idiot

Feb 26 at 19:54, by Mathieu Guindon

oh, I'm an idiot

Jan 29 at 15:55, by KySoto

im an idiot

Nov 30 '18 at 4:14, by Comintern

Oh, it's because I'm an idiot.