/// <summary>If this is a method, this attempts to find the correct overload
        /// by using the set of arguments given in the method call.</summary>
        /// <param name="arguments">The set of arguments given in the method call.</param>
        /// <returns>The MethodInfo if found; null otherwise.</returns>
        public MethodInfo GetOverload(CompiledFragment[] arguments)
        {
            Type fragType = OfType();

            if (Types.IsDynamic(fragType))
            {
                CompiledClass cc = Method.Script.GetClass(fragType);
                return((cc == null)?null:cc.FindMethodOverload(Name, arguments));
            }
            else if (Name == "gettype" && (arguments == null || arguments.Length == 0))
            {
                return(fragType.GetMethod("GetType", new Type[0]));
            }
            else
            {
                if (!Method.Script.AllowUse(fragType))
                {
                    Error("Unable to call methods on type " + fragType.Name + " as it is restricted.");
                }
                Type[]     paramTypes = Types.GetTypes(arguments);
                MethodInfo result     = Types.GetOverload(fragType.GetMethods(), Name, paramTypes, true);

                if (IsStatic && result != null && !result.IsStatic)
                {
                    // Special case! This is where we're calling e.g. ToString on a straight type, for example int.ToString();
                    // Another example is actually the call below! We're getting a type, then calling a method on the type - not a static method of it.
                    // The method is not static yet we're 'expecting' one.
                    // So, look for the same method on System.Type and return that instead.
                    return(Types.GetOverload(typeof(System.Type).GetMethods(), Name, paramTypes, true));
                }

                return(result);
            }
        }
Example #2
0
        /// <summary>If this is a method, this attempts to find the correct overload
        /// by using the set of arguments given in the method call.</summary>
        /// <param name="arguments">The set of arguments given in the method call.</param>
        /// <returns>The MethodInfo if found; null otherwise.</returns>
        public MethodInfo GetOverload(Type[] paramTypes)
        {
            // Get the parent type:
            Type fragType = OfType();

            if (Methods != null)
            {
                // Extension methods.

                int count = 0;

                if (paramTypes != null)
                {
                    count = paramTypes.Length;
                }

                // Get types:
                Type[] argTypes = new Type[count + 1];

                if (paramTypes != null)
                {
                    Array.Copy(paramTypes, 0, argTypes, 1, count);
                }

                // Get the overload:
                return(Types.GetOverload(Methods, argTypes));
            }

            if (Types.IsDynamic(fragType))
            {
                CompiledClass cc = Method.Script.GetClass(fragType);

                return((cc == null)?null:cc.FindMethodOverload(Name, paramTypes));
            }
            else if (Name == "gettype" && (paramTypes == null || paramTypes.Length == 0))
            {
                return(fragType.GetMethod("GetType", new Type[0]));
            }

            if (!Method.Script.AllowUse(fragType))
            {
                Error("Unable to call methods on type " + fragType.Name + " as it is restricted.");
            }

            MethodInfo result = Types.GetOverload(fragType.GetMethods(), Name, paramTypes, true);

            if (IsStatic && result != null && !result.IsStatic)
            {
                // Special case! This is where we're calling e.g. ToString on a straight type, for example int.ToString();
                // Another example is actually the call below! We're getting a type, then calling a method on the type - not a static method of it.
                // The method is not static yet we're 'expecting' one.
                // So, look for the same method on System.Type and return that instead.
                return(Types.GetOverload(typeof(System.Type).GetMethods(), Name, paramTypes, true));
            }

            return(result);
        }
