Declares an external component like a dll, or an ocx, or an olb, or a tlb whose components are referenced by a source code but not defined within the source code.

Declares a class within a library.

Declares a class that is actually defined as the union of a set of classes.

Declares an enumeration within a class or a library.

Declares a method within a class.

Declares an argument within a method, event or accessor.

Declares a property within a class

Declares separate Get, Set, Let components within a property

Declares a property in a class whose origin was a class variable as opposed to a property.

Declares a property with both set and get access that has arguments.

Declares a event within a class.

Declares a constant within a class or library.

Declares a structure within a class or library

Declares a typedef within a library.

The component is declared as being private to the parent that contains it. This may because of an explicit declaration or it may be a flag added to the component for some reason.

The component is declared as being public. This normally means that it may be referenced anywhere in the code.

The component is declared as being static. This normally means that its parent keeps only one parent-wide value for the component as opposed to allocating a new value each time a parent object is created.

The component was declared as being WithEvents. Which means that events can occur for the object for which event handlers might be present in the source code.

The component is an argument of a subprogram or method or accessor or event.

The component is an argument which will be called by value.

The component is an argument which will be called by reference.

The component was referenced in a comprehensible way, but no definition of it could be found in either the user code or the libraries being referenced.

The component has been marked as being dead code. This means that its declaration will be skipped. This flag has no effect on references to the component. See the Migration status flags for more information on dead component references.

The component requires the use of a "getter" to access its value.

The component is an argument whose value will be stored in the calling reference location when its subprogram exits.

The component is an argument that may be optionally omitted when its subprogram is called.

The component is being used as a variable but was never declared.

The component has been assigned a type which should not be changed by the analyser.

The component has the Friend status, which is derived but which often simply means that it was not explicitly declared to be public or private.

The component needs to be explicitly given the Overload adornment when declared.

The component when declared was explicitly dimensioned via a size or set of size specifications. This size specification is stored as well.

In processing the source code the compiler determined that the value of the component was being changed. This flag is later used by the algorithm that assigns arguments ByVal calling status.

The component was declared as being new.

The argument component is in fact a parameter array -- will contain a variable-length list of objects/values being passed to a subprogram.

The component is allocated to an external library and its declaration may require extra adornments. This is used in particular with structures that are referenced via declare arguments.

The component is the default component for its parent.

The component is a collection class or a control vector.

The component is declared or is referenced as though it were an array even though it may not have been explicitly dimensioned.

The component is declared or is referenced as though it were a two-dimensional array even though it may not have been explicitly dimensioned.

The component has an inferred type.

The component requires the protected adornment when it is declared.

The component is declared within a module file.

When the component is declared it should be initialized with the default initialization value for its type.

The component has a set of resources associated with it that were originally stored in an frx file.

The component is an argument whose calling status is unspecified, that has been passed to another subprogram. This flag is needed to trace the change status of that argument.

The component has no implementation in the target. References to it are commented out and adorned using "#if !DEBUG\n\t#error \sUPGRADE ISSUE: %1d was not upgraded.\s\n#endif\n"

The component should be deleted from the target. References to it are literally removed from the target code.

The component itself, or its instances, are checked for being empty. These instances can be Null as well. References to them in the intermediate code have to be checked if they are they are Null or Empty.

There may be runtime gmNI user code for processing this component. The identifier of this component, that triggers the event handler code, is specified for the component in its comment field.

The component is external to the parent in the target implementation to which it was assigned in the source implementation. Therefore, when authoring the identifier of the component do not precede it with its source parent membership information.

In general this flag specifies whether the component needs to be initialized by the author in the target code. For control arrays, when the analyser detects an explicit reference to the control array in any subprogram code, it sets this flag for the control. When used with an argument it will add the optional default even if Select.OptionalArguments is off.

There is a user-defined or library-defined migClass that controls some aspect of the component.

The library was formed as via a translation of a VB6 project within the migration set as opposed to being formed directly from an IDL file.

References to the component should be removed as opposed to deleting and statements that reference the component. This is used primarily for subprograms and subprogram arguments.

This flag is deprecated and not currently used, though references to it may still exist in older reference files.

This flag is used with subprograms. It indicates that an argument should be added to the argument list in the target translation.

The surface form pattern associated with the component should be used when it is referenced, not when it is translated.

For components that are used to satisfy Implementation requirements, this flag forces the component to have the attributes as specified in the interface as opposed to as specified in the user code. When applied to classes whose identifiers match those of control classes within the internal VB6 language description, this flag indicates that the internal description should be overridden.

Set by the analyser to mark property setters and/or getters that can be skipped.

The component is static in the target implementation and thus any New creations must be removed.

The component is a class whose instances should be checked against DbNull as opposed to Null.

The component must be corrected in the target. References to it are commented out and adorned using "#if !DEBUG\n\t#error \sUPGRADE ISSUE: %1d was not upgraded.\s\n#endif\n"

The component class objects cannot be created. When declaring objects of this class simply NULL them as opposed to using new to create an instance.

The library component has been referenced as a singleton, without any class or parent designation. This may be an incorrect reference that has to be repaired.

Any code associated with the component should be ignored but a stub for the component should still be declared.

The subprogram component requires the Override specification when it is declared.

The component does not require type casts when setting its values.

This flag is used by the author to mark those components that are actually referenced and that need to be included when authoring a wrapper.

The library component has been used as a singleton, without any class or parent designation. This usage may be incorrect and in need of repair.

