public CSharpSetMemberBinder (CSharpBinderFlags flags, string name, Type callingContext, IEnumerable<CSharpArgumentInfo> argumentInfo) : base (name, false) { this.flags = flags; this.callingContext = callingContext; this.argumentInfo = argumentInfo.ToReadOnly (); }
public void LoadProvinces(IEnumerable<Province> provinces) { Provinces = provinces.ToReadOnly(); SeaProvinces = Provinces.OfType<SeaProvince>().ToReadOnly(); LandProvinces = Provinces.OfType<LandProvince>().ToReadOnly(); ProvincePicker.Initialize(Provinces.First().Zones.First()); }
public ClientJoinExpression(ProjectionExpression projection, IEnumerable<Expression> outerKey, IEnumerable<Expression> innerKey) : base(DbExpressionType.ClientJoin, projection.Type) { this.outerKey = outerKey.ToReadOnly(); this.innerKey = innerKey.ToReadOnly(); this.projection = projection; }
public CSharpInvokeBinder (CSharpBinderFlags flags, Type callingContext, IEnumerable<CSharpArgumentInfo> argumentInfo) : base (CSharpArgumentInfo.CreateCallInfo (argumentInfo, 1)) { this.flags = flags; this.callingContext = callingContext; this.argumentInfo = argumentInfo.ToReadOnly (); }
public UpdateCommandExpression(IdentifiableExpression identifiable, Expression where, IEnumerable<FieldAssignment> assignments) : base(DbExpressionType.Update, typeof(int)) { this.identifiable = identifiable; this.where = where; this.assignments = assignments.ToReadOnly(); }
public static SwitchExpression Switch(Expression value, LabelTarget label, IEnumerable<SwitchCase> cases) { RequiresCanRead(value, "value"); ContractUtils.Requires(value.Type == typeof(int), "value", Strings.ValueMustBeInt); ContractUtils.RequiresNotNull(cases, "cases"); var caseList = cases.ToReadOnly(); ContractUtils.RequiresNotEmpty(caseList, "cases"); ContractUtils.RequiresNotNullItems(caseList, "cases"); // TODO: does it make sense for switch to have non-void type? ContractUtils.Requires(label == null || label.Type == typeof(void), "label", Strings.LabelTypeMustBeVoid); bool @default = false; int max = Int32.MinValue; int min = Int32.MaxValue; foreach (SwitchCase sc in caseList) { if (sc.IsDefault) { ContractUtils.Requires(@default == false, "cases", Strings.OnlyDefaultIsAllowed); @default = true; } else { int val = sc.Value; if (val > max) max = val; if (val < min) min = val; } } ContractUtils.Requires(UniqueCaseValues(caseList, min, max), "cases", Strings.CaseValuesMustBeUnique); return new SwitchExpression(value, label, caseList); }
public static Expression VariableDictionary(IEnumerable<ParameterExpression> variables) { var vars = variables.ToReadOnly(); return Expression.New( typeof(LocalsDictionary).GetConstructor(new[] { typeof(IRuntimeVariables), typeof(SymbolId[]) }), Expression.RuntimeVariables(vars), AstUtils.Constant(vars.Map(v => SymbolTable.StringToIdOrEmpty(v.Name))) ); }
public CSharpInvokeMemberBinder (CSharpBinderFlags flags, string name, Type callingContext, IEnumerable<Type> typeArguments, IEnumerable<CSharpArgumentInfo> argumentInfo) : base (name, false, CSharpArgumentInfo.CreateCallInfo (argumentInfo, 1)) { this.flags = flags; this.callingContext = callingContext; this.argumentInfo = argumentInfo.ToReadOnly (); this.typeArguments = typeArguments.ToReadOnly (); }
/// <summary> /// Creates a <see cref="MemberMemberBinding"/> that represents the recursive initialization of members of a field or property. /// </summary> /// <param name="member">The <see cref="MemberInfo"/> to set the <see cref="P:MemberBinding.Member"/> property equal to.</param> /// <param name="bindings">An <see cref="IEnumerable{T}"/> that contains <see cref="MemberBinding"/> objects to use to populate the <see cref="P:MemberMemberBindings.Bindings"/> collection.</param> /// <returns>A <see cref="MemberMemberBinding"/> that has the <see cref="P:MemberBinding.BindingType"/> property equal to <see cref="MemberBinding"/> and the <see cref="P:MemberBinding.Member"/> and <see cref="P:MemberMemberBindings.Bindings"/> properties set to the specified values.</returns> public static MemberMemberBinding MemberBind(MemberInfo member, IEnumerable<MemberBinding> bindings) { ContractUtils.RequiresNotNull(member, "member"); ContractUtils.RequiresNotNull(bindings, "bindings"); ReadOnlyCollection<MemberBinding> roBindings = bindings.ToReadOnly(); Type memberType; ValidateGettableFieldOrPropertyMember(member, out memberType); ValidateMemberInitArgs(memberType, roBindings); return new MemberMemberBinding(member, roBindings); }
//CONFORMING ///<summary>Creates a <see cref="T:System.Linq.Expressions.MemberListBinding" /> where the member is a field or property.</summary> ///<returns>A <see cref="T:System.Linq.Expressions.MemberListBinding" /> that has the <see cref="P:System.Linq.Expressions.MemberBinding.BindingType" /> property equal to <see cref="F:System.Linq.Expressions.MemberBindingType.ListBinding" /> and the <see cref="P:System.Linq.Expressions.MemberBinding.Member" /> and <see cref="P:System.Linq.Expressions.MemberListBinding.Initializers" /> properties set to the specified values.</returns> ///<param name="member">A <see cref="T:System.Reflection.MemberInfo" /> that represents a field or property to set the <see cref="P:System.Linq.Expressions.MemberBinding.Member" /> property equal to.</param> ///<param name="initializers">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.ElementInit" /> objects to use to populate the <see cref="P:System.Linq.Expressions.MemberListBinding.Initializers" /> collection.</param> ///<exception cref="T:System.ArgumentNullException"> ///<paramref name="member" /> is null. -or-One or more elements of <paramref name="initializers" /> is null.</exception> ///<exception cref="T:System.ArgumentException"> ///<paramref name="member" /> does not represent a field or property.-or-The <see cref="P:System.Reflection.FieldInfo.FieldType" /> or <see cref="P:System.Reflection.PropertyInfo.PropertyType" /> of the field or property that <paramref name="member" /> represents does not implement <see cref="T:System.Collections.IEnumerable" />.</exception> public static MemberListBinding ListBind(MemberInfo member, IEnumerable<ElementInit> initializers) { ContractUtils.RequiresNotNull(member, "member"); ContractUtils.RequiresNotNull(initializers, "initializers"); Type memberType; ValidateGettableFieldOrPropertyMember(member, out memberType); ReadOnlyCollection<ElementInit> initList = initializers.ToReadOnly(); ValidateListInitArgs(memberType, initList); return new MemberListBinding(member, initList); }
//CONFORMING public static ElementInit ElementInit(MethodInfo addMethod, IEnumerable<Expression> arguments) { ContractUtils.RequiresNotNull(addMethod, "addMethod"); ContractUtils.RequiresNotNull(arguments, "arguments"); RequiresCanRead(arguments, "arguments"); ValidateElementInitAddMethodInfo(addMethod); ReadOnlyCollection<Expression> argumentsRO = arguments.ToReadOnly(); ValidateArgumentTypes(addMethod, ExpressionType.Call, ref argumentsRO); return new ElementInit(addMethod, argumentsRO); }
/// <summary> /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />. /// </summary> /// <param name="binder">The runtime binder for the dynamic operation.</param> /// <param name="returnType">The result type of the dynamic expression.</param> /// <param name="arguments">The arguments to the dynamic operation.</param> /// <returns> /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the /// <see cref="DynamicExpression.Binder">Binder</see> and /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values. /// </returns> /// <remarks> /// The <see cref="DynamicExpression.DelegateType">DelegateType</see> property of the /// result will be inferred from the types of the arguments and the specified return type. /// </remarks> public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, IEnumerable<Expression> arguments) { ContractUtils.RequiresNotNull(arguments, nameof(arguments)); ContractUtils.RequiresNotNull(returnType, nameof(returnType)); var args = arguments.ToReadOnly(); ContractUtils.RequiresNotEmpty(args, nameof(args)); return MakeDynamic(binder, returnType, args); }
/// <summary> /// Creates a <see cref="System.Linq.Expressions.SwitchCase">SwitchCase</see> for use in a <see cref="SwitchExpression"/>. /// </summary> /// <param name="body">The body of the case.</param> /// <param name="testValues">The test values of the case.</param> /// <returns>The created <see cref="System.Linq.Expressions.SwitchCase">SwitchCase</see>.</returns> public static SwitchCase SwitchCase(Expression body, IEnumerable<Expression> testValues) { RequiresCanRead(body, "body"); var values = testValues.ToReadOnly(); RequiresCanRead(values, "testValues"); ContractUtils.RequiresNotEmpty(values, "testValues"); return new SwitchCase(body, values); }
/// <summary> /// Creates a <see cref="Expressions.SwitchCase"/> for use in a <see cref="SwitchExpression"/>. /// </summary> /// <param name="body">The body of the case.</param> /// <param name="testValues">The test values of the case.</param> /// <returns>The created <see cref="Expressions.SwitchCase"/>.</returns> public static SwitchCase SwitchCase(Expression body, IEnumerable<Expression> testValues) { RequiresCanRead(body, nameof(body)); ReadOnlyCollection<Expression> values = testValues.ToReadOnly(); ContractUtils.RequiresNotEmpty(values, nameof(testValues)); RequiresCanRead(values, nameof(testValues)); return new SwitchCase(body, values); }
//CONFORMING public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable<Expression> initializers) { ContractUtils.RequiresNotNull(newExpression, "newExpression"); ContractUtils.RequiresNotNull(initializers, "initializers"); ReadOnlyCollection<Expression> initializerlist = initializers.ToReadOnly(); if (initializerlist.Count == 0) { throw Error.ListInitializerWithZeroMembers(); } MethodInfo addMethod = FindMethod(newExpression.Type, "Add", null, new Expression[] { initializerlist[0] }, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); return ListInit(newExpression, addMethod, initializers); }
public CSharpUnaryOperationBinder (ExpressionType operation, CSharpBinderFlags flags, Type context, IEnumerable<CSharpArgumentInfo> argumentInfo) : base (operation) { this.argumentInfo = argumentInfo.ToReadOnly (); if (this.argumentInfo.Count != 1) throw new ArgumentException ("Unary operation requires 1 argument"); this.flags = flags; this.context = context; }
/// <summary> /// Creates a new CallInfo that represents arguments in the dynamic binding process. /// </summary> /// <param name="argCount">The number of arguments.</param> /// <param name="argNames">The argument names.</param> /// <returns>The new CallInfo</returns> public CallInfo(int argCount, IEnumerable<string> argNames) { ContractUtils.RequiresNotNull(argNames, "argNames"); var argNameCol = argNames.ToReadOnly(); if (argCount < argNameCol.Count) throw Error.ArgCntMustBeGreaterThanNameCnt(); ContractUtils.RequiresNotNullItems(argNameCol, "argNames"); _argCount = argCount; _argNames = argNameCol; }
/// <summary> /// Creates a new CallInfo that represents arguments in the dynamic binding process. /// </summary> /// <param name="argCount">The number of arguments.</param> /// <param name="argNames">The argument names.</param> /// <returns>The new CallInfo</returns> public CallInfo(int argCount, IEnumerable<string> argNames) { ContractUtils.RequiresNotNull(argNames, nameof(argNames)); var argNameCol = argNames.ToReadOnly(); if (argCount < argNameCol.Count) throw System.Linq.Expressions.Error.ArgCntMustBeGreaterThanNameCnt(); ContractUtils.RequiresNotNullItems(argNameCol, nameof(argNames)); ArgumentCount = argCount; ArgumentNames = argNameCol; }
/// <summary> /// Creates an instance of <see cref="T:System.Linq.Expressions.RuntimeVariablesExpression" />. /// </summary> /// <param name="variables">A collection of <see cref="T:System.Linq.Expressions.ParameterExpression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.RuntimeVariablesExpression.Variables" /> collection.</param> /// <returns>An instance of <see cref="T:System.Linq.Expressions.RuntimeVariablesExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.RuntimeVariables" /> and the <see cref="P:System.Linq.Expressions.RuntimeVariablesExpression.Variables" /> property set to the specified value.</returns> public static RuntimeVariablesExpression RuntimeVariables(IEnumerable<ParameterExpression> variables) { ContractUtils.RequiresNotNull(variables, "variables"); var vars = variables.ToReadOnly(); for (int i = 0; i < vars.Count; i++) { Expression v = vars[i]; if (v == null) { throw new ArgumentNullException("variables[" + i + "]"); } } return new RuntimeVariablesExpression(vars); }
/// <summary> /// Initializes a new instance of the <see cref="SelectExpression"/> class. /// </summary> /// <param name="alias">The alias.</param> /// <param name="columns">The columns.</param> /// <param name="from">From.</param> /// <param name="where">The where.</param> /// <param name="orderBy">The order by.</param> /// <param name="groupBy">The group by.</param> /// <param name="isDistinct">if set to <c>true</c> [is distinct].</param> /// <param name="skip">The skip.</param> /// <param name="take">The take.</param> /// <param name="reverse">if set to <c>true</c> [reverse].</param> public SelectExpression(TableAlias alias, IEnumerable <ColumnDeclaration> columns, Expression from, Expression where, IEnumerable <OrderExpression> orderBy, IEnumerable <Expression> groupBy, bool isDistinct, Expression skip, Expression take, bool reverse) : base(DbExpressionType.Select, typeof(void), alias) { this.Columns = columns.ToReadOnly(); this.IsDistinct = isDistinct; this.From = from; this.Where = where; this.OrderBy = orderBy.ToReadOnly(); this.GroupBy = groupBy.ToReadOnly(); this.Take = take; this.Skip = skip; this.IsReverse = reverse; }
public static NewArrayExpression NewArrayHelper(Type type, IEnumerable <Expression> initializers) { ContractUtils.RequiresNotNull(type, "type"); ContractUtils.RequiresNotNull(initializers, "initializers"); if (type.Equals(typeof(void))) { throw new ArgumentException("Argument type cannot be System.Void."); } ReadOnlyCollection <Expression> initializerList = initializers.ToReadOnly(); Expression[] clone = null; for (int i = 0; i < initializerList.Count; i++) { Expression initializer = initializerList[i]; ContractUtils.RequiresNotNull(initializer, "initializers"); if (!TypeUtils.AreReferenceAssignable(type, initializer.Type)) { if (clone == null) { clone = new Expression[initializerList.Count]; for (int j = 0; j < i; j++) { clone[j] = initializerList[j]; } } if (type.IsSubclassOf(typeof(Expression)) && TypeUtils.AreAssignable(type, initializer.GetType())) { initializer = Expression.Quote(initializer); } else { initializer = Expression.Convert(initializer, type); } } if (clone != null) { clone[i] = initializer; } } if (clone != null) { initializerList = new ReadOnlyCollection <Expression>(clone); } return(Expression.NewArrayInit(type, initializerList)); }
/// <summary> /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />. /// </summary> /// <param name="delegateType">The type of the delegate used by the <see cref="CallSite" />.</param> /// <param name="binder">The runtime binder for the dynamic operation.</param> /// <param name="arguments">The arguments to the dynamic operation.</param> /// <returns> /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the /// <see cref="DynamicExpression.DelegateType">DelegateType</see>, /// <see cref="DynamicExpression.Binder">Binder</see>, and /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values. /// </returns> public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, IEnumerable <Expression> arguments) { ContractUtils.RequiresNotNull(delegateType, "delegateType"); ContractUtils.RequiresNotNull(binder, "binder"); ContractUtils.Requires(delegateType.IsSubclassOf(typeof(Delegate)), "delegateType", Strings.TypeMustBeDerivedFromSystemDelegate); var method = GetValidMethodForDynamic(delegateType); var args = arguments.ToReadOnly(); ValidateArgumentTypes(method, ExpressionType.Dynamic, ref args); return(DynamicExpression.Make(method.GetReturnType(), delegateType, binder, args)); }
public MixinEntityExpression(Type type, IEnumerable <FieldBinding> bindings, Alias mainEntityAlias, FieldMixin fieldMixin) : base(DbExpressionType.MixinInit, type) { if (bindings == null) { throw new ArgumentNullException("bindings"); } Bindings = bindings.ToReadOnly(); FieldMixin = fieldMixin; MainEntityAlias = mainEntityAlias; }
/// <summary> /// Creates a <see cref="BlockExpression"/> that contains the given variables and expressions. /// </summary> /// <param name="variables">The variables in the block.</param> /// <param name="expressions">The expressions in the block.</param> /// <returns>The created <see cref="BlockExpression"/>.</returns> public static BlockExpression Block(IEnumerable <ParameterExpression> variables, IEnumerable <Expression> expressions) { ContractUtils.RequiresNotNull(expressions, nameof(expressions)); var variableList = variables.ToReadOnly(); if (variableList.Count == 0) { return(GetOptimizedBlockExpression(expressions as IReadOnlyList <Expression> ?? expressions.ToReadOnly())); } var expressionList = expressions.ToReadOnly(); return(BlockCore(null, variableList, expressionList)); }
public SwitchStatement(Expression expression, IEnumerable <SwitchCase> cases) { Expression = expression; Cases = cases.ToReadOnly(); if (Cases.Count(x => x.ContainsDefault) > 1) { throw new ArgumentException("default ラベルは switch ステートメント内に複数存在できません。"); } Expression.Parent = this; foreach (var cs in Cases) { cs.Parent = this; } }
/// <summary> /// Creates a new CallInfo that represents arguments in the dynamic binding process. /// </summary> /// <param name="argCount">The number of arguments.</param> /// <param name="argNames">The argument names.</param> /// <returns>The new CallInfo</returns> public CallInfo(int argCount, IEnumerable <string> argNames) { ContractUtils.RequiresNotNull(argNames, nameof(argNames)); var argNameCol = argNames.ToReadOnly(); if (argCount < argNameCol.Count) { throw System.Linq.Expressions.Error.ArgCntMustBeGreaterThanNameCnt(); } ContractUtils.RequiresNotNullItems(argNameCol, nameof(argNames)); _argCount = argCount; _argNames = argNameCol; }
public FunctionDefinition(string name, IEnumerable <ParameterDefinition> parameters, IEnumerable <Statement> body) { Name = name; Parameters = parameters.ToReadOnly(); foreach (var param in Parameters) { param.Parent = this; } Body = body.ToReadOnly(); foreach (var statement in Body) { statement.Parent = this; } ReturnLabel = Ast.Label(typeof(object)); }
private FunctionSymbol(string name, IEnumerable <Signature> signatures, bool hidden, bool constantFoldable, ResultNameKind resultNameKind, string resultNamePrefix) : base(name) { this.Signatures = signatures.ToReadOnly(); foreach (var signature in this.Signatures) { signature.Symbol = this; } this.hidden = hidden; this.constantFoldable = constantFoldable; this.resultNameKind = resultNameKind; this.resultNamePrefix = resultNamePrefix; }
/// <summary> /// Creates a new array expression of the specified type from the provided initializers. /// </summary> /// <param name="type">A Type that represents the element type of the array.</param> /// <param name="initializers">The expressions used to create the array elements.</param> /// <returns>An instance of the <see cref="NewArrayExpression"/>.</returns> public static NewArrayExpression NewArrayInit(Type type, IEnumerable <Expression> initializers) { ContractUtils.RequiresNotNull(type, "type"); ContractUtils.RequiresNotNull(initializers, "initializers"); if (type.Equals(typeof(void))) { throw Error.ArgumentCannotBeOfTypeVoid(); } ReadOnlyCollection <Expression> initializerList = initializers.ToReadOnly(); Expression[] newList = null; for (int i = 0, n = initializerList.Count; i < n; i++) { Expression expr = initializerList[i]; RequiresCanRead(expr, "initializers"); if (!TypeUtils.AreReferenceAssignable(type, expr.Type)) { if (TypeUtils.IsSameOrSubclass(typeof(LambdaExpression), type) && type.IsAssignableFrom(expr.GetType())) { expr = Expression.Quote(expr); } else { throw Error.ExpressionTypeCannotInitializeArrayType(expr.Type, type); } if (newList == null) { newList = new Expression[initializerList.Count]; for (int j = 0; j < i; j++) { newList[j] = initializerList[j]; } } } if (newList != null) { newList[i] = expr; } } if (newList != null) { initializerList = new TrueReadOnlyCollection <Expression>(newList); } return(NewArrayExpression.Make(ExpressionType.NewArrayInit, type.MakeArrayType(), initializerList)); }
public void ToReadOnly_Passing_Valid_Collection_Returns_Readonly_Collection() { var collectionExpected = new List <string>() { "a", "e", "i", "o", "u", }; Collection = new List <string>() { "a", "e", "i", "o", "u", }; var collectionActual = Collection.ToReadOnly(); CollectionAssert.AreEqual(collectionExpected, collectionActual); }
/// <summary> /// Creates a <see cref="Optimizers.LambdaAbstraction" /> that abstracts over unknown query nodes and non-query nodes. /// </summary> /// <param name="body">The <see cref="LambdaExpression" /> which represents the unknown parts of a query with holes for known sub-parts.</param> /// <param name="parameters">The known sub-parts of a query.</param> /// <returns>A <see cref="Optimizers.LambdaAbstraction" /> with holes and parameters to fill the holes.</returns> public LambdaAbstraction LambdaAbstraction(LambdaExpression body, IEnumerable <QueryTree> parameters) { RequireNotNull(body, nameof(body)); RequireNotNull(body.Parameters, nameof(body)); RequireNotNull(parameters, nameof(parameters)); var p = parameters.ToReadOnly(); if (p.Count != body.Parameters.Count) { throw new ArgumentException("Number of parameters in body and parameter list is not consistent."); } return(new LambdaAbstraction(body, p)); }
/// <summary> /// Creates a <see cref="InterpolatedStringCSharpExpression"/> that represents an interpolated string expression. /// </summary> /// <param name="type">The type of the interpolated string. This can be any of <see cref="string"/>, <see cref="FormattableString"/>, or <see cref="IFormattable"/>.</param> /// <param name="interpolations">The interpolations that make up the interpolated string.</param> /// <returns>An instance of the <see cref="InterpolatedStringCSharpExpression"/>.</returns> public static InterpolatedStringCSharpExpression InterpolatedString(Type type, IEnumerable <Interpolation> interpolations) { ContractUtils.RequiresNotNull(type, nameof(type)); if (type == typeof(string)) { return(InterpolatedString(interpolations)); } if (type != typeof(FormattableString) && type != typeof(IFormattable)) { throw Error.InvalidInterpolatedStringType(type); } return(new FormattableInterpolatedStringCSharpExpression(type, interpolations.ToReadOnly())); }
/// <summary> /// Creates a new expression representing a dynamically bound (possibly generic) member invocation with the specified binder flags and the specified type context. /// </summary> /// <param name="object">The expression representing the object to invoke the member on.</param> /// <param name="name">The name of the member to invoke.</param> /// <param name="typeArguments">An enumerable sequence of type arguments to pass to the generic member. (Specify null for non-generic members.)</param> /// <param name="arguments">An enumerable sequence of dynamic arguments representing the arguments passed to the member upon invocation.</param> /// <param name="binderFlags">The binder flags to use for the dynamic operation.</param> /// <param name="context">The type representing the context in which the dynamic operation is bound.</param> /// <returns>A new expression representing a dynamically bound member invocation.</returns> public static InvokeMemberDynamicCSharpExpression DynamicInvokeMember(Expression @object, string name, IEnumerable<Type> typeArguments, IEnumerable<DynamicCSharpArgument> arguments, CSharpBinderFlags binderFlags, Type context) { RequiresCanRead(@object, nameof(@object)); RequiresNotNull(name, nameof(name)); var typeArgList = typeArguments.ToReadOnly(); foreach (var type in typeArgList) { ValidateType(type); } var argList = arguments.ToReadOnly(); return new InvokeInstanceMemberDynamicCSharpExpression(context, binderFlags, @object, name, typeArgList, argList); }
public MixinEntityExpression(Type type, IEnumerable <FieldBinding> bindings, Alias?mainEntityAlias, FieldMixin?fieldMixin, EntityContextInfo?info) : base(DbExpressionType.MixinInit, type) { if (bindings == null) { throw new ArgumentNullException(nameof(bindings)); } Bindings = bindings.ToReadOnly(); FieldMixin = fieldMixin; EntityContext = info; MainEntityAlias = mainEntityAlias; }
/// <summary> /// Creates a <see cref="ListInitExpression"/> that uses a method named "Add" to add elements to a collection. /// </summary> /// <param name="newExpression">A <see cref="NewExpression"/> to set the <see cref="P:ListInitExpression.NewExpression"/> property equal to.</param> /// <param name="initializers">An <see cref="IEnumerable{T}"/> that contains <see cref="M:ElementInit"/> objects to use to populate the <see cref="ListInitExpression.Initializers"/> collection.</param> /// <returns>A <see cref="ListInitExpression"/> that has the <see cref="P:ListInitExpression.NodeType"/> property equal to ListInit and the <see cref="P:ListInitExpression.NewExpression"/> property set to the specified value.</returns> public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable <Expression> initializers) { ContractUtils.RequiresNotNull(newExpression, nameof(newExpression)); ContractUtils.RequiresNotNull(initializers, nameof(initializers)); ReadOnlyCollection <Expression> initializerlist = initializers.ToReadOnly(); if (initializerlist.Count == 0) { return(new ListInitExpression(newExpression, EmptyReadOnlyCollection <ElementInit> .Instance)); } MethodInfo addMethod = FindMethod(newExpression.Type, "Add", null, new Expression[] { initializerlist[0] }, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); return(ListInit(newExpression, addMethod, initializers)); }
public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable <Expression> initializers) { ArgumentNullException.ThrowIfNull(newExpression); ArgumentNullException.ThrowIfNull(initializers); ReadOnlyCollection <Expression> initializerlist = initializers.ToReadOnly(); if (initializerlist.Count == 0) { return(new ListInitExpression(newExpression, EmptyReadOnlyCollection <ElementInit> .Instance)); } MethodInfo?addMethod = FindMethod(newExpression.Type, "Add", null, new Expression[] { initializerlist[0] }, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); return(ListInit(newExpression, addMethod, initializerlist)); }
/// <summary> /// Creates a <see cref="ListInitExpression"/> that uses a method named "Add" to add elements to a collection. /// </summary> /// <param name="newExpression">A <see cref="NewExpression"/> to set the <see cref="P:ListInitExpression.NewExpression"/> property equal to.</param> /// <param name="initializers">An <see cref="IEnumerable{T}"/> that contains <see cref="M:ElementInit"/> objects to use to populate the <see cref="ListInitExpression.Initializers"/> collection.</param> /// <returns>A <see cref="ListInitExpression"/> that has the <see cref="P:ListInitExpression.NodeType"/> property equal to ListInit and the <see cref="P:ListInitExpression.NewExpression"/> property set to the specified value.</returns> public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable <Expression> initializers) { ContractUtils.RequiresNotNull(newExpression, "newExpression"); ContractUtils.RequiresNotNull(initializers, "initializers"); var initializerlist = initializers.ToReadOnly(); if (initializerlist.Count == 0) { throw Error.ListInitializerWithZeroMembers(); } MethodInfo addMethod = FindMethod(newExpression.Type, "Add", null, new Expression[] { initializerlist[0] }, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); return(ListInit(newExpression, addMethod, initializers)); }
public static NewExpression New(ConstructorInfo constructor, IEnumerable <Expression>?arguments, IEnumerable <MemberInfo>?members) { ArgumentNullException.ThrowIfNull(constructor); if (constructor.DeclaringType is null) { #pragma warning disable CA2208 throw new ArgumentNullException($"{nameof(constructor)}.{nameof(constructor.DeclaringType)}"); #pragma warning restore CA2208 } TypeUtils.ValidateType(constructor.DeclaringType !, nameof(constructor), allowByRef: true, allowPointer: true); ValidateConstructor(constructor, nameof(constructor)); ReadOnlyCollection <MemberInfo> memberList = members.ToReadOnly(); ReadOnlyCollection <Expression> argList = arguments.ToReadOnly(); ValidateNewArgs(constructor, ref argList, ref memberList); return(new NewExpression(constructor, argList, memberList)); }
/// <summary> /// Creates a new array expression of the specified type from the provided initializers. /// </summary> /// <param name="type">A Type that represents the element type of the array.</param> /// <param name="initializers">The expressions used to create the array elements.</param> /// <returns>An instance of the <see cref="NewArrayExpression"/>.</returns> public static NewArrayExpression NewArrayInit(Type type, IEnumerable <Expression> initializers) { ContractUtils.RequiresNotNull(type, "type"); ContractUtils.RequiresNotNull(initializers, "initializers"); if (type == typeof(void)) { throw Error.ArgumentCannotBeOfTypeVoid(); } var initializerList = initializers.ToReadOnly(); Expression[] newList = null; var n = initializerList.Count; for (var i = 0; i < n; i++) { var expr = initializerList[i]; RequiresCanRead(expr, "initializers"); if (!TypeHelper.AreReferenceAssignable(type, expr.Type)) { if (!TryQuote(type, ref expr)) { throw Error.ExpressionTypeCannotInitializeArrayType(expr.Type, type); } if (newList == null) { newList = new Expression[n]; for (var j = 0; j < i; j++) { newList[j] = initializerList[j]; } } } if (newList != null) { newList[i] = expr; } } if (newList != null) { initializerList = new TrueReadOnlyCollection <Expression>(newList); } return(NewArrayExpression.Make(ExpressionType.NewArrayInit, type.MakeArrayType(), initializerList)); }
private QueryOperatorParameter( string name, QueryOperatorParameterKind kind, bool isCaseSensitive, IEnumerable <string> values, bool isRepeatable, bool isHidden, IReadOnlyList <string> aliases) { this.Name = name; this.Kind = kind; this.Values = values.ToReadOnly(); this.IsCaseSensitive = isCaseSensitive; this.IsRepeatable = isRepeatable; this.IsHidden = isHidden; this.Aliases = aliases.ToReadOnly(); }
/// <summary> /// Creates an instance of <see cref="T:System.Linq.Expressions.RuntimeVariablesExpression" />. /// </summary> /// <param name="variables">A collection of <see cref="T:System.Linq.Expressions.ParameterExpression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.RuntimeVariablesExpression.Variables" /> collection.</param> /// <returns>An instance of <see cref="T:System.Linq.Expressions.RuntimeVariablesExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.RuntimeVariables" /> and the <see cref="P:System.Linq.Expressions.RuntimeVariablesExpression.Variables" /> property set to the specified value.</returns> public static RuntimeVariablesExpression RuntimeVariables(IEnumerable <ParameterExpression> variables) { ContractUtils.RequiresNotNull(variables, "variables"); var vars = variables.ToReadOnly(); for (int i = 0; i < vars.Count; i++) { Expression v = vars[i]; if (v == null) { throw new ArgumentNullException("variables[" + i + "]"); } } return(new RuntimeVariablesExpression(vars)); }
/// <summary> /// Creates a <see cref="NewArrayExpression"/> that represents creating an array that has a specified rank. /// </summary> /// <param name="type">A <see cref="System.Type"/> that represents the element type of the array.</param> /// <param name="bounds">An <see cref="IEnumerable{T}"/> that contains <see cref="Expression"/> objects to use to populate the <see cref="NewArrayExpression.Expressions"/> collection.</param> /// <returns>A <see cref="NewArrayExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.NewArrayBounds"/> and the <see cref="NewArrayExpression.Expressions"/> property set to the specified value.</returns> public static NewArrayExpression NewArrayBounds(Type type, IEnumerable <Expression> bounds) { ContractUtils.RequiresNotNull(type, nameof(type)); ContractUtils.RequiresNotNull(bounds, nameof(bounds)); if (type == typeof(void)) { throw Error.ArgumentCannotBeOfTypeVoid(nameof(type)); } TypeUtils.ValidateType(type, nameof(type)); ReadOnlyCollection <Expression> boundsList = bounds.ToReadOnly(); int dimensions = boundsList.Count; if (dimensions <= 0) { throw Error.BoundsCannotBeLessThanOne(nameof(bounds)); } for (int i = 0; i < dimensions; i++) { Expression expr = boundsList[i]; ExpressionUtils.RequiresCanRead(expr, nameof(bounds), i); if (!expr.Type.IsInteger()) { throw Error.ArgumentMustBeInteger(nameof(bounds), i); } } Type arrayType; if (dimensions == 1) { //To get a vector, need call Type.MakeArrayType(). //Type.MakeArrayType(1) gives a non-vector array, which will cause type check error. arrayType = type.MakeArrayType(); } else { arrayType = type.MakeArrayType(dimensions); } return(NewArrayExpression.Make(ExpressionType.NewArrayBounds, arrayType, boundsList)); }
private static IndexCSharpExpression MakeIndex(Expression instance, PropertyInfo indexer, MethodInfo method, ParameterInfo[] parameters, IEnumerable <ParameterAssignment> arguments) { RequiresCanRead(instance, nameof(instance)); var argList = arguments.ToReadOnly(); ValidateIndexer(instance.Type, indexer, parameters, argList); if (method != null) { return(new IndexCSharpExpression.MethodBased(instance, method, argList)); } else { return(new IndexCSharpExpression.PropertyBased(instance, indexer, argList)); } }
public static CSharpSwitchCase SwitchCase(IEnumerable <object> testValues, IEnumerable <Expression> statements) { RequiresNotNull(testValues, nameof(testValues)); RequiresNotNull(statements, nameof(statements)); // NB: We don't check the body for Break statements; worst case we'll insert one at the end during Reduce. // Note that the semantics are nonetheless consistent with C#, i.e. no implicit fall-through. var testValuesList = testValues.ToReadOnly(); RequiresNotEmpty(testValuesList, nameof(testValues)); var testType = default(Type); var uniqueTestValues = new HashSet <object>(); foreach (var testValue in testValuesList) { if (!uniqueTestValues.Add(testValue)) { throw Error.DuplicateTestValue(testValue); } // NB: Null is fine; every valid governing type in C# has a nullable variant (trivial for string). if (testValue != null && testValue != SwitchCaseDefaultValue) { var testValueType = testValue.GetType(); if (testType == null) { testType = testValueType; } else { if (testType != testValueType) { throw Error.TestValuesShouldHaveConsistentType(); } } } } var statementsList = GetStatements(statements); return(new CSharpSwitchCase(testValuesList, statementsList)); }
/// <summary> /// Creates a copy of this <see cref="Parser{TInput}"/> with the annotations specified. /// </summary> public Parser <TInput> WithAnnotations(IEnumerable <object> annotations) { var list = annotations.ToReadOnly(); if (this.Annotations != list) { var clone = this.Clone(); clone.Annotations = list; clone.Tag = this.Tag; clone.IsHidden = this.IsHidden; return(clone); } else { return(this); } }
/// <summary> /// Creates a <see cref="NewArrayExpression"/> of the specified type from the provided initializers. /// </summary> /// <param name="type">A Type that represents the element type of the array.</param> /// <param name="initializers">The expressions used to create the array elements.</param> /// <returns>A <see cref="NewArrayExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.NewArrayInit"/> and the <see cref="NewArrayExpression.Expressions"/> property set to the specified value.</returns> public static NewArrayExpression NewArrayInit(Type type, IEnumerable <Expression> initializers) { ContractUtils.RequiresNotNull(type, nameof(type)); ContractUtils.RequiresNotNull(initializers, nameof(initializers)); if (type == typeof(void)) { throw Error.ArgumentCannotBeOfTypeVoid(nameof(type)); } TypeUtils.ValidateType(type, nameof(type)); ReadOnlyCollection <Expression> initializerList = initializers.ToReadOnly(); Expression[]? newList = null; for (int i = 0, n = initializerList.Count; i < n; i++) { Expression expr = initializerList[i]; ExpressionUtils.RequiresCanRead(expr, nameof(initializers), i); if (!TypeUtils.AreReferenceAssignable(type, expr.Type)) { if (!TryQuote(type, ref expr)) { throw Error.ExpressionTypeCannotInitializeArrayType(expr.Type, type); } if (newList == null) { newList = new Expression[initializerList.Count]; for (int j = 0; j < i; j++) { newList[j] = initializerList[j]; } } } if (newList != null) { newList[i] = expr; } } if (newList != null) { initializerList = new TrueReadOnlyCollection <Expression>(newList); } return(NewArrayExpression.Make(ExpressionType.NewArrayInit, type.MakeArrayType(), initializerList)); }
public CaseExpression(IEnumerable <When> whens, Expression?defaultValue) : base(DbExpressionType.Case, GetType(whens, defaultValue)) { if (whens.IsEmpty()) { throw new ArgumentNullException(nameof(whens)); } Type refType = this.Type.UnNullify(); if (whens.Any(w => w.Value.Type.UnNullify() != refType)) { throw new ArgumentException("whens"); } this.Whens = whens.ToReadOnly(); this.DefaultValue = defaultValue; }
/// <summary> /// Creates a new expression representing a dynamically bound (possibly generic) member invocation with the specified binder flags and the specified type context. /// </summary> /// <param name="type">The type containing the static member to invoke.</param> /// <param name="name">The name of the member to invoke.</param> /// <param name="typeArguments">An enumerable sequence of type arguments to pass to the generic member. (Specify null for non-generic members.)</param> /// <param name="arguments">An enumerable sequence of dynamic arguments representing the arguments passed to the member upon invocation.</param> /// <param name="binderFlags">The binder flags to use for the dynamic operation.</param> /// <param name="context">The type representing the context in which the dynamic operation is bound.</param> /// <returns>A new expression representing a dynamically bound member invocation.</returns> public static InvokeMemberDynamicCSharpExpression DynamicInvokeMember(Type type, string name, IEnumerable <Type> typeArguments, IEnumerable <DynamicCSharpArgument> arguments, CSharpBinderFlags binderFlags, Type context) { ContractUtils.RequiresNotNull(type, nameof(type)); ContractUtils.RequiresNotNull(name, nameof(name)); ValidateType(type); var typeArgList = typeArguments.ToReadOnly(); foreach (var typeArg in typeArgList) { ValidateType(typeArg); } var argList = arguments.ToReadOnly(); return(new InvokeStaticMemberDynamicCSharpExpression(context, binderFlags, type, name, typeArgList, argList)); }
/// <summary> /// Creates a <see cref="ListInitExpression"/> that uses a specified method to add elements to a collection. /// </summary> /// <param name="newExpression">A <see cref="NewExpression"/> to set the <see cref="P:ListInitExpression.NewExpression"/> property equal to.</param> /// <param name="addMethod">A <see cref="MethodInfo"/> that represents an instance method named "Add" (case insensitive), that adds an element to a collection. </param> /// <param name="initializers">An <see cref="IEnumerable{T}"/> that contains <see cref="Expression"/> objects to use to populate the Initializers collection.</param> /// <returns>A <see cref="ListInitExpression"/> that has the <see cref="P:ListInitExpression.NodeType"/> property equal to ListInit and the <see cref="P:ListInitExpression.NewExpression"/> property set to the specified value.</returns> public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, IEnumerable <Expression> initializers) { if (addMethod == null) { return(ListInit(newExpression, initializers)); } ContractUtils.RequiresNotNull(newExpression, nameof(newExpression)); ContractUtils.RequiresNotNull(initializers, nameof(initializers)); ReadOnlyCollection <Expression> initializerlist = initializers.ToReadOnly(); ElementInit[] initList = new ElementInit[initializerlist.Count]; for (int i = 0; i < initializerlist.Count; i++) { initList[i] = ElementInit(addMethod, initializerlist[i]); } return(ListInit(newExpression, new TrueReadOnlyCollection <ElementInit>(initList))); }
public static NewArrayExpression NewArrayHelper(Type type, IEnumerable<Expression> initializers) { ContractUtils.RequiresNotNull(type, "type"); ContractUtils.RequiresNotNull(initializers, "initializers"); if (type.Equals(typeof(void))) { throw new ArgumentException("Argument type cannot be System.Void."); } ReadOnlyCollection<Expression> initializerList = initializers.ToReadOnly(); Expression[] clone = null; for (int i = 0; i < initializerList.Count; i++) { Expression initializer = initializerList[i]; ContractUtils.RequiresNotNull(initializer, "initializers"); if (!TypeUtils.AreReferenceAssignable(type, initializer.Type)) { if (clone == null) { clone = new Expression[initializerList.Count]; for (int j = 0; j < i; j++) { clone[j] = initializerList[j]; } } if (type.IsSubclassOf(typeof(Expression)) && TypeUtils.AreAssignable(type, initializer.GetType())) { initializer = Expression.Quote(initializer); } else { initializer = Convert(initializer, type); } } if (clone != null) { clone[i] = initializer; } } if (clone != null) { initializerList = new ReadOnlyCollection<Expression>(clone); } return Expression.NewArrayInit(type, initializerList); }
public EntityExpression(Type type, Expression externalId, Alias tableAlias, IEnumerable<FieldBinding> bindings, IEnumerable<MixinEntityExpression> mixins, bool avoidExpandOnRetrieving) : base(DbExpressionType.Entity, type) { if (type == null) throw new ArgumentNullException("type"); if (!type.IsIdentifiableEntity()) throw new ArgumentException("type"); if (externalId == null) throw new ArgumentNullException("externalId"); this.Table = Schema.Current.Table(type); this.ExternalId = externalId; this.TableAlias = tableAlias; this.Bindings = bindings.ToReadOnly(); this.Mixins = mixins.ToReadOnly(); this.AvoidExpandOnRetrieving = avoidExpandOnRetrieving; }
public SelectExpression( IdentifiableAlias alias, IEnumerable<FieldDeclaration> fields, Expression from, Expression where, IEnumerable<OrderExpression> orderBy, IEnumerable<Expression> groupBy, bool isDistinct, Expression skip, Expression take, bool reverse ) : base(DbExpressionType.Select, typeof(void), alias) { this.fields = fields.ToReadOnly(); this.isDistinct = isDistinct; this.from = from; this.where = where; this.orderBy = orderBy.ToReadOnly(); this.groupBy = groupBy.ToReadOnly(); this.take = take; this.skip = skip; this.reverse = reverse; }
///<summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents applying an array index operator to an array of rank more than one.</summary> ///<returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> and <see cref="P:System.Linq.Expressions.MethodCallExpression.Arguments" /> properties set to the specified values.</returns> ///<param name="array">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> property equal to.</param> ///<param name="indexes">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.Expression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.MethodCallExpression.Arguments" /> collection.</param> ///<exception cref="T:System.ArgumentNullException"> ///<paramref name="array" /> or <paramref name="indexes" /> is null.</exception> ///<exception cref="T:System.ArgumentException"> ///<paramref name="array" />.Type does not represent an array type.-or-The rank of <paramref name="array" />.Type does not match the number of elements in <paramref name="indexes" />.-or-The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of one or more elements of <paramref name="indexes" /> does not represent the <see cref="T:System.Int32" /> type.</exception> public static MethodCallExpression ArrayIndex(Expression array, IEnumerable<Expression> indexes) { RequiresCanRead(array, "array"); ContractUtils.RequiresNotNull(indexes, "indexes"); Type arrayType = array.Type; if (!arrayType.IsArray) { throw Error.ArgumentMustBeArray(); } ReadOnlyCollection<Expression> indexList = indexes.ToReadOnly(); if (arrayType.GetArrayRank() != indexList.Count) { throw Error.IncorrectNumberOfIndexes(); } foreach (Expression e in indexList) { RequiresCanRead(e, "indexes"); if (e.Type != typeof(int)) { throw Error.ArgumentMustBeArrayIndexType(); } } MethodInfo mi = array.Type.GetMethod("Get", BindingFlags.Public | BindingFlags.Instance); return Call(array, mi, indexList); }
///<summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a method call.</summary> ///<returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" />, <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" />, and <see cref="P:System.Linq.Expressions.MethodCallExpression.Arguments" /> properties set to the specified values.</returns> ///<param name="instance">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> property equal to (pass null for a static (Shared in Visual Basic) method).</param> ///<param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> property equal to.</param> ///<param name="arguments">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.Expression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.MethodCallExpression.Arguments" /> collection.</param> ///<exception cref="T:System.ArgumentNullException"> ///<paramref name="method" /> is null.-or-<paramref name="instance" /> is null and <paramref name="method" /> represents an instance method.</exception> ///<exception cref="T:System.ArgumentException"> ///<paramref name="instance" />.Type is not assignable to the declaring type of the method represented by <paramref name="method" />.-or-The number of elements in <paramref name="arguments" /> does not equal the number of parameters for the method represented by <paramref name="method" />.-or-One or more of the elements of <paramref name="arguments" /> is not assignable to the corresponding parameter for the method represented by <paramref name="method" />.</exception> public static MethodCallExpression Call(Expression instance, MethodInfo method, IEnumerable<Expression> arguments) { IReadOnlyList<Expression> argumentList = arguments as IReadOnlyList<Expression>; if (argumentList != null) { int argCount = argumentList.Count; switch (argCount) { case 0: return Call(instance, method); case 1: return Call(instance, method, argumentList[0]); case 2: return Call(instance, method, argumentList[0], argumentList[1]); case 3: return Call(instance, method, argumentList[0], argumentList[1], argumentList[2]); } if (instance == null) { switch (argCount) { case 4: return Call(method, argumentList[0], argumentList[1], argumentList[2], argumentList[3]); case 5: return Call(method, argumentList[0], argumentList[1], argumentList[2], argumentList[3], argumentList[4]); } } } ContractUtils.RequiresNotNull(method, "method"); ReadOnlyCollection<Expression> argList = arguments.ToReadOnly(); ValidateMethodInfo(method); ValidateStaticOrInstanceMethod(instance, method); ValidateArgumentTypes(method, ExpressionType.Call, ref argList); if (instance == null) { return new MethodCallExpressionN(method, argList); } else { return new InstanceMethodCallExpressionN(method, instance, argList); } }
/// <summary> /// Creates an instance of <see cref="RuntimeVariablesExpression"/>. /// </summary> /// <param name="variables">A collection of <see cref="ParameterExpression"/> objects to use to populate the <see cref="RuntimeVariablesExpression.Variables"/> collection.</param> /// <returns>An instance of <see cref="RuntimeVariablesExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.RuntimeVariables"/> and the <see cref="RuntimeVariablesExpression.Variables"/> property set to the specified value.</returns> public static RuntimeVariablesExpression RuntimeVariables(IEnumerable<ParameterExpression> variables) { ContractUtils.RequiresNotNull(variables, nameof(variables)); ReadOnlyCollection<ParameterExpression> vars = variables.ToReadOnly(); for (int i = 0; i < vars.Count; i++) { ContractUtils.RequiresNotNull(vars[i], nameof(variables), i); } return new RuntimeVariablesExpression(vars); }
/// <summary> /// Creates a <see cref="ForCSharpStatement"/> that represents a for loop. /// </summary> /// <param name="initializers">The loop initializers.</param> /// <param name="test">The condition of the loop.</param> /// <param name="iterators">The loop iterators.</param> /// <param name="body">The body of the loop.</param> /// <param name="break">The break target used by the loop body.</param> /// <param name="continue">The continue target used by the loop body.</param> /// <returns>The created <see cref="ForCSharpStatement"/>.</returns> public static ForCSharpStatement For(IEnumerable<BinaryExpression> initializers, Expression test, IEnumerable<Expression> iterators, Expression body, LabelTarget @break, LabelTarget @continue) { ValidateLoop(test, body, @break, @continue, optionalTest: true); // NB: While C# requires all initializers to be of the same type, we don't quite need that restriction here. // This can be revisited. We will check whether all initializers are simple assignments though. var initializerList = initializers.ToReadOnly<Expression>(); RequiresNotNullItems(initializerList, nameof(initializers)); var uniqueVariables = new HashSet<ParameterExpression>(); var variables = new List<ParameterExpression>(); foreach (BinaryExpression initializer in initializerList) { if (initializer.NodeType != ExpressionType.Assign || initializer.Left.NodeType != ExpressionType.Parameter) { throw Error.InvalidInitializer(); } var variable = (ParameterExpression)initializer.Left; if (!uniqueVariables.Add(variable)) { throw LinqError.DuplicateVariable(variable); } // NB: We keep them in the order specified and don't rely on the hash set. variables.Add(variable); } var variableList = variables.ToReadOnly(); var iteratorList = iterators.ToReadOnly(); RequiresNotNullItems(iteratorList, nameof(iterators)); return ForCSharpStatement.Make(variableList, initializerList, test, iteratorList, body, @break, @continue); }
///<summary> ///Creates an <see cref="T:System.Linq.Expressions.InvocationExpression" /> that ///applies a delegate or lambda expression to a list of argument expressions. ///</summary> ///<returns> ///An <see cref="T:System.Linq.Expressions.InvocationExpression" /> that ///applies the specified delegate or lambda expression to the provided arguments. ///</returns> ///<param name="expression"> ///An <see cref="T:System.Linq.Expressions.Expression" /> that represents the delegate ///or lambda expression to be applied. ///</param> ///<param name="arguments"> ///An <see cref="T:System.Collections.Generic.IEnumerable`1" /> of <see cref="T:System.Linq.Expressions.Expression" /> objects ///that represent the arguments that the delegate or lambda expression is applied to. ///</param> ///<exception cref="T:System.ArgumentNullException"> ///<paramref name="expression" /> is null.</exception> ///<exception cref="T:System.ArgumentException"> ///<paramref name="expression" />.Type does not represent a delegate type or an <see cref="T:System.Linq.Expressions.Expression`1" />.-or-The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of an element of <paramref name="arguments" /> is not assignable to the type of the corresponding parameter of the delegate represented by <paramref name="expression" />.</exception> ///<exception cref="T:System.InvalidOperationException"> ///<paramref name="arguments" /> does not contain the same number of elements as the list of parameters for the delegate represented by <paramref name="expression" />.</exception> public static InvocationExpression Invoke(Expression expression, IEnumerable<Expression> arguments) { RequiresCanRead(expression, "expression"); var args = arguments.ToReadOnly(); var mi = GetInvokeMethod(expression); ValidateArgumentTypes(mi, ExpressionType.Invoke, ref args); return new InvocationExpression(expression, args, mi.ReturnType); }
/// <summary> /// Creates a <see cref="TryExpression"/> representing a try block with the specified elements. /// </summary> /// <param name="type">The result type of the try expression. If null, bodh and all handlers must have identical type.</param> /// <param name="body">The body of the try block.</param> /// <param name="finally">The body of the finally block. Pass null if the try block has no finally block associated with it.</param> /// <param name="fault">The body of the t block. Pass null if the try block has no fault block associated with it.</param> /// <param name="handlers">A collection of <see cref="CatchBlock"/>s representing the catch statements to be associated with the try block.</param> /// <returns>The created <see cref="TryExpression"/>.</returns> public static TryExpression MakeTry(Type type, Expression body, Expression @finally, Expression fault, IEnumerable<CatchBlock> handlers) { RequiresCanRead(body, "body"); var @catch = handlers.ToReadOnly(); ContractUtils.RequiresNotNullItems(@catch, "handlers"); ValidateTryAndCatchHaveSameType(type, body, @catch); if (fault != null) { if (@finally != null || @catch.Count > 0) { throw Error.FaultCannotHaveCatchOrFinally(); } RequiresCanRead(fault, "fault"); } else if (@finally != null) { RequiresCanRead(@finally, "finally"); } else if (@catch.Count == 0) { throw Error.TryMustHaveCatchFinallyOrFault(); } return new TryExpression(type ?? body.Type, body, @finally, fault, @catch); }
/// <summary> /// Creates a <see cref="SwitchExpression"/>. /// </summary> /// <param name="type">The result type of the switch.</param> /// <param name="switchValue">The value to be tested against each case.</param> /// <param name="defaultBody">The result of the switch if no cases are matched.</param> /// <param name="comparison">The equality comparison method to use.</param> /// <param name="cases">The valid cases for this switch.</param> /// <returns>The created <see cref="SwitchExpression"/>.</returns> public static SwitchExpression Switch(Type type, Expression switchValue, Expression defaultBody, MethodInfo comparison, IEnumerable<SwitchCase> cases) { RequiresCanRead(switchValue, nameof(switchValue)); if (switchValue.Type == typeof(void)) throw Error.ArgumentCannotBeOfTypeVoid(nameof(switchValue)); ReadOnlyCollection<SwitchCase> caseList = cases.ToReadOnly(); ContractUtils.RequiresNotNullItems(caseList, nameof(cases)); // Type of the result. Either provided, or it is type of the branches. Type resultType; if (type != null) resultType = type; else if (caseList.Count != 0) resultType = caseList[0].Body.Type; else if (defaultBody != null) resultType = defaultBody.Type; else resultType = typeof(void); bool customType = type != null; if (comparison != null) { ParameterInfo[] pms = comparison.GetParametersCached(); if (pms.Length != 2) { throw Error.IncorrectNumberOfMethodCallArguments(comparison, nameof(comparison)); } // Validate that the switch value's type matches the comparison method's // left hand side parameter type. ParameterInfo leftParam = pms[0]; bool liftedCall = false; if (!ParameterIsAssignable(leftParam, switchValue.Type)) { liftedCall = ParameterIsAssignable(leftParam, switchValue.Type.GetNonNullableType()); if (!liftedCall) { throw Error.SwitchValueTypeDoesNotMatchComparisonMethodParameter(switchValue.Type, leftParam.ParameterType); } } ParameterInfo rightParam = pms[1]; foreach (SwitchCase c in caseList) { ContractUtils.RequiresNotNull(c, nameof(cases)); ValidateSwitchCaseType(c.Body, customType, resultType, nameof(cases)); for (int i = 0; i < c.TestValues.Count; i++) { // When a comparison method is provided, test values can have different type but have to // be reference assignable to the right hand side parameter of the method. Type rightOperandType = c.TestValues[i].Type; if (liftedCall) { if (!rightOperandType.IsNullableType()) { throw Error.TestValueTypeDoesNotMatchComparisonMethodParameter(rightOperandType, rightParam.ParameterType); } rightOperandType = rightOperandType.GetNonNullableType(); } if (!ParameterIsAssignable(rightParam, rightOperandType)) { throw Error.TestValueTypeDoesNotMatchComparisonMethodParameter(rightOperandType, rightParam.ParameterType); } } } // if we have a non-boolean user-defined equals, we don't want it. if (comparison.ReturnType != typeof(bool)) { throw Error.EqualityMustReturnBoolean(comparison, nameof(comparison)); } } else if (caseList.Count != 0) { // When comparison method is not present, all the test values must have // the same type. Use the first test value's type as the baseline. Expression firstTestValue = caseList[0].TestValues[0]; foreach (SwitchCase c in caseList) { ContractUtils.RequiresNotNull(c, nameof(cases)); ValidateSwitchCaseType(c.Body, customType, resultType, nameof(cases)); // When no comparison method is provided, require all test values to have the same type. for (int i = 0; i < c.TestValues.Count; i++) { if (!TypeUtils.AreEquivalent(firstTestValue.Type, c.TestValues[i].Type)) { throw Error.AllTestValuesMustHaveSameType(nameof(cases)); } } } // Now we need to validate that switchValue.Type and testValueType // make sense in an Equal node. Fortunately, Equal throws a // reasonable error, so just call it. BinaryExpression equal = Equal(switchValue, firstTestValue, false, comparison); // Get the comparison function from equals node. comparison = equal.Method; } if (defaultBody == null) { if (resultType != typeof(void)) throw Error.DefaultBodyMustBeSupplied(nameof(defaultBody)); } else { ValidateSwitchCaseType(defaultBody, customType, resultType, nameof(defaultBody)); } return new SwitchExpression(resultType, switchValue, defaultBody, comparison, caseList); }
/// <summary> /// Creates a <see cref="ForCSharpStatement"/> that represents a for loop. /// </summary> /// <param name="variables">The variables in scope of the loop.</param> /// <param name="initializers">The loop initializers.</param> /// <param name="test">The condition of the loop.</param> /// <param name="iterators">The loop iterators.</param> /// <param name="body">The body of the loop.</param> /// <param name="break">The break target used by the loop body.</param> /// <param name="continue">The continue target used by the loop body.</param> /// <returns>The created <see cref="ForCSharpStatement"/>.</returns> public static ForCSharpStatement For(IEnumerable<ParameterExpression> variables, IEnumerable<Expression> initializers, Expression test, IEnumerable<Expression> iterators, Expression body, LabelTarget @break, LabelTarget @continue) { ValidateLoop(test, body, @break, @continue, optionalTest: true); // NB: While C# requires all initializers to be of the same type, we don't quite need that restriction here. // This can be revisited. We will check whether all initializers are simple assignments though. var variableList = variables.ToReadOnly(); var initializerList = initializers.ToReadOnly<Expression>(); RequiresNotNullItems(initializerList, nameof(initializers)); var uniqueVariables = new HashSet<ParameterExpression>(); foreach (var variable in variableList) { if (!uniqueVariables.Add(variable)) { throw LinqError.DuplicateVariable(variable); } } var iteratorList = iterators.ToReadOnly(); RequiresNotNullItems(iteratorList, nameof(iterators)); return ForCSharpStatement.Make(variableList, initializerList, test, iteratorList, body, @break, @continue); }