The Labs \ Source Viewer \ SSCLI \ Microsoft.JScript \ TypeReference

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. namespace Microsoft.JScript
  16. {
  17.     using System;
  18.     using System.Reflection;
  19.     using Microsoft.JScript.Vsa;
  20.    
  21.     internal sealed class TypeReferences
  22.     {
  23.         internal TypeReferences(Module jscriptReferenceModule)
  24.         {
  25.             this._jscriptReferenceModule = jscriptReferenceModule;
  26.             this._typeTable = new Type[(int)TypeReferenceArrayLength];
  27.         }
  28.        
  29.         // PREDEFINED TYPES
  30.         // GetPredefinedType uses the following mapping of predefined type names to actual types.
  31.         // Note that types in mscorlib live in both the execution and reflection only loader
  32.         // contexts and thus do not have to be mapped via GetTypeReference.
  33.         private static readonly SimpleHashtable _predefinedTypeTable = new SimpleHashtable(34);
  34.        
  35.         internal Type GetPredefinedType(string typeName)
  36.         {
  37.             object value = TypeReferences._predefinedTypeTable[typeName];
  38.             Type predefinedType = value as Type;
  39.             if (predefinedType == null) {
  40.                 if (value is TypeReference)
  41.                     predefinedType = this.GetTypeReference((TypeReference)value);
  42.             }
  43.             return predefinedType;
  44.         }
  45.        
  46.         static TypeReferences()
  47.         {
  48.             _predefinedTypeTable["boolean"] = typeof(bool);
  49.             _predefinedTypeTable["byte"] = typeof(byte);
  50.             _predefinedTypeTable["char"] = typeof(char);
  51.             _predefinedTypeTable["decimal"] = typeof(decimal);
  52.             _predefinedTypeTable["double"] = typeof(double);
  53.             _predefinedTypeTable["float"] = typeof(float);
  54.             _predefinedTypeTable["int"] = typeof(int);
  55.             _predefinedTypeTable["long"] = typeof(long);
  56.             _predefinedTypeTable["sbyte"] = typeof(sbyte);
  57.             _predefinedTypeTable["short"] = typeof(short);
  58.             _predefinedTypeTable["void"] = typeof(void);
  59.             _predefinedTypeTable["uint"] = typeof(uint);
  60.             _predefinedTypeTable["ulong"] = typeof(ulong);
  61.             _predefinedTypeTable["ushort"] = typeof(ushort);
  62.            
  63.             _predefinedTypeTable["ActiveXObject"] = typeof(object);
  64.             _predefinedTypeTable["Boolean"] = typeof(bool);
  65.             _predefinedTypeTable["Number"] = typeof(double);
  66.             _predefinedTypeTable["Object"] = typeof(object);
  67.             _predefinedTypeTable["String"] = typeof(string);
  68.             _predefinedTypeTable["Type"] = typeof(System.Type);
  69.            
  70.             _predefinedTypeTable["Array"] = TypeReference.ArrayObject;
  71.             _predefinedTypeTable["Date"] = TypeReference.DateObject;
  72.             _predefinedTypeTable["Enumerator"] = TypeReference.EnumeratorObject;
  73.             _predefinedTypeTable["Error"] = TypeReference.ErrorObject;
  74.             _predefinedTypeTable["EvalError"] = TypeReference.EvalErrorObject;
  75.             _predefinedTypeTable["Function"] = TypeReference.ScriptFunction;
  76.             _predefinedTypeTable["RangeError"] = TypeReference.RangeErrorObject;
  77.             _predefinedTypeTable["ReferenceError"] = TypeReference.ReferenceErrorObject;
  78.             _predefinedTypeTable["RegExp"] = TypeReference.RegExpObject;
  79.             _predefinedTypeTable["SyntaxError"] = TypeReference.SyntaxErrorObject;
  80.             _predefinedTypeTable["TypeError"] = TypeReference.TypeErrorObject;
  81.             _predefinedTypeTable["URIError"] = TypeReference.URIErrorObject;
  82.             _predefinedTypeTable["VBArray"] = TypeReference.VBArrayObject;
  83.         }
  84.        
  85.        
  86.        
  87.         // TYPE AND MEMBER REFERENCES
  88.         private Type[] _typeTable;
  89.         // Size is TypeReference.Length
  90.         private Module _jscriptReferenceModule;
  91.         private Module JScriptReferenceModule {
  92.             get { return this._jscriptReferenceModule; }
  93.         }
  94.        
  95.        
  96.         // Get the type associated with the TypeReference.
  97.         private Type GetTypeReference(TypeReference typeRef)
  98.         {
  99.             Type type = this._typeTable[(int)typeRef];
  100.             if (null == type) {
  101.                 string prefix = "Microsoft.JScript.";
  102.                 if ((int)typeRef >= TypeReferenceStartOfSpecialCases) {
  103.                     // Special Cases
  104.                     switch (typeRef) {
  105.                         case TypeReference.BaseVsaStartup:
  106.                             prefix = "Microsoft.Vsa.";
  107.                             break;
  108.                         case TypeReference.VsaEngine:
  109.                             prefix = "Microsoft.JScript.Vsa.";
  110.                             break;
  111.                     }
  112.                 }
  113.                
  114.                 type = this.JScriptReferenceModule.GetType(prefix + System.Enum.GetName(typeof(TypeReference), (int)typeRef));
  115.                 this._typeTable[(int)typeRef] = type;
  116.             }
  117.             return type;
  118.         }
  119.        
  120.         // This is the first value in TypeReference which is handled specially by GetTypeReference.
  121.         private const int TypeReferenceStartOfSpecialCases = (int)TypeReference.BaseVsaStartup;
  122.         private const int TypeReferenceArrayLength = (int)TypeReference.VsaEngine + 1;
  123.        
  124.         private enum TypeReference
  125.         {
  126.             // GetTypeReference will get prepended with "Microsoft.JScript." to generate the full type name.
  127.             ArgumentsObject,
  128.             ArrayConstructor,
  129.             ArrayObject,
  130.             ArrayWrapper,
  131.             Binding,
  132.             BitwiseBinary,
  133.             BooleanObject,
  134.             BreakOutOfFinally,
  135.             BuiltinFunction,
  136.             ClassScope,
  137.             Closure,
  138.             ContinueOutOfFinally,
  139.             Convert,
  140.             DateObject,
  141.             Empty,
  142.             EnumeratorObject,
  143.             Equality,
  144.             ErrorObject,
  145.             Eval,
  146.             EvalErrorObject,
  147.             Expando,
  148.             FieldAccessor,
  149.             ForIn,
  150.             FunctionDeclaration,
  151.             FunctionExpression,
  152.             FunctionObject,
  153.             FunctionWrapper,
  154.             GlobalObject,
  155.             GlobalScope,
  156.             Globals,
  157.             Hide,
  158.             IActivationObject,
  159.             INeedEngine,
  160.             Import,
  161.             In,
  162.             Instanceof,
  163.             JSError,
  164.             JSFunctionAttribute,
  165.             JSFunctionAttributeEnum,
  166.             JSLocalField,
  167.             JSObject,
  168.             JScriptException,
  169.             LateBinding,
  170.             LenientGlobalObject,
  171.             MathObject,
  172.             MethodInvoker,
  173.             Missing,
  174.             Namespace,
  175.             NotRecommended,
  176.             NumberObject,
  177.             NumericBinary,
  178.             NumericUnary,
  179.             ObjectConstructor,
  180.             Override,
  181.             Package,
  182.             Plus,
  183.             PostOrPrefixOperator,
  184.             RangeErrorObject,
  185.             ReferenceAttribute,
  186.             ReferenceErrorObject,
  187.             RegExpConstructor,
  188.             RegExpObject,
  189.             Relational,
  190.             ReturnOutOfFinally,
  191.             Runtime,
  192.             ScriptFunction,
  193.             ScriptObject,
  194.             ScriptStream,
  195.             SimpleHashtable,
  196.             StackFrame,
  197.             StrictEquality,
  198.             StringObject,
  199.             SyntaxErrorObject,
  200.             Throw,
  201.             Try,
  202.             TypedArray,
  203.             TypeErrorObject,
  204.             Typeof,
  205.             URIErrorObject,
  206.             VBArrayObject,
  207.             With,
  208.            
  209.             // GetTypeReference has a switch to check for the special cases that follow.
  210.             BaseVsaStartup,
  211.             VsaEngine
  212.         }
  213.        
  214.         // [Microsoft.JScript]Microsoft.JScript
  215.         internal Type ArgumentsObject {
  216.             get { return GetTypeReference(TypeReference.ArgumentsObject); }
  217.         }
  218.         internal Type ArrayConstructor {
  219.             get { return GetTypeReference(TypeReference.ArrayConstructor); }
  220.         }
  221.         internal Type ArrayObject {
  222.             get { return GetTypeReference(TypeReference.ArrayObject); }
  223.         }
  224.         internal Type ArrayWrapper {
  225.             get { return GetTypeReference(TypeReference.ArrayWrapper); }
  226.         }
  227.         internal Type BaseVsaStartup {
  228.             get { return GetTypeReference(TypeReference.BaseVsaStartup); }
  229.         }
  230.         internal Type Binding {
  231.             get { return GetTypeReference(TypeReference.Binding); }
  232.         }
  233.         internal Type BitwiseBinary {
  234.             get { return GetTypeReference(TypeReference.BitwiseBinary); }
  235.         }
  236.         internal Type BooleanObject {
  237.             get { return GetTypeReference(TypeReference.BooleanObject); }
  238.         }
  239.         internal Type BreakOutOfFinally {
  240.             get { return GetTypeReference(TypeReference.BreakOutOfFinally); }
  241.         }
  242.         internal Type BuiltinFunction {
  243.             get { return GetTypeReference(TypeReference.BuiltinFunction); }
  244.         }
  245.         internal Type ClassScope {
  246.             get { return GetTypeReference(TypeReference.ClassScope); }
  247.         }
  248.         internal Type Closure {
  249.             get { return GetTypeReference(TypeReference.Closure); }
  250.         }
  251.         internal Type ContinueOutOfFinally {
  252.             get { return GetTypeReference(TypeReference.ContinueOutOfFinally); }
  253.         }
  254.         internal Type Convert {
  255.             get { return GetTypeReference(TypeReference.Convert); }
  256.         }
  257.         internal Type DateObject {
  258.             get { return GetTypeReference(TypeReference.DateObject); }
  259.         }
  260.         internal Type Empty {
  261.             get { return GetTypeReference(TypeReference.Empty); }
  262.         }
  263.         internal Type EnumeratorObject {
  264.             get { return GetTypeReference(TypeReference.EnumeratorObject); }
  265.         }
  266.         internal Type Equality {
  267.             get { return GetTypeReference(TypeReference.Equality); }
  268.         }
  269.         internal Type ErrorObject {
  270.             get { return GetTypeReference(TypeReference.ErrorObject); }
  271.         }
  272.         internal Type Eval {
  273.             get { return GetTypeReference(TypeReference.Eval); }
  274.         }
  275.         internal Type EvalErrorObject {
  276.             get { return GetTypeReference(TypeReference.EvalErrorObject); }
  277.         }
  278.         internal Type Expando {
  279.             get { return GetTypeReference(TypeReference.Expando); }
  280.         }
  281.         internal Type FieldAccessor {
  282.             get { return GetTypeReference(TypeReference.FieldAccessor); }
  283.         }
  284.         internal Type ForIn {
  285.             get { return GetTypeReference(TypeReference.ForIn); }
  286.         }
  287.         internal Type FunctionDeclaration {
  288.             get { return GetTypeReference(TypeReference.FunctionDeclaration); }
  289.         }
  290.         internal Type FunctionExpression {
  291.             get { return GetTypeReference(TypeReference.FunctionExpression); }
  292.         }
  293.         internal Type FunctionObject {
  294.             get { return GetTypeReference(TypeReference.FunctionObject); }
  295.         }
  296.         internal Type FunctionWrapper {
  297.             get { return GetTypeReference(TypeReference.FunctionWrapper); }
  298.         }
  299.         internal Type GlobalObject {
  300.             get { return GetTypeReference(TypeReference.GlobalObject); }
  301.         }
  302.         internal Type GlobalScope {
  303.             get { return GetTypeReference(TypeReference.GlobalScope); }
  304.         }
  305.         internal Type Globals {
  306.             get { return GetTypeReference(TypeReference.Globals); }
  307.         }
  308.         internal Type Hide {
  309.             get { return GetTypeReference(TypeReference.Hide); }
  310.         }
  311.         internal Type IActivationObject {
  312.             get { return GetTypeReference(TypeReference.IActivationObject); }
  313.         }
  314.         internal Type INeedEngine {
  315.             get { return GetTypeReference(TypeReference.INeedEngine); }
  316.         }
  317.         internal Type Import {
  318.             get { return GetTypeReference(TypeReference.Import); }
  319.         }
  320.         internal Type In {
  321.             get { return GetTypeReference(TypeReference.In); }
  322.         }
  323.         internal Type Instanceof {
  324.             get { return GetTypeReference(TypeReference.Instanceof); }
  325.         }
  326.         internal Type JSError {
  327.             get { return GetTypeReference(TypeReference.JSError); }
  328.         }
  329.         internal Type JSFunctionAttribute {
  330.             get { return GetTypeReference(TypeReference.JSFunctionAttribute); }
  331.         }
  332.         internal Type JSFunctionAttributeEnum {
  333.             get { return GetTypeReference(TypeReference.JSFunctionAttributeEnum); }
  334.         }
  335.         internal Type JSLocalField {
  336.             get { return GetTypeReference(TypeReference.JSLocalField); }
  337.         }
  338.         internal Type JSObject {
  339.             get { return GetTypeReference(TypeReference.JSObject); }
  340.         }
  341.         internal Type JScriptException {
  342.             get { return GetTypeReference(TypeReference.JScriptException); }
  343.         }
  344.         internal Type LateBinding {
  345.             get { return GetTypeReference(TypeReference.LateBinding); }
  346.         }
  347.         internal Type LenientGlobalObject {
  348.             get { return GetTypeReference(TypeReference.LenientGlobalObject); }
  349.         }
  350.         internal Type MathObject {
  351.             get { return GetTypeReference(TypeReference.MathObject); }
  352.         }
  353.         internal Type MethodInvoker {
  354.             get { return GetTypeReference(TypeReference.MethodInvoker); }
  355.         }
  356.         internal Type Missing {
  357.             get { return GetTypeReference(TypeReference.Missing); }
  358.         }
  359.         internal Type Namespace {
  360.             get { return GetTypeReference(TypeReference.Namespace); }
  361.         }
  362.         internal Type NotRecommended {
  363.             get { return GetTypeReference(TypeReference.NotRecommended); }
  364.         }
  365.         internal Type NumberObject {
  366.             get { return GetTypeReference(TypeReference.NumberObject); }
  367.         }
  368.         internal Type NumericBinary {
  369.             get { return GetTypeReference(TypeReference.NumericBinary); }
  370.         }
  371.         internal Type NumericUnary {
  372.             get { return GetTypeReference(TypeReference.NumericUnary); }
  373.         }
  374.         internal Type ObjectConstructor {
  375.             get { return GetTypeReference(TypeReference.ObjectConstructor); }
  376.         }
  377.         internal Type Override {
  378.             get { return GetTypeReference(TypeReference.Override); }
  379.         }
  380.         internal Type Package {
  381.             get { return GetTypeReference(TypeReference.Package); }
  382.         }
  383.         internal Type Plus {
  384.             get { return GetTypeReference(TypeReference.Plus); }
  385.         }
  386.         internal Type PostOrPrefixOperator {
  387.             get { return GetTypeReference(TypeReference.PostOrPrefixOperator); }
  388.         }
  389.         internal Type RangeErrorObject {
  390.             get { return GetTypeReference(TypeReference.RangeErrorObject); }
  391.         }
  392.         internal Type ReferenceAttribute {
  393.             get { return GetTypeReference(TypeReference.ReferenceAttribute); }
  394.         }
  395.         internal Type ReferenceErrorObject {
  396.             get { return GetTypeReference(TypeReference.ReferenceErrorObject); }
  397.         }
  398.         internal Type RegExpConstructor {
  399.             get { return GetTypeReference(TypeReference.RegExpConstructor); }
  400.         }
  401.         internal Type RegExpObject {
  402.             get { return GetTypeReference(TypeReference.RegExpObject); }
  403.         }
  404.         internal Type Relational {
  405.             get { return GetTypeReference(TypeReference.Relational); }
  406.         }
  407.         internal Type ReturnOutOfFinally {
  408.             get { return GetTypeReference(TypeReference.ReturnOutOfFinally); }
  409.         }
  410.         internal Type Runtime {
  411.             get { return GetTypeReference(TypeReference.Runtime); }
  412.         }
  413.         internal Type ScriptFunction {
  414.             get { return GetTypeReference(TypeReference.ScriptFunction); }
  415.         }
  416.         internal Type ScriptObject {
  417.             get { return GetTypeReference(TypeReference.ScriptObject); }
  418.         }
  419.         internal Type ScriptStream {
  420.             get { return GetTypeReference(TypeReference.ScriptStream); }
  421.         }
  422.         internal Type SimpleHashtable {
  423.             get { return GetTypeReference(TypeReference.SimpleHashtable); }
  424.         }
  425.         internal Type StackFrame {
  426.             get { return GetTypeReference(TypeReference.StackFrame); }
  427.         }
  428.         internal Type StrictEquality {
  429.             get { return GetTypeReference(TypeReference.StrictEquality); }
  430.         }
  431.         internal Type StringObject {
  432.             get { return GetTypeReference(TypeReference.StringObject); }
  433.         }
  434.         internal Type SyntaxErrorObject {
  435.             get { return GetTypeReference(TypeReference.SyntaxErrorObject); }
  436.         }
  437.         internal Type Throw {
  438.             get { return GetTypeReference(TypeReference.Throw); }
  439.         }
  440.         internal Type Try {
  441.             get { return GetTypeReference(TypeReference.Try); }
  442.         }
  443.         internal Type TypedArray {
  444.             get { return GetTypeReference(TypeReference.TypedArray); }
  445.         }
  446.         internal Type TypeErrorObject {
  447.             get { return GetTypeReference(TypeReference.TypeErrorObject); }
  448.         }
  449.         internal Type Typeof {
  450.             get { return GetTypeReference(TypeReference.Typeof); }
  451.         }
  452.         internal Type URIErrorObject {
  453.             get { return GetTypeReference(TypeReference.URIErrorObject); }
  454.         }
  455.         internal Type VBArrayObject {
  456.             get { return GetTypeReference(TypeReference.VBArrayObject); }
  457.         }
  458.         internal Type With {
  459.             get { return GetTypeReference(TypeReference.With); }
  460.         }
  461.         internal Type VsaEngine {
  462.             get { return GetTypeReference(TypeReference.VsaEngine); }
  463.         }
  464.        
  465.         // The types in mscorlib live in both the execution and reflection only loader contexts
  466.         // and thus do not need to be mapped.
  467.         internal Type Array {
  468.             get { return typeof(System.Array); }
  469.         }
  470.         internal Type Attribute {
  471.             get { return typeof(System.Attribute); }
  472.         }
  473.         internal Type AttributeUsageAttribute {
  474.             get { return typeof(System.AttributeUsageAttribute); }
  475.         }
  476.         internal Type Byte {
  477.             get { return typeof(byte); }
  478.         }
  479.         internal Type Boolean {
  480.             get { return typeof(bool); }
  481.         }
  482.         internal Type Char {
  483.             get { return typeof(char); }
  484.         }
  485.         internal Type CLSCompliantAttribute {
  486.             get { return typeof(System.CLSCompliantAttribute); }
  487.         }
  488.         internal Type ContextStaticAttribute {
  489.             get { return typeof(System.ContextStaticAttribute); }
  490.         }
  491.         internal Type DateTime {
  492.             get { return typeof(System.DateTime); }
  493.         }
  494.         internal Type DBNull {
  495.             get { return typeof(System.DBNull); }
  496.         }
  497.         internal Type Delegate {
  498.             get { return typeof(System.Delegate); }
  499.         }
  500.         internal Type Decimal {
  501.             get { return typeof(decimal); }
  502.         }
  503.         internal Type Double {
  504.             get { return typeof(double); }
  505.         }
  506.         internal Type Enum {
  507.             get { return typeof(System.Enum); }
  508.         }
  509.         internal Type Exception {
  510.             get { return typeof(System.Exception); }
  511.         }
  512.         internal Type IConvertible {
  513.             get { return typeof(System.IConvertible); }
  514.         }
  515.         internal Type IntPtr {
  516.             get { return typeof(System.IntPtr); }
  517.         }
  518.         internal Type Int16 {
  519.             get { return typeof(short); }
  520.         }
  521.         internal Type Int32 {
  522.             get { return typeof(int); }
  523.         }
  524.         internal Type Int64 {
  525.             get { return typeof(long); }
  526.         }
  527.         internal Type Object {
  528.             get { return typeof(object); }
  529.         }
  530.         internal Type ObsoleteAttribute {
  531.             get { return typeof(System.ObsoleteAttribute); }
  532.         }
  533.         internal Type ParamArrayAttribute {
  534.             get { return typeof(System.ParamArrayAttribute); }
  535.         }
  536.         internal Type RuntimeTypeHandle {
  537.             get { return typeof(System.RuntimeTypeHandle); }
  538.         }
  539.         internal Type SByte {
  540.             get { return typeof(sbyte); }
  541.         }
  542.         internal Type Single {
  543.             get { return typeof(float); }
  544.         }
  545.         internal Type String {
  546.             get { return typeof(string); }
  547.         }
  548.         internal Type Type {
  549.             get { return typeof(System.Type); }
  550.         }
  551.         internal Type TypeCode {
  552.             get { return typeof(System.TypeCode); }
  553.         }
  554.         internal Type UIntPtr {
  555.             get { return typeof(System.UIntPtr); }
  556.         }
  557.         internal Type UInt16 {
  558.             get { return typeof(ushort); }
  559.         }
  560.         internal Type UInt32 {
  561.             get { return typeof(uint); }
  562.         }
  563.         internal Type UInt64 {
  564.             get { return typeof(ulong); }
  565.         }
  566.         internal Type ValueType {
  567.             get { return typeof(System.ValueType); }
  568.         }
  569.         internal Type Void {
  570.             get { return typeof(void); }
  571.         }
  572.        
  573.         internal Type IEnumerable {
  574.             get { return typeof(System.Collections.IEnumerable); }
  575.         }
  576.         internal Type IEnumerator {
  577.             get { return typeof(System.Collections.IEnumerator); }
  578.         }
  579.         internal Type IList {
  580.             get { return typeof(System.Collections.IList); }
  581.         }
  582.        
  583.         internal Type Debugger {
  584.             get { return typeof(System.Diagnostics.Debugger); }
  585.         }
  586.         internal Type DebuggableAttribute {
  587.             get { return typeof(System.Diagnostics.DebuggableAttribute); }
  588.         }
  589.         internal Type DebuggerHiddenAttribute {
  590.             get { return typeof(System.Diagnostics.DebuggerHiddenAttribute); }
  591.         }
  592.         internal Type DebuggerStepThroughAttribute {
  593.             get { return typeof(System.Diagnostics.DebuggerStepThroughAttribute); }
  594.         }
  595.        
  596.         internal Type DefaultMemberAttribute {
  597.             get { return typeof(System.Reflection.DefaultMemberAttribute); }
  598.         }
  599.         internal Type EventInfo {
  600.             get { return typeof(System.Reflection.EventInfo); }
  601.         }
  602.         internal Type FieldInfo {
  603.             get { return typeof(System.Reflection.FieldInfo); }
  604.         }
  605.        
  606.         internal Type CompilerGlobalScopeAttribute {
  607.             get { return typeof(System.Runtime.CompilerServices.CompilerGlobalScopeAttribute); }
  608.         }
  609.         internal Type RequiredAttributeAttribute {
  610.             get { return typeof(System.Runtime.CompilerServices.RequiredAttributeAttribute); }
  611.         }
  612.        
  613.         internal Type IExpando {
  614.             get { return typeof(System.Runtime.InteropServices.Expando.IExpando); }
  615.         }
  616.        
  617.         internal Type CodeAccessSecurityAttribute {
  618.             get { return typeof(System.Security.Permissions.CodeAccessSecurityAttribute); }
  619.         }
  620.         internal Type AllowPartiallyTrustedCallersAttribute {
  621.             get { return typeof(System.Security.AllowPartiallyTrustedCallersAttribute); }
  622.         }
  623.        
  624.         // Special cases where name isn't exactly the unqualified type name.
  625.         internal Type ArrayOfObject {
  626.             get { return typeof(object[]); }
  627.         }
  628.         internal Type ArrayOfString {
  629.             get { return typeof(string[]); }
  630.         }
  631.         internal Type SystemConvert {
  632.             get { return typeof(System.Convert); }
  633.         }
  634.         internal Type ReflectionMissing {
  635.             get { return typeof(System.Reflection.Missing); }
  636.         }
  637.        
  638.         // Member infos
  639.         internal MethodInfo constructArrayMethod {
  640.             get { return this.ArrayConstructor.GetMethod("ConstructArray"); }
  641.         }
  642.         internal MethodInfo isMissingMethod {
  643.             get { return this.Binding.GetMethod("IsMissing"); }
  644.         }
  645.         internal ConstructorInfo bitwiseBinaryConstructor {
  646.             get { return this.BitwiseBinary.GetConstructor(new Type[] {this.Int32}); }
  647.         }
  648.         internal MethodInfo evaluateBitwiseBinaryMethod {
  649.             get { return this.BitwiseBinary.GetMethod("EvaluateBitwiseBinary"); }
  650.         }
  651.         internal ConstructorInfo breakOutOfFinallyConstructor {
  652.             get { return this.BreakOutOfFinally.GetConstructor(new Type[] {this.Int32}); }
  653.         }
  654.         internal ConstructorInfo closureConstructor {
  655.             get { return this.Closure.GetConstructor(new Type[] {this.FunctionObject}); }
  656.         }
  657.         internal ConstructorInfo continueOutOfFinallyConstructor {
  658.             get { return this.ContinueOutOfFinally.GetConstructor(new Type[] {this.Int32}); }
  659.         }
  660.         internal MethodInfo checkIfDoubleIsIntegerMethod {
  661.             get { return this.Convert.GetMethod("CheckIfDoubleIsInteger"); }
  662.         }
  663.         internal MethodInfo checkIfSingleIsIntegerMethod {
  664.             get { return this.Convert.GetMethod("CheckIfSingleIsInteger"); }
  665.         }
  666.         internal MethodInfo coerce2Method {
  667.             get { return this.Convert.GetMethod("Coerce2"); }
  668.         }
  669.         internal MethodInfo coerceTMethod {
  670.             get { return this.Convert.GetMethod("CoerceT"); }
  671.         }
  672.         internal MethodInfo throwTypeMismatch {
  673.             get { return this.Convert.GetMethod("ThrowTypeMismatch"); }
  674.         }
  675.         internal MethodInfo doubleToBooleanMethod {
  676.             get { return this.Convert.GetMethod("ToBoolean", new Type[] {this.Double}); }
  677.         }
  678.         internal MethodInfo toBooleanMethod {
  679.             get { return this.Convert.GetMethod("ToBoolean", new Type[] {this.Object, this.Boolean}); }
  680.         }
  681.         internal MethodInfo toForInObjectMethod {
  682.             get { return this.Convert.GetMethod("ToForInObject", new Type[] {this.Object, this.VsaEngine}); }
  683.         }
  684.         internal MethodInfo toInt32Method {
  685.             get { return this.Convert.GetMethod("ToInt32", new Type[] {this.Object}); }
  686.         }
  687.         internal MethodInfo toNativeArrayMethod {
  688.             get { return this.Convert.GetMethod("ToNativeArray"); }
  689.         }
  690.         internal MethodInfo toNumberMethod {
  691.             get { return this.Convert.GetMethod("ToNumber", new Type[] {this.Object}); }
  692.         }
  693.         internal MethodInfo toObjectMethod {
  694.             get { return this.Convert.GetMethod("ToObject", new Type[] {this.Object, this.VsaEngine}); }
  695.         }
  696.         internal MethodInfo toObject2Method {
  697.             get { return this.Convert.GetMethod("ToObject2", new Type[] {this.Object, this.VsaEngine}); }
  698.         }
  699.         internal MethodInfo doubleToStringMethod {
  700.             get { return this.Convert.GetMethod("ToString", new Type[] {this.Double}); }
  701.         }
  702.         internal MethodInfo toStringMethod {
  703.             get { return this.Convert.GetMethod("ToString", new Type[] {this.Object, this.Boolean}); }
  704.         }
  705.         internal FieldInfo undefinedField {
  706.             get { return this.Empty.GetField("Value"); }
  707.         }
  708.         internal ConstructorInfo equalityConstructor {
  709.             get { return this.Equality.GetConstructor(new Type[] {this.Int32}); }
  710.         }
  711.         internal MethodInfo evaluateEqualityMethod {
  712.             get { return this.Equality.GetMethod("EvaluateEquality", new Type[] {this.Object, this.Object}); }
  713.         }
  714.         internal MethodInfo jScriptEqualsMethod {
  715.             get { return this.Equality.GetMethod("JScriptEquals"); }
  716.         }
  717.         internal MethodInfo jScriptEvaluateMethod1 {
  718.             get { return this.Eval.GetMethod("JScriptEvaluate", new Type[] {this.Object, this.VsaEngine}); }
  719.         }
  720.         internal MethodInfo jScriptEvaluateMethod2 {
  721.             get { return this.Eval.GetMethod("JScriptEvaluate", new Type[] {this.Object, this.Object, this.VsaEngine}); }
  722.         }
  723.         internal MethodInfo jScriptGetEnumeratorMethod {
  724.             get { return this.ForIn.GetMethod("JScriptGetEnumerator"); }
  725.         }
  726.         internal MethodInfo jScriptFunctionDeclarationMethod {
  727.             get { return this.FunctionDeclaration.GetMethod("JScriptFunctionDeclaration"); }
  728.         }
  729.         internal MethodInfo jScriptFunctionExpressionMethod {
  730.             get { return this.FunctionExpression.GetMethod("JScriptFunctionExpression"); }
  731.         }
  732.         internal FieldInfo contextEngineField {
  733.             get { return this.Globals.GetField("contextEngine"); }
  734.         }
  735.         internal MethodInfo fastConstructArrayLiteralMethod {
  736.             get { return this.Globals.GetMethod("ConstructArrayLiteral"); }
  737.         }
  738.         internal ConstructorInfo globalScopeConstructor {
  739.             get { return this.GlobalScope.GetConstructor(new Type[] {this.GlobalScope, this.VsaEngine}); }
  740.         }
  741.         internal MethodInfo getDefaultThisObjectMethod {
  742.             get { return this.IActivationObject.GetMethod("GetDefaultThisObject"); }
  743.         }
  744.         internal MethodInfo getFieldMethod {
  745.             get { return this.IActivationObject.GetMethod("GetField", new Type[] {this.String, this.Int32}); }
  746.         }
  747.         internal MethodInfo getGlobalScopeMethod {
  748.             get { return this.IActivationObject.GetMethod("GetGlobalScope"); }
  749.         }
  750.         internal MethodInfo getMemberValueMethod {
  751.             get { return this.IActivationObject.GetMethod("GetMemberValue", new Type[] {this.String, this.Int32}); }
  752.         }
  753.         internal MethodInfo jScriptImportMethod {
  754.             get { return this.Import.GetMethod("JScriptImport"); }
  755.         }
  756.         internal MethodInfo jScriptInMethod {
  757.             get { return this.In.GetMethod("JScriptIn"); }
  758.         }
  759.         internal MethodInfo getEngineMethod {
  760.             get { return this.INeedEngine.GetMethod("GetEngine"); }
  761.         }
  762.         internal MethodInfo setEngineMethod {
  763.             get { return this.INeedEngine.GetMethod("SetEngine"); }
  764.         }
  765.         internal MethodInfo jScriptInstanceofMethod {
  766.             get { return this.Instanceof.GetMethod("JScriptInstanceof"); }
  767.         }
  768.         internal ConstructorInfo scriptExceptionConstructor {
  769.             get { return this.JScriptException.GetConstructor(new Type[] {this.JSError}); }
  770.         }
  771.         internal ConstructorInfo jsFunctionAttributeConstructor {
  772.             get { return this.JSFunctionAttribute.GetConstructor(new Type[] {this.JSFunctionAttributeEnum}); }
  773.         }
  774.         internal ConstructorInfo jsLocalFieldConstructor {
  775.             get { return this.JSLocalField.GetConstructor(new Type[] {this.String, this.RuntimeTypeHandle, this.Int32}); }
  776.         }
  777.         internal MethodInfo setMemberValue2Method {
  778.             get { return this.JSObject.GetMethod("SetMemberValue2", new Type[] {this.String, this.Object}); }
  779.         }
  780.         internal ConstructorInfo lateBindingConstructor2 {
  781.             get { return this.LateBinding.GetConstructor(new Type[] {this.String, this.Object}); }
  782.         }
  783.         internal ConstructorInfo lateBindingConstructor {
  784.             get { return this.LateBinding.GetConstructor(new Type[] {this.String}); }
  785.         }
  786.         internal FieldInfo objectField {
  787.             get { return this.LateBinding.GetField("obj"); }
  788.         }
  789.         internal MethodInfo callMethod {
  790.             get { return this.LateBinding.GetMethod("Call", new Type[] {this.ArrayOfObject, this.Boolean, this.Boolean, this.VsaEngine}); }
  791.         }
  792.         internal MethodInfo callValueMethod {
  793.             get { return this.LateBinding.GetMethod("CallValue", new Type[] {this.Object, this.Object, this.ArrayOfObject, this.Boolean, this.Boolean, this.VsaEngine}); }
  794.         }
  795.         internal MethodInfo callValue2Method {
  796.             get { return this.LateBinding.GetMethod("CallValue2", new Type[] {this.Object, this.Object, this.ArrayOfObject, this.Boolean, this.Boolean, this.VsaEngine}); }
  797.         }
  798.         internal MethodInfo deleteMethod {
  799.             get { return this.LateBinding.GetMethod("Delete"); }
  800.         }
  801.         internal MethodInfo deleteMemberMethod {
  802.             get { return this.LateBinding.GetMethod("DeleteMember"); }
  803.         }
  804.         internal MethodInfo getNonMissingValueMethod {
  805.             get { return this.LateBinding.GetMethod("GetNonMissingValue"); }
  806.         }
  807.         internal MethodInfo getValue2Method {
  808.             get { return this.LateBinding.GetMethod("GetValue2"); }
  809.         }
  810.         internal MethodInfo setIndexedPropertyValueStaticMethod {
  811.             get { return this.LateBinding.GetMethod("SetIndexedPropertyValueStatic"); }
  812.         }
  813.         internal MethodInfo setValueMethod {
  814.             get { return this.LateBinding.GetMethod("SetValue"); }
  815.         }
  816.         internal FieldInfo missingField {
  817.             get { return this.Missing.GetField("Value"); }
  818.         }
  819.         internal MethodInfo getNamespaceMethod {
  820.             get { return this.Namespace.GetMethod("GetNamespace"); }
  821.         }
  822.         internal ConstructorInfo numericBinaryConstructor {
  823.             get { return this.NumericBinary.GetConstructor(new Type[] {this.Int32}); }
  824.         }
  825.         internal MethodInfo numericbinaryDoOpMethod {
  826.             get { return this.NumericBinary.GetMethod("DoOp"); }
  827.         }
  828.         internal MethodInfo evaluateNumericBinaryMethod {
  829.             get { return this.NumericBinary.GetMethod("EvaluateNumericBinary"); }
  830.         }
  831.         internal ConstructorInfo numericUnaryConstructor {
  832.             get { return this.NumericUnary.GetConstructor(new Type[] {this.Int32}); }
  833.         }
  834.         internal MethodInfo evaluateUnaryMethod {
  835.             get { return this.NumericUnary.GetMethod("EvaluateUnary"); }
  836.         }
  837.         internal MethodInfo constructObjectMethod {
  838.             get { return this.ObjectConstructor.GetMethod("ConstructObject"); }
  839.         }
  840.         internal MethodInfo jScriptPackageMethod {
  841.             get { return this.Package.GetMethod("JScriptPackage"); }
  842.         }
  843.         internal ConstructorInfo plusConstructor {
  844.             get { return this.Plus.GetConstructor(new Type[] {}); }
  845.         }
  846.         internal MethodInfo plusDoOpMethod {
  847.             get { return this.Plus.GetMethod("DoOp"); }
  848.         }
  849.         internal MethodInfo evaluatePlusMethod {
  850.             get { return this.Plus.GetMethod("EvaluatePlus"); }
  851.         }
  852.         internal ConstructorInfo postOrPrefixConstructor {
  853.             get { return this.PostOrPrefixOperator.GetConstructor(new Type[] {this.Int32}); }
  854.         }
  855.         internal MethodInfo evaluatePostOrPrefixOperatorMethod {
  856.             get { return this.PostOrPrefixOperator.GetMethod("EvaluatePostOrPrefix"); }
  857.         }
  858.         internal ConstructorInfo referenceAttributeConstructor {
  859.             get { return this.ReferenceAttribute.GetConstructor(new Type[] {this.String}); }
  860.         }
  861.         internal MethodInfo regExpConstructMethod {
  862.             get { return this.RegExpConstructor.GetMethod("Construct", new Type[] {this.String, this.Boolean, this.Boolean, this.Boolean}); }
  863.         }
  864.         internal ConstructorInfo relationalConstructor {
  865.             get { return this.Relational.GetConstructor(new Type[] {this.Int32}); }
  866.         }
  867.         internal MethodInfo evaluateRelationalMethod {
  868.             get { return this.Relational.GetMethod("EvaluateRelational"); }
  869.         }
  870.         internal MethodInfo jScriptCompareMethod {
  871.             get { return this.Relational.GetMethod("JScriptCompare"); }
  872.         }
  873.         internal ConstructorInfo returnOutOfFinallyConstructor {
  874.             get { return this.ReturnOutOfFinally.GetConstructor(new Type[] {}); }
  875.         }
  876.         internal MethodInfo doubleToInt64 {
  877.             get { return this.Runtime.GetMethod("DoubleToInt64"); }
  878.         }
  879.         internal MethodInfo uncheckedDecimalToInt64Method {
  880.             get { return this.Runtime.GetMethod("UncheckedDecimalToInt64"); }
  881.         }
  882.         internal FieldInfo engineField {
  883.             get { return this.ScriptObject.GetField("engine"); }
  884.         }
  885.         internal MethodInfo getParentMethod {
  886.             get { return this.ScriptObject.GetMethod("GetParent"); }
  887.         }
  888.         internal MethodInfo writeMethod {
  889.             get { return this.ScriptStream.GetMethod("Write"); }
  890.         }
  891.         internal MethodInfo writeLineMethod {
  892.             get { return this.ScriptStream.GetMethod("WriteLine"); }
  893.         }
  894.         internal ConstructorInfo hashtableCtor {
  895.             get { return this.SimpleHashtable.GetConstructor(new Type[] {this.UInt32}); }
  896.         }
  897.         internal MethodInfo hashtableGetItem {
  898.             get { return this.SimpleHashtable.GetMethod("get_Item", new Type[] {this.Object}); }
  899.         }
  900.         internal MethodInfo hashTableGetEnumerator {
  901.             get { return this.SimpleHashtable.GetMethod("GetEnumerator", Type.EmptyTypes); }
  902.         }
  903.         internal MethodInfo hashtableRemove {
  904.             get { return this.SimpleHashtable.GetMethod("Remove", new Type[1] {this.Object}); }
  905.         }
  906.         internal MethodInfo hashtableSetItem {
  907.             get { return this.SimpleHashtable.GetMethod("set_Item", new Type[] {this.Object, this.Object}); }
  908.         }
  909.         internal FieldInfo closureInstanceField {
  910.             get { return this.StackFrame.GetField("closureInstance"); }
  911.         }
  912.         internal FieldInfo localVarsField {
  913.             get { return this.StackFrame.GetField("localVars"); }
  914.         }
  915.         internal MethodInfo pushStackFrameForMethod {
  916.             get { return this.StackFrame.GetMethod("PushStackFrameForMethod"); }
  917.         }
  918.         internal MethodInfo pushStackFrameForStaticMethod {
  919.             get { return this.StackFrame.GetMethod("PushStackFrameForStaticMethod"); }
  920.         }
  921.         internal MethodInfo jScriptStrictEqualsMethod {
  922.             get { return this.StrictEquality.GetMethod("JScriptStrictEquals", new Type[] {this.Object, this.Object}); }
  923.         }
  924.         internal MethodInfo jScriptThrowMethod {
  925.             get { return this.Throw.GetMethod("JScriptThrow"); }
  926.         }
  927.         internal MethodInfo jScriptExceptionValueMethod {
  928.             get { return this.Try.GetMethod("JScriptExceptionValue"); }
  929.         }
  930.         internal MethodInfo jScriptTypeofMethod {
  931.             get { return this.Typeof.GetMethod("JScriptTypeof"); }
  932.         }
  933.         internal ConstructorInfo vsaEngineConstructor {
  934.             get { return this.VsaEngine.GetConstructor(new Type[] {}); }
  935.         }
  936.         internal MethodInfo createVsaEngine {
  937.             get { return this.VsaEngine.GetMethod("CreateEngine", new Type[] {}); }
  938.         }
  939.         internal MethodInfo createVsaEngineWithType {
  940.             get { return this.VsaEngine.GetMethod("CreateEngineWithType", new Type[] {this.RuntimeTypeHandle}); }
  941.         }
  942.         internal MethodInfo getOriginalArrayConstructorMethod {
  943.             get { return this.VsaEngine.GetMethod("GetOriginalArrayConstructor"); }
  944.         }
  945.         internal MethodInfo getOriginalObjectConstructorMethod {
  946.             get { return this.VsaEngine.GetMethod("GetOriginalObjectConstructor"); }
  947.         }
  948.         internal MethodInfo getOriginalRegExpConstructorMethod {
  949.             get { return this.VsaEngine.GetMethod("GetOriginalRegExpConstructor"); }
  950.         }
  951.         internal MethodInfo popScriptObjectMethod {
  952.             get { return this.VsaEngine.GetMethod("PopScriptObject"); }
  953.         }
  954.         internal MethodInfo pushScriptObjectMethod {
  955.             get { return this.VsaEngine.GetMethod("PushScriptObject"); }
  956.         }
  957.         internal MethodInfo scriptObjectStackTopMethod {
  958.             get { return this.VsaEngine.GetMethod("ScriptObjectStackTop"); }
  959.         }
  960.         internal MethodInfo getLenientGlobalObjectMethod {
  961.             get { return this.VsaEngine.GetProperty("LenientGlobalObject").GetGetMethod(); }
  962.         }
  963.         internal MethodInfo jScriptWithMethod {
  964.             get { return this.With.GetMethod("JScriptWith"); }
  965.         }
  966.        
  967.         internal ConstructorInfo clsCompliantAttributeCtor {
  968.             get { return this.CLSCompliantAttribute.GetConstructor(new Type[] {this.Boolean}); }
  969.         }
  970.         internal MethodInfo getEnumeratorMethod {
  971.             get { return this.IEnumerable.GetMethod("GetEnumerator", Type.EmptyTypes); }
  972.         }
  973.         internal MethodInfo moveNextMethod {
  974.             get { return this.IEnumerator.GetMethod("MoveNext", Type.EmptyTypes); }
  975.         }
  976.         internal MethodInfo getCurrentMethod {
  977.             get { return this.IEnumerator.GetProperty("Current", Type.EmptyTypes).GetGetMethod(); }
  978.         }
  979.         internal ConstructorInfo contextStaticAttributeCtor {
  980.             get { return this.ContextStaticAttribute.GetConstructor(new Type[] {}); }
  981.         }
  982.         internal MethodInfo changeTypeMethod {
  983.             get { return this.SystemConvert.GetMethod("ChangeType", new Type[] {this.Object, this.TypeCode}); }
  984.         }
  985.         internal MethodInfo convertCharToStringMethod {
  986.             get { return this.SystemConvert.GetMethod("ToString", new Type[] {this.Char}); }
  987.         }
  988.         internal ConstructorInfo dateTimeConstructor {
  989.             get { return this.DateTime.GetConstructor(new Type[] {this.Int64}); }
  990.         }
  991.         internal MethodInfo dateTimeToStringMethod {
  992.             get { return this.DateTime.GetMethod("ToString", new Type[] {}); }
  993.         }
  994.         internal MethodInfo dateTimeToInt64Method {
  995.             get { return this.DateTime.GetProperty("Ticks").GetGetMethod(); }
  996.         }
  997.         internal ConstructorInfo decimalConstructor {
  998.             get { return this.Decimal.GetConstructor(new Type[] {this.Int32, this.Int32, this.Int32, this.Boolean, this.Byte}); }
  999.         }
  1000.         internal FieldInfo decimalZeroField {
  1001.             get { return this.Decimal.GetField("Zero"); }
  1002.         }
  1003.         internal MethodInfo decimalCompare {
  1004.             get { return this.Decimal.GetMethod("Compare", new Type[] {this.Decimal, this.Decimal}); }
  1005.         }
  1006.         internal MethodInfo doubleToDecimalMethod {
  1007.             get { return this.Decimal.GetMethod("op_Explicit", new Type[] {this.Double}); }
  1008.         }
  1009.         internal MethodInfo int32ToDecimalMethod {
  1010.             get { return this.Decimal.GetMethod("op_Implicit", new Type[] {this.Int32}); }
  1011.         }
  1012.         internal MethodInfo int64ToDecimalMethod {
  1013.             get { return this.Decimal.GetMethod("op_Implicit", new Type[] {this.Int64}); }
  1014.         }
  1015.         internal MethodInfo uint32ToDecimalMethod {
  1016.             get { return this.Decimal.GetMethod("op_Implicit", new Type[] {this.UInt32}); }
  1017.         }
  1018.         internal MethodInfo uint64ToDecimalMethod {
  1019.             get { return this.Decimal.GetMethod("op_Implicit", new Type[] {this.UInt64}); }
  1020.         }
  1021.         internal MethodInfo decimalToDoubleMethod {
  1022.             get { return this.Decimal.GetMethod("ToDouble", new Type[] {this.Decimal}); }
  1023.         }
  1024.         internal MethodInfo decimalToInt32Method {
  1025.             get { return this.Decimal.GetMethod("ToInt32", new Type[] {this.Decimal}); }
  1026.         }
  1027.         internal MethodInfo decimalToInt64Method {
  1028.             get { return this.Decimal.GetMethod("ToInt64", new Type[] {this.Decimal}); }
  1029.         }
  1030.         internal MethodInfo decimalToStringMethod {
  1031.             get { return this.Decimal.GetMethod("ToString", new Type[] {}); }
  1032.         }
  1033.         internal MethodInfo decimalToUInt32Method {
  1034.             get { return this.Decimal.GetMethod("ToUInt32", new Type[] {this.Decimal}); }
  1035.         }
  1036.         internal MethodInfo decimalToUInt64Method {
  1037.             get { return this.Decimal.GetMethod("ToUInt64", new Type[] {this.Decimal}); }
  1038.         }
  1039.         internal MethodInfo debugBreak {
  1040.             get { return this.Debugger.GetMethod("Break", new Type[] {}); }
  1041.         }
  1042.         internal ConstructorInfo debuggerHiddenAttributeCtor {
  1043.             get { return this.DebuggerHiddenAttribute.GetConstructor(new Type[] {}); }
  1044.         }
  1045.         internal ConstructorInfo debuggerStepThroughAttributeCtor {
  1046.             get { return this.DebuggerStepThroughAttribute.GetConstructor(new Type[] {}); }
  1047.         }
  1048.         internal MethodInfo int32ToStringMethod {
  1049.             get { return this.Int32.GetMethod("ToString", new Type[] {}); }
  1050.         }
  1051.         internal MethodInfo int64ToStringMethod {
  1052.             get { return this.Int64.GetMethod("ToString", new Type[] {}); }
  1053.         }
  1054.         internal MethodInfo equalsMethod {
  1055.             get { return this.Object.GetMethod("Equals", new Type[] {this.Object}); }
  1056.         }
  1057.         internal ConstructorInfo defaultMemberAttributeCtor {
  1058.             get { return this.DefaultMemberAttribute.GetConstructor(new Type[] {this.String}); }
  1059.         }
  1060.         internal MethodInfo getFieldValueMethod {
  1061.             get { return this.FieldInfo.GetMethod("GetValue", new Type[] {this.Object}); }
  1062.         }
  1063.         internal MethodInfo setFieldValueMethod {
  1064.             get { return this.FieldInfo.GetMethod("SetValue", new Type[] {this.Object, this.Object}); }
  1065.         }
  1066.         internal FieldInfo systemReflectionMissingField {
  1067.             get { return this.ReflectionMissing.GetField("Value"); }
  1068.         }
  1069.         internal ConstructorInfo compilerGlobalScopeAttributeCtor {
  1070.             get { return this.CompilerGlobalScopeAttribute.GetConstructor(new Type[] {}); }
  1071.         }
  1072.         internal MethodInfo stringConcatArrMethod {
  1073.             get { return this.String.GetMethod("Concat", new Type[] {this.ArrayOfString}); }
  1074.         }
  1075.         internal MethodInfo stringConcat4Method {
  1076.             get { return this.String.GetMethod("Concat", new Type[] {this.String, this.String, this.String, this.String}); }
  1077.         }
  1078.         internal MethodInfo stringConcat3Method {
  1079.             get { return this.String.GetMethod("Concat", new Type[] {this.String, this.String, this.String}); }
  1080.         }
  1081.         internal MethodInfo stringConcat2Method {
  1082.             get { return this.String.GetMethod("Concat", new Type[] {this.String, this.String}); }
  1083.         }
  1084.         internal MethodInfo stringEqualsMethod {
  1085.             get { return this.String.GetMethod("Equals", new Type[] {this.String, this.String}); }
  1086.         }
  1087.         internal MethodInfo stringLengthMethod {
  1088.             get { return this.String.GetProperty("Length").GetGetMethod(); }
  1089.         }
  1090.         internal MethodInfo getMethodMethod {
  1091.             get { return this.Type.GetMethod("GetMethod", new Type[] {this.String}); }
  1092.         }
  1093.         internal MethodInfo getTypeMethod {
  1094.             get { return this.Type.GetMethod("GetType", new Type[] {this.String}); }
  1095.         }
  1096.         internal MethodInfo getTypeFromHandleMethod {
  1097.             get { return this.Type.GetMethod("GetTypeFromHandle", new Type[] {this.RuntimeTypeHandle}); }
  1098.         }
  1099.         internal MethodInfo uint32ToStringMethod {
  1100.             get { return this.UInt32.GetMethod("ToString", new Type[] {}); }
  1101.         }
  1102.         internal MethodInfo uint64ToStringMethod {
  1103.             get { return this.UInt64.GetMethod("ToString", new Type[] {}); }
  1104.         }
  1105.        
  1106.        
  1107.         // MAPPING TO REFERENCE CONTEXT
  1108.         internal Type ToReferenceContext(Type type)
  1109.         {
  1110.             if (this.InReferenceContext(type))
  1111.                 return type;
  1112.             if (type.IsArray)
  1113.                 return Microsoft.JScript.Convert.ToType(Microsoft.JScript.TypedArray.ToRankString(type.GetArrayRank()), this.ToReferenceContext(type.GetElementType()));
  1114.             return this.JScriptReferenceModule.ResolveType(type.MetadataToken, null, null);
  1115.         }
  1116.        
  1117.         internal IReflect ToReferenceContext(IReflect ireflect)
  1118.         {
  1119.             if (ireflect is Type)
  1120.                 return this.ToReferenceContext((Type)ireflect);
  1121.             return ireflect;
  1122.         }
  1123.        
  1124.         internal MethodInfo ToReferenceContext(MethodInfo method)
  1125.         {
  1126.             if (method is JSMethod)
  1127.                 method = ((JSMethod)method).GetMethodInfo(null);
  1128.             else if (method is JSMethodInfo)
  1129.                 method = ((JSMethodInfo)method).method;
  1130.             return (MethodInfo)this.MapMemberInfoToReferenceContext(method);
  1131.         }
  1132.        
  1133.         internal PropertyInfo ToReferenceContext(PropertyInfo property)
  1134.         {
  1135.             return (PropertyInfo)this.MapMemberInfoToReferenceContext(property);
  1136.         }
  1137.         internal FieldInfo ToReferenceContext(FieldInfo field)
  1138.         {
  1139.             return (FieldInfo)this.MapMemberInfoToReferenceContext(field);
  1140.         }
  1141.         internal ConstructorInfo ToReferenceContext(ConstructorInfo constructor)
  1142.         {
  1143.             return (ConstructorInfo)this.MapMemberInfoToReferenceContext(constructor);
  1144.         }
  1145.        
  1146.         // Helper to implement others. We don't want to make this internal since we want to make
  1147.         // sure the appropriate subclass overload is called as they do special things.
  1148.         private MemberInfo MapMemberInfoToReferenceContext(MemberInfo member)
  1149.         {
  1150.             if (this.InReferenceContext(member.DeclaringType))
  1151.                 return member;
  1152.             return this.JScriptReferenceModule.ResolveMember(member.MetadataToken);
  1153.         }
  1154.        
  1155.         internal bool InReferenceContext(Type type)
  1156.         {
  1157.             if (type == null)
  1158.                 return true;
  1159.             Assembly assembly = type.Assembly;
  1160.             return assembly.ReflectionOnly || assembly != typeof(TypeReferences).Assembly || !this.JScriptReferenceModule.Assembly.ReflectionOnly;
  1161.         }
  1162.        
  1163.         internal bool InReferenceContext(MemberInfo member)
  1164.         {
  1165.             if (member == null)
  1166.                 return true;
  1167.             if (member is JSMethod)
  1168.                 member = ((JSMethod)member).GetMethodInfo(null);
  1169.             else if (member is JSMethodInfo)
  1170.                 member = ((JSMethodInfo)member).method;
  1171.             return this.InReferenceContext(member.DeclaringType);
  1172.         }
  1173.        
  1174.         internal bool InReferenceContext(IReflect ireflect)
  1175.         {
  1176.             if (ireflect == null)
  1177.                 return true;
  1178.             if (ireflect is Type)
  1179.                 return this.InReferenceContext((Type)ireflect);
  1180.             return true;
  1181.         }
  1182.        
  1183.        
  1184.         // MAPPING TO EXECUTION CONTEXT
  1185.         static internal Type ToExecutionContext(Type type)
  1186.         {
  1187.             if (TypeReferences.InExecutionContext(type))
  1188.                 return type;
  1189.             return typeof(TypeReferences).Module.ResolveType(type.MetadataToken, null, null);
  1190.         }
  1191.        
  1192.         static internal IReflect ToExecutionContext(IReflect ireflect)
  1193.         {
  1194.             if (ireflect is Type)
  1195.                 return TypeReferences.ToExecutionContext((Type)ireflect);
  1196.             return ireflect;
  1197.         }
  1198.        
  1199.         static internal MethodInfo ToExecutionContext(MethodInfo method)
  1200.         {
  1201.             if (method is JSMethod)
  1202.                 method = ((JSMethod)method).GetMethodInfo(null);
  1203.             else if (method is JSMethodInfo)
  1204.                 method = ((JSMethodInfo)method).method;
  1205.             return (MethodInfo)TypeReferences.MapMemberInfoToExecutionContext(method);
  1206.         }
  1207.        
  1208.         static internal PropertyInfo ToExecutionContext(PropertyInfo property)
  1209.         {
  1210.             return (PropertyInfo)TypeReferences.MapMemberInfoToExecutionContext(property);
  1211.         }
  1212.         static internal FieldInfo ToExecutionContext(FieldInfo field)
  1213.         {
  1214.             return (FieldInfo)TypeReferences.MapMemberInfoToExecutionContext(field);
  1215.         }
  1216.         static internal ConstructorInfo ToExecutionContext(ConstructorInfo constructor)
  1217.         {
  1218.             return (ConstructorInfo)TypeReferences.MapMemberInfoToExecutionContext(constructor);
  1219.         }
  1220.        
  1221.         private static MemberInfo MapMemberInfoToExecutionContext(MemberInfo member)
  1222.         {
  1223.             if (TypeReferences.InExecutionContext(member.DeclaringType))
  1224.                 return member;
  1225.             return typeof(TypeReferences).Module.ResolveMember(member.MetadataToken);
  1226.         }
  1227.        
  1228.         static internal bool InExecutionContext(Type type)
  1229.         {
  1230.             if (type == null)
  1231.                 return true;
  1232.            
  1233.             Assembly assembly = type.Assembly;
  1234.             return !assembly.ReflectionOnly || assembly.Location != typeof(TypeReferences).Assembly.Location;
  1235.         }
  1236.        
  1237.         static internal object GetDefaultParameterValue(ParameterInfo parameter)
  1238.         {
  1239.             if (parameter.GetType().Assembly == typeof(TypeReferences).Assembly || !parameter.Member.DeclaringType.Assembly.ReflectionOnly)
  1240.                 return parameter.DefaultValue;
  1241.             return parameter.RawDefaultValue;
  1242.         }
  1243.        
  1244.         static internal object GetConstantValue(FieldInfo field)
  1245.         {
  1246.             if (field.GetType().Assembly == typeof(TypeReferences).Assembly || !field.DeclaringType.Assembly.ReflectionOnly)
  1247.                 return field.GetValue(null);
  1248.            
  1249.             Type type = field.FieldType;
  1250.             object value = field.GetRawConstantValue();
  1251.             if (type.IsEnum)
  1252.                 return MetadataEnumValue.GetEnumValue(type, value);
  1253.             return value;
  1254.         }
  1255.     }
  1256. }

Developer Fusion