The component is an application wide singleton object which requires that special AppObject code be authored for it.

The component is two-dimensional but should be authored as a array of arrays -- e.g. [][] -- as opposed to [,].

The interface component is a module as opposed to a class, so its members may be referenced as singletons.

The class or interface component is implemented by another class in the current migration group.

The coclass component is a control which can appear on a form; consequently there are special Ax naming conventions that must be used.

The component should be treated as though it were an ActiveX control.

This deprecated flag is used by the compiler when it encounters a potential late binding to this component. It checks if that late binding could be resolved if the reference were boxed to one of several types. If so do it, if not do the late binding. The CallByName refactoring statement provides an extensive facility for dealing with late bindings.

This indicates a library component should be authored with public visibility.  

When the main analyser logic encounters a reference to the VB6 function AddressOf then it must determine if the use of the AddressOf call is to establish a CallBack. If so then it marks both the method that is the callback and the argument receiving the AddressOf with the CallBack flag so that they can be dealt with properly by the author.

This is not set internally only via refactoring statements. It is used by the analyser to decrement subscripted references to components with this flag set.

When coclasses that were ActiveX controls are declared they are marked with this flag. It is used by the author to indicate the need to inherit from the Control class.

This flag is attributable to classes and coclasses. It indicates that the component is used in ForEach and must, therefore, implement IEnumerable.

This attribute is a flag attributable to members whose On entry indicates that they are being called directly within the code; therefore, their wrapper class requires a constructor.

This attribute is a flag attributable to the library whose On entry indicates that a referenced component within the class has a collection type; therefore, the library stub must import VBNET = Microsoft.VisualBasic.

This attribute is a flag attributable to event handlers whose On entry indicates that they have arguments.

This attribute is attributed to library methods to indicate that they are being used to set a property value and thus need a Let.

When the compiler notes that a component is being used to implement a separate component it marks the implementing component with this flag.

'Shadows' is yet another alternative to 'Overrides' and 'Overloads'. The 'Shadows' keyword indicates that a declared programming element shadows, or hides, an identically named element, or set of overloaded elements, in a base class. You can shadow any kind of declared element with any other kind. The purpose of shadowing is to protect the definition of the class members. It is used with Class, Const, Declare, Delegate, Dim, Enum, Event, Function, Interface, Property, Structure, and Sub Statements.

This attribute tells the property bag processor of to look for BeginProperty and NameValue pairs for this component.

This attribute tells the analyser to turn off the "On Error Resume Next" to try-catch conversions for a particular subprogram. The algorithms used here are fairly robust, but can never be perfect. Specific codes may well encounter problems that are best dealt with by simply turning the algorithms off.

This attribute tells the analyser to turn off the "On Error Goto" to try-catch conversions for a particular subprogram. The algorithms used here are fairly robust, but specific codes may well encounter problems that are best dealt with by simply turning the algorithms off.

The component requires the Overloads adornment when it is declared within VB.NET as a subprogram. When applied to a parameter, it means that the parameter is an optional argument whose value must be supplied when the subprogram containing it is declared.

Indicates that the code associated with a code unit has already been analysed.

Indicates that the type of a component has been inferred.

Indicates that a component is in an interface

First if Option Base = 1, the pass1 compiler marks those variables that have explicit dimensions as having OptionBase1 subscripts; Second, the final pass of the analyser looks for references to the LBound and UBound functions applied to the variables marked and adjusts them by adding 1; Third, the author of the subscripts makes the appropriate adjustment to the dimension value in the declaration of the marked variables.

This attribute is applies to an ASP page once it has been processed by the Fix logic. Once this flag is set the page is skipped if it appears in a subsequent pageslice.

Indicates that a quantity of type Variant or Object should not be type inferred.

This attribute is applied to subprograms. It blocks the formation of a TempArg when converting a Select into an If.

Indicates that a quantity has had its array status inferred based on a reference to it in the code.

Only public symbols in classes are exposed in VB6 however in .NET module components can be exposed as well. The SharedFile logic marks these components accordingly.

Not used

Some value bearing components like members of structures, even in an indexed context, can not be passed by reference. This flag is used to indicate this.

When a refactoring specification for an external component encounters gmSL code it scans that code for transform methods. Any component for which a transform method is found is has its HasCodeHandler flag set true and has its migTransform method set equal to the root offset of the handling user code method.

This attribute is set true via the refactoring FixType statement. It applies to subprogram parameters and means that any argument passed to this parameter should have the parameter type enforced on it as opposed to doing any type inference.

This attribute is set true via the refactoring Migrate statement. It applies to library components that have setters. If the attribute is True then the setter is treated as having type Variant or object regardless of any type associated with the component. It also blocks any type inferences for the component that might be derived from a strongly typed set to it.

This attribute is set within the processing of Property statements in external classes. It indicates that the old GetSetLet syntax was used to define those patterns. The pattern capabilities were extended to use a generalize pattern syntax and this flag blocks a migration that does not apply to the older form.

This attribute is set true via the refactoring Remove statement. It tells the author that rather than stubbing out the code the code should be removed by surrounding it with conditional statements.

This attribute is set true via the ImplicitByRef attribute on the library declaration statement. When it is on, the tool assumes that the .NET compiler will be handling ref arguments implicitly. For the purposes of ByRef optimization, the analyzer will still treat ref arguments as ByRef, but it will not generate temporary arguments.

byte, Byte

short, Short

int, Integer

long, Long

decimal, Decimal

float, Single

double, Double

string, String

bool, Boolean