Representing Type Information in a Compiler and Programming Tools Framework

1. A method, implemented at least in part by a computing device comprising a processing unit and memory, of representing type information for a typed intermediate language via objects of classes in a class hierarchy, wherein the class hierarchy comprises at least one class and a plurality of sub-classes for representing different type classifications, the method comprising: with the computing device: instantiating one or more objects of one or more of the sub-classes of the hierarchy, wherein the one or more sub-classes represent classifications of types for the typed intermediate language; and storing information in the one or more objects; wherein the typed intermediate language is capable of representing a plurality of different programming languages, and wherein the one or more objects represent type information for instructions in the typed intermediate language; wherein the classifications of types comprises a primitive type associated with a primitive type size, and wherein the primitive type size is settable to represent a constant size, the primitive type size is settable to represent a symbolic size, and the primitive type size is settable to represent an unknown size; and wherein one of the sub-classes representing a primitive type represents an unknown type, wherein the unknown type can represent any type, wherein the unknown type represents a lack of all type information, wherein a compiler drops type information by changing a known type to the unknown type during a stage of lowering, wherein the unknown type is set independently of the primitive type size, and wherein the classifications of types support an unknown type with an unknown primitive type size.

2. The method of claim 1 wherein at least one of the objects comprises information for a size of a type represented by the object.

3. The method of claim 1 wherein at least one of the one or more sub-classes inherits from an abstract type that wraps an externally defined type, the abstract type providing a mapping from the typed intermediate language to original source code.

4. The method of claim 1 wherein at least one of the one or more sub-classes represents container types.

5. The method of claim 1 wherein at least one of the one or more sub-classes represents pointer types.

6. The method of claim 1 wherein at least one of the one or more sub-classes represents function types.

7. The method of claim 1 wherein at least one of the one or more sub-classes represents unmanaged array types.

8. The method of claim 1 wherein at least one of the one or more sub-classes represents class types.

9. The method of claim 1 wherein at least one of the one or more sub-classes represents managed array types.

10. The method of claim 1 wherein at least one of the one or more sub-classes represents struct types.

11. The method of claim 1 wherein at least one of the one or more sub-classes represents interface types.

12. The method of claim 1 wherein at least one of the one or more sub-classes represents enumerated types.

13. The method of claim 1 wherein at least one of the sub-classes representing primitive types represents the following types: int, float, and void.

14. The method of claim 1 wherein at least one of the sub-classes representing primitive types is extensible to represent one or more additional primitive types.

15. The method of claim 1 wherein at least one of the one or more sub-classes is defined from the group consisting of: ‘ContainerType’, ‘PtrType’, ‘FuncType’, ‘ClassType’, ‘StructType’, ‘InterfaceType’, and ‘EnumType’.

16. The method of claim 1 wherein at least one of the one or more sub-classes is defined as ‘PrimType’.

17. A computer-readable medium storing a software program thereon, the program comprising computer executable instructions for implementing a method for representing type information for a typed intermediate language using a class hierarchy for representing different type classifications, the method comprising: defining a programming class of the class hierarchy as ‘PrimType’, wherein the programming class represents primitive type information for the typed intermediate language; associating a size with instances of the ‘PrimType’ class, wherein the size is settable to represent an actual size of instances of the ‘PrimType’ class, settable to represent a symbolic size of instances of the ‘PrimType’ class, and settable to represent an unknown size of instances of the ‘PrimType’ class, and wherein the actual size and the symbolic size are defined as a number of bits; and associating a kind of type with instances of the ‘PrimType’ class; wherein the class ‘PrimType’ represents a plurality of types comprising at least an unknown type, wherein the unknown type can represent any type, wherein the unknown type represents a lack of all type information, wherein a compiler drops type information during compilation by changing a known type to the unknown type, in the typed intermediate language, during a stage of lowering, wherein the unknown type is set independently of the size, and wherein the ‘PrimType’ class supports an unknown type with an unknown size.

18. The computer-readable medium of claim 17 wherein the size represents a size of a machine representation of a value.

19. The computer-readable medium of claim 17 wherein the kind of type represents a type classification.

20. The computer-readable medium of claim 17 wherein associating a kind of primitive type with instances of the ‘PrimType’ class comprises defining the kind of type as ‘PrimTypekind’.

21. The computer-readable medium of claim 17 wherein associating a type of size with instances of the ‘PrimType’ class comprises defining the type of size as ‘SizeKind’.