Example #3
0
        public override Type OutputType(out CompiledFragment v)
        {
            v = this;

            Type type = OfType();

            // Map to functionality:
            CompiledClass Class     = null;
            bool          isDynamic = Types.IsDynamic(type);

            // (Constant) binding flags:
            BindingFlags flags = BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;

            if (Name == "length" && type.IsGenericType && !isDynamic)
            {
                // Does length actually exist as a field/ property?

                Field = type.GetField(Name, flags);

                if (Field == null)
                {
                    Property = type.GetProperty(Name, flags);

                    if (Property == null)
                    {
                        // Assume we meant count instead:
                        Name = "Count";
                    }
                }
            }

            if (isDynamic)
            {
                Class = Method.Script.GetClass(type);
            }
            else if (!Method.Script.AllowUse(type))
            {
                Error("Unable to access properties of type " + type + " as it has not been made accessible.");
            }

            if (isDynamic)
            {
                Field = Class.GetField(Name);
            }
            else
            {
                Field = type.GetField(Name, flags);
            }

            if (Field != null)
            {
                if (IsStatic && !Field.IsStatic)
                {
                    Error("Property " + Name + " is not static. You must use an object reference to access it.");
                }

                return(Field.FieldType);
            }

            if (isDynamic)
            {
                Property = Class.GetProperty(Name);
            }
            else
            {
                Property = type.GetProperty(Name, flags);
            }

            if (Property != null)
            {
                if (IsStatic)
                {
                    MethodInfo staticTest = Property.GetGetMethod();
                    if (staticTest == null)
                    {
                        staticTest = Property.GetSetMethod();
                    }
                    if (!staticTest.IsStatic)
                    {
                        Error("Property " + Name + " is not static. You must use an object reference to access it.");
                    }
                }
                return(Property.PropertyType);
            }

            if (isDynamic)
            {
                MethodReturnType = Class.MethodReturnType(Name);
            }
            else
            {
                MethodReturnType = Types.MethodReturnType(type, Name);
            }

            if (MethodReturnType != null)
            {
                if (Types.IsVoid(MethodReturnType))
                {
                    MethodReturnType = typeof(Void);
                }
                return(DynamicMethodCompiler.TypeFor(MethodReturnType));
            }

            if (Of.GetType() == typeof(ThisOperation))
            {
                // This was the first property - it can potentially be a static type name too.
                Type staticType = Method.Script.GetType(Name);
                if (staticType != null)
                {
                    // It's a static type! Generate a new type operation to replace this one and return the type.
                    v = new TypeOperation(Method, staticType);
                    return(v.OutputType(out v));
                }
            }

            if (Name == "this")
            {
                // This is handled here as it allows variables called "This". Use case: PowerUI.
                v = new ThisOperation(Method);
                return(v.OutputType(out v));
            }

            // Does it support indexing? If so, Do Parent["property"] instead.

            MethodOperation mOp = null;

            if (Input0 != null)
            {
                // This is a set. Input0 is the object we're setting.

                Type setType = Input0.OutputType(out Input0);

                // Get the set method:
                MethodInfo mInfo;

                if (isDynamic)
                {
                    mInfo = Class.FindMethodOverload("set_Item", new Type[] { typeof(string), setType });
                }
                else
                {
                    // Grab all the methods of the type:
                    MethodInfo[] allMethods = type.GetMethods();
                    mInfo = Types.GetOverload(allMethods, "set_Item", new Type[] { typeof(string), setType });
                }

                if (mInfo == null)
                {
                    // Try finding the extension method:
                    mInfo = FindExtensionMethod(type, "set");

                    if (mInfo == null)
                    {
                        // It doesn't exist!
                        // Error("Property '"+ToString()+"' is not a property or extension of "+type.ToString()+".");

                        // Create as a global:
                        Field = Method.Script.MainClass.DefineField(Name, true, setType);

                        return(setType);
                    }

                    // Extension property or method.
                    // -> We only know which based on MethodOperation later calling GetOverload.
                    //    Or OutputSet/ OutputIL being called.

                    return(mInfo.ReturnType);
                }

                // It exists - create the method operation now.
                mOp          = new MethodOperation(Method, mInfo, new CompiledFragment(Name), Input0);
                v            = mOp;
                mOp.CalledOn = Of;
                return(setType);
            }
            else
            {
                // Get.

                // Get the get method:
                MethodInfo mInfo;

                if (isDynamic)
                {
                    mInfo = Class.FindMethodOverload("get_Item", new Type[] { typeof(string) });
                }
                else
                {
                    // Grab all the methods of the type:
                    MethodInfo[] allMethods = type.GetMethods();
                    mInfo = Types.GetOverload(allMethods, "get_Item", new Type[] { typeof(string) });
                }


                if (mInfo == null)
                {
                    // Try finding the extension method:
                    mInfo = FindExtensionMethod(type, "get");

                    if (mInfo == null)
                    {
                        // It doesn't exist!
                        // Error("Property '"+ToString()+"' is not a property or extension of "+type.ToString()+".");

                        // Create as a global:
                        Field = Method.Script.MainClass.DefineField(Name, true, typeof(object));

                        return(typeof(object));
                    }

                    // Extension property or method.
                    // -> We only know which based on MethodOperation later calling GetOverload.
                    //    Or OutputSet/ OutputIL being called.

                    return(mInfo.ReturnType);
                }

                // It exists - create the method operation now:
                mOp          = new MethodOperation(Method, mInfo, new CompiledFragment(Name));
                v            = mOp;
                mOp.CalledOn = Of;
                return(mInfo.ReturnType);
            }
        }