Stop Visual Basic 6 from changing my casing

Question

Very simple question that is apparently impossible to find a decent answer to: How can I make Visual Basic 6 stop changing my ^@#*ing variable casing!?!

I know that the general opinion of a great many VB users is that this "feature" is actually quite helpful, but I doubt that they use it much with any source control system. This is absolutely INFURIATING when you are trying to collaborate on a project of any significant size with several other developers. If ignored, you produce thousands of false-positive "changes" to your files (even ones with no actual code changes!) that pollute the revision history and make it near impossible in some cases to locate the actual change that took place.

If you don't ignore it (like my office, where we have been forced to implement a "no unneeded case change" policy), you spend 5x the time you would normally on each commit because you have to carefully revert out VB's "corrections" on every file, sometimes reverting hundreds of lines to put in a one line change.

Surely there must be a setting, plugin, hack, etc. out there that can remove this unwanted "feature"? I am willing to take any method I can get as long as it doesn't require me to pick through piles of phantom diffs. And to squash a couple of complaints up front: No, I can't turn off case detection in my diff tool, that's not the point. No, we can't just make the case changes globally. We're working with hundreds of thousands of LOC being worked on by multiple developers spanning many years of development. Synchronizing that is not feasible from a business standpoint. And, finally: No, we cannot upgrade to VB.net or port to another language (as much as I would love to).

(And yes, I am just a tiny bit peeved at the moment. Can you tell? My apologies, but this is costing me time and my company money, and I don't find that acceptable.)

Answer 1

Here is a real world scenario and how we solved it for our 350k LOC VB6 project.

We are using Janus Grid and at some point all the code lines which referenced DefaultValue property of JSColumn turned to defaultValue. This was an opportunity to debug the whole IDE nuisance.

What I found was that a reference to MSXML has just been added and now the IDE picks up ISchemaAttributes' defaultValue property before the Janus Grid typelib.

After some experiments I found out that the IDE collects "registered" identifiers in the following order:

• Referenced Libraries/Projects from Project->References in the order they are listed

• Controls from Project->Components (in unknown order)

• Source Code

So the simple fix we did was to create a dummy class/interface with methods that hold our proper casing. Since we already had a project-wide typelib we referenced from every project before anything other typelib, this was painless to do.

Here is part of the IDL for our IUcsVbIntellisenseFix interface:

[
  odl,
  uuid(<<guid_here>>),
  version(1.0),
  dual,
  nonextensible,
  oleautomation
]
interface IUcsVbIntellisenseFix : IDispatch {
    [id(1)] HRESULT DefaultValue();
    [id(2)] HRESULT Selector();
    [id(3)] HRESULT Standalone();
    ...
}

We added a lot of methods to IUcsVbIntellisenseFix, some of them named after enum items we used to misspell and whatever we wanted to fix. The same can be done with a simple VB class in a common library (ActiveX DLL) that's referenced from every project.

This way our source code at some point converged to proper casing because upon check-out the IDE actually fixed the casing as per IUcsVbIntellisenseFix casing. Now we can't misspell enums, methods or properties even if we try to.

Update

Another thing to try is additionally declaring same named UDTs in your typelib like this

    typedef struct { long _ID; } DefaultValue;
    typedef struct { long _ID; } Selector;
    typedef struct { long _ID; } Standalone;
    ...

FYI, the samples are from source code of an .idl file compiled directly with mktyplib.exe into a .tlb file.

Answer 2

In this example VB6 was changing the case of the following line following a typo I made when referencing a library: -

Dim MyRecordset As ADODB.REcordset

Ugly, and now every other instance of an ADODB.REcordset thus acquired the new misspelling. I fixed this as follows: -

1. Type in a new declaration as follows

   Dim VB6CasingSucks AS ADODB, Recordset

   Note the comma and space after ADODB. Hit [ENTER] for VB6 to check the line.

2. At this point all instances of REcordset change back to Recordset.

3. Delete your new declaration.

I don't know if this fix will help with enums/other variable names.

Answer 3

I have a similar problem:

in a bas module there I wrote :

Private sub bla_bla()
  Dim K as integer
End Sub

so in a class module the Dim k as integer will automatically be replaced by IDE become 'Dim K as integer' <-- it's not logical but then: I correct the bas module become:

Private sub bla_bla()
  Dim k as integer
End Sub

then magically the problem in the class module was solved (still be k and not automatically replaced by IDE become K). Sorry I'm poor in English

Answer 4

Specifically for controlling the case of enum values, there is a VB6 IDE add-in which may be helpful. Enums seem to have a slightly unique version of this problem.

As described in the link below:

The VB6 IDE has an annoying quirk when it comes to the case of Enum members. Unlike with other identifiers, the IDE doesn't enforce the case of an Enum member as it was declared in the Enum block. That occasionally causes an Enum member that was manually written to lose its original case, unless a coder typed it carefully enough. ...

However, if a project contains a lot of Enums and/or a particular Enum has a lot of members, redeclaring the members in each of them can get quite tedious fast. ...

Ref: http://www.vbforums.com/showthread.php?778109-VB6-modLockEnumCase-bas-Enforce-Case-of-Enums

...load and unload the add-in as needed via the Add-In Manager dialog box. Usage is as simple as selecting the entire Enum block, right-clicking and then choosing the "Lock Enum Case" context menu item.

Answer 5

I standardised the case across the codebase, normally by using the examples above (Dim CorrectCase), and removing it again. I then triggered VB to save EVERY file, by doing a case sensitive search/replace of "End" with "End" (no functional change, but enough to get VB to resave). Once that was done, I could then do a single commit to standardise the case, making it MUCH easier to keep on top of it at a later date.

Answer 6

SIMPLE WAY: Dim each variable in the case that you want. Otherwise, VBA will change it in a way that is not understandable.

Dim x, X1, X2, y, Yy  as variant

in a subroutine will change ALL cases to those in the Dim statement

Answer 7

I can sympathise. Luckily we're allowed to turn off case sensitivity in our version control diff tool!

It seems the VB6 IDE automatic case-correction occasionally changes case in variable declarations and references, perhaps depending on the order in which modules are listed in the VBP file? But the IDE doesn't tell you that the file needs to be saved. So the problem only shows up when you saved the file because of another edit. We briefly tried to prevent this by checking out all the files in a project and setting the case carefully, but it didn't go away.

I suppose you could list the variable names that are affected - the usual suspects are one letter names like "I", "X" and "Y", perhaps because they are used in standard event handlers like MouseDown. Then write an add-in that'll search for all declarations " As" and force the case to upper. Run the add-in on your modules before you check them in. You might be able to trigger the add-in to run automatically when you save in VB6.

EDIT: Something I've just thought of: adapt Fred's answer. From now on, every time you check in a file, add a block at the top to establish canonical case for the usual suspects. If nothing else, it's easier than reverting hundreds of lines by hand. Eventually you will have this block in every file & maybe then the problem will stop happening.

#If False Then
  Dim I, X, Y ' etc '
#End If

Answer 8

Depending on your situation adding

#If False Then
    Dim CorrectCase
#End If

might help.

Answer 9

I don't think there's any to do it. The IDE will change the case of the variable name to whatever it is when it's declared. But, honestly, back in the day I worked on several large VB6 projects and never found this to be a problem. Why are people on your development team constantly changing variable declarations? It seems like you have not established a clear variable naming policy that you enforce. I know your upset, so no offense, but it might be your policies that are lacking in this regard.

Unfortunately, according to this SO thread, alternate VB6 IDEs are hard to come by. So, your best bet is to solve this problem via policy. Or move to VB.NET. :)