/// <summary> /// Creates a new ScriptScope whose storage contains the provided dictionary of objects /// /// Accesses to the ScriptScope will turn into get,set, and delete members against this dictionary /// </summary> public ScriptScope CreateScope(IDictionary <string, object> dictionary) { ContractUtils.RequiresNotNull(dictionary, "dictionary"); return(new ScriptScope(this, _language.CreateScope(dictionary))); }
public SwitchCaseProxy(SwitchCase node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
public SwitchExpressionProxy(SwitchExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
public MethodCallExpressionProxy(MethodCallExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
public ParameterExpressionProxy(ParameterExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
public DefaultExpressionProxy(DefaultExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
public LambdaExpressionProxy(LambdaExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
/// <summary> /// Gets the formatting information for the given format. This is a list of tuples. The tuples /// include: /// /// text, field name, format spec, conversion /// </summary> public static IEnumerable <PythonTuple /*!*/> /*!*/ GetFormatInfo(string /*!*/ format) { ContractUtils.RequiresNotNull(format, nameof(format)); return(StringFormatParser.Parse(format)); }
/// <summary> /// Initializes a new instance of the <see cref="InvokeBinder" />. /// </summary> /// <param name="callInfo">The signature of the arguments at the call site.</param> protected InvokeBinder(CallInfo callInfo) { ContractUtils.RequiresNotNull(callInfo, "callInfo"); _callInfo = callInfo; }
/// <summary> /// Returns a new ObjectOperations object that inherits any semantics particular to the provided ScriptScope. /// /// See the Operations property for why you might want to call this. /// </summary> public ObjectOperations CreateOperations(ScriptScope scope) { ContractUtils.RequiresNotNull(scope, "scope"); return(new ObjectOperations(_language.Operations, this)); }
internal SymbolDocumentInfo(string fileName) { ContractUtils.RequiresNotNull(fileName, "fileName"); _fileName = fileName; }
/// <summary> /// These methods return ScriptSource objects from stream contents with the current engine as the language binding. /// /// The default SourceCodeKind is File. /// /// The encoding defaults to Encoding.Default. /// </summary> public ScriptSource CreateScriptSource(StreamContentProvider content, string path) { ContractUtils.RequiresNotNull(content, "content"); return(CreateScriptSource(content, path, StringUtils.DefaultEncoding, SourceCodeKind.File)); }
/// <summary> /// Return a ScriptSource object from string contents with the current engine as the language binding. /// /// The default SourceCodeKind is AutoDetect. /// </summary> public ScriptSource CreateScriptSourceFromString(string expression, string path) { ContractUtils.RequiresNotNull(expression, "expression"); return(CreateScriptSource(new SourceStringContentProvider(expression), path, SourceCodeKind.AutoDetect)); }
/// <summary> /// Creates a new ScriptScope whose storage is an arbitrary object. /// /// Accesses to the ScriptScope will turn into get, set, and delete members against the object. /// </summary> public ScriptScope CreateScope(IDynamicMetaObjectProvider storage) { ContractUtils.RequiresNotNull(storage, "storage"); return(new ScriptScope(this, _language.CreateScope(storage))); }
/// <summary> /// Creates a <see cref="MemberMemberBinding"/> that represents the recursive initialization of members of a member that is accessed by using a property accessor method. /// </summary> /// <param name="propertyAccessor">The <see cref="MemberInfo"/> that represents a property accessor method.</param> /// <param name="bindings">An <see cref="IEnumerable{T}"/> that contains <see cref="MemberBinding"/> objects to use to populate the <see cref="MemberMemberBinding.Bindings"/> collection.</param> /// <returns> /// A <see cref="MemberMemberBinding"/> that has the <see cref="MemberBinding.BindingType"/> property equal to <see cref="MemberBinding"/>, /// the Member property set to the <see cref="PropertyInfo"/> that represents the property accessed in <paramref name="propertyAccessor"/>, /// and <see cref="MemberMemberBinding.Bindings"/> properties set to the specified values. /// </returns> public static MemberMemberBinding MemberBind(MethodInfo propertyAccessor, IEnumerable <MemberBinding> bindings) { ContractUtils.RequiresNotNull(propertyAccessor, nameof(propertyAccessor)); return(MemberBind(GetProperty(propertyAccessor, nameof(propertyAccessor)), bindings)); }
/// <summary> /// Compiles the lambda into a method definition and custom debug information. /// </summary> /// <param name="method">A <see cref="MethodBuilder"/> which will be used to hold the lambda's IL.</param> /// <param name="debugInfoGenerator">Debugging information generator used by the compiler to mark sequence points and annotate local variables.</param> public void CompileToMethod(MethodBuilder method, DebugInfoGenerator debugInfoGenerator) { ContractUtils.RequiresNotNull(debugInfoGenerator, "debugInfoGenerator"); CompileToMethodInternal(method, debugInfoGenerator); }
/// <summary> /// Creates a <see cref="MemberExpression"/> accessing a property. /// </summary> /// <param name="expression">The containing object of the property. This can be null for static properties.</param> /// <param name="propertyAccessor">An accessor method of the property to be accessed.</param> /// <returns>The created <see cref="MemberExpression"/>.</returns> public static MemberExpression Property(Expression expression, MethodInfo propertyAccessor) { ContractUtils.RequiresNotNull(propertyAccessor, "propertyAccessor"); ValidateMethodInfo(propertyAccessor); return(Property(expression, GetProperty(propertyAccessor))); }
/// <summary> /// Produces a delegate that represents the lambda expression. /// </summary> /// <param name="debugInfoGenerator">Debugging information generator used by the compiler to mark sequence points and annotate local variables.</param> /// <returns>A delegate containing the compiled version of the lambda.</returns> public new TDelegate Compile(DebugInfoGenerator debugInfoGenerator) { ContractUtils.RequiresNotNull(debugInfoGenerator, "debugInfoGenerator"); return((TDelegate)(object)LambdaCompiler.Compile(this, debugInfoGenerator)); }
public InvocationExpressionProxy(InvocationExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
/// <summary> /// Creates a <see cref="CatchBlock"/> representing a catch statement with /// an <see cref="Exception"/> filter and a reference to the caught <see cref="Exception"/> object. /// </summary> /// <param name="variable">A <see cref="ParameterExpression"/> representing a reference to the <see cref="Exception"/> object caught by this handler.</param> /// <param name="body">The body of the catch statement.</param> /// <param name="filter">The body of the <see cref="Exception"/> filter.</param> /// <returns>The created <see cref="CatchBlock"/>.</returns> public static CatchBlock Catch(ParameterExpression variable, Expression body, Expression filter) { ContractUtils.RequiresNotNull(variable, nameof(variable)); return(MakeCatchBlock(variable.Type, variable, body, filter)); }
public MemberInitExpressionProxy(MemberInitExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
/// <summary> /// Creates a <see cref="DebugInfoExpression"/> for clearing a sequence point. /// </summary> /// <param name="document">The <see cref="SymbolDocumentInfo"/> that represents the source file.</param> /// <returns>An instance of <see cref="DebugInfoExpression"/> for clearning a sequence point.</returns> public static DebugInfoExpression ClearDebugInfo(SymbolDocumentInfo document) { ContractUtils.RequiresNotNull(document, "document"); return(new ClearDebugInfoExpression(document)); }
public NewArrayExpressionProxy(NewArrayExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
/// <summary> /// Initializes a new instance of the <see cref="DeleteIndexBinder" />. /// </summary> /// <param name="callInfo">The signature of the arguments at the call site.</param> protected DeleteIndexBinder(CallInfo callInfo) { ContractUtils.RequiresNotNull(callInfo, "callInfo"); _callInfo = callInfo; }
public RuntimeVariablesExpressionProxy(RuntimeVariablesExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
/// <summary> /// EventInfo.EventHandlerType getter is marked SecuritySafeCritical in CoreCLR /// This method is to get to the property without using Reflection /// </summary> /// <param name="eventInfo"></param> /// <returns></returns> public static Type GetEventHandlerType(EventInfo eventInfo) { ContractUtils.RequiresNotNull(eventInfo, nameof(eventInfo)); return(eventInfo.EventHandlerType); }
public BlockExpressionProxy(BlockExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
/// <summary> /// Performs the runtime binding of the dynamic operation on a set of arguments. /// </summary> /// <param name="args">An array of arguments to the dynamic operation.</param> /// <param name="parameters">The array of <see cref="ParameterExpression"/> instances that represent the parameters of the call site in the binding process.</param> /// <param name="returnLabel">A LabelTarget used to return the result of the dynamic binding.</param> /// <returns> /// An Expression that performs tests on the dynamic operation arguments, and /// performs the dynamic operation if the tests are valid. If the tests fail on /// subsequent occurrences of the dynamic operation, Bind will be called again /// to produce a new <see cref="Expression"/> for the new argument types. /// </returns> public sealed override Expression Bind(object[] args, ReadOnlyCollection <ParameterExpression> parameters, LabelTarget returnLabel) { ContractUtils.RequiresNotNull(args, nameof(args)); ContractUtils.RequiresNotNull(parameters, nameof(parameters)); ContractUtils.RequiresNotNull(returnLabel, nameof(returnLabel)); if (args.Length == 0) { throw System.Linq.Expressions.Error.OutOfRange("args.Length", 1); } if (parameters.Count == 0) { throw System.Linq.Expressions.Error.OutOfRange("parameters.Count", 1); } if (args.Length != parameters.Count) { throw new ArgumentOutOfRangeException(nameof(args)); } // Ensure that the binder's ReturnType matches CallSite's return // type. We do this so meta objects and language binders can // compose trees together without needing to insert converts. Type expectedResult; if (IsStandardBinder) { expectedResult = ReturnType; if (returnLabel.Type != typeof(void) && !TypeUtils.AreReferenceAssignable(returnLabel.Type, expectedResult)) { throw System.Linq.Expressions.Error.BinderNotCompatibleWithCallSite(expectedResult, this, returnLabel.Type); } } else { // Even for non-standard binders, we have to at least make sure // it works with the CallSite's type to build the return. expectedResult = returnLabel.Type; } DynamicMetaObject target = DynamicMetaObject.Create(args[0], parameters[0]); DynamicMetaObject[] metaArgs = CreateArgumentMetaObjects(args, parameters); DynamicMetaObject binding = Bind(target, metaArgs); if (binding == null) { throw System.Linq.Expressions.Error.BindingCannotBeNull(); } Expression body = binding.Expression; BindingRestrictions restrictions = binding.Restrictions; // Ensure the result matches the expected result type. if (expectedResult != typeof(void) && !TypeUtils.AreReferenceAssignable(expectedResult, body.Type)) { // // Blame the last person that handled the result: assume it's // the dynamic object (if any), otherwise blame the language. // if (target.Value is IDynamicMetaObjectProvider) { throw System.Linq.Expressions.Error.DynamicObjectResultNotAssignable(body.Type, target.Value.GetType(), this, expectedResult); } else { throw System.Linq.Expressions.Error.DynamicBinderResultNotAssignable(body.Type, this, expectedResult); } } // if the target is IDO, standard binders ask it to bind the rule so we may have a target-specific binding. // it makes sense to restrict on the target's type in such cases. // ideally IDO metaobjects should do this, but they often miss that type of "this" is significant. if (IsStandardBinder && args[0] is IDynamicMetaObjectProvider) { if (restrictions == BindingRestrictions.Empty) { throw System.Linq.Expressions.Error.DynamicBindingNeedsRestrictions(target.Value !.GetType(), this); } } // Add the return if (body.NodeType != ExpressionType.Goto) { body = Expression.Return(returnLabel, body); } // Finally, add restrictions if (restrictions != BindingRestrictions.Empty) { body = Expression.IfThen(restrictions.ToExpression(), body); } return(body); }
public TypeBinaryExpressionProxy(TypeBinaryExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
/// <summary> /// Constructs a <see cref="ReadOnlyCollectionBuilder{T}"/> with a given initial capacity. /// The contents are empty but builder will have reserved room for the given /// number of elements before any reallocations are required. /// </summary> /// <param name="capacity">Initial capacity of the builder.</param> public ReadOnlyCollectionBuilder(int capacity) { ContractUtils.Requires(capacity >= 0, nameof(capacity)); _items = new T[capacity]; }