Beispiel #1
0
        public override MSAst TransformCore(ScriptGenerator generator)
        {
            var arguments = Arguments.Transform(generator);

            var propertyExpression = Target as PropertyExpression;

            if (propertyExpression != null)
            {
                MSAst instance = null;

                if (propertyExpression.InstanceExpression != null)
                {
                    instance = propertyExpression.InstanceExpression.TransformCore(generator);
                }

                // ReSharper disable AssignNullToNotNullAttribute
                return(MSAst.MakeIndex(
                           instance,
                           propertyExpression.PropertyInfo,
                           arguments));
                // ReSharper restore AssignNullToNotNullAttribute
            }

            return(MSAst.ArrayIndex(
                       Target.Transform(generator),
                       arguments));
        }
Beispiel #2
0
        public override MSAst.Expression TransformCore(ScriptGenerator generator)
        {
            var constructorInfo = (ConstructorInfo)_constructor;

            //if (this.ExpressionType.IsGenericType)
            return(MSAst.Expression.New(
                       constructorInfo,
                       Arguments.Transform(_arguments, generator)));
        }
Beispiel #3
0
        public static MSAst[] Transform(Arguments arguments, ScriptGenerator generator)
        {
            if (arguments == null)
            {
                return(new MSAst[0]);
            }

            return(arguments.Transform(generator));
        }
Beispiel #4
0
        public override MSAst TransformCore(ScriptGenerator generator)
        {
            var target     = Target;
            var type       = (Type)null;
            var targetType = target as TypeExpression;

            MSAst transformedTarget;

            if (targetType != null)
            {
                type = targetType.Type;
                transformedTarget = MSAst.Constant(type, typeof(Type));
            }
            else
            {
                transformedTarget = target.Transform(generator);
            }

            var method = Method;

            if (method != null)
            {
                return(MSAstUtil.ComplexCallHelper(
                           (type != null) ? null : transformedTarget,
                           method,
                           Arguments.Select(o => o.Value.Transform(generator)).ToArray()));
            }

            if (type != null)
            {
                return(MSAst.Call(
                           type,
                           MethodName,
                           TypeArguments.ResolvedTypes,
                           _arguments.Transform(generator)));
            }

            return(MSAst.Call(
                       transformedTarget,
                       MethodName,
                       TypeArguments.ResolvedTypes,
                       _arguments.Transform(generator)));
        }
Beispiel #5
0
        public override MSAst.Expression TransformCore(ScriptGenerator generator)
        {
            //if (_arguments.Count != 2)
            //    throw new InvalidOperationException("arguments.Count != 2");

            return(Microsoft.Scripting.Ast.Utils.ComplexCallHelper(
                       CommonMembers.StringConcat,
                       _arguments.Transform(generator)));

            //return MSAst.Expression.Add(
            //    _arguments[0].Value.Transform(generator),
            //    _arguments[1].Value.Transform(generator),
            //    CommonMembers.StringConcat);
        }
Beispiel #6
0
 public override MSAst.Expression TransformCore(ScriptGenerator generator)
 {
     return(MSAst.Expression.Call(
                (MethodInfo)_method,
                _arguments.Transform(generator)));
 }