22. The computer-readable medium of claim 17 wherein the class ‘PrimType’ further represents int, float, void, condition code, and unsigned int types.

23. A method, implemented at least in part by a computing device comprising a processing unit and memory, for representing type information for a typed intermediate language using a class hierarchy by programmatically defining a type representation, the method comprising: with the computing device: defining a base class of the class hierarchy; defining a plurality of classes hierarchically below the base class, wherein the plurality of classes represent type information for the typed intermediate language, and wherein the plurality of classes represent at least pointer types, container types and function types of a plurality of programming languages, and wherein the plurality of classes further comprise primitive types and the primitive types are associated with a primitive type size settable to represent a constant size, settable to represent a symbolic size, and settable to represent an unknown size; wherein one of the primitive types represents an unknown type, wherein the unknown type can represent any type, wherein the unknown type represents a lack of all type information, wherein a compiler drops type information by changing a known type to the unknown type during a stage of lowering, wherein the unknown type is set independently of the primitive type size, and wherein the plurality of classes support an unknown type with an unknown primitive type size.

24. The method of claim 23 further comprising defining a plurality of classes hierarchically below the class representing container types, wherein the plurality of classes represent type information for the typed intermediate language, and wherein the plurality of classes represent at least class types, struct types, interface types, and enumerated types of a plurality of programming languages.

25. The method of claim 24 further comprising defining a class hierarchically below the class representing class types, wherein the class represents type information for the typed intermediate language, and wherein the class represents unmanaged array types of a plurality of programming languages.

26. The method of claim 23 further comprising defining a class hierarchically below one of the plurality of classes, wherein the class represents type information for the typed intermediate language.

27. A computer-readable medium storing a software program thereon, the program comprising computer executable instructions for implementing a method for representing type information for a typed intermediate language using a class hierarchy for representing different type classifications, the method comprising: defining a programming class of the class hierarchy as ‘ContainerType’, wherein an object of class ‘ContainerType’ is a type representation for the typed intermediate language for container types in a section of code written in one of a plurality of programming languages; defining a programming class of the class hierarchy as ‘PtrType’, wherein an object of class ‘PtrType’ is a type representation for the typed intermediate language for pointer types in a section of code written in one of a plurality of programming languages; defining a programming class of the class hierarchy as ‘FuncType’, wherein an object of class ‘FuncType’ is a type representation for the typed intermediate language for function types in a section of code written in one of a plurality of programming languages; defining a programming class of the class hierarchy as ‘ClassType’, wherein an object of class ‘ClassType’ is a type representation for the typed intermediate language for class types in a section of code written in one of a plurality of programming languages; defining a programming class of the class hierarchy as ‘StructType’, wherein an object of class ‘StructType’ is a type representation for the typed intermediate language for struct types in a section of code written in one of a plurality of programming languages; defining a programming class of the class hierarchy as ‘InterfaceType’, wherein an object of class ‘InterfaceType’ is a type representation for the typed intermediate language for interface types in a section of code written in one of a plurality of programming languages; defining a programming class of the class hierarchy as ‘EnumType’, wherein an object of class ‘EnumType’ is a type representation for the typed intermediate language for enumerated types in a section of code written in one of a plurality of programming languages; and defining a programming class of the class hierarchy as ‘PrimType’, wherein an object of class ‘PrimType’ is a type representation for the typed intermediate language for primitive types in a section of code written in one of a plurality of programming languages; wherein the object of class ‘PrimType’ is associated with a size settable to represent a constant size for the object of class ‘PrimType’, settable to represent a symbolic size for the object of class ‘PrimType’, and settable to represent an unknown size for the object of class ‘PrimType’; and wherein the class ‘PrimType’ represents a plurality of types comprising at least an unknown type, wherein the unknown type can represent any type, wherein the unknown type represents a lack of all type information, wherein a compiler drops type information by changing a known type to the unknown type during a stage of lowering, wherein the unknown type is set independently of the size, and wherein the ‘PrimType’ class supports an unknown type with an unknown size.

28. The computer-readable medium storing a software program thereon, the program comprising computer executable instructions for implementing a method, of claim 27 wherein the method further comprises program code for associating a size with an object of any class.

29. The computer-readable medium storing a software program thereon, the program comprising computer executable instructions for implementing a method, of claim 27 wherein the method further comprises program code for associating a kind of type with an object of any class.