/// <summary> /// Performs an assignment variable = value /// </summary> public static BoundAssignment Assign(Variable variable, Expression value) { Contract.RequiresNotNull(variable, "variable"); Contract.RequiresNotNull(value, "value"); Contract.Requires(TypeUtils.CanAssign(variable.Type, value.Type)); return(new BoundAssignment(variable, value)); }
private static void ValidateCallArguments(IList <ParameterInfo> parameters, IList <Expression> arguments) { Contract.Requires(parameters.Count == arguments.Count, "arguments", "Argument count must match parameter count"); int count = parameters.Count; for (int index = 0; index < count; index++) { Type pt = parameters[index].ParameterType; Contract.Requires(!TypeUtils.IsGeneric(pt), "arguments"); if (pt.IsByRef) { pt = pt.GetElementType(); } if (!TypeUtils.CanAssign(pt, arguments[index].Type)) { throw new ArgumentException( String.Format( "Invalid type for argument {0}. Expected {1}, got {2}.", index, pt.Name, arguments[index].Type.Name ), "arguments" ); } } }
public static CatchBlock Catch(SourceSpan span, SourceLocation header, Type type, Variable target, Statement body) { Contract.RequiresNotNull(type, "type"); Contract.Requires(target == null || TypeUtils.CanAssign(target.Type, type), "target"); Contract.RequiresNotNull(body, "body"); return(new CatchBlock(span, header, type, target, body)); }
public static MethodCallExpression Call(Expression instance, MethodInfo method, params Expression[] arguments) { Contract.RequiresNotNull(method, "method"); Contract.Requires(!method.IsGenericMethodDefinition, "method"); Contract.Requires(!method.ContainsGenericParameters, "method"); if (method.IsStatic) { Contract.Requires(instance == null, "instance", "Instance must be null for static method"); } else { Contract.RequiresNotNull(instance, "instance"); if (!TypeUtils.CanAssign(method.DeclaringType, instance.Type)) { throw new ArgumentException( String.Format( "Invalid instance type for {0}.{1}. Expected {0}, got {2}.", method.DeclaringType.Name, method.Name, instance.Type.Name ), "instance" ); } } Contract.RequiresNotNullItems(arguments, "arguments"); ParameterInfo[] parameters = method.GetParameters(); ValidateCallArguments(parameters, arguments); return(new MethodCallExpression(method, instance, CollectionUtils.ToReadOnlyCollection(arguments), parameters)); }
public static NewArrayExpression NewArrayHelper(Type type, IList <Expression> initializers) { Contract.RequiresNotNullItems(initializers, "initializers"); Contract.RequiresNotNull(type, "type"); Contract.Requires(type.IsArray, "type", "Not an array type"); Type element = type.GetElementType(); Expression[] clone = null; for (int i = 0; i < initializers.Count; i++) { Expression initializer = initializers[i]; if (!TypeUtils.CanAssign(element, initializer.Type)) { if (clone == null) { clone = new Expression[initializers.Count]; for (int j = 0; j < i; j++) { clone[j] = initializers[j]; } } initializer = Ast.Convert(initializer, element); } if (clone != null) { clone[i] = initializer; } } return(NewArray(type, clone ?? initializers)); }
internal static void CheckField(FieldInfo info, Expression instance, Expression rightValue) { Contract.RequiresNotNull(info, "field"); Contract.Requires((instance == null) == info.IsStatic, "expression", "Static field requires null expression, non-static field requires non-null expression."); Contract.Requires(instance == null || TypeUtils.CanAssign(info.DeclaringType, instance.Type), "expression", "Incorrect instance type for the property"); Contract.Requires(rightValue == null || TypeUtils.CanAssign(info.FieldType, rightValue.Type), "value", "Incorrect value type for the field"); }
public static ScopeStatement Scope(SourceSpan span, Expression scope, Statement body) { Contract.RequiresNotNull(scope, "scope"); Contract.RequiresNotNull(body, "body"); Contract.Requires(TypeUtils.CanAssign(typeof(IAttributesCollection), scope.Type), "scope", "Scope must be IAttributesCollection"); return(new ScopeStatement(span, scope, body)); }
public static ThrowStatement Throw(SourceSpan span, Expression value) { if (value != null) { Contract.Requires(TypeUtils.CanAssign(typeof(Exception), value.Type)); } return(new ThrowStatement(span, value)); }
public static CodeBlock Generator(SourceSpan span, string name, Type generator, Type next) { Contract.RequiresNotNull(name, "name"); Contract.RequiresNotNull(generator, "generator"); Contract.RequiresNotNull(next, "next"); Contract.Requires(TypeUtils.CanAssign(typeof(Generator), generator), "generator", "The generator type must inherit from Generator"); return(new GeneratorCodeBlock(span, name, generator, next)); }
internal static void CheckProperty(PropertyInfo info, Expression instance, Expression rightValue) { Contract.RequiresNotNull(info, "property"); MethodInfo mi = (rightValue != null) ? info.GetSetMethod() : info.GetGetMethod(); Contract.Requires(mi != null, "Property is not readable"); Contract.Requires((instance == null) == mi.IsStatic, "expression", "Static property requires null expression, non-static property requires non-null expression."); Contract.Requires(instance == null || TypeUtils.CanAssign(info.DeclaringType, instance.Type), "expression", "Incorrect instance type for the property"); Contract.Requires(rightValue == null || TypeUtils.CanAssign(info.PropertyType, rightValue.Type), "value", "Incorrect value type for the property"); }
public static ConstantExpression Constant(object value, Type type) { Contract.RequiresNotNull(type, "type"); if (value == null) { Contract.Requires(!type.IsValueType, "type"); } else { Contract.Requires(TypeUtils.CanAssign(type, value.GetType()), "type"); } return(new ConstantExpression(value, type)); }
/// <summary> /// Creates a new array expression of the specified type from the provided initializers. /// </summary> /// <param name="type">The type of the array (e.g. object[]).</param> /// <param name="initializers">The expressions used to create the array elements.</param> public static NewArrayExpression NewArray(Type type, IList <Expression> initializers) { Contract.RequiresNotNull(initializers, "initializers"); Contract.RequiresNotNull(type, "type"); Contract.Requires(type.IsArray, "type", "Not an array type"); Contract.RequiresNotNullItems(initializers, "initializers"); Type element = type.GetElementType(); foreach (Expression expression in initializers) { Contract.Requires(TypeUtils.CanAssign(element, expression.Type), "initializers"); } return(new NewArrayExpression(type, CollectionUtils.ToReadOnlyCollection(initializers))); }
private static Expression CoalesceInternal(CodeBlock currentBlock, Expression left, Expression right, MethodInfo isTrue, bool isReverse) { Contract.RequiresNotNull(currentBlock, "currentBlock"); Contract.RequiresNotNull(left, "left"); Contract.RequiresNotNull(right, "right"); // A bit too strict, but on a safe side. Contract.Requires(left.Type == right.Type, "Expression types must match"); Variable tmp = currentBlock.CreateTemporaryVariable(SymbolTable.StringToId("tmp_left"), left.Type); Expression condition; if (isTrue != null) { Contract.Requires(isTrue.ReturnType == typeof(bool), "isTrue", "Predicate must return bool."); ParameterInfo[] parameters = isTrue.GetParameters(); Contract.Requires(parameters.Length == 1, "isTrue", "Predicate must take one parameter."); Contract.Requires(isTrue.IsStatic && isTrue.IsPublic, "isTrue", "Predicate must be public and static."); Type pt = parameters[0].ParameterType; Contract.Requires(TypeUtils.CanAssign(pt, left.Type), "left", "Incorrect left expression type"); condition = Call(isTrue, Assign(tmp, left)); } else { Contract.Requires(TypeUtils.CanCompareToNull(left.Type), "left", "Incorrect left expression type"); condition = Equal(Assign(tmp, left), Null(left.Type)); } Expression t, f; if (isReverse) { t = Read(tmp); f = right; } else { t = right; f = Read(tmp); } return(Condition(condition, t, f)); }
private static Expression CoalesceInternal(Expression left, Expression right, MethodInfo isTrue, bool isReverse, out ParameterExpression temp) { ContractUtils.RequiresNotNull(left, "left"); ContractUtils.RequiresNotNull(right, "right"); // A bit too strict, but on a safe side. ContractUtils.Requires(left.Type == right.Type, "Expression types must match"); temp = Expression.Variable(left.Type, "tmp_left"); Expression condition; if (isTrue != null) { ContractUtils.Requires(isTrue.ReturnType == typeof(bool), "isTrue", "Predicate must return bool."); ParameterInfo[] parameters = isTrue.GetParameters(); ContractUtils.Requires(parameters.Length == 1, "isTrue", "Predicate must take one parameter."); ContractUtils.Requires(isTrue.IsStatic && isTrue.IsPublic, "isTrue", "Predicate must be public and static."); Type pt = parameters[0].ParameterType; ContractUtils.Requires(TypeUtils.CanAssign(pt, left.Type), "left", "Incorrect left expression type"); condition = Expression.Call(isTrue, Expression.Assign(temp, left)); } else { ContractUtils.Requires(TypeUtils.CanCompareToNull(left.Type), "left", "Incorrect left expression type"); condition = Expression.Equal(Expression.Assign(temp, left), AstUtils.Constant(null, left.Type)); } Expression t, f; if (isReverse) { t = temp; f = right; } else { t = right; f = temp; } return(Expression.Condition(condition, t, f)); }
internal static Variable Create(SymbolId name, VariableKind kind, CodeBlock block, Type type, Expression defaultValue) { Contract.Requires(defaultValue == null || TypeUtils.CanAssign(type, defaultValue.Type)); Contract.Requires(kind != VariableKind.Parameter, "kind"); return(new Variable(name, kind, block, type, defaultValue)); }