| Name |
Description |
| ActionBinder |
|
| BinderMappingInfo |
Contains the mapping information for a single Combo Binder. This includes the original meta-binder and the mapping of parameters, sub-sites, and constants into the binding. |
| BoundMemberTracker |
|
| ComboActionRewriter |
A tree rewriter which will find dynamic sites which consume dynamic sites and turn them into a single combo dynamic site. The combo dynamic site will then run the individual meta binders and produce the resulting code in a single dynamic site. |
| ComboActionRewriter.ComboDynamicSiteExpression |
A reducible node which we use to generate the combo dynamic sites. Each time we encounter a dynamic site we replace it with a ComboDynamicSiteExpression. When a child of a dynamic site turns out to be a ComboDynamicSiteExpression we will then merge the child with the parent updating the binding mapping info. If any of the inputs cause side effects then we'll stop the combination. |
| ComboBinder |
A binder which can combine multiple binders into a single dynamic site. The creator of this needs to perform the mapping of parameters, constants, and sub-site expressions and provide a List of BinderMappingInfo representing this data. From there the ComboBinder just processes the list to create the resulting code. |
| ComboBinder.ReplaceUpdateVisitor |
|
| ConditionalBuilder |
Builds up a series of conditionals when the False clause isn't yet known. We can keep appending conditions and if true's. Each subsequent true branch becomes the false branch of the previous condition and body. Finally a non-conditional terminating branch must be added. |
| ConstructorTracker |
|
| DefaultBinder |
|
| DefaultBinder.GetMemberInfo |
Helper class for flowing information about the GetMember request. |
| DefaultBinder.TargetInfo |
Encapsulates information about the target of the call. This includes an implicit instance for the call, the methods that we'll be calling as well as any restrictions required to perform the call. |
| DefaultOverloadResolver |
|
| DefaultOverloadResolverFactory |
|
| ErrorInfo |
Encapsulates information about the result that should be produced when a OldDynamicAction cannot be performed. The ErrorInfo can hold one of: an expression which creates an Exception to be thrown an expression which produces a value which should be returned directly to the user and represents an error has occured (for example undefined in JavaScript) an expression which produces a value which should be returned directly to the user but does not actually represent an error. ErrorInfo's are produced by an ActionBinder in response to a failed binding. |
| ErrorMetaObject |
A MetaObject which was produced as the result of a failed binding. |
| EventTracker |
|
| EventTracker.ComHandlerList |
|
| EventTracker.HandlerList |
Holds on a list of delegates hooked to the event. We need the list because we cannot enumerate the delegates hooked to CLR event and we need to do so in handler removal (we need to do custom delegate comparison there). If BCL enables the enumeration we could remove this. |
| EventTracker.NormalHandlerList |
|
| ExtensionBinaryOperationBinder |
|
| ExtensionUnaryOperationBinder |
|
| Interceptor |
Interceptor prototype. The interceptor is a call site binder that wraps a real call site binder and can perform arbitrary operations on the expression trees that the wrapped binder produces: * Dumping the trees * Additional rewriting * Static compilation * ... |
| Interceptor.InterceptorSiteBinder |
|
| Interceptor.InterceptorWalker |
|
| MemberTracker |
Represents a logical member of a type. The member could either be real concrete member on a type or an extension member. This seperates the "physical" members that .NET knows exist on types from the members that logically exist on a type. It also provides other abstractions above the level of .NET reflection such as MemberGroups and NamespaceTracker's. It also provides a wrapper around the reflection APIs which cannot be extended from partial trust. |
| MemberTracker.MemberKey |
We ensure we only produce one MemberTracker for each member which logically lives on the declaring type. So for example if you get a member from a derived class which is declared on the base class it should be the same as getting the member from the base class. That’s easy enough until you get into extension members – here there might be one extension member which is being applied to multiple types. Therefore we need to take into account the extension type when ensuring that we only have 1 MemberTracker ever created. |
| MethodGroup |
MethodGroup's represent a unique collection of method's. Typically this unique set is all the methods which are overloaded by the same name including methods with different arity. These methods represent a single logically overloaded element of a .NET type. The base DLR binders will produce MethodGroup's when provided with a MemberGroup which contains only methods. The MethodGroup's will be unique instances per each unique group of methods. |
| MethodGroup.TypeList |
|
| MethodTracker |
|
| NestedTypeTracker |
|
| OperationBinder |
|
| OperationMetaObject |
|
| OperatorInfo |
OperatorInfo provides a mapping from DLR ExpressionType to their associated .NET methods. |
| ParameterMappingInfo |
Provides a mapping for inputs of combo action expressions. The input can map to either an input of the new dynamic site, an input of a previous DynamicExpression, or a ConstantExpression which has been pulled out of the dynamic site arguments. |
| PropertyTracker |
Represents a logical Property as a member of a Type. This Property can either be a real concrete Property on a type (implemented with a ReflectedPropertyTracker) or an extension property (implemented with an ExtensionPropertyTracker). |
| ReflectedPropertyTracker |
|
| TopNamespaceTracker |
Represents the top reflected package which contains extra information such as all the assemblies loaded and the built-in modules. |
| TypeGroup |
A TypeCollision is used when we have a collision between two types with the same name. Currently this is only possible w/ generic methods that should logically have arity as a portion of their name. For eg: System.EventHandler and System.EventHandler[T] System.Nullable and System.Nullable[T] System.IComparable and System.IComparable[T] The TypeCollision provides an indexer but also is a real type. When used as a real type it is the non-generic form of the type. The indexer allows the user to disambiguate between the generic and non-generic versions. Therefore users must always provide additional information to get the generic version. |
| TypeTracker |
|