Resolve Late Bound Variable Types
The Visual Basic Upgrade Companion performs an extensive data analysis to infer
the most appropriate data types for variables, parameters, and return values, avoiding
the use of generic data types like Variant and Object.
When a variant data-type variable is found, the Visual Basic Upgrade Companion declares
the variable with the appropriate type and avoids unnecessary Warning messages generated
in the target code.
This preliminary stage not only makes the resulting code better by declaring appropriate
types, but it also achieves substantial improvements in the overall conversion process
by allowing a considerable amount of advanced transformation rules to apply over
variables and compound expressions, whose correct types are accurately identified
by the main conversion engine.
Some of these advanced transformations can only be applied when the correct types
are known and uses of generic data types have been removed:
- Type castings, coercions and other crucial corrections for achieving strict typing
- Default properties resolution
- Application of appropriate transformation for library members
- Conversion of arrays with lower bounds different to 0
- Many Other
The Type inference engine analyzes each variable and all of its references in order
to obtain implicit typing information from the VB6 late binding environment. When
a late bound variable is detected, the typing engine will analyze all the references
made to this variable in order to deduce the correct data type; this analysis can
be done with different levels of granularity. These options can be tweaked from
the graphical user interface in the Main Project Grid:
- Full Typing: This option will make the typing engine to analyze all the typing
information using the entire upgrade solution scope. This means, all the late bound
variables information will be analyzed from a global scope including references
found on other projects detected during the preprocessing stage.
- Local Typing: The typing information will be processed only from each file
- No Typing: Leaves the variable types as they were defined in the original
The VBUC is able to have different type inference settings for each project in the
upgrade solution. Depending on the internal structure and the typing/binding techniques
of the original VB6 system, some files can be upgraded without the compulsory need
of full typing, thus, changing this setting to local typing or no typing can save
some time during the automated migration stage.
The next code sample demonstrates a couple of subroutines containing non typed variables.
Original VB6 Code:
Public Sub typeInference()
Dim var4 As String * 50
var4 = App.Path & "\createDsn.ini"
var1 = ArgTypeInference(var2, var3, var4, CInt(var3))
Public Function ArgTypeInference(ByVal arg1 As Integer, ByVal arg2 As String, ByVal arg3 As String, ByVal arg4 As Integer)
MsgBox arg1, , "Argument1"
MsgBox arg2, , "Argument2"
MsgBox arg3, , "Argument3"
MsgBox arg4, , "Argument4"
ArgTypeInference = 1
Due to its advanced type inference mechanism, the Visual Basic Upgrade Companion’s resulting source code contains clearly defined data types. For this example, var1, var2 and var3 were typed based on their usage (Byte, Integer and String respectively). Also the “ArgTypeInference” function return value was upgraded to an explicit call of the “return” keyword.
Resulting VB.NET code
All the transformations applied in the previous example are available for C# source code generation as well.
Resulting C# Code:
The Visual Basic Upgrade Companion’s resulting source code contains clearly defined data types.
For this example, var1, var2 and var3 were typed based on their usage (Byte, Integer and String respectively). Also the “ArgTypeInference” function return value was upgraded to an explicit call of the “return” keyword.
static public void typeInference()
int var2 = 0;
string var3 = String.Empty;
FixedLengthString var4 = new FixedLengthString(50);
var4.Value = Path.GetDirectoryName(Application.ExecutablePath) + "\\createDsn.ini";
byte var1 = ArgTypeInference(var2, var3, var4.Value, Convert.ToInt32(Double.Parse(var3)));
static public byte ArgTypeInference( int arg1, string arg2, string arg3, int arg4)