<?xml version="1.0"?>
<doc>
    <assembly>
        <name>IronPython</name>
    </assembly>
    <members>
        <member name="M:IronPython.Compiler.Ast.ClassDefinition.GetParentClosureTuple">
            <summary>
            Gets the closure tuple from our parent context.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.ComprehensionScope">
            <summary>
            Scope for the comprehension.  Because scopes are usually statements and comprehensions are expressions
            this doesn't actually show up in the AST hierarchy and instead hangs off the comprehension expression.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.FunctionDefinition.GetParentClosureTuple">
            <summary>
            Pulls the closure tuple from our function/generator which is flowed into each function call.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.FunctionDefinition.MakeFunctionExpression">
            <summary>
            Returns an expression which creates the function object.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.FunctionDefinition.EnsureFunctionLambda">
            <summary>
            Creates the LambdaExpression which is the actual function body.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.FunctionDefinition.CreateFunctionLambda">
            <summary>
            Creates the LambdaExpression which implements the body of the function.
            
            The functions signature is either "object Function(PythonFunction, ...)"
            where there is one object parameter for each user defined parameter or
            object Function(PythonFunction, object[]) for functions which take more
            than PythonCallTargets.MaxArgs arguments.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.FunctionDefinition.GetDelegateType(IronPython.Compiler.Ast.Parameter[],System.Boolean,System.Delegate@)">
            <summary>
            Determines delegate type for the Python function
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.FunctionDefinition.ArbitraryGlobalsVisitor">
            <summary>
            Rewrites the tree for performing lookups against globals instead of being bound
            against the optimized scope. This is used if the user creates a function using public
            PythonFunction ctor.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.Node.CanThrow">
            <summary>
            Returns true if the node can throw, false otherwise.  Used to determine
            whether or not we need to update the current dynamic stack info.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.Node.AddFrame(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
            <summary>
            Creates a method frame for tracking purposes and enforces recursion
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.Node.RemoveFrame(System.Linq.Expressions.Expression)">
            <summary>
            Removes the frames from generated code for when we're compiling the tracing delegate
            which will track the frames it's self.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.Node.LineNumberUpdated">
            <summary>
            A temporary variable to track if the current line number has been emitted via the fault update block.
            
            For example consider:
            
            try:
                raise Exception()
            except Exception, e:
                # do something here
                raise
                
            At "do something here" we need to have already emitted the line number, when we re-raise we shouldn't add it 
            again.  If we handled the exception then we should have set the bool back to false.
            
            We also sometimes directly check _lineNoUpdated to avoid creating this unless we have nested exceptions.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.Node.LineNumberExpression">
            <summary>
            A temporary variable to track the current line number
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.Parameter">
            <summary>
            Parameter base class
            </summary>
        </member>
        <member name="F:IronPython.Compiler.Ast.Parameter._name">
            <summary>
            Position of the parameter: 0-based index
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.Parameter.Name">
            <summary>
            Parameter name
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.PythonAst">
            <summary>
            Top-level ast for all Python code.  Typically represents a module but could also
            be exec or eval code.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.PythonAst.#ctor(System.Boolean,IronPython.Runtime.ModuleOptions,System.Boolean,Microsoft.Scripting.Runtime.CompilerContext)">
            <summary>
            Creates a new PythonAst without a body.  ParsingFinished should be called afterwards to set
            the body.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.PythonAst.ParsingFinished(System.Int32[],IronPython.Compiler.Ast.Statement,IronPython.Runtime.ModuleOptions)">
            <summary>
            Called when parsing is complete, the body is built, the line mapping and language features are known.
            
            This is used in conjunction with the constructor which does not take a body.  It enables creating
            the outer most PythonAst first so that nodes can always have a global parent.  This lets an un-bound
            tree to still provide it's line information immediately after parsing.  When we set the location
            of each node during construction we also set the global parent.  When we name bind the global 
            parent gets replaced with the real parent ScopeStatement.
            </summary>
            <param name="lineLocations">a mapping of where each line begins</param>
            <param name="body">The body of code</param>
            <param name="languageFeatures">The language features which were set during parsing.</param>
        </member>
        <member name="M:IronPython.Compiler.Ast.PythonAst.Bind">
            <summary>
            Binds an AST and makes it capable of being reduced and compiled.  Before calling Bind an AST cannot successfully
            be reduced.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.PythonAst.EnsureGlobalVariable(System.String)">
            <summary>
            Creates a variable at the global level.  Called for known globals (e.g. __name__),
            for variables explicitly declared global by the user, and names accessed
            but not defined in the lexical scope.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.PythonAst.Reduce">
            <summary>
            Reduces the PythonAst to a LambdaExpression of type Type.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.PythonAst.TrueDivision">
            <summary>
            True division is enabled in this AST.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.PythonAst.AllowWithStatement">
            <summary>
            True if the with statement is enabled in this AST.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.PythonAst.AbsoluteImports">
            <summary>
            True if absolute imports are enabled
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.PythonAst.ToScriptCode">
            <summary>
            Returns a ScriptCode object for this PythonAst.  The ScriptCode object
            can then be used to execute the code against it's closed over scope or
            to execute it against a different scope.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.PythonAst.MakeLookupCode">
            <summary>
            Rewrites the tree for performing lookups against globals instead of being bound
            against the optimized scope.  This is used if the user compiles optimied code and then
            runs it against a different scope.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.PythonAst.OnDiskProxy">
            <summary>
            True if this is on-disk code which we don't really have an AST for.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.PythonReference">
            <summary>
            Represents a reference to a name.  A PythonReference is created for each name
            referred to in a scope (global, class, or function).  
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.PythonVariable.ReadBeforeInitialized">
            <summary>
            True iff there is a path in control flow graph on which the variable is used before initialized (assigned or deleted).
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.PythonVariable.AccessedInNestedScope">
            <summary>
            True iff the variable is referred to from the inner scope.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.PythonWalker">
            <summary>
            PythonWalker class - The Python AST Walker (default result is true)
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.PythonWalkerNonRecursive">
            <summary>
            PythonWalkerNonRecursive class - The Python AST Walker (default result is false)
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.ScopeStatement.LocalParentTuple">
            <summary>
            The variable used to hold out parents closure tuple in our local scope.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.ScopeStatement.LocalContext">
            <summary>
            Gets the expression associated with the local CodeContext.  If the function
            doesn't have a local CodeContext then this is the global context.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.ScopeStatement.IsClosure">
            <summary>
            True if this scope accesses a variable from an outer scope.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.ScopeStatement.ContainsNestedFreeVariables">
            <summary>
            True if an inner scope is accessing a variable defined in this scope.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.ScopeStatement.NeedsLocalsDictionary">
            <summary>
            True if we are forcing the creation of a dictionary for storing locals.
            
            This occurs for calls to locals(), dir(), vars(), unqualified exec, and
            from ... import *.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.ScopeStatement.HasLateBoundVariableSets">
            <summary>
            True if variables can be set in a late bound fashion that we don't
            know about at code gen time - for example via from foo import *.
            
            This is tracked independently of the ContainsUnqualifiedExec/NeedsLocalsDictionary
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.ScopeStatement.GetOrMakeFunctionCode">
            <summary>
            Gets or creates the FunctionCode object for this FunctionDefinition.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.ScopeStatement.FreeVariables">
            <summary>
            Variables that are bound in an outer scope - but not a global scope
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.ScopeStatement.GlobalVariables">
            <summary>
            Variables that are bound to the global scope
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.ScopeStatement.CellVariables">
            <summary>
            Variables that are referred to from a nested scope and need to be
            promoted to cells.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.ScopeStatement.GetUpdateTrackbackExpression(System.Linq.Expressions.ParameterExpression)">
            <summary>
            Gets the expression for updating the dynamic stack trace at runtime when an
            exception is thrown.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.ScopeStatement.GetSaveLineNumberExpression(System.Linq.Expressions.ParameterExpression,System.Boolean)">
            <summary>
            Gets the expression for the actual updating of the line number for stack traces to be available
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.ScopeStatement.WrapScopeStatements(System.Linq.Expressions.Expression,System.Boolean)">
            <summary>
            Wraps the body of a statement which should result in a frame being available during
            exception handling.  This ensures the line number is updated as the stack is unwound.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.ScopeStatement.DelayedFunctionCode">
            <summary>
            Provides a place holder for the expression which represents
            a FunctionCode.  For functions/classes this gets updated after
            the AST has been generated because the FunctionCode needs to
            know about the tree which gets generated.  For modules we 
            immediately have the value because it always comes in as a parameter.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.ScopeStatement.DelayedProfiling">
            <summary>
            Reducible node so that re-writing for profiling does not occur until
            after the script code has been completed and is ready to be compiled.
            
            Without this extra node profiling would force reduction of the node
            and we wouldn't have setup our constant access correctly yet.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.SerializedScopeStatement">
            <summary>
            Fake ScopeStatement for FunctionCode's to hold on to after we have deserialized pre-compiled code.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Ast.SliceExpression.StepProvided">
            <summary>
            True if the user provided a step parameter (either providing an explicit parameter
            or providing an empty step parameter) false if only start and stop were provided.
            </summary>
        </member>
        <member name="F:IronPython.Compiler.Ast.TryStatement._body">
            <summary>
            The statements under the try-block.
            </summary>
        </member>
        <member name="F:IronPython.Compiler.Ast.TryStatement._handlers">
            <summary>
            Array of except (catch) blocks associated with this try. NULL if there are no except blocks.
            </summary>
        </member>
        <member name="F:IronPython.Compiler.Ast.TryStatement._else">
            <summary>
            The body of the optional Else block for this try. NULL if there is no Else block.
            </summary>
        </member>
        <member name="F:IronPython.Compiler.Ast.TryStatement._finally">
            <summary>
            The body of the optional finally associated with this try. NULL if there is no finally block.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.TryStatement.TransformHandlers(System.Linq.Expressions.ParameterExpression)">
            <summary>
            Transform multiple python except handlers for a try block into a single catch body.
            </summary>
            <param name="exception">The variable for the exception in the catch block.</param>
            <returns>Null if there are no except handlers. Else the statement to go inside the catch handler</returns>
        </member>
        <member name="M:IronPython.Compiler.Ast.TryStatement.GetTracebackHeader(IronPython.Compiler.Ast.Statement,System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression)">
            <summary>
            Surrounds the body of an except block w/ the appropriate code for maintaining the traceback.
            </summary>
        </member>
        <member name="F:IronPython.Compiler.Ast.VariableKind.Local">
            <summary>
            Local variable.
            
            Local variables can be referenced from nested lambdas
            </summary>
        </member>
        <member name="F:IronPython.Compiler.Ast.VariableKind.Parameter">
            <summary>
            Parameter to a LambdaExpression
            
            Like locals, they can be referenced from nested lambdas
            </summary>
        </member>
        <member name="F:IronPython.Compiler.Ast.VariableKind.Global">
            <summary>
            Global variable
            
            Should only appear in global (top level) lambda.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.WithStatement.Reduce">
            <summary>
            WithStatement is translated to the DLR AST equivalent to
            the following Python code snippet (from with statement spec):
            
            mgr = (EXPR)
            exit = mgr.__exit__  # Not calling it yet
            value = mgr.__enter__()
            exc = True
            try:
                VAR = value  # Only if "as VAR" is present
                BLOCK
            except:
                # The exceptional case is handled here
                exc = False
                if not exit(*sys.exc_info()):
                    raise
                # The exception is swallowed if exit() returns true
            finally:
                # The normal and non-local-goto cases are handled here
                if exc:
                    exit(None, None, None)
            
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.CollectableCompilationMode">
            <summary>
            A global allocator that puts all of the globals into an array access.  The array is an
            array of PythonGlobal objects.  We then just close over the array for any inner functions.
            
            Once compiled a RuntimeScriptCode is produced which is closed over the entire execution
            environment.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.LookupCompilationMode">
            <summary>
            Provides globals for when we need to lookup into a dictionary for each global access.
            
            This is the slowest form of globals and is only used when we need to run against an
            arbitrary dictionary given to us by a user.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Ast.UncollectableCompilationMode">
            <summary>
            Implements globals which are backed by a static type, followed by an array if the static types' slots become full.  The global
            variables are stored in static fields on a type for fast access.  The type also includes fields for constants and call sites
            so they can be accessed much fasetr.
            
            We don't generate any code into the type though - DynamicMethod's are much faster for code gen then normal ref emit.
            </summary>
            <summary>
            Implements globals which are backed by a static type, followed by an array if the static types' slots become full.  The global
            variables are stored in static fields on a type for fast access.  The type also includes fields for constants and call sites
            so they can be accessed much fasetr.
            
            We don't generate any code into the type though - DynamicMethod's are much faster for code gen then normal ref emit.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Ast.StorageData.ContextStorageType(System.Int32)">
            <summary>Ensures the underlying array is long enough to accomodate the given index</summary>
            <returns>The context storage type corresponding to the given index</returns>
        </member>
        <member name="M:IronPython.Compiler.Ast.StorageData.ConstantStorageType(System.Int32)">
            <summary>Ensures the underlying array is long enough to accomodate the given index</summary>
            <returns>The constant storage type corresponding to the given index</returns>
        </member>
        <member name="M:IronPython.Compiler.Ast.StorageData.GlobalStorageType(System.Int32)">
            <summary>Ensures the underlying array is long enough to accomodate the given index</summary>
            <returns>The global storage type corresponding to the given index</returns>
        </member>
        <member name="M:IronPython.Compiler.Ast.SiteStorage`1.SiteStorageType(System.Int32)">
            <summary>Ensures the underlying array is long enough to accomodate the given index</summary>
            <returns>The site storage type corresponding to the given index</returns>
        </member>
        <member name="T:IronPython.Compiler.ClosureExpression">
            <summary>
            Small reducable node which just fetches the value from a ClosureCell
            object.  Like w/ global variables the compiler recognizes these on 
            sets and turns them into assignments on the python global object.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.ClosureExpression.ClosureCell">
            <summary>
            Gets the expression which points at the closure cell.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.ClosureExpression.OriginalParameter">
            <summary>
            The original expression for the incoming parameter if this is a parameter closure.  Otherwise
            the value is null.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.ClosureExpression.PythonVariable">
            <summary>
            Gets the PythonVariable for which this closure expression was created.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.ClosureExpression.Create">
            <summary>
            Creates the storage for the closure cell.  If this is a closure over a parameter it
            captures the initial incoming parameter value.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.ClosureExpression.Reduce">
            <summary>
            Reduces the closure cell to a read of the value stored in the cell.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.ClosureExpression.Assign(System.Linq.Expressions.Expression)">
            <summary>
            Assigns a value to the closure cell.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.ClosureExpression.Delete">
            <summary>
            Removes the current value from the closure cell.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.ReferenceClosureInfo">
            <summary>
            Tracking for variables lifted into closure objects. Used to store information in a function
            about the outer variables it accesses.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.CompilationMode">
            <summary>
            Specifies the compilation mode which will be used during the AST transformation
            </summary>
        </member>
        <member name="F:IronPython.Compiler.CompilationMode.ToDisk">
            <summary>
            Compilation will proceed in a manner in which the resulting AST can be serialized to disk.
            </summary>
        </member>
        <member name="F:IronPython.Compiler.CompilationMode.Uncollectable">
            <summary>
            Compilation will use a type and declare static fields for globals.  The resulting type
            is uncollectible and therefore extended use of this will cause memory leaks.
            </summary>
        </member>
        <member name="F:IronPython.Compiler.CompilationMode.Collectable">
            <summary>
            Compilation will use an array for globals.  The resulting code will be fully collectible
            and once all references are released will be collected.
            </summary>
        </member>
        <member name="F:IronPython.Compiler.CompilationMode.Lookup">
            <summary>
            Compilation will force all global accesses to do a full lookup.  This will also happen for
            any unbound local references.  This is the slowest form of code generation and is only
            used for exec/eval code where we can run against an arbitrary dictionary.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.GeneratorRewriter">
            <summary>
            When finding a yield return or yield break, this rewriter flattens out
            containing blocks, scopes, and expressions with stack state. All
            scopes encountered have their variables promoted to the generator's
            closure, so they survive yields.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.GeneratorRewriter.ToTemp(System.Linq.Expressions.Expression@)">
            <summary>
            Spills the right side into a temp, and replaces it with its temp.
            Returns the expression that initializes the temp.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.GeneratorRewriter.MakeAssign(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
            <summary>
            Makes an assignment to this variable. Pushes the assignment as far
            into the right side as possible, to allow jumps into it.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.DelayedTupleExpression">
            <summary>
            Accesses the property of a tuple.  The node can be created first and then the tuple and index
            type can be filled in before the tree is actually generated.  This enables creation of these
            nodes before the tuple type is actually known.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.LazyCode`1">
            <summary>
            Represents code which can be lazily compiled.
            
            The code is created in an AST which provides the Expression of T and 
            whether or not the code should be interpreted.  For non-pre compiled
            scenarios the code will not be compiled until the 1st time it is run.
            
            For pre-compiled scenarios the code is IExpressionSerializable and will
            turn into a normal pre-compiled method.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.OnDiskScriptCode">
            <summary>
            A ScriptCode which has been loaded from an assembly which is saved on disk.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.OnDiskScriptCode.MakeAstFromSourceUnit(Microsoft.Scripting.SourceUnit)">
            <summary>
            Creates a fake PythonAst object which is represenative of the on-disk script code.
            </summary>
        </member>
        <member name="F:IronPython.Compiler.Parser._languageFeatures">
            <summary>
            Language features initialized on parser construction and possibly updated during parsing. 
            The code can set the language features (e.g. "from __future__ import division").
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Parser.ParseInteractiveCode(Microsoft.Scripting.ScriptCodeParseResult@)">
            <summary>
            Parse one or more lines of interactive input
            </summary>
            <returns>null if input is not yet valid but could be with more lines</returns>
        </member>
        <member name="M:IronPython.Compiler.Parser.GetNextAutoIndentSize(System.String,System.Int32)">
            <summary>
            Given the interactive text input for a compound statement, calculate what the
            indentation level of the next line should be
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Parser.ParseYieldExpression">
            <summary>
            Peek if the next token is a 'yield' and parse a yield expression. Else return null.
            
            Called w/ yield already eaten.
            </summary>
            <returns>A yield expression if present, else null. </returns>
        </member>
        <member name="M:IronPython.Compiler.Parser.MaybeEatNewLine">
            <summary>
            Maybe eats a new line token returning true if the token was
            eaten.
            
            Python always tokenizes to have only 1  new line character in a 
            row.  But we also craete NLToken's and ignore them except for 
            error reporting purposes.  This gives us the same errors as 
            CPython and also matches the behavior of the standard library 
            tokenize module.  This function eats any present NL tokens and throws
            them away.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Parser.EatNewLine">
            <summary>
            Eats a new line token throwing if the next token isn't a new line.  
            
            Python always tokenizes to have only 1  new line character in a 
            row.  But we also craete NLToken's and ignore them except for 
            error reporting purposes.  This gives us the same errors as 
            CPython and also matches the behavior of the standard library 
            tokenize module.  This function eats any present NL tokens and throws
            them away.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.PythonCompilerOptions.#ctor">
            <summary>
            Creates a new PythonCompilerOptions with the default language features enabled.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.PythonCompilerOptions.#ctor(IronPython.Runtime.ModuleOptions)">
            <summary>
            Creates a new PythonCompilerOptions with the specified language features enabled.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.PythonCompilerOptions.#ctor(System.Boolean)">
            <summary>
            Creates a new PythonCompilerOptions and enables or disables true division.
            
            This overload is obsolete, instead you should use the overload which takes a
            ModuleOptions.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.PythonCompilerOptions.InitialIndent">
            <summary>
            Gets or sets the initial indentation.  This can be set to allow parsing
            partial blocks of code that are already indented.
            
            For each element of the array there is an additional level of indentation.
            Each integer value represents the number of spaces used for the indentation.
            
            If this value is null then no indentation level is specified.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.PythonGlobal">
            <summary>
            Provides cached global variable for modules to enable optimized access to
            module globals.  Both the module global value and the cached value can be held
            onto and the cached value can be invalidated by the providing LanguageContext.
            
            The cached value is provided by the LanguageContext.GetModuleCache API.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.PythonGlobalVariableExpression">
            <summary>
            Small reducable node which just fetches the value from a PythonGlobal
            object.  The compiler recognizes these on sets and turns them into
            assignments on the python global object.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.PythonSavableScriptCode">
            <summary>
            A ScriptCode which can be saved to disk.  We only create this when called via
            the clr.CompileModules API.  This ScriptCode does not support running.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.PythonScriptCode">
            <summary>
            Represents a script code which can be dynamically bound to execute against
            arbitrary Scope objects.  This is used for code when the user runs against
            a particular scope as well as for exec and eval code as well.  It is also
            used when tracing is enabled.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.ReducableDynamicExpression">
            <summary>
            Provides a wrapper around "dynamic" expressions which we've opened coded (for optimized code generation).
            
            This lets us recognize both normal Dynamic and our own Dynamic expressions and apply the combo binder on them.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.RuntimeScriptCode">
            <summary>
            Represents a script code which can be consumed at runtime as-is.  This code has
            no external dependencies and is closed over its scope.  
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Token">
            <summary>
            Summary description for Token.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Tokenizer">
            <summary>
            IronPython tokenizer
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Tokenizer.#ctor(Microsoft.Scripting.ErrorSink,IronPython.Compiler.PythonCompilerOptions,System.Boolean)">
            <summary>
            Used to create tokenizer for hosting API.
            </summary>
        </member>
        <member name="T:IronPython.Compiler.Tokenizer.TokenEqualityComparer">
            <summary>
            Equality comparer that can compare strings to our current token w/o creating a new string first.
            </summary>
        </member>
        <member name="P:IronPython.Compiler.Tokenizer.EndContinues">
            <summary>
            True if the last characters in the buffer are a backslash followed by a new line indicating
            that their is an incompletement statement which needs further input to complete.
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Tokenizer.ReadNewline">
            <summary>
            Returns whether the 
            </summary>
        </member>
        <member name="M:IronPython.Compiler.Tokenizer.ResizeInternal(System.Char[]@,System.Int32,System.Int32,System.Int32)">
            <summary>
            Resizes an array to a speficied new size and copies a portion of the original array into its beginning.
            </summary>
        </member>
        <member name="T:IronPython.Hosting.Python">
            <summary>
            Provides helpers for interacting with IronPython.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.CreateRuntime">
            <summary>
            Creates a new ScriptRuntime with the IronPython scipting engine pre-configured.
            </summary>
            <returns></returns>
        </member>
        <member name="M:IronPython.Hosting.Python.CreateRuntime(System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Creates a new ScriptRuntime with the IronPython scipting engine pre-configured and
            additional options.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.CreateEngine">
            <summary>
            Creates a new ScriptRuntime and returns the ScriptEngine for IronPython. If
            the ScriptRuntime is required it can be acquired from the Runtime property
            on the engine.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.CreateEngine(System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Creates a new ScriptRuntime with the specified options and returns the 
            ScriptEngine for IronPython. If the ScriptRuntime is required it can be 
            acquired from the Runtime property on the engine.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.GetEngine(Microsoft.Scripting.Hosting.ScriptRuntime)">
            <summary>
            Given a ScriptRuntime gets the ScriptEngine for IronPython.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.GetSysModule(Microsoft.Scripting.Hosting.ScriptRuntime)">
            <summary>
            Gets a ScriptScope which is the Python sys module for the provided ScriptRuntime.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.GetSysModule(Microsoft.Scripting.Hosting.ScriptEngine)">
            <summary>
            Gets a ScriptScope which is the Python sys module for the provided ScriptEngine.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.GetBuiltinModule(Microsoft.Scripting.Hosting.ScriptRuntime)">
            <summary>
            Gets a ScriptScope which is the Python __builtin__ module for the provided ScriptRuntime.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.GetBuiltinModule(Microsoft.Scripting.Hosting.ScriptEngine)">
            <summary>
            Gets a ScriptScope which is the Python __builtin__ module for the provided ScriptEngine.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.GetClrModule(Microsoft.Scripting.Hosting.ScriptRuntime)">
            <summary>
            Gets a ScriptScope which is the Python clr module for the provided ScriptRuntime.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.GetClrModule(Microsoft.Scripting.Hosting.ScriptEngine)">
            <summary>
            Gets a ScriptScope which is the Python clr module for the provided ScriptEngine.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.ImportModule(Microsoft.Scripting.Hosting.ScriptRuntime,System.String)">
            <summary>
            Imports the Python module by the given name and returns its ScriptSCope.  If the 
            module does not exist an exception is raised.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.ImportModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String)">
            <summary>
            Imports the Python module by the given name and returns its ScriptSCope.  If the 
            module does not exist an exception is raised.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.ImportModule(Microsoft.Scripting.Hosting.ScriptScope,System.String)">
            <summary>
            Imports the Python module by the given name and inserts it into the ScriptScope as that name. If the
            module does not exist an exception is raised.
            </summary>
            <param name="scope"></param>
            <param name="moduleName"></param>
        </member>
        <member name="M:IronPython.Hosting.Python.SetHostVariables(Microsoft.Scripting.Hosting.ScriptRuntime,System.String,System.String,System.String)">
            <summary>
            Sets sys.exec_prefix, sys.executable and sys.version and adds the prefix to sys.path
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.SetHostVariables(Microsoft.Scripting.Hosting.ScriptEngine,System.String,System.String,System.String)">
            <summary>
            Sets sys.exec_prefix, sys.executable and sys.version and adds the prefix to sys.path
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.SetTrace(Microsoft.Scripting.Hosting.ScriptEngine,IronPython.Runtime.Exceptions.TracebackDelegate)">
            <summary>
            Enables call tracing for the current thread in this ScriptEngine.  
            
            TracebackDelegate will be called back for each function entry, exit, exception, and line change.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.SetTrace(Microsoft.Scripting.Hosting.ScriptRuntime,IronPython.Runtime.Exceptions.TracebackDelegate)">
            <summary>
            Enables call tracing for the current thread for the Python engine in this ScriptRuntime.  
            
            TracebackDelegate will be called back for each function entry, exit, exception, and line change.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.CallTracing(Microsoft.Scripting.Hosting.ScriptRuntime,System.Object,System.Object[])">
            <summary>
            Provides nested level debugging support when SetTrace or SetProfile are used.
            
            This saves the current tracing information and then calls the provided object.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.CallTracing(Microsoft.Scripting.Hosting.ScriptEngine,System.Object,System.Object[])">
            <summary>
            Provides nested level debugging support when SetTrace or SetProfile are used.
            
            This saves the current tracing information and then calls the provided object.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.CreateRuntimeSetup(System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Creates a ScriptRuntimeSetup object which includes the Python script engine with the specified options.
            
            The ScriptRuntimeSetup object can then be additional configured and used to create a ScriptRuntime.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.CreateLanguageSetup(System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Creates a LanguageSetup object which includes the Python script engine with the specified options.
            
            The LanguageSetup object can be used with other LanguageSetup objects from other languages to
            configure a ScriptRuntimeSetup object.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.CreateModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String)">
            <summary>
            Creates a new PythonModule with the specified name and published it in sys.modules.  
            
            Returns the ScriptScope associated with the module.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.CreateModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String,System.String)">
            <summary>
            Creates a new PythonModule with the specified name and filename published it 
            in sys.modules.  
            
            Returns the ScriptScope associated with the module.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.CreateModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String,System.String,System.String)">
            <summary>
            Creates a new PythonModule with the specified name, filename, and doc string and 
            published it in sys.modules.  
            
            Returns the ScriptScope associated with the module.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.Python.GetModuleFilenames(Microsoft.Scripting.Hosting.ScriptEngine)">
            <summary>
            Gets the list of loaded Python module files names which are available in the provided ScriptEngine.
            </summary>
        </member>
        <member name="T:IronPython.Hosting.PythonCommandLine">
            <summary>
            A simple Python command-line should mimic the standard python.exe
            </summary>
        </member>
        <member name="M:IronPython.Hosting.PythonCommandLine.GetLogoDisplay">
            <summary>
            Returns the display look for IronPython.  
            
            The returned string uses This \n instead of Environment.NewLine for it's line seperator 
            because it is intended to be outputted through the Python I/O system.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.PythonCommandLine.InitializeExtensionDLLs">
            <summary>
            Loads any extension DLLs present in sys.prefix\DLLs directory and adds references to them.
            
            This provides an easy drop-in location for .NET assemblies which should be automatically referenced
            (exposed via import), COM libraries, and pre-compiled Python code.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.PythonCommandLine.TryInteractiveActionWorker">
            <summary>
            Attempts to run a single interaction and handle any language-specific
            exceptions.  Base classes can override this and call the base implementation
            surrounded with their own exception handling.
            
            Returns null if successful and execution should continue, or an exit code.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.PythonCommandLine.RunOneInteraction">
            <summary>
            Parses a single interactive command and executes it.  
            
            Returns null if successful and execution should continue, or the appropiate exit code.
            </summary>
        </member>
        <member name="P:IronPython.Hosting.PythonConsoleOptions.SkipFirstSourceLine">
            <summary>
            Skip the first line of the code to execute. This is useful for executing Unix scripts which
            have the command to execute specified in the first line.
            This only apply to the script code executed by the ScriptEngine APIs, but not for other script code 
            that happens to get called as a result of the execution.
            </summary>
        </member>
        <member name="M:IronPython.Hosting.PythonOptionsParser.ParseArgument(System.String)">
            <exception cref="T:System.Exception">On error.</exception>
        </member>
        <member name="T:IronPython.Hosting.PythonService">
            <summary>
            Helper class for implementing the Python class.
            
            This is exposed as a service through PythonEngine and the helper class
            uses this service to get the correct remoting semantics.
            </summary>
        </member>
        <member name="F:IronPython.Hosting.ErrorCodes.IncompleteStatement">
            <summary>
            The error involved an incomplete statement due to an unexpected EOF.
            </summary>
        </member>
        <member name="F:IronPython.Hosting.ErrorCodes.IncompleteToken">
            <summary>
            The error involved an incomplete token.
            </summary>
        </member>
        <member name="F:IronPython.Hosting.ErrorCodes.ErrorMask">
            <summary>
            The mask for the actual error values 
            </summary>
        </member>
        <member name="F:IronPython.Hosting.ErrorCodes.SyntaxError">
            <summary>
            The error was a general syntax error
            </summary>
        </member>
        <member name="F:IronPython.Hosting.ErrorCodes.IndentationError">
            <summary>
            The error was an indentation error.
            </summary>
        </member>
        <member name="F:IronPython.Hosting.ErrorCodes.TabError">
            <summary>
            The error was a tab error.
            </summary>
        </member>
        <member name="F:IronPython.Hosting.ErrorCodes.NoCaret">
            <summary>
            syntax error shouldn't include a caret (no column offset should be included)
            </summary>
        </member>
        <member name="T:IronPython.MaybeNotImplementedAttribute">
            <summary>
            Marks that the return value of a function might include NotImplemented.
            
            This is added to an operator method to ensure that all necessary methods are called
            if one cannot guarantee that it can perform the comparison.
            </summary>
        </member>
        <member name="M:IronPython.Modules.Builtin.filter(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.PythonTuple)">
            <summary>
            Specialized version because enumerating tuples by Python's definition
            doesn't call __getitem__, but filter does!
            </summary>
        </member>
        <member name="M:IronPython.Modules.Builtin.open(IronPython.Runtime.CodeContext,System.String,System.String,System.Int32)">
            <summary>
            Opens a file and returns a new file object.
            
            name -> the name of the file to open.
            mode -> the mode to open the file (r for reading, w for writing, a for appending, default is r).
            bufsize -> the size of the buffer to be used (&lt;= 0 indicates to use the default size)
            </summary>
        </member>
        <member name="M:IronPython.Modules.Builtin.open(IronPython.Runtime.CodeContext,System.IO.Stream)">
            <summary>
            Creates a new Python file object from a .NET stream object.
            
            stream -> the stream to wrap in a file object.
            </summary>
        </member>
        <member name="M:IronPython.Modules.Builtin.range(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            object overload of range - attempts to convert via __int__, and __trunc__ if arg is
            an OldInstance
            </summary>
        </member>
        <member name="M:IronPython.Modules.Builtin.range(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object)">
            <summary>
            object overload of range - attempts to convert via __int__, and __trunc__ if arg is
            an OldInstance
            </summary>
        </member>
        <member name="M:IronPython.Modules.Builtin.GetRuntimeGeneratedCodeCompilerOptions(IronPython.Runtime.CodeContext,System.Boolean,IronPython.Runtime.CompileFlags)">
            <summary>
            Gets the appropriate LanguageContext to be used for code compiled with Python's compile, eval, execfile, etc...
            </summary>
        </member>
        <member name="M:IronPython.Modules.Builtin.GetCompilerInheritance(System.Object)">
            <summary> Returns true if we should inherit our callers context (true division, etc...), false otherwise </summary>
        </member>
        <member name="M:IronPython.Modules.Builtin.GetCompilerFlags(System.Int32)">
            <summary> Returns the default compiler flags or the flags the user specified. </summary>
        </member>
        <member name="M:IronPython.Modules.Builtin.GetExecEvalScopeOptional(IronPython.Runtime.CodeContext,IronPython.Runtime.PythonDictionary,System.Object,System.Boolean)">
            <summary>
            Gets a scope used for executing new code in optionally replacing the globals and locals dictionaries.
            </summary>
        </member>
        <member name="M:IronPython.Modules.SysModule.callstats">
            <summary>
            Returns detailed call statistics.  Not implemented in IronPython and always returns None.
            </summary>
        </member>
        <member name="M:IronPython.Modules.SysModule.displayhookImpl(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Handles output of the expression statement.
            Prints the value and sets the __builtin__._
            </summary>
        </member>
        <member name="T:IronPython.Modules._ast.AugLoad">
            <summary>
            Not used.
            </summary>
        </member>
        <member name="T:IronPython.Modules._ast.AugStore">
            <summary>
            Not used.
            </summary>
        </member>
        <member name="T:IronPython.Modules._ast.Suite">
            <summary>
            Not an actual node. We don't create this, but it's here for compatibility.
            </summary>
        </member>
        <member name="T:IronPython.Resources">
            <summary>
              A strongly-typed resource class, for looking up localized strings, etc.
            </summary>
        </member>
        <member name="P:IronPython.Resources.ResourceManager">
            <summary>
              Returns the cached ResourceManager instance used by this class.
            </summary>
        </member>
        <member name="P:IronPython.Resources.Culture">
            <summary>
              Overrides the current thread's CurrentUICulture property for all
              resource lookups using this strongly typed resource class.
            </summary>
        </member>
        <member name="P:IronPython.Resources.CantFindMember">
            <summary>
              Looks up a localized string similar to couldn&apos;t find member {0}.
            </summary>
        </member>
        <member name="P:IronPython.Resources.DefaultRequired">
            <summary>
              Looks up a localized string similar to default value must be specified here.
            </summary>
        </member>
        <member name="P:IronPython.Resources.DuplicateArgumentInFuncDef">
            <summary>
              Looks up a localized string similar to duplicate argument &apos;{0}&apos; in function definition.
            </summary>
        </member>
        <member name="P:IronPython.Resources.DuplicateKeywordArg">
            <summary>
              Looks up a localized string similar to duplicate keyword argument.
            </summary>
        </member>
        <member name="P:IronPython.Resources.EofInString">
            <summary>
              Looks up a localized string similar to &lt;eof&gt; while reading string.
            </summary>
        </member>
        <member name="P:IronPython.Resources.EofInTripleQuotedString">
            <summary>
              Looks up a localized string similar to EOF while scanning triple-quoted string.
            </summary>
        </member>
        <member name="P:IronPython.Resources.EolInSingleQuotedString">
            <summary>
              Looks up a localized string similar to EOL while scanning single-quoted string.
            </summary>
        </member>
        <member name="P:IronPython.Resources.ExpectedIndentation">
            <summary>
              Looks up a localized string similar to expected an indented block.
            </summary>
        </member>
        <member name="P:IronPython.Resources.ExpectedName">
            <summary>
              Looks up a localized string similar to expected name.
            </summary>
        </member>
        <member name="P:IronPython.Resources.ExpectingIdentifier">
            <summary>
              Looks up a localized string similar to Expecting identifier:.
            </summary>
        </member>
        <member name="P:IronPython.Resources.InconsistentWhitespace">
            <summary>
              Looks up a localized string similar to inconsistent use of tabs and spaces in indentation.
            </summary>
        </member>
        <member name="P:IronPython.Resources.IndentationMismatch">
            <summary>
              Looks up a localized string similar to unindent does not match any outer indentation level.
            </summary>
        </member>
        <member name="P:IronPython.Resources.InvalidArgumentValue">
            <summary>
              Looks up a localized string similar to Invalid argument value..
            </summary>
        </member>
        <member name="P:IronPython.Resources.InvalidOperation_MakeGenericOnNonGeneric">
            <summary>
              Looks up a localized string similar to MakeGenericType on non-generic type.
            </summary>
        </member>
        <member name="P:IronPython.Resources.InvalidParameters">
            <summary>
              Looks up a localized string similar to Invalid parameter collection for the function..
            </summary>
        </member>
        <member name="P:IronPython.Resources.InvalidToken">
            <summary>
              Looks up a localized string similar to invalid token
            </summary>
        </member>
        <member name="P:IronPython.Resources.InvalidSyntax">
            <summary>
              Looks up a localized string similar to invalid syntax.
            </summary>
        </member>
        <member name="P:IronPython.Resources.KeywordCreateUnavailable">
            <summary>
              Looks up a localized string similar to object ({0}) is not creatable w/ keyword arguments.
            </summary>
        </member>
        <member name="P:IronPython.Resources.KeywordOutOfSequence">
            <summary>
              Looks up a localized string similar to keywords must come before * args.
            </summary>
        </member>
        <member name="P:IronPython.Resources.MemberDoesNotExist">
            <summary>
              Looks up a localized string similar to type does not have {0} field.
            </summary>
        </member>
        <member name="P:IronPython.Resources.MisplacedFuture">
            <summary>
              Looks up a localized string similar to from __future__ imports must occur at the beginning of the file.
            </summary>
        </member>
        <member name="P:IronPython.Resources.MisplacedReturn">
            <summary>
              Looks up a localized string similar to &apos;return&apos; outside function.
            </summary>
        </member>
        <member name="P:IronPython.Resources.MisplacedYield">
            <summary>
              Looks up a localized string similar to &apos;yield&apos; outside function.
            </summary>
        </member>
        <member name="P:IronPython.Resources.NewLineInDoubleQuotedString">
            <summary>
              Looks up a localized string similar to NEWLINE in double-quoted string.
            </summary>
        </member>
        <member name="P:IronPython.Resources.NewLineInSingleQuotedString">
            <summary>
              Looks up a localized string similar to NEWLINE in single-quoted string.
            </summary>
        </member>
        <member name="P:IronPython.Resources.NoFutureStar">
            <summary>
              Looks up a localized string similar to future statement does not support import *.
            </summary>
        </member>
        <member name="P:IronPython.Resources.NonKeywordAfterKeywordArg">
            <summary>
              Looks up a localized string similar to non-keyword arg after keyword arg.
            </summary>
        </member>
        <member name="P:IronPython.Resources.NotAChance">
            <summary>
              Looks up a localized string similar to not a chance.
            </summary>
        </member>
        <member name="P:IronPython.Resources.NotImplemented">
            <summary>
              Looks up a localized string similar to The method or operation is not implemented..
            </summary>
        </member>
        <member name="P:IronPython.Resources.OneKeywordArgOnly">
            <summary>
              Looks up a localized string similar to only one ** allowed.
            </summary>
        </member>
        <member name="P:IronPython.Resources.OneListArgOnly">
            <summary>
              Looks up a localized string similar to only one * allowed.
            </summary>
        </member>
        <member name="P:IronPython.Resources.PythonContextRequired">
            <summary>
              Looks up a localized string similar to Context must be PythonCompilerContext.
            </summary>
        </member>
        <member name="P:IronPython.Resources.Slot_CantDelete">
            <summary>
              Looks up a localized string similar to cannot delete slot.
            </summary>
        </member>
        <member name="P:IronPython.Resources.Slot_CantGet">
            <summary>
              Looks up a localized string similar to cannot get slot.
            </summary>
        </member>
        <member name="P:IronPython.Resources.Slot_CantSet">
            <summary>
              Looks up a localized string similar to cannot set slot.
            </summary>
        </member>
        <member name="P:IronPython.Resources.StaticAccessFromInstanceError">
            <summary>
              Looks up a localized string similar to static property &apos;{0}&apos; of &apos;{1}&apos; can only be read through a type, not an instance.
            </summary>
        </member>
        <member name="P:IronPython.Resources.StaticAssignmentFromInstanceError">
            <summary>
              Looks up a localized string similar to static property &apos;{0}&apos; of &apos;{1}&apos; can only be assigned to through a type, not an instance.
            </summary>
        </member>
        <member name="P:IronPython.Resources.TokenHasNoValue">
            <summary>
              Looks up a localized string similar to no value for this token.
            </summary>
        </member>
        <member name="P:IronPython.Resources.TooManyVersions">
            <summary>
              Looks up a localized string similar to too many versions.
            </summary>
        </member>
        <member name="P:IronPython.Resources.UnexpectedToken">
            <summary>
              Looks up a localized string similar to unexpected token &apos;{0}&apos;.
            </summary>
        </member>
        <member name="P:IronPython.Resources.UnknownFutureFeature">
            <summary>
              Looks up a localized string similar to future feature is not defined:.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.BindingWarnings">
            <summary>
            Provides support for emitting warnings when built in methods are invoked at runtime.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.Binders.Convert(System.Linq.Expressions.Expression,IronPython.Runtime.PythonContext,System.Type,Microsoft.Scripting.Actions.ConversionResultKind,System.Linq.Expressions.Expression)">
            <summary>
            Backwards compatible Convert for the old sites that need to flow CodeContext
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.Binders.InvokeSplat(IronPython.Runtime.PythonContext)">
            <summary>
            Creates a new InvokeBinder which will call with positional splatting.
            
            The signature of the target site should be object(function), object[], retType
            </summary>
            <param name="state"></param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Binding.Binders.InvokeKeywords(IronPython.Runtime.PythonContext)">
            <summary>
            Creates a new InvokeBinder which will call with positional and keyword splatting.
            
            The signature of the target site should be object(function), object[], dictionary, retType
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.BindingHelpers">
            <summary>
            Common helpers used by the various binding logic.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.BindingHelpers.TryGetStaticFunction(IronPython.Runtime.PythonContext,System.String,System.Dynamic.DynamicMetaObject,IronPython.Runtime.Types.BuiltinFunction@)">
            <summary>
            Tries to get the BuiltinFunction for the given name on the type of the provided MetaObject.  
            
            Succeeds if the MetaObject is a BuiltinFunction or BuiltinMethodDescriptor.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.BindingHelpers.GetCallSignature(System.Dynamic.DynamicMetaObjectBinder)">
            <summary>
            Gets the best CallSignature from a MetaAction.
            
            The MetaAction should be either a Python InvokeBinder, or a DLR InvokeAction or 
            CreateAction.  For Python we can use a full-fidelity 
            </summary>
            <param name="action"></param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Binding.BindingHelpers.GenericInvokeMember(System.Dynamic.InvokeMemberBinder,IronPython.Runtime.Binding.ValidationInfo,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Transforms an invoke member into a Python GetMember/Invoke.  The caller should
            verify that the given attribute is not resolved against a normal .NET class
            before calling this.  If it is a normal .NET member then a fallback InvokeMember
            is preferred.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.BindingHelpers.IsSubclassOf(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject)">
            <summary>
            Determines if the type associated with the first MetaObject is a subclass of the
            type associated with the second MetaObject.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.BindingHelpers.AddRecursionCheck(IronPython.Runtime.PythonContext,System.Linq.Expressions.Expression)">
            <summary>
            Adds a try/finally which enforces recursion limits around the target method.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.BindingHelpers.InvokeFallback(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Helper to do fallback for Invoke's so we can handle both StandardAction and Python's 
            InvokeBinder.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.BindingHelpers.GetComArguments(System.Dynamic.DynamicMetaObject[])">
            <summary>
            Converts arguments into a form which can be used for COM interop.
            
            The argument is only converted if we have an IronPython specific
            conversion when calling COM methods.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.BindingHelpers.GetComArgument(System.Dynamic.DynamicMetaObject)">
            <summary>
            Converts a single argument into a form which can be used for COM 
            interop.  
            
            The argument is only converted if we have an IronPython specific
            conversion when calling COM methods.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.CompatibilityInvokeBinder">
            <summary>
            Fallback action for performing an invoke from Python.  We translate the
            CallSignature which supports splatting position and keyword args into
            their expanded form.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.ConditionalBuilder">
            <summary>
            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.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.ConditionalBuilder.AddCondition(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
            <summary>
            Adds a new conditional and body.  The first call this becomes the top-level
            conditional, subsequent calls will have it added as false statement of the
            previous conditional.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.ConditionalBuilder.ExtendLastCondition(System.Linq.Expressions.Expression)">
            <summary>
            If present, converts the finish condition body be a normal conditional body. 
            The builder instance will become unfinished again. 
            
            If no finish condition body is available, this extends the last condition check 
            with the new condition.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.ConditionalBuilder.FinishCondition(System.Linq.Expressions.Expression)">
            <summary>
            Adds the non-conditional terminating node.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Binding.ConditionalBuilder.NoConditions">
            <summary>
            Returns true if no conditions have been added
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Binding.ConditionalBuilder.IsFinal">
            <summary>
            Returns true if a final, non-conditional, body has been added.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.ConditionalBuilder.GetMetaObject(System.Dynamic.DynamicMetaObject[])">
            <summary>
            Gets the resulting meta object for the full body.  FinishCondition
            must have been called.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.ConditionalBuilder.AddVariable(System.Linq.Expressions.ParameterExpression)">
            <summary>
            Adds a variable which will be scoped at the level of the final expression.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.ContextArgBuilder">
            <summary>
            ArgBuilder which provides the CodeContext parameter to a method.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.CreateFallback">
            <summary>
            Fallback action for performing a new() on a foreign IDynamicMetaObjectProvider.  used
            when call falls back.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.FastGetBase">
            <summary>
            Base class for all of our fast get delegates.  This holds onto the
            delegate and provides the Update function.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.FastGetBase.Update(System.Runtime.CompilerServices.CallSite,System.Object,IronPython.Runtime.CodeContext)">
            <summary>
            Updates the call site when the current rule is no longer applicable.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.FastSetBase`1">
            <summary>
            Base class for all of our fast set delegates.  This holds onto the
            delegate and provides the Update and Optimize functions.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.FastSetBase`1.Update(System.Runtime.CompilerServices.CallSite,System.Object,`0)">
            <summary>
            Updates the call site when the current rule is no longer applicable.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.IComConvertible">
            <summary>
            An interface that is implemented on DynamicMetaObjects.
            
            This allows objects to opt-into custom conversions when calling
            COM APIs.  The IronPython binders all call this interface before
            doing any COM binding.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.IPythonExpandable">
            <summary>
            Interface used to mark objects which contain a dictionary of custom attributes that shadow
            their existing attributes in a dynamic fashion.  <seealso cref="T:MetaExpandable"/>
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.IPythonExpandable.EnsureCustomAttributes">
            <summary>
            Ensures that a non-null IDictionary instance is created for CustomAttributes and
            returns it.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.MetaExpandable`1">
            <summary>
            Meta-object which allows IPythonExpandable objects to behave like Python objects in their
            ability to dynamically add and remove new or existing custom attributes, generally shadowing
            existing built-in members.  <seealso cref="T:IPythonExpandable"/>
            
            Getting: Member accesses first consult the object's CustomAttributes dictionary, then fall
                through to the underlying object.
            
            Setting: Values can be bound to any member name, shadowing any existing attributes except
                public non-PythonHidden fields and properties, which will bypass the dictionary.  Thus,
                it is possible for SetMember to fail, for example if the property is read-only or of
                the wrong type.
            
            Deleting: Any member represented in the dictionary can be deleted, re-exposing the
                underlying member if it exists.  Any other deletions will fail.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.IPythonInvokable">
            <summary>
            Interface used to mark objects as being invokable from Python.  These objects support
            calling with splatted positional and keyword arguments.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Binding.IPythonSite.Context">
            <summary>
            Gets the PythonContext which the CallSiteBinder is associated with.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.MetaOldInstance">
            <summary>
            Provides a MetaObject for instances of Python's old-style classes.
            
            TODO: Lots of CodeConetxt references, need to move CodeContext onto OldClass and pull it from there.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper">
            <summary>
            Performs the actual work of binding to the function.
            
            Overall this works by going through the arguments and attempting to bind all the outstanding known
            arguments - position arguments and named arguments which map to parameters are easy and handled
            in the 1st pass for GetArgumentsForRule.  We also pick up any extra named or position arguments which
            will need to be passed off to a kw argument or a params array.
            
            After all the normal args have been assigned to do a 2nd pass in FinishArguments.  Here we assign
            a value to either a value from the params list, kw-dict, or defaults.  If there is ambiguity between
            this (e.g. we have a splatted params list, kw-dict, and defaults) we call a helper which extracts them
            in the proper order (first try the list, then the dict, then the defaults).
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetRestrictions">
            <summary>
            Makes the test for our rule.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetSimpleRestriction">
            <summary>
            Makes the test when we just have simple positional arguments.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetComplexRestriction">
            <summary>
            Makes the test when we have a keyword argument call or splatting.
            </summary>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetArgumentsForRule">
            <summary>
            Gets the array of expressions which correspond to each argument for the function.  These
            correspond with the function as it's defined in Python and must be transformed for our
            delegate type before being used.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.FinishArguments(System.Linq.Expressions.Expression[],System.Collections.Generic.List{System.Linq.Expressions.Expression},System.Collections.Generic.Dictionary{System.String,System.Linq.Expressions.Expression})">
            <summary>
            Binds any missing arguments to values from params array, kw dictionary, or default values.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.TryFinishList(System.Linq.Expressions.Expression[],System.Collections.Generic.List{System.Linq.Expressions.Expression})">
            <summary>
            Creates the argument for the list expansion parameter.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeParamsAddition(System.Collections.Generic.List{System.Linq.Expressions.Expression})">
            <summary>
            Adds extra positional arguments to the start of the expanded list.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.TryFinishDictionary(System.Linq.Expressions.Expression[],System.Collections.Generic.Dictionary{System.String,System.Linq.Expressions.Expression})">
            <summary>
            Creates the argument for the dictionary expansion parameter.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeDictionaryAddition(System.Collections.Generic.KeyValuePair{System.String,System.Linq.Expressions.Expression})">
            <summary>
            Adds an unbound keyword argument into the dictionary.
            </summary>
            <param name="kvp"></param>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.AddCheckForNoExtraParameters(System.Linq.Expressions.Expression[])">
            <summary>
            Adds a check to the last parameter (so it's evaluated after we've extracted
            all the parameters) to ensure that we don't have any extra params or kw-params
            when we don't have a params array or params dict to expand them into.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ValidateNotDuplicate(System.Linq.Expressions.Expression,System.String,System.Int32)">
            <summary>
            Helper function to validate that a named arg isn't duplicated with by
            a params list or the dictionary (or both).
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractNonDefaultValue(System.String)">
            <summary>
            Helper function to get a value (which has no default) from either the 
            params list or the dictionary (or both).
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractDictionaryArgument(System.String)">
            <summary>
            Helper function to get the specified variable from the dictionary.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractDefaultValue(System.Int32,System.Int32)">
            <summary>
            Helper function to extract the variable from defaults, or to call a helper
            to check params / kw-dict / defaults to see which one contains the actual value.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractFromListOrDictionary(System.String)">
            <summary>
            Helper function to extract from the params list or dictionary depending upon
            which one has an available value.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractNextParamsArg">
            <summary>
            Helper function to extract the next argument from the params list.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetArgumentsForTargetType(System.Linq.Expressions.Expression[])">
            <summary>
            Fixes up the argument list for the appropriate target delegate type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetFunctionParam">
            <summary>
            Helper function to get the function argument strongly typed.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeDictionaryCopy(System.Dynamic.DynamicMetaObject)">
            <summary>
            Called when the user is expanding a dictionary - we copy the user
            dictionary and verify that it contains only valid string names.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeParamsCopy(System.Linq.Expressions.Expression)">
            <summary>
            Called when the user is expanding a params argument
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeDictionary(System.Collections.Generic.Dictionary{System.String,System.Linq.Expressions.Expression})">
            <summary>
            Called when the user hasn't supplied a dictionary to be expanded but the
            function takes a dictionary to be expanded.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeParamsTuple(System.Collections.Generic.List{System.Linq.Expressions.Expression})">
            <summary>
            Helper function to create the expression for creating the actual tuple passed through.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeFunctionInvoke(System.Linq.Expressions.Expression[])">
            <summary>
            Creates the code to invoke the target delegate function w/ the specified arguments.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.AddInitialization(System.Linq.Expressions.Expression)">
            <summary>
            Appends the initialization code for the call to the function if any exists.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonObject.MakeDelegateTarget(System.Dynamic.DynamicMetaObjectBinder,System.Type,System.Dynamic.DynamicMetaObject)">
            <summary>
            Creates a target which creates a new dynamic method which contains a single
            dynamic site that invokes the callable object.
            
            TODO: This should be specialized for each callable object
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonType.MakeStandardDotNetTypeCall(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Creating a standard .NET type is easy - we just call it's constructor with the provided
            arguments.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonType.MakePythonTypeCall(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Creating a Python type involves calling __new__ and __init__.  We resolve them
            and generate calls to either the builtin funcions directly or embed sites which
            call the slots at runtime.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonType.TooManyArgsForDefaultNew(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Checks if we have a default new and init - in this case if we have any
            arguments we don't allow the call.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaPythonType.MakeVersionCheck">
            <summary>
            Creates a test which tests the specific version of the type.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.MetaPythonType.GetBinderHelper`1">
            <summary>
            Base class for performing member binding.  Derived classes override Add methods
            to produce the actual final result based upon what the GetBinderHelper resolves.
            </summary>
            <typeparam name="TResult"></typeparam>
        </member>
        <member name="T:IronPython.Runtime.Binding.MetaPythonType.MetaGetBinderHelper">
            <summary>
            Provides the normal meta binder binding.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.MetaPythonType.FastGetBinderHelper">
            <summary>
            Provides delegate based fast binding.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaUserObject.GetConversionFailedReturnValue(IronPython.Runtime.Binding.PythonConversionBinder,System.Dynamic.DynamicMetaObject)">
            <summary>
             Various helpers related to calling Python __*__ conversion methods 
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaUserObject.Fallback(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject)">
            <summary>
            Helper for falling back - if we have a base object fallback to it first (which can
            then fallback to the calling site), otherwise fallback to the calling site.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaUserObject.Fallback(System.Dynamic.SetMemberBinder,System.Dynamic.DynamicMetaObject)">
            <summary>
            Helper for falling back - if we have a base object fallback to it first (which can
            then fallback to the calling site), otherwise fallback to the calling site.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.MetaUserObject.GetOrInvokeBinderHelper`1">
            <summary>
            Provides the lookup logic for resolving a Python object.  Subclasses
            provide the actual logic for producing the binding result.  Currently
            there are two forms of the binding result: one is the DynamicMetaObject
            form used for non-optimized bindings.  The other is the Func of CallSite,
            object, CodeContext, object form which is used for fast binding and
            pre-compiled rules.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.MetaUserObject.MetaGetBinderHelper">
            <summary>
            GetBinder which produces a DynamicMetaObject.  This binder always
            successfully produces a DynamicMetaObject which can perform the requested get.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaUserObject.MetaGetBinderHelper.MakeGetAttributeRule(IronPython.Runtime.Binding.MetaUserObject.GetBindingInfo,IronPython.Runtime.Types.IPythonObject,IronPython.Runtime.Types.PythonTypeSlot,System.Dynamic.DynamicMetaObject)">
            <summary>
            Makes a rule which calls a user-defined __getattribute__ function and falls back to __getattr__ if that
            raises an AttributeError.
            
            slot is the __getattribute__ method to be called.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaUserObject.MetaGetBinderHelper.MakeOldStyleAccess">
            <summary>
            Checks a range of the MRO to perform old-style class lookups if any old-style classes
            are present.  We will call this twice to produce a search before a slot and after
            a slot.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaUserObject.TryGetGetAttribute(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.Types.PythonTypeSlot@)">
            <summary>
            Checks to see if this type has __getattribute__ that overrides all other attribute lookup.
            
            This is more complex then it needs to be.  The problem is that when we have a 
            mixed new-style/old-style class we have a weird __getattribute__ defined.  When
            we always dispatch through rules instead of PythonTypes it should be easy to remove
            this.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaUserObject.MetaSetBinderHelper.FallbackSetError(System.Dynamic.SetMemberBinder,System.Dynamic.DynamicMetaObject)">
            <summary>
            Helper for falling back - if we have a base object fallback to it first (which can
            then fallback to the calling site), otherwise fallback to the calling site.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaUserObject.FindSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.IPythonObject,System.Boolean@,System.Boolean@,System.Boolean@)">
            <summary>
            Looks up the associated PythonTypeSlot from the object.  Indicates if the result
            came from a standard .NET type in which case we will fallback to the sites binder.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaUserObject.FallbackGetError(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject)">
            <summary>
            Helper for falling back - if we have a base object fallback to it first (which can
            then fallback to the calling site), otherwise fallback to the calling site.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.MetaUserObject.FallbackDeleteError(System.Dynamic.DeleteMemberBinder,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Helper for falling back - if we have a base object fallback to it first (which can
            then fallback to the calling site), otherwise fallback to the calling site.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.MakeReadOnlyMemberError(System.Type,System.String)">
            <summary>
            Provides a way for the binder to provide a custom error message when lookup fails.  Just
            doing this for the time being until we get a more robust error return mechanism.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.MakeUndeletableMemberError(System.Type,System.String)">
            <summary>
            Provides a way for the binder to provide a custom error message when lookup fails.  Just
            doing this for the time being until we get a more robust error return mechanism.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.GetBinder(IronPython.Runtime.CodeContext)">
            <summary>
            Gets the PythonBinder associated with tihs CodeContext
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.TryLookupSlot(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
            <summary>
            Performs .NET member resolution.  This looks within the given type and also
            includes any extension members.  Base classes and their extension members are 
            not searched.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.TryLookupProtectedSlot(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
            <summary>
            Performs .NET member resolution.  This looks within the given type and also
            includes any extension members.  Base classes and their extension members are 
            not searched.
            
            This version allows PythonType's for protected member resolution.  It shouldn't
            be called externally for other purposes.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.TryResolveSlot(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.Types.PythonType,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
            <summary>
            Performs .NET member resolution.  This looks the type and any base types
            for members.  It also searches for extension members in the type and any base types.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.LookupMembers(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.PythonDictionary)">
            <summary>
            Gets the member names which are defined in this type and any extension members.
            
            This search does not include members in any subtypes or their extension members.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.ResolveMemberNames(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.Types.PythonType,System.Collections.Generic.Dictionary{System.String,System.String})">
            <summary>
            Gets the member names which are defined in the type and any subtypes.  
            
            This search includes members in the type and any subtypes as well as extension
            types of the type and its subtypes.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.MakeExtensionTypes">
            <summary>
            Creates the initial table of extension types.  These are standard extension that we apply
            to well known .NET types to make working with them better.  Being added to this table does
            not make a type a Python type though so that it's members are generally accessible w/o an
            import clr and their type is not re-named.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.MakeSystemTypes">
            <summary>
            Creates a table of standard .NET types which are also standard Python types.  These types have a standard
            set of extension types which are shared between all runtimes.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.DomainManager_AssemblyLoaded(System.Object,Microsoft.Scripting.AssemblyLoadedEventArgs)">
            <summary>
            Event handler for when our domain manager has an assembly loaded by the user hosting the script
            runtime.  Here we can gather any information regarding extension methods.  
            
            Currently DLR-style extension methods become immediately available w/o an explicit import step.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonBinder.SlotCache">
            <summary>
            Provides a cache from Type/name -> PythonTypeSlot and also allows access to
            all members (and remembering whether all members are cached).
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.CacheSlot(System.Type,System.Boolean,System.String,IronPython.Runtime.Types.PythonTypeSlot,Microsoft.Scripting.Actions.MemberGroup)">
            <summary>
            Writes to a cache the result of a type lookup.  Null values are allowed for the slots and they indicate that
            the value does not exist.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.TryGetCachedSlot(System.Type,System.Boolean,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
            <summary>
            Looks up a cached type slot for the specified member and type.  This may return true and return a null slot - that indicates
            that a cached result for a member which doesn't exist has been stored.  Otherwise it returns true if a slot is found or
            false if it is not.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.TryGetCachedMember(System.Type,System.String,System.Boolean,Microsoft.Scripting.Actions.MemberGroup@)">
            <summary>
            Looks up a cached member group for the specified member and type.  This may return true and return a null group - that indicates
            that a cached result for a member which doesn't exist has been stored.  Otherwise it returns true if a group is found or
            false if it is not.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.IsFullyCached(System.Type,System.Boolean)">
            <summary>
            Checks to see if all members have been populated for the provided type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.CacheAll(System.Type,System.Boolean,System.Collections.Generic.Dictionary{System.String,System.Collections.Generic.KeyValuePair{IronPython.Runtime.Types.PythonTypeSlot,Microsoft.Scripting.Actions.MemberGroup}})">
            <summary>
            Populates the type with all the provided members and marks the type 
            as being fully cached.
            
            The dictionary is used for the internal storage and should not be modified after
            providing it to the cache.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.GetAllMembers(System.Type,System.Boolean)">
            <summary>
            Returns an enumerable object which provides access to all the members of the provided type.
            
            The caller must check that the type is fully cached and populate the cache if it isn't before
            calling this method.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonGetMemberBinder.Bind(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Python's Invoke is a non-standard action.  Here we first try to bind through a Python
            internal interface (IPythonInvokable) which supports CallSigantures.  If that fails
            and we have an IDO then we translate to the DLR protocol through a nested dynamic site -
            this includes unsplatting any keyword / position arguments.  Finally if it's just a plain
            old .NET type we use the default binder which supports CallSignatures.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonInvokeBinder">
            <summary>
            The Action used for Python call sites.  This supports both splatting of position and keyword arguments.
            
            When a foreign object is encountered the arguments are expanded into normal position/keyword arguments.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.Bind(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Python's Invoke is a non-standard action.  Here we first try to bind through a Python
            internal interface (IPythonInvokable) which supports CallSigantures.  If that fails
            and we have an IDO then we translate to the DLR protocol through a nested dynamic site -
            this includes unsplatting any keyword / position arguments.  Finally if it's just a plain
            old .NET type we use the default binder which supports CallSignatures.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.Fallback(System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Fallback - performs the default binding operation if the object isn't recognized
            as being invokable.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Binding.PythonInvokeBinder.Signature">
            <summary>
            Gets the CallSignature for this invocation which describes how the MetaObject array
            is to be mapped.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.InvokeForeignObject(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Creates a nested dynamic site which uses the unpacked arguments.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.TranslateArguments(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[],System.Dynamic.CallInfo@,System.Collections.Generic.List{System.Linq.Expressions.Expression}@,System.Linq.Expressions.Expression@,System.Dynamic.BindingRestrictions@)">
            <summary>
            Translates our CallSignature into a DLR Argument list and gives the simple MetaObject's which are extracted
            from the tuple or dictionary parameters being splatted.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Binding.PythonOperationBinder.ReturnType">
            <summary>
            The result type of the operation.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonOperationKind">
            <summary>
            Custom dynamic site kinds for simple sites that just take a fixed set of parameters.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Documentation">
            <summary>
            Unary operator.
            
            Gets various documentation about the object returned as a string
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.CallSignatures">
            <summary>
            Unary operator.
            
            Gets information about the type of parameters, returned as a string.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.IsCallable">
            <summary>
            Unary operator.
            
            Checks whether the object is callable or not, returns true if it is.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Contains">
            <summary>
            Binary operator.
            
            Checks to see if the instance contains another object.  Returns true or false.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Length">
            <summary>
            Unary operator.
            
            Returns the number of items stored in the object.
            </summary>      
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Compare">
            <summary>
            Binary operator.
            
            Compares two instances returning an integer indicating the relationship between them.  May
            throw if the object types are uncomparable.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.DivMod">
            <summary>
            Binary operator.
            
            Returns both the dividend and quotioent of x / y.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.AbsoluteValue">
            <summary>
            Unary operator.
            
            Get the absolute value of the instance.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Positive">
            <summary>
            Unary operator.
            
            Gets the positive value of the instance.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Negate">
            <summary>
            Unary operator.
            
            Negates the instance and return the new value.
            </summary>        
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.OnesComplement">
            <summary>
            Unary operator.
            
            Returns the ones complement of the instance.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.IsFalse">
            <summary>
            Unary operator.
            
            Boolean negation
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Not">
            <summary>
            Unary operator.
            
            Negation, returns object
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.GetEnumeratorForIteration">
            <summary>
            Get enumerator for iteration binder.  Returns a KeyValuePair&lt;IEnumerator, IDisposable&gt;
            
            The IEnumerator is used for iteration.  The IDisposable is provided if the object was an
            IEnumerable or IEnumerable&lt;T&gt; and is a disposable object.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Add">
            <summary>Operator for performing add</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Subtract">
            <summary>Operator for performing sub</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Power">
            <summary>Operator for performing pow</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Multiply">
            <summary>Operator for performing mul</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.FloorDivide">
            <summary>Operator for performing floordiv</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Divide">
            <summary>Operator for performing div</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.TrueDivide">
            <summary>Operator for performing truediv</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Mod">
            <summary>Operator for performing mod</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.LeftShift">
            <summary>Operator for performing lshift</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.RightShift">
            <summary>Operator for performing rshift</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.BitwiseAnd">
            <summary>Operator for performing and</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.BitwiseOr">
            <summary>Operator for performing or</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ExclusiveOr">
            <summary>Operator for performing xor</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.LessThan">
            <summary>Operator for performing lt</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.GreaterThan">
            <summary>Operator for performing gt</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.LessThanOrEqual">
            <summary>Operator for performing le</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.GreaterThanOrEqual">
            <summary>Operator for performing ge</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Equal">
            <summary>Operator for performing eq</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.NotEqual">
            <summary>Operator for performing ne</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.LessThanGreaterThan">
            <summary>Operator for performing lg</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceAdd">
            <summary>Operator for performing in-place add</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceSubtract">
            <summary>Operator for performing in-place sub</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlacePower">
            <summary>Operator for performing in-place pow</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceMultiply">
            <summary>Operator for performing in-place mul</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceFloorDivide">
            <summary>Operator for performing in-place floordiv</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceDivide">
            <summary>Operator for performing in-place div</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceTrueDivide">
            <summary>Operator for performing in-place truediv</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceMod">
            <summary>Operator for performing in-place mod</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceLeftShift">
            <summary>Operator for performing in-place lshift</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceRightShift">
            <summary>Operator for performing in-place rshift</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceBitwiseAnd">
            <summary>Operator for performing in-place and</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceBitwiseOr">
            <summary>Operator for performing in-place or</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceExclusiveOr">
            <summary>Operator for performing in-place xor</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseAdd">
            <summary>Operator for performing reverse add</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseSubtract">
            <summary>Operator for performing reverse sub</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReversePower">
            <summary>Operator for performing reverse pow</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseMultiply">
            <summary>Operator for performing reverse mul</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseFloorDivide">
            <summary>Operator for performing reverse floordiv</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseDivide">
            <summary>Operator for performing reverse div</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseTrueDivide">
            <summary>Operator for performing reverse truediv</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseMod">
            <summary>Operator for performing reverse mod</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseLeftShift">
            <summary>Operator for performing reverse lshift</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseRightShift">
            <summary>Operator for performing reverse rshift</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseBitwiseAnd">
            <summary>Operator for performing reverse and</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseBitwiseOr">
            <summary>Operator for performing reverse or</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseExclusiveOr">
            <summary>Operator for performing reverse xor</summary>
        </member>
        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseDivMod">
            <summary>Operator for performing reverse divmod</summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonProtocol">
            <summary>
            Provides binding logic which is implemented to follow various Python protocols.  This includes
            things such as calling __call__ to perform calls, calling __nonzero__/__len__ to convert to
            bool, calling __add__/__radd__ to do addition, etc...  
            
            This logic gets shared between both the IDynamicMetaObjectProvider implementation for Python objects as well
            as the Python sites.  This ensures the logic we follow for our builtin types and user defined
            types is identical and properly conforming to the various protocols.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.ConvertToBool(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject)">
            <summary>
            Gets a MetaObject which converts the provided object to a bool using __nonzero__ or __len__
            protocol methods.  This code is shared between both our fallback for a site and our MetaObject
            for user defined objects.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.GetConvertByLengthBody(IronPython.Runtime.PythonContext,System.Linq.Expressions.Expression)">
            <summary>
            Used for conversions to bool
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeContainsOperation(IronPython.Runtime.Binding.PythonOperationBinder,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Creates a rule for the contains operator.  This is exposed via "x in y" in 
            IronPython.  It is implemented by calling the __contains__ method on x and
            passing in y.  
            
            If a type doesn't define __contains__ but does define __getitem__ then __getitem__ is 
            called repeatedly in order to see if the object is there.
            
            For normal .NET enumerables we'll walk the iterator and see if it's present.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonProtocol.ComparisonHelper">
            <summary>
            Delegate for finishing the comparison.   This takes in a condition and a return value and needs to update the ConditionalBuilder
            with the appropriate resulting body.  The condition may be null.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeOneCompareGeneric(IronPython.Runtime.Binding.SlotOrFunction,System.Boolean,System.Dynamic.DynamicMetaObject[],IronPython.Runtime.Binding.PythonProtocol.ComparisonHelper,IronPython.Runtime.Binding.ConditionalBuilder,System.Type)">
            <summary>
            Helper to handle a comparison operator call.  Checks to see if the call can
            return NotImplemented and allows the caller to modify the expression that
            is ultimately returned (e.g. to turn __cmp__ into a bool after a comparison)
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.DoCoerce(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.ConditionalBuilder,IronPython.Runtime.Binding.PythonOperationKind,System.Dynamic.DynamicMetaObject[],System.Boolean,System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            calls __coerce__ for old-style classes and performs the operation if the coercion is successful.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeSortComparisonRule(System.Dynamic.DynamicMetaObject[],System.Dynamic.DynamicMetaObjectBinder,IronPython.Runtime.Binding.PythonOperationKind)">
            <summary>
            Makes the comparison rule which returns an int (-1, 0, 1).  TODO: Better name?
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeIndexerOperation(System.Dynamic.DynamicMetaObjectBinder,IronPython.Runtime.Binding.PythonIndexType,System.Dynamic.DynamicMetaObject[],System.Dynamic.DynamicMetaObject)">
            <summary>
            Python has three protocols for slicing:
               Simple Slicing x[i:j]
               Extended slicing x[i,j,k,...]
               Long Slice x[start:stop:step]
            
            The first maps to __*slice__ (get, set, and del).  
               This takes indexes - i, j - which specify the range of elements to be
               returned.  In the slice variants both i, j must be numeric data types.  
            The 2nd and 3rd are both __*item__.  
               This receives a single index which is either a Tuple or a Slice object (which 
               encapsulates the start, stop, and step values) 
            
            This is in addition to a simple indexing x[y].
            
            For simple slicing and long slicing Python generates Operators.*Slice.  For
            the extended slicing and simple indexing Python generates a Operators.*Item
            action.
            
            Extended slicing maps to the normal .NET multi-parameter input.  
            
            So our job here is to first determine if we're to call a __*slice__ method or
            a __*item__ method.  
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.ConvertArgs(System.Dynamic.DynamicMetaObject[])">
            <summary>
            Helper to convert all of the arguments to their known types.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.GetItemSliceArguments(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.PythonIndexType,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Gets the arguments that need to be provided to __*item__ when we need to pass a slice object.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonProtocol.Callable">
            <summary>
            Base class for calling indexers.  We have two subclasses that target built-in functions and user defined callable objects.
            
            The Callable objects get handed off to ItemBuilder's which then call them with the appropriate arguments.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.Callable.MakeCallable(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.PythonIndexType,IronPython.Runtime.Types.BuiltinFunction,IronPython.Runtime.Types.PythonTypeSlot)">
            <summary>
            Creates a new CallableObject.  If BuiltinFunction is available we'll create a BuiltinCallable otherwise
            we create a SlotCallable.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.Callable.GetTupleArguments(System.Dynamic.DynamicMetaObject[])">
            <summary>
            Gets the arguments in a form that should be used for extended slicing.
            
            Python defines that multiple tuple arguments received (x[1,2,3]) get 
            packed into a Tuple.  For most .NET methods we just want to expand
            this into the multiple index arguments.  For slots and old-instances
            we want to pass in the tuple
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.Callable.CompleteRuleTarget(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject[],System.Func{System.Dynamic.DynamicMetaObject})">
            <summary>
            Adds the target of the call to the rule.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonProtocol.BuiltinCallable">
            <summary>
            Subclass of Callable for a built-in function.  This calls a .NET method performing
            the appropriate bindings.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonProtocol.SlotCallable">
            <summary>
            Callable to a user-defined callable object.  This could be a Python function,
            a class defining __call__, etc...
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonProtocol.IndexBuilder">
            <summary>
            Base class for building a __*item__ or __*slice__ call.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonProtocol.SliceBuilder">
            <summary>
            Derived IndexBuilder for calling __*slice__ methods
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.PythonProtocol.ItemBuilder">
            <summary>
            Derived IndexBuilder for calling __*item__ methods.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.GetIndexOperators(IronPython.Runtime.Binding.PythonIndexType,System.String@,System.String@,System.Int32@)">
            <summary>
            Helper to get the symbols for __*item__ and __*slice__ based upon if we're doing
            a get/set/delete and the minimum number of arguments required for each of those.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.ShouldCoerce(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.PythonOperationKind,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject,System.Boolean)">
            <summary>
            Checks if a coercion check should be performed.  We perform coercion under the following
            situations:
                1. Old instances performing a binary operator (excluding rich comparisons)
                2. User-defined new instances calling __cmp__ but only if we wouldn't dispatch to a built-in __coerce__ on the parent type
                
            This matches the behavior of CPython.
            </summary>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Binding.PythonProtocol.TypeError(System.Dynamic.DynamicMetaObjectBinder,System.String,System.Dynamic.DynamicMetaObject[])">
            <summary>
            Produces an error message for the provided message and type names.  The error message should contain
            string formatting characters ({0}, {1}, etc...) for each of the type names.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Binding.SlotOrFunction">
            <summary>
            Provides an abstraction for calling something which might be a builtin function or
            might be some arbitrary user defined slot.  If the object is a builtin function the
            call will go directly to the underlying .NET method.  If the object is an arbitrary
            callable object we will setup a nested dynamic site for performing the additional
            dispatch.
            
            TODO: We could probably do a specific binding to the object if it's another IDyanmicObject.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.SlotOrFunction.GetCombinedTargets(IronPython.Runtime.Binding.SlotOrFunction,IronPython.Runtime.Binding.SlotOrFunction,IronPython.Runtime.Binding.SlotOrFunction@,IronPython.Runtime.Binding.SlotOrFunction@)">
            <summary>
            Combines two methods, which came from two different binary types, selecting the method which has the best
            set of conversions (the conversions which result in the least narrowing).
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Binding.SlotOrFunction.TryGetBinder(IronPython.Runtime.PythonContext,System.Dynamic.DynamicMetaObject[],System.String,System.String,IronPython.Runtime.Binding.SlotOrFunction@,IronPython.Runtime.Types.PythonType@)">
            <summary>
            Tries to get a MethodBinder associated with the slot for the specified type.
            
            If a method is found the binder is set and true is returned.
            If nothing is found binder is null and true is returned.
            If something other than a method is found false is returned.
            
            TODO: Remove rop
            </summary>
        </member>
        <member name="T:IronPython.Runtime.BuiltinPythonModule">
            <summary>
            Implements a built-in module which is instanced per PythonContext.
            
            Implementers can subclass this type and then have a module which has efficient access
            to internal state (this doesn't need to go through PythonContext.GetModuleState).  These
            modules can also declare module level globals which they'd like to provide efficient
            access to by overloading GetGlobalVariableNames.  When Initialize is called these
            globals are provided and can be cached in the instance for fast global access.
            
            Just like normal static modules these modules are registered with the PythonModuleAttribute.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.BuiltinPythonModule.Initialize(IronPython.Runtime.CodeContext,System.Collections.Generic.Dictionary{System.String,IronPython.Compiler.PythonGlobal})">
            <summary>
            Initializes the module for it's first usage.  By default this calls PerformModuleReload with the
            the dictionary.
            </summary>
            <param name="codeContext">The CodeContext for the module.</param>
            <param name="optimizedGlobals">A list of globals which have optimize access.  Contains at least all of the global variables reutrned by GetGlobalVariableNames.</param>
        </member>
        <member name="M:IronPython.Runtime.BuiltinPythonModule.GetGlobalVariableNames">
            <summary>
            Gets a list of variable names which should have optimized storage (instances of PythonGlobal objects).
            The module receives the global objects during the Initialize call and can hold onto them for
            direct access to global members.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.BuiltinPythonModule.PerformModuleReload">
            <summary>
            Called when the user attempts to reload() on your module and by the base class Initialize method.
            
            This provides an opportunity to allocate any per-module data which is not simply function definitions.
            
            A common usage here is to create exception objects which are allocated by the module using PythonExceptions.CreateSubType.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.BuiltinPythonModule.Context">
            <summary>
            Provides access to the PythonContext which this module was created for.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.BuiltinPythonModule.Globals">
            <summary>
            Provides access to the CodeContext for the module.  Returns null before Initialize() is called.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ByteArray">
            <summary>
            bytearray(string, encoding[, errors]) -> bytearray
            bytearray(iterable) -> bytearray
            
            Construct a mutable bytearray object from:
             - an iterable yielding values in range(256), including:
                + a list of integer values
                + a bytes, bytearray, buffer, or array object
             - a text string encoded using the specified encoding
             
            bytearray([int]) -> bytearray
            
            Construct a zero-ititialized bytearray of the specified length.
            (default=0)
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ByteArray.istitle">
            <summary>
            return true if self is a titlecased string and there is at least one
            character in self; also, uppercase characters may only follow uncased
            characters (e.g. whitespace) and lowercase characters only cased ones. 
            return false otherwise.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ByteArray.join(System.Object)">
            <summary>
            Return a string which is the concatenation of the strings 
            in the sequence seq. The separator between elements is the 
            string providing this method
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ByteArray.op_Addition(IronPython.Runtime.ByteArray,System.String)">
            <summary>
            This overload is specifically implemented because in IronPython strings are unicode
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Bytes.istitle">
            <summary>
            return true if self is a titlecased string and there is at least one
            character in self; also, uppercase characters may only follow uncased
            characters (e.g. whitespace) and lowercase characters only cased ones. 
            return false otherwise.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Bytes.join(System.Object)">
            <summary>
            Return a string which is the concatenation of the strings 
            in the sequence seq. The separator between elements is the 
            string providing this method
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Bytes.ToByteArray">
            <summary>
            Returns a copy of the internal byte array.
            </summary>
            <returns>
            System.Byte[]
            </returns>
        </member>
        <member name="M:IronPython.Runtime.Bytes.GetUnsafeByteArray">
            <summary>
            This method returns the underlying byte array directly.
            It should be used sparingly!
            </summary>
            <returns>
            System.Byte[]
            </returns>
        </member>
        <member name="T:IronPython.Runtime.ClassMethodAttribute">
            <summary>
            Marks a method as being a class method.  The PythonType which was used to access
            the method will then be passed as the first argument.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ClrModule">
            <summary>
            this class contains objecs and static methods used for
            .NET/CLS interop with Python.  
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.GetCurrentRuntime(IronPython.Runtime.CodeContext)">
            <summary>
            Gets the current ScriptDomainManager that IronPython is loaded into.  The
            ScriptDomainManager can then be used to work with the language portion of the
            DLR hosting APIs.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.Use(IronPython.Runtime.CodeContext,System.String)">
            <summary>
            Use(name) -> module
            
            Attempts to load the specified module searching all languages in the loaded ScriptRuntime.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.Use(IronPython.Runtime.CodeContext,System.String,System.String)">
            <summary>
            Use(path, language) -> module
            
            Attempts to load the specified module belonging to a specific language loaded into the
            current ScriptRuntime.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.SetCommandDispatcher(IronPython.Runtime.CodeContext,System.Action{System.Action})">
            <summary>
            SetCommandDispatcher(commandDispatcher)
            
            Sets the current command dispatcher for the Python command line.  
            
            The command dispatcher will be called with a delegate to be executed.  The command dispatcher
            should invoke the target delegate in the desired context.
            
            A common use for this is to enable running all REPL commands on the UI thread while the REPL
            continues to run on a non-UI thread.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.GetClrType(System.Type)">
            <summary>
            Gets the CLR Type object from a given Python type object.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.GetPythonType(System.Type)">
            <summary>
            Gets the Python type object from a given CLR Type object.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.GetDynamicType(System.Type)">
            <summary>
            OBSOLETE: Gets the Python type object from a given CLR Type object.
            
            Use clr.GetPythonType instead.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.accepts(System.Object[])">
            <summary>
            accepts(*types) -> ArgChecker
            
            Decorator that returns a new callable object which will validate the arguments are of the specified types.
            </summary>
            <param name="types"></param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.returns(System.Object)">
            <summary>
            returns(type) -> ReturnChecker
            
            Returns a new callable object which will validate the return type is of the specified type.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ClrModule.ArgChecker">
            <summary>
            Decorator for verifying the arguments to a function are of a specified type.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ClrModule.RuntimeArgChecker">
            <summary>
            Returned value when using clr.accepts/ArgChecker.  Validates the argument types and
            then calls the original function.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ClrModule.ReturnChecker">
            <summary>
            Decorator for verifying the return type of functions.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ClrModule.RuntimeReturnChecker">
            <summary>
            Returned value when using clr.returns/ReturnChecker.  Calls the original function and
            validates the return type is of a specified type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.Dir(System.Object)">
            <summary>
            returns the result of dir(o) as-if "import clr" has not been performed.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.DirClr(System.Object)">
            <summary>
            Returns the result of dir(o) as-if "import clr" has been performed.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.Convert(IronPython.Runtime.CodeContext,System.Object,System.Type)">
            <summary>
            Attempts to convert the provided object to the specified type.  Conversions that 
            will be attempted include standard Python conversions as well as .NET implicit
            and explicit conversions.
            
            If the conversion cannot be performed a TypeError will be raised.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.CompileModules(IronPython.Runtime.CodeContext,System.String,System.Collections.Generic.IDictionary{System.String,System.Object},System.String[])">
            <summary>
            Provides a helper for compiling a group of modules into a single assembly.  The assembly can later be
            reloaded using the clr.AddReference API.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.CompileSubclassTypes(System.String,System.Object[])">
            <summary>
            clr.CompileSubclassTypes(assemblyName, *typeDescription)
            
            Provides a helper for creating an assembly which contains pre-generated .NET 
            base types for new-style types.
            
            This assembly can then be AddReferenced or put sys.prefix\DLLs and the cached 
            types will be used instead of generating the types at runtime.
            
            This function takes the name of the assembly to save to and then an arbitrary 
            number of parameters describing the types to be created.  Each of those
            parameter can either be a plain type or a sequence of base types.
            
            clr.CompileSubclassTypes(object) -> create a base type for object
            clr.CompileSubclassTypes(object, str, System.Collections.ArrayList) -> create 
                base  types for both object and ArrayList.
                
            clr.CompileSubclassTypes(object, (object, IComparable)) -> create base types for 
                object and an object which implements IComparable.
            
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.GetSubclassedTypes">
            <summary>
            clr.GetSubclassedTypes() -> tuple
            
            Returns a tuple of information about the types which have been subclassed. 
            
            This tuple can be passed to clr.CompileSubclassTypes to cache these
            types on disk such as:
            
            clr.CompileSubclassTypes('assembly', *clr.GetSubclassedTypes())
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ClrModule.FileStreamContentProvider">
            <summary>
            Provides a StreamContentProvider for a stream of content backed by a file on disk.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.BuildPackageMap(System.String[])">
            <summary>
            Goes through the list of files identifying the relationship between packages
            and subpackages.  Returns a dictionary with all of the package filenames (minus __init__.py)
            mapping to their full name.  For example given a structure:
            
            C:\
                someDir\
                    package\
                        __init__.py
                        a.py
                        b\
                            __init.py
                            c.py
                    
            Returns:
                {r'C:\somedir\package' : 'package', r'C:\somedir\package\b', 'package.b'}
                
            This can then be used for calculating the full module name of individual files
            and packages.  For example a's full name is "package.a" and c's full name is
            "package.b.c".
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.GetProfilerData(IronPython.Runtime.CodeContext,System.Boolean)">
            <summary>
            Returns a list of profile data. The values are tuples of Profiler.Data objects
            
            All times are expressed in the same unit of measure as DateTime.Ticks
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.ClearProfilerData(IronPython.Runtime.CodeContext)">
            <summary>
            Resets all profiler counters back to zero
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.EnableProfiler(IronPython.Runtime.CodeContext,System.Boolean)">
            <summary>
            Enable or disable profiling for the current ScriptEngine.  This will only affect code
            that is compiled after the setting is changed; previously-compiled code will retain
            whatever setting was active when the code was originally compiled.
            
            The easiest way to recompile a module is to reload() it.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.Serialize(System.Object)">
            <summary>
            Serializes data using the .NET serialization formatter for complex
            types.  Returns a tuple identifying the serialization format and the serialized 
            data which can be fed back into clr.Deserialize.
            
            Current serialization formats include custom formats for primitive .NET
            types which aren't already recognized as tuples.  None is used to indicate
            that the Binary .NET formatter is used.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ClrModule.Deserialize(System.String,System.String)">
            <summary>
            Deserializes the result of a Serialize call.  This can be used to perform serialization
            for .NET types which are serializable.  This method is the callable object provided
            from __reduce_ex__ for .serializable .NET types.
            
            The first parameter indicates the serialization format and is the first tuple element
            returned from the Serialize call.  
            
            The second parameter is the serialized data.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.CodeContext">
            <summary>
            Captures and flows the state of executing code from the generated 
            Python code into the IronPython runtime.
            </summary>    
        </member>
        <member name="M:IronPython.Runtime.CodeContext.#ctor(IronPython.Runtime.PythonDictionary,IronPython.Runtime.ModuleContext)">
            <summary>
            Creates a new CodeContext which is backed by the specified Python dictionary.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.CodeContext.ModuleContext">
            <summary>
            Gets the module state for top-level code.
            </summary>   
        </member>
        <member name="P:IronPython.Runtime.CodeContext.GlobalScope">
            <summary>
            Gets the DLR scope object that corresponds to the global variables of this context.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.CodeContext.LanguageContext">
            <summary>
            Gets the PythonContext which created the CodeContext.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.CodeContext.GlobalDict">
            <summary>
            Gets the dictionary for the global variables from the ModuleContext.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.CodeContext.ShowCls">
            <summary>
            True if this global context should display CLR members on shared types (for example .ToString on int/bool/etc...)
            
            False if these attributes should be hidden.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CodeContext.TryLookupName(System.String,System.Object@)">
            <summary>
            Attempts to lookup the provided name in this scope or any outer scope.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CodeContext.TryLookupBuiltin(System.String,System.Object@)">
            <summary>
            Looks up a global variable.  If the variable is not defined in the
            global scope then built-ins is consulted.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.CodeContext.Dict">
            <summary>
            Gets the dictionary used for storage of local variables.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CodeContext.TryGetVariable(System.String,System.Object@)">
            <summary>
            Attempts to lookup the variable in the local scope.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CodeContext.TryRemoveVariable(System.String)">
            <summary>
            Removes a variable from the local scope.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CodeContext.SetVariable(System.String,System.Object)">
            <summary>
            Sets a variable in the local scope.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CodeContext.TryGetGlobalVariable(System.String,System.Object@)">
            <summary>
            Gets a variable from the global scope.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CodeContext.SetGlobalVariable(System.String,System.Object)">
            <summary>
            Sets a variable in the global scope.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CodeContext.TryRemoveGlobalVariable(System.String)">
            <summary>
            Removes a variable from the global scope.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CodeContext.GetBuiltinsDict">
            <summary>
            Returns the dictionary associated with __builtins__ if one is
            set or null if it's not available.  If __builtins__ is a module
            the module's dictionary is returned.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.CommonDictionaryStorage">
            <summary>
            General purpose storage used for most PythonDictionarys.
            
            This dictionary storage is thread safe for multiple readers or writers.
            
            Mutations to the dictionary involves a simple locking strategy of
            locking on the DictionaryStorage object to ensure that only one
            mutation happens at a time.
            
            Reads against the dictionary happen lock free.  When the dictionary is mutated
            it is either adding or removing buckets in a thread-safe manner so that the readers
            will either see a consistent picture as if the read occured before or after the mutation.
            
            When resizing the dictionary the buckets are replaced atomically so that the reader
            sees the new buckets or the old buckets.  When reading the reader first reads
            the buckets and then calls a static helper function to do the read from the bucket
            array to ensure that readers are not seeing multiple bucket arrays.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor">
            <summary>
            Creates a new dictionary storage with no buckets
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor(System.Int32)">
            <summary>
            Creates a new dictionary storage with no buckets
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor(System.Object[],System.Boolean)">
            <summary>
            Creates a new dictionary geting values/keys from the
            items arary
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Int32,System.Type,System.Func{System.Object,System.Int32},System.Func{System.Object,System.Object,System.Boolean},IronPython.Runtime.CommonDictionaryStorage.NullValue)">
            <summary>
            Creates a new dictionary storage with the given set of buckets
            and size.  Used when cloning the dictionary storage.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Add(System.Object,System.Object)">
            <summary>
            Adds a new item to the dictionary, replacing an existing one if it already exists.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Initialize">
            <summary>
            Initializes the buckets to their initial capacity, the caller
            must check if the buckets are empty first.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Add(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Object,System.Object)">
            <summary>
            Add helper that works over a single set of buckets.  Used for
            both the normal add case as well as the resize case.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.AddWorker(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Object,System.Object,System.Int32)">
            <summary>
            Add helper which adds the given key/value (where the key is not null) with
            a pre-computed hash code.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Remove(IronPython.Runtime.DictionaryStorage@,System.Object)">
            <summary>
            Removes an entry from the dictionary and returns true if the
            entry was removed or false.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.RemoveAlwaysHash(System.Object)">
            <summary>
            Removes an entry from the dictionary and returns true if the
            entry was removed or false.  The key will always be hashed
            so if it is unhashable an exception will be thrown - even
            if the dictionary has no buckets.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Contains(System.Object)">
            <summary>
            Checks to see if the key exists in the dictionary.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.TryGetValue(System.Object,System.Object@)">
            <summary>
            Trys to get the value associated with the given key and returns true
            if it's found or false if it's not present.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.TryGetValue(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Object,System.Object@)">
            <summary>
            Static helper to try and get the value from the dictionary.
            
            Used so the value lookup can run against a buckets while a writer
            replaces the buckets.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.CommonDictionaryStorage.Count">
            <summary>
            Returns the number of key/value pairs currently in the dictionary.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Clear(IronPython.Runtime.DictionaryStorage@)">
            <summary>
            Clears the contents of the dictionary.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Clone">
            <summary>
            Clones the storage returning a new DictionaryStorage object.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Hash(System.Object)">
            <summary>
            Helper to hash the given key w/ support for null.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.CommonDictionaryStorage.Bucket">
            <summary>
            Used to store a single hashed key/value.
            
            Bucket is not serializable because it stores the computed hash
            code which could change between serialization and deserialization.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.CommonDictionaryStorage.DeserializationNullValue">
            <summary>
            Special marker NullValue used during deserialization to not add
            an extra field to the dictionary storage type.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ConstantDictionaryStorage">
            <summary>
            Copy on write constant dictionary storage used for dictionaries created with constant items.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Converter.TryConvert(System.Object,System.Type,System.Object@)">
            <summary>
            General conversion routine TryConvert - tries to convert the object to the desired type.
            Try to avoid using this method, the goal is to ultimately remove it!
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Converter.TryConvertToIEnumerator(System.Object,System.Collections.IEnumerator@)">
            <summary>
            This function tries to convert an object to IEnumerator, or wraps it into an adapter
            Do not use this function directly. It is only meant to be used by Ops.GetEnumerator.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Converter.ConvertToIEnumerator(System.Object)">
            <summary>
            This function tries to convert an object to IEnumerator, or wraps it into an adapter
            Do not use this function directly. It is only meant to be used by Ops.GetEnumerator.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Converter.TryConvertToIndex(System.Object,System.Boolean,System.Int32@)">
            <summary>
            Attempts to convert value into a index usable for slicing and return the integer
            value.  If the conversion fails false is returned.
            
            If throwOverflowError is true then BigInteger's outside the normal range of integers will
            result in an OverflowError.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Converter.TryConvertToIndex(System.Object,System.Boolean,System.Object@)">
            <summary>
            Attempts to convert value into a index usable for slicing and return the integer
            value.  If the conversion fails false is returned.
            
            If throwOverflowError is true then BigInteger's outside the normal range of integers will
            result in an OverflowError.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Converter.ImplicitConvertToInt32(System.Object)">
            <summary>
            Converts a value to int ignoring floats
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CustomDictionaryStorage.GetExtraItems">
            <summary>
            Gets all of the extra names and values stored in the dictionary.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CustomDictionaryStorage.TrySetExtraValue(System.String,System.Object)">
            <summary>
            Attemps to sets a value in the extra keys.  Returns true if the value is set, false if 
            the value is not an extra key.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CustomDictionaryStorage.TryGetExtraValue(System.String,System.Object@)">
            <summary>
            Attempts to get a value from the extra keys.  Returns true if the value is an extra
            key and has a value.  False if it is not an extra key or doesn't have a value.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.CustomDictionaryStorage.TryRemoveExtraValue(System.String)">
            <summary>
            Attempts to remove the key.  Returns true if the key is removed, false
            if the key was not removed, or null if the key is not an extra key.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DebuggerDictionaryStorage">
            <summary>
            Adapts an IDictionary[object, object] for use as a PythonDictionary used for
            our debug frames.  Also hides the special locals which start with $.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DictionaryOps">
            <summary>
            Provides both helpers for implementing Python dictionaries as well
            as providing public methods that should be exposed on all dictionary types.
            
            Currently these are published on IDictionary&lt;object, object&gt;
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DictionaryStorage">
            <summary>
            Abstract base class for all PythonDictionary storage.
            
            Defined as a class instead of an interface for performance reasons.  Also not
            using IDictionary* for keeping a simple interface.
            
            Full locking is defined as being on the DictionaryStorage object it's self,
            not an internal member.  This enables subclasses to provide their own locking
            aruond large operations and call lock free functions.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.DictionaryStorage.CopyTo(IronPython.Runtime.DictionaryStorage@)">
            <summary>
            Adds items from this dictionary into the other dictionary
            </summary>
        </member>
        <member name="M:IronPython.Runtime.DictionaryStorage.TryGetPath(System.Object@)">
            <summary>
            Provides fast access to the __path__ attribute if the dictionary storage supports caching it.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.DictionaryStorage.TryGetPackage(System.Object@)">
            <summary>
            Provides fast access to the __package__ attribute if the dictionary storage supports caching it.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.DictionaryStorage.TryGetBuiltins(System.Object@)">
            <summary>
            Provides fast access to the __builtins__ attribute if the dictionary storage supports caching it.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.DictionaryStorage.TryGetName(System.Object@)">
            <summary>
            Provides fast access to the __name__ attribute if the dictionary storage supports caching it.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.DictionaryStorage.TryGetImport(System.Object@)">
            <summary>
            Provides fast access to the __import__ attribute if the dictionary storage supports caching it.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DontMapGetMemberNamesToDirAttribute">
            <summary>
            Marks a type so that IronPython will not expose types which have GetMemberNames
            as having a __dir__ method.
            
            Also suppresses __dir__ on something which implements IDynamicMetaObjectProvider
            but is not an IPythonObject.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DontMapICollectionToLenAttribute">
            <summary>
            Marks a type so that IronPython will not expose the ICollection interface out as
            __len__.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DontMapIDisposableToContextManagerAttribute">
            <summary>
            Marks a type so that IronPython will not expose the IDisposable interface out as
            __enter__ and __exit__ methods of a context manager.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DontMapIEnumerableToContainsAttribute">
            <summary>
            Marks a type so that IronPython will not expose the IEnumerable interface out as
            __contains__
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DontMapIEnumerableToIterAttribute">
            <summary>
            Marks a type so that IronPython will not expose the IEnumerable interface out as
            __iter__
            </summary>
        </member>
        <member name="T:IronPython.Runtime.EmptyDictionaryStorage">
            <summary>
            Singleton used for dictionaries which contain no items.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Exceptions.GeneratorExitException">
            <summary>
            GeneratorExitException is a standard exception raised by Generator.Close() to allow a caller
            to close out a generator.
            </summary>
            <remarks>GeneratorExit is introduced in Pep342 for Python2.5. </remarks>
        </member>
        <member name="T:IronPython.Runtime.Exceptions.IndentationException">
            <summary>
            .NET exception thrown when a Python syntax error is related to incorrect indentation.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Exceptions.PythonExceptions">
            <summary>
            Implementation of the Python exceptions module and the IronPython/CLR exception mapping 
            mechanism.  The exception module is the parent module for all Python exception classes
            and therefore is built-in to IronPython.dll instead of IronPython.Modules.dll.
            
            The exception mapping mechanism is exposed as internal surface area available to only
            IronPython / IronPython.Modules.dll.  The actual exceptions themselves are all public.
            
            Because the oddity of the built-in exception types all sharing the same physical layout
            (see also PythonExceptions.BaseException) some classes are defined as classes w/ their
            proper name and some classes are defined as PythonType fields.  When a class is defined
            for convenience their's also an _TypeName version which is the PythonType.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Exceptions.PythonExceptions.BaseException">
            <summary>
            Base class for all Python exception objects.
            
            When users throw exceptions they typically throw an exception which is
            a subtype of this.  A mapping is maintained between Python exceptions
            and .NET exceptions and a corresponding .NET exception is thrown which
            is associated with the Python exception.  This class represents the
            base class for the Python exception hierarchy.  
            
            Users can catch exceptions rooted in either hierarchy.  The hierarchy
            determines whether the user catches the .NET exception object or the 
            Python exception object.
            
            Most built-in Python exception classes are actually instances of the BaseException
            class here.  This is important because in CPython the exceptions do not 
            add new members and therefore their layouts are compatible for multiple
            inheritance.  The exceptions to this rule are the classes which define 
            their own fields within their type, therefore altering their layout:
                EnvironmentError
                SyntaxError
                    IndentationError     (same layout as SyntaxError)
                    TabError             (same layout as SyntaxError)
                SystemExit
                UnicodeDecodeError
                UnicodeEncodeError
                UnicodeTranslateError
                
            These exceptions cannot be combined in multiple inheritance, e.g.:
                class foo(EnvironmentError, IndentationError): pass
                
            fails but they can be combined with anything which is just a BaseException:
                class foo(UnicodeDecodeError, SystemError): pass
                
            Therefore the majority of the classes are just BaseException instances with a 
            custom PythonType object.  The specialized ones have their own .NET class
            which inherits from BaseException.  User defined exceptions likewise inherit
            from this and have their own .NET class.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__init__(System.Object[])">
            <summary>
            Initializes the Exception object with an unlimited number of arguments
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.message">
            <summary>
            Returns the exception 'message' if only a single argument was provided 
            during creation or an empty string.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.args">
            <summary>
            Gets or sets the arguments used for creating the exception
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__reduce__">
            <summary>
            Returns a tuple of (type, (arg0, ..., argN)) for implementing pickling/copying
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__reduce_ex__(System.Int32)">
            <summary>
            Returns a tuple of (type, (arg0, ..., argN)) for implementing pickling/copying
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.Item(System.Int32)">
            <summary>
            Gets the nth member of the args property
            </summary>            
        </member>
        <member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__dict__">
            <summary>
            Gets or sets the dictionary which is used for storing members not declared to have space reserved
            within the exception object.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__setstate__(IronPython.Runtime.PythonDictionary)">
            <summary>
            Updates the exception's state (dictionary) with the new values
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.clsException">
            <summary>
            Gets the CLR exception associated w/ this Python exception.  Not visible
            until a .NET namespace is imported.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.GetBoundMember(System.String)">
            <summary>
            Provides custom member lookup access that fallbacks to the dictionary
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.SetMemberAfter(System.String,System.Object)">
            <summary>
            Provides custom member assignment which stores values in the dictionary
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.DeleteCustomMember(System.String)">
            <summary>
            Provides custom member deletion which deletes values from the dictionary
            or allows clearing 'message'.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__repr__(IronPython.Runtime.CodeContext)">
            <summary>
            Implements __repr__ which returns the type name + the args
            tuple code formatted.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.InitializeFromClr(System.Exception)">
            <summary>
            Initializes the Python exception from a .NET exception
            </summary>
            <param name="exception"></param>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.GetClrException">
            <summary>
            Helper to get the CLR exception associated w/ this Python exception
            creating it if one has not already been created.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateThrowableForRaise(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Object)">
            <summary>
            Creates a new throwable exception of type type where the type is an new-style exception.
            
            Used at runtime when creating the exception from a user provided type via the raise statement.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateThrowableForRaise(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.OldClass,System.Object)">
            <summary>
            Creates a throwable exception of type type where the type is an OldClass.
            
            Used at runtime when creating the exception form a user provided type that's an old class (via the raise statement).
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.ToClr(System.Object)">
            <summary>
            Returns the CLR exception associated with a Python exception
            creating a new exception if necessary
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.ToPython(System.Exception)">
            <summary>
            Given a CLR exception returns the Python exception which most closely maps to the CLR exception.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.ToPythonNewStyle(System.Exception)">
            <summary>
            Creates a new style Python exception from the .NET exception
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.SetPythonException(System.Exception,System.Object)">
            <summary>
            Internal helper to associate a .NET exception and a Python exception.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.GetPythonException(System.Exception)">
            <summary>
            Internal helper to get the associated Python exception from a .NET exception.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.SyntaxErrorToPython(Microsoft.Scripting.SyntaxErrorException)">
            <summary>
            Converts the DLR SyntaxErrorException into a Python new-style SyntaxError instance.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
            <summary>
            Creates a PythonType for a built-in module.  These types are mutable like
            normal user types.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType,System.Type,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
            <summary>
            Creates a PythonType for a built-in module.  These types are mutable like
            normal user types.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType[],System.Type,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
            <summary>
            Creates a PythonType for a built-in module, where the type may inherit
            from multiple bases.  These types are mutable like normal user types. 
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.Types.PythonType,System.String,System.Func{System.String,System.Exception})">
            <summary>
            Creates a new type for a built-in exception which derives from another Python
            type.  .  These types are built-in and immutable like any other normal type.  For 
            example StandardError.x = 3 is illegal.  This isn't for module exceptions which 
            are like user defined types.  thread.error.x = 3 is legal.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.Types.PythonType,System.Type,System.Func{System.String,System.Exception})">
            <summary>
            Creates a new type for a built-in exception which is the root concrete type.  
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.GetDynamicStackFrames(System.Exception)">
            <summary>
            Gets the list of DynamicStackFrames for the current exception.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Exceptions.StopIterationException">
            <summary>
            .NET exception that is thrown to signal the end of iteration in Python
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Exceptions.SystemExitException">
            <summary>
            .NET exception that is thrown to shutdown the interpretter and exit the system.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.SystemExitException.GetExitCode(System.Object@)">
            <summary>
            Result of sys.exit(n)
            </summary>
            <param name="otherCode">
            null if the script exited using "sys.exit(int_value)"
            null if the script exited using "sys.exit(None)"
            x    if the script exited using "sys.exit(x)" where isinstance(x, int) == False
            </param>
            <returns>
            int_value if the script exited using "sys.exit(int_value)"
            1 otherwise
            </returns>
        </member>
        <member name="T:IronPython.Runtime.Exceptions.TabException">
            <summary>
            .NET Exception thrown when a Python syntax error is related to incorrect tabs.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Exceptions.TraceBack.Extract">
            <summary>
            returns string containing human readable representation of traceback
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ExtensionMethodSet">
            <summary>
            Represents the set of extension methods which are loaded into a module.
            
            This set is immutable (as far the external viewer is considered).  When a 
            new extension method set is loaded into a module we create a new ExtensionMethodsSet object.  
            
            Multiple modules which have the same set of extension methods use the same set.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ExtensionMethodSet.AssemblyLoadInfo">
            <summary>
            Tracks the extension types that are loaded for a given assembly.
            
            We can have either types, namespaces, or a full assembly added as a reference.
            
            When the user just adds types we just add them to the type hash set.
            
            When the user adds namespaces we add them to the namespaces hashset.  On the
            next lookup we'll lazily load the types from that namespace and put them in Types.
            
            When the user adds assemblies we set the value to the NotYetLoadedButFullAssembly
            value.  The next load request will load the types from that namespace and put them
            in Types.  When we do that we'll mark the assembly as FullyLoaded so we don't 
            have to go through that again if the user adds a namespace.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ExtensionMethodSet.GetExtensionMethods(System.String)">
            <summary>
            Returns all of the extension methods with the given name.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ExtensionMethodSet.GetExtensionMethods(IronPython.Runtime.Types.PythonType)">
            <summary>
            Returns all of the extension methods which are applicable for the given type.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FormattingHelper.InvariantCommaNumberInfo">
            <summary>
            Helper NumberFormatInfo for use by int/BigInteger __format__ routines
            for width specified leading zero support that contains ','s every 3 digits.
            i.e. For use by d/g/G format specifiers. NOT for use by n format specifiers.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.FunctionAttributes.ArgumentList">
            <summary>
            Set if the function includes a *args argument list.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.FunctionAttributes.KeywordDictionary">
            <summary>
            Set if the function includes a **kwargs argument dictionary.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.FunctionAttributes.Generator">
            <summary>
            Set if the function is a generator.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.FunctionAttributes.FutureDivision">
            <summary>
            Set if the function was compiled with future division.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.FunctionAttributes.CanSetSysExcInfo">
            <summary>
            IronPython specific: Set if the function includes nested exception handling and therefore can alter
            sys.exc_info().
            </summary>
        </member>
        <member name="F:IronPython.Runtime.FunctionAttributes.ContainsTryFinally">
            <summary>
            IronPython specific: Set if the function includes a try/finally block.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.FunctionCode">
            <summary>
            Represents a piece of code.  This can reference either a CompiledCode
            object or a Function.   The user can explicitly call FunctionCode by
            passing it into exec or eval.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.FunctionCode._CodeCreateAndUpdateDelegateLock">
            <summary>
            This is both the lock that is held while enumerating the threads or updating the thread accounting
            information.  It's also a marker CodeList which is put in place when we are enumerating the thread
            list and all additions need to block.
            
            This lock is also acquired whenever we need to calculate how a function's delegate should be created 
            so that we don't race against sys.settrace/sys.setprofile.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.FunctionCode.#ctor(IronPython.Runtime.PythonContext,System.Delegate,IronPython.Compiler.Ast.ScopeStatement,System.String,System.Int32)">
            <summary>
            Constructor used to create a FunctionCode for code that's been serialized to disk.  
            
            Code constructed this way cannot be interpreted or debugged using sys.settrace/sys.setprofile.
            
            Function codes created this way do support recursion enforcement and are therefore registered in the global function code registry.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.FunctionCode.#ctor(IronPython.Runtime.PythonContext,System.Delegate,IronPython.Compiler.Ast.ScopeStatement,System.String,System.Nullable{System.Boolean},System.Boolean)">
            <summary>
            Constructor to create a FunctionCode at runtime.
            
            Code constructed this way supports both being interpreted and debugged.  When necessary the code will
            be re-compiled or re-interpreted for that specific purpose.
            
            Function codes created this way do support recursion enforcement and are therefore registered in the global function code registry.
            
            the initial delegate provided here should NOT be the actual code.  It should always be a delegate which updates our Target lazily.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.FunctionCode.RegisterFunctionCode(IronPython.Runtime.PythonContext)">
            <summary>
            Registers the current function code in our global weak list of all function codes.
            
            The weak list can be enumerated with GetAllCode().
            
            Ultimately there are 3 types of threads we care about races with:
                1. Other threads which are registering function codes
                2. Threads calling sys.settrace which require the world to stop and get updated
                3. Threads running cleanup (thread pool thread, or call to gc.collect).
                
            The 1st two must have perfect synchronization.  We cannot have a thread registering
            a new function which another thread is trying to update all of the functions in the world.  Doing
            so would mean we could miss adding tracing to a thread.   
            
            But the cleanup thread can run in parallel to either registrying or sys.settrace.  The only
            thing it needs to take a lock for is updating our accounting information about the
            number of code objects are alive.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.FunctionCode.GetAllCode(IronPython.Runtime.PythonContext)">
            <summary>
            Enumerates all function codes for updating the current type of targets we generate.
            
            While enumerating we hold a lock so that users cannot change sys.settrace/sys.setprofile
            until the lock is released.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_cellvars">
            <summary>
            Returns a list of variable names which are accessed from nested functions.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_code">
            <summary>
            Returns the byte code.  IronPython does not implement this and always
            returns an empty string for byte code.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_consts">
            <summary>
            Returns a list of constants used by the function.
            
            The first constant is the doc string, or None if no doc string is provided.
            
            IronPython currently does not include any other constants than the doc string.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_filename">
            <summary>
            Returns the filename that the code object was defined in.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_firstlineno">
            <summary>
            Returns the 1st line number of the code object.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_flags">
            <summary>
            Returns a set of flags for the function.
            
                0x04 is set if the function used *args
                0x08 is set if the function used **args
                0x20 is set if the function is a generator
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_freevars">
            <summary>
            Returns a list of free variables (variables accessed
            from an outer scope).  This does not include variables
            accessed in the global scope.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_lnotab">
            <summary>
            Returns a mapping between byte code and line numbers.  IronPython does
            not implement this because byte code is not available.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_name">
            <summary>
            Returns the name of the code (function name, class name, or &lt;module&gt;).
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_names">
            <summary>
            Returns a list of global variable names accessed by the code.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_nlocals">
            <summary>
            Returns the number of local varaibles defined in the function.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.co_stacksize">
            <summary>
            Returns the stack size.  IronPython does not implement this
            because byte code is not supported.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.FunctionCode.Target">
            <summary>
            The current target for the function.  This can change based upon adaptive compilation, recursion enforcement, and tracing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.FunctionCode.FromSourceUnit(Microsoft.Scripting.SourceUnit,IronPython.Compiler.PythonCompilerOptions,System.Boolean)">
            <summary>
            Creates a FunctionCode object for exec/eval/execfile'd/compile'd code.
            
            The code is then executed in a specific CodeContext by calling the .Call method.
            
            If the code is being used for compile (vs. exec/eval/execfile) then it needs to be
            registered in case our tracing mode changes.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.FunctionCode.LazyCompileFirstTarget(IronPython.Runtime.PythonFunction)">
            <summary>
            Called the 1st time a function is invoked by our OriginalCallTarget* methods
            over in PythonCallTargets.  This computes the real delegate which needs to be
            created for the function.  Usually this means starting off interpretering.  It 
            also involves adding the wrapper function for recursion enforcement.
            
            Because this can race against sys.settrace/setprofile we need to take our 
            _ThreadIsEnumeratingAndAccountingLock to ensure no one is actively changing all
            of the live functions.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.FunctionCode.UpdateDelegate(IronPython.Runtime.PythonContext,System.Boolean)">
            <summary>
            Updates the delegate based upon current Python context settings for recursion enforcement
            and for tracing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.FunctionCode.SetDebugTarget(IronPython.Runtime.PythonContext,System.Delegate)">
            <summary>
            Called to set the initial target delegate when the user has passed -X:Debug to enable
            .NET style debugging.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.FunctionCode.GetGeneratorOrNormalLambdaTracing(IronPython.Runtime.PythonContext)">
            <summary>
            Gets the LambdaExpression for tracing.  
            
            If this is a generator function code then the lambda gets tranformed into the correct generator code.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.FunctionCode.GetGeneratorOrNormalLambda">
            <summary>
            Gets the correct final LambdaExpression for this piece of code.
            
            This is either just _lambda or _lambda re-written to be a generator expression.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.FunctionCode.CodeList">
            <summary>
            Extremely light weight linked list of weak references used for tracking
            all of the FunctionCode objects which get created and need to be updated
            for purposes of recursion enforcement or tracing.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonGenerator._active">
            <summary>
            True iff the thread is currently inside the generator (ie, invoking the _next delegate).
            This can be used to enforce that a generator does not call back into itself. 
            Pep255 says that a generator should throw a ValueError if called reentrantly.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonGenerator._LastFinalizer">
            <summary>
            We cache the GeneratorFinalizer of generators that were closed on the user
            thread, and did not get finalized on the finalizer thread. We can then reuse
            the object. Reusing objects with a finalizer is good because it reduces
            the load on the GC's finalizer queue.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonGenerator._excInfo">
            <summary>
            Fields set by Throw() to communicate an exception to the yield point.
            These are plumbed through the generator to become parameters to Raise(...) invoked 
            at the yield suspension point in the generator.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonGenerator._sendValue">
            <summary>
            Value sent by generator.send().
            Since send() could send an exception, we need to keep this different from throwable's value.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonGenerator.throw(System.Object)">
            <summary>
            See PEP 342 (http://python.org/dev/peps/pep-0342/) for details of new methods on Generator.
            Full signature including default params for throw is:
               throw(type, value=None, traceback=None)
            Use multiple overloads to resolve the default parameters.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonGenerator.throw(System.Object,System.Object,System.Object,System.Boolean)">
            <summary>
            Throw(...) is like Raise(...) being called from the yield point within the generator.
            Note it must come from inside the generator so that the traceback matches, and so that it can 
            properly cooperate with any try/catch/finallys inside the generator body.
            
            If the generator catches the exception and yields another value, that is the return value of g.throw().
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonGenerator.send(System.Object)">
            <summary>
            send() was added in Pep342. It sends a result back into the generator, and the expression becomes
            the result of yield when used as an expression.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonGenerator.close(System.Boolean)">
            <summary>
            Close introduced in Pep 342.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonGenerator.__name__">
            <summary>
            Gets the name of the function that produced this generator object.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonGenerator.MoveNextWorker">
            <summary>
            Core implementation of IEnumerator.MoveNext()
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonGenerator.NextWorker">
            <summary>
            Core implementation of Python's next() method.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonGenerator.CheckThrowableAndReturnSendValue">
            <summary>
            Helper called from PythonOps after the yield statement
            Keepin this in a helper method:
            - reduces generated code size
            - allows better coupling with PythonGenerator.Throw()
            - avoids throws from emitted code (which can be harder to debug).
            </summary>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.PythonGenerator.CheckThrowable">
            <summary>
            Called to throw an exception set by Throw().
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonGenerator.GeneratorFlags.Closed">
            <summary>
            True if the generator has finished (is "closed"), else false.
            Python language spec mandates that calling Next on a closed generator gracefully throws a StopIterationException.
            This can never be reset.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonGenerator.GeneratorFlags.CanSetSysExcInfo">
            <summary>
            True if the generator can set sys exc info and therefore needs exception save/restore.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Importer">
            <summary>
            Importer class - used for importing modules.  Used by Ops and __builtin__
            Singleton living on Python engine.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Importer.Import(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,System.Int32)">
            <summary>
            Gateway into importing ... called from Ops.  Performs the initial import of
            a module and returns the module.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Importer.ImportLightThrow(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,System.Int32)">
            <summary>
            Gateway into importing ... called from Ops.  Performs the initial import of
            a module and returns the module.  This version returns light exceptions instead of throwing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Importer.ImportFrom(IronPython.Runtime.CodeContext,System.Object,System.String)">
            <summary>
            Gateway into importing ... called from Ops.  This is called after
            importing the module and is used to return individual items from
            the module.  The outer modules dictionary is then updated with the
            result.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Importer.ImportModule(IronPython.Runtime.CodeContext,System.Object,System.String,System.Boolean,System.Int32)">
            <summary>
            Called by the __builtin__.__import__ functions (general importing) and ScriptEngine (for site.py)
            
            level indiciates whether to perform absolute or relative imports.
                -1 indicates both should be performed
                0 indicates only absolute imports should be performed
                Positive numbers indicate the # of parent directories to search relative to the calling module
            </summary>        
        </member>
        <member name="M:IronPython.Runtime.Importer.TryGetNameAndPath(IronPython.Runtime.CodeContext,System.Object,System.String,System.Int32,System.String,System.String@,IronPython.Runtime.List@,IronPython.Runtime.PythonModule@)">
            <summary>
            Interrogates the importing module for __name__ and __path__, which determine
            whether the imported module (whose name is 'name') is being imported as nested
            module (__path__ is present) or as sibling.
            
            For sibling import, the full name of the imported module is parent.sibling
            For nested import, the full name of the imported module is parent.module.nested
            where parent.module is the mod.__name__
            </summary>
            <param name="context"></param>
            <param name="globals">the globals dictionary</param>
            <param name="name">Name of the module to be imported</param>
            <param name="full">Output - full name of the module being imported</param>
            <param name="path">Path to use to search for "full"</param>
            <param name="level">the import level for relaive imports</param>
            <param name="parentMod">the parent module</param>
            <param name="package">the global __package__ value</param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Importer.GetParentPathAndModule(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonModule@)">
            <summary>
            Given the parent module name looks up the __path__ property.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Importer.TryGetExistingOrMetaPathModule(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.List,System.Object@)">
            <summary>
            Trys to get an existing module and if that fails fall backs to searching 
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Importer.TryLoadMetaPathModule(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.List,System.Object@)">
            <summary>
            Attempts to load a module from sys.meta_path as defined in PEP 302.
            
            The meta_path provides a list of importer objects which can be used to load modules before
            searching sys.path but after searching built-in modules.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Importer.FindAndLoadModuleFromImporter(IronPython.Runtime.CodeContext,System.Object,System.String,IronPython.Runtime.List,System.Object@)">
            <summary>
            Given a user defined importer object as defined in PEP 302 tries to load a module.
            
            First the find_module(fullName, path) is invoked to get a loader, then load_module(fullName) is invoked
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Importer.FindImporterForPath(IronPython.Runtime.CodeContext,System.String)">
            <summary>
            Finds a user defined importer for the given path or returns null if no importer
            handles this path.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Index">
            <summary>
            Wrapper class used when a user defined type (new-style or old-style)
            defines __index__.  We provide a conversion from all user defined
            types to the Index type so they can be used for determing and method bind
            time the most appropriate method to dispatch to.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.InstancedModuleDictionaryStorage">
            <summary>
            ModuleDictionaryStorage for a built-in module which is bound to a specific instance.
            
            These modules don't need to use PythonContext.GetModuleState() for storage and therefore
            can provide efficient access to internal variables.  They can also cache PythonGlobal
            objects and provide efficient access to module globals.  
            
            To the end user these modules appear just like any other module.  These modules are
            implemented by subclassing the BuiltinPythonModule class.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.IWeakReferenceable">
            <summary>
            Defines the internal interface used for accessing weak references and adding finalizers
            to user-defined types.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.IWeakReferenceable.GetWeakRef">
            <summary>
            Gets the current WeakRefTracker for an object that can be used to
            append additional weak references.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.IWeakReferenceable.SetWeakRef(IronPython.Runtime.WeakRefTracker)">
            <summary>
            Attempts to set the WeakRefTracker for an object.  Used on the first
            addition of a weak ref tracker to an object.  If the object doesn't
            support adding weak references then it returns false.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.IWeakReferenceable.SetFinalizer(IronPython.Runtime.WeakRefTracker)">
            <summary>
            Sets a WeakRefTracker on an object for the purposes of supporting finalization.
            All user types (new-style and old-style) support finalization even if they don't
            support weak-references, and therefore this function always succeeds.  Note the
            slot used to store the WeakRefTracker is still shared between SetWeakRef and 
            SetFinalizer if a type supports both.
            </summary>
            <param name="value"></param>
        </member>
        <member name="T:IronPython.Runtime.IWeakReferenceableByProxy">
            <summary>
            Allow types to implement weakvreference tracking by returning a proxy.
            
            The proxy can refer to the current Python context, whihc is the main purpose.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.IWeakReferenceableByProxy.GetWeakRefProxy(IronPython.Runtime.PythonContext)">
            <summary>
            
            </summary>
        </member>
        <member name="T:IronPython.Runtime.IPythonMembersList">
            <summary>
            Provides a list of all the members of an instance.  ie. all the keys in the 
            dictionary of the object. Note that it can contain objects that are not strings. 
            
            Such keys can be added in IronPython using syntax like:
                obj.__dict__[100] = someOtherObject
                
            This Python specific version also supports filtering based upon the show cls 
            flag by flowing in the code context.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.IParameterSequence">
            <summary>
            Represents a sequence which may have been provided as a set of parameters to an indexer.
            
            TODO: This should be removed, and all uses of this should go to [SpecialName]object GetItem(..., params object[] keys)
            and [SpecialName]void SetItem(..., params object [] keys) or this[params object[]xyz] which is also legal.  
            
            currently this exists for backwards compatibility w/ IronPython's "expandable tuples".
            </summary>
        </member>
        <member name="M:IronPython.Runtime.List.FromArrayNoCopy(System.Object[])">
            <summary>
            Creates a new list with the data in the array and a size
            the same as the length of the array.  The array is held
            onto and may be mutated in the future by the list.
            </summary>
            <param name="data">params array to use for lists storage</param>
        </member>
        <member name="M:IronPython.Runtime.List.GetAddSize(System.Int32,System.Int32)">
            <summary>
            Gets a reasonable size for the addition of two arrays.  We round
            to a power of two so that we usually have some extra space if
            the resulting array gets added to.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.List.AddNoLock(System.Object)">
            <summary>
            Non-thread safe adder, should only be used by internal callers that
            haven't yet exposed their list.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.List.DoCompare(System.Object[],System.Collections.IComparer,System.Int32,System.Int32,System.Boolean)">
            <summary>
            Compares the two specified keys
            </summary>
        </member>
        <member name="P:IronPython.Runtime.List.Item(System.Object)">
            <summary>
            Supports __index__ on arbitrary types, also prevents __float__
            </summary>
        </member>
        <member name="T:IronPython.Runtime.OrderedLocker">
            <summary>
            we need to lock both objects (or copy all of one's data w/ it's lock held, and
            then compare, which is bad).  Therefore we have a strong order for locking on 
            the two objects based upon the hash code or object identity in case of a collision
            </summary>
        </member>
        <member name="T:IronPython.Runtime.LiteralParser">
            <summary>
            Summary description for ConstantValue.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.MemoryView.FixSlice(IronPython.Runtime.Slice,System.Int32,System.Int32@,System.Int32@)">
            <summary>
            MemoryView slicing is somewhat different and more restricted than
            standard slicing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Method.CheckSelf(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Validates that the current self object is usable for this method.  
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ModuleContext">
            <summary>
            Captures the globals and other state of module code.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ModuleContext.#ctor(IronPython.Runtime.PythonDictionary,IronPython.Runtime.PythonContext)">
            <summary>
            Creates a new ModuleContext which is backed by the specified dictionary.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ModuleContext.#ctor(IronPython.Runtime.PythonModule,IronPython.Runtime.PythonContext)">
            <summary>
            Creates a new ModuleContext for the specified module.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.ModuleContext.Globals">
            <summary>
            Gets the dictionary used for the global variables in the module
            </summary>
        </member>
        <member name="P:IronPython.Runtime.ModuleContext.Context">
            <summary>
            Gets the language context which created this module.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.ModuleContext.GlobalScope">
            <summary>
            Gets the DLR Scope object which is associated with the modules dictionary.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.ModuleContext.GlobalContext">
            <summary>
            Gets the global CodeContext object which is used for execution of top-level code.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.ModuleContext.Module">
            <summary>
            Gets the module object which this code is executing in.
            
            This module may or may not be published in sys.modules.  For user defined
            code typically the module gets published at the start of execution.  But if
            this ModuleContext is attached to a Scope, or if we've just created a new
            module context for executing code it will not be in sys.modules.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.ModuleContext.Features">
            <summary>
            Gets the features that code has been compiled with in the module.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.ModuleContext.ShowCls">
            <summary>
            Gets or sets whether code running in this context should display
            CLR members (for example .ToString on objects).
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ModuleContext.InitializeBuiltins(System.Boolean)">
            <summary>
            Initializes __builtins__ for the module scope.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ModuleDictionaryStorage">
            <summary>
            Enables lazy initialization of module dictionaries.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ModuleGlobalCache">
            <summary>
            Cached global value.  Created and maintained on a per-language basis.  Default
            implementation returns a singleton which indicates caching is not occuring.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ModuleGlobalCache.#ctor(System.Object)">
            <summary>
            Creates a new ModuleGlobalCache with the specified value.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.ModuleGlobalCache.IsCaching">
            <summary>
            True if the ModuleGlobalCache is participating in a caching strategy.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.ModuleGlobalCache.HasValue">
            <summary>
            True if there is currently a value associated with this global variable.  False if
            it is currently unassigned.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.ModuleGlobalCache.Value">
            <summary>
            Gets or sets the current cached value
            </summary>
        </member>
        <member name="M:IronPython.Runtime.ModuleGlobalCache.Changed(System.Object,Microsoft.Scripting.Runtime.ModuleChangeEventArgs)">
            <summary>
            Event handler for when the value has changed.  Language implementors should call this when
            the cached value is invalidated.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.TrueDivision">
            <summary>
            Enable true division (1/2 == .5)
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.ShowClsMethods">
            <summary>
            Indicates that .NET methods such as .ToString should be available on Python objects.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.Optimized">
            <summary>
            Indicates that the module should be generated in an optimal form which will result
            in it being uncollectable.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.Initialize">
            <summary>
            Indicates when the module should be executed immedatiately upon creation.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.WithStatement">
            <summary>
            Enable usage of the with statement
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.AbsoluteImports">
            <summary>
            Enable absolute imports
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.NoBuiltins">
            <summary>
            Indiciates that __builtins__ should not be set in the module
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.ModuleBuiltins">
            <summary>
            Indiciates that when the module is initialized it should set __builtins__ to the __builtin__ module
            instead of the __builtin__ dictionary.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.ExecOrEvalCode">
            <summary>
            Marks code as being created for exec, eval.  Code generated this way will
            be capable of running against different scopes and will do lookups at runtime
            for free global variables.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.SkipFirstLine">
            <summary>
            Indiciates that the first line of code should be skipped.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.PrintFunction">
            <summary>
            Enable usage of print as a function for better compatibility with Python 3.0.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.Interpret">
            <summary>
            Forces the code to be interpreted rather than compiled
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.UnicodeLiterals">
            <summary>
            String Literals should be parsed as Unicode strings
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.Verbatim">
            <summary>
            Include comments in the parse tree
            </summary>
        </member>
        <member name="F:IronPython.Runtime.ModuleOptions.LightThrow">
            <summary>
            Generated code should support light exceptions
            </summary>
        </member>
        <member name="T:IronPython.Runtime.NewStringFormatter">
             <summary>
             New string formatter for 'str'.format(...) calls and support for the Formatter
             library via the _formatter_parser / _formatter_field_name_split
             methods.
            
             We parse this format:
            
             replacement_field =  "{" field_name ["!" conversion] [":" format_spec] "}"
             field_name        =  (identifier | integer) ("." attribute_name | "[" element_index "]")*
             attribute_name    =  identifier
             element_index     =  identifier
             conversion        =  "r" | "s"
             format_spec       = any char, { must be balanced (for computed values), passed to __format__ method on object
             </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.FormatString(IronPython.Runtime.PythonContext,System.String,IronPython.Runtime.PythonTuple,System.Collections.Generic.IDictionary{System.Object,System.Object})">
            <summary>
            Runs the formatting operation on the given format and keyword arguments
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.GetFormatInfo(System.String)">
             <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>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.GetFieldNameInfo(System.String)">
             <summary>
             Parses a field name returning the argument name and an iterable
             object which can be used to access the individual attribute
             or element accesses.  The iterator yields tuples of:
            
             bool (true if attribute, false if element index), attribute/index value
             </summary>
        </member>
        <member name="T:IronPython.Runtime.NewStringFormatter.StringFormatParser">
            <summary>
            Base class used for parsing the format.  Subclasss override Text/ReplacementField methods.  Those
            methods get called when they call Parse and then they can do the appropriate actions for the
            format.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.Parse(System.String)">
             <summary>
             Gets an enumerable object for walking the parsed format.
            
             TODO: object array?  struct?
             </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.Parse">
            <summary>
            Provides an enumerable of the parsed format.  The elements of the tuple are:
                the text preceding the format information
                the field name
                the format spec
                the conversion
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseDoubleBracket(System.Int32,System.String@)">
            <summary>
            Handles {{ and }} within the string.  Returns true if a double bracket
            is found and yields the text
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseConversion">
            <summary>
            Parses the conversion character and returns it
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.CheckEnd">
            <summary>
            Checks to see if we're at the end of the format.  If there's no more characters left we report
            the error, otherwise if we hit a } we return true to indicate parsing should stop.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseFormatSpec(System.Int32@)">
            <summary>
            Parses the format spec string and returns it.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseFieldName(System.Int32@)">
            <summary>
            Parses the field name and returns it.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseFieldOrSpecWorker(System.Char[],System.Int32@)">
             <summary>
             Handles parsing the field name and the format spec and returns it.  At the parse
             level these are basically the same - field names just have more terminating characters.
            
             The most complex part of parsing them is they both allow nested braces and require
             the braces are matched.  Strangely though the braces need to be matched across the
             combined field and format spec - not within each format.
             </summary>
        </member>
        <member name="T:IronPython.Runtime.NewStringFormatter.Formatter">
            <summary>
            Provides the built-in string formatter which is exposed to Python via the str.format API.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.Formatter.ReplaceComputedFormats(System.String)">
            <summary>
            Inspects a format spec to see if it contains nested format specs which
            we need to compute.  If so runs another string formatter on the format
            spec to compute those values.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.Formatter.GetArgumentValue(IronPython.Runtime.NewStringFormatter.FieldName)">
            <summary>
            Given the field name gets the object from our arguments running
            any of the member/index accessors.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.Formatter.ApplyConversion(System.Nullable{System.Char},System.Object)">
            <summary>
            Applies the known built-in conversions to the object if a conversion is
            specified.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.Formatter.GetUnaccessedObject(IronPython.Runtime.NewStringFormatter.FieldName)">
            <summary>
            Gets the initial object represented by the field name - e.g. the 0 or
            keyword name.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.Formatter.DoAccessors(IronPython.Runtime.NewStringFormatter.FieldName,System.Object)">
            <summary>
            Given the object value runs the accessors in the field name (if any) against the object.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.ParseFieldName(System.String,System.Boolean)">
            <summary>
            Parses the field name including attribute access or element indexing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.ParseFieldAccessors(System.String,System.Int32,System.Boolean)">
            <summary>
            Parses the field name including attribute access or element indexing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.AccessorsToPython(System.Collections.Generic.IEnumerable{IronPython.Runtime.NewStringFormatter.FieldAccessor})">
            <summary>
            Converts accessors from our internal structure into a PythonTuple matching how CPython
            exposes these
            </summary>
        </member>
        <member name="M:IronPython.Runtime.NewStringFormatter.ParseIdentifier(System.String,System.Boolean,System.Int32@)">
            <summary>
            Parses an identifier and returns it
            </summary>
        </member>
        <member name="T:IronPython.Runtime.NewStringFormatter.FieldName">
            <summary>
            Encodes all the information about the field name.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.NewStringFormatter.FieldAccessor">
            <summary>
            Encodes a single field accessor (.b or [number] or [str])
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ArrayOps.Multiply(System.Array,System.Int32)">
            <summary>
            Multiply two object[] arrays - slow version, we need to get the type, etc...
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ArrayOps.Multiply(System.Object[],System.Int32,System.Int32)">
            <summary>
            Multiply two object[] arrays - internal version used for objects backed by arrays
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ArrayOps.Add(System.Object[],System.Int32,System.Object[],System.Int32)">
            <summary>
            Add two arrays - internal versions for objects backed by arrays
            </summary>
            <param name="data1"></param>
            <param name="size1"></param>
            <param name="data2"></param>
            <param name="size2"></param>
            <returns></returns>
        </member>
        <member name="T:IronPython.Runtime.Operations.CharOps">
            <summary>
            We override the behavior of equals, compare and hashcode to make
            chars seem as much like strings as possible.  In Python there is no
            difference between these types.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Operations.CustomTypeDescHelpers">
            <summary>
            Helper class that all custom type descriptor implementations call for
            the bulk of their implementation.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.DecimalOps.DecimalToFormatString(IronPython.Runtime.CodeContext,System.Decimal,IronPython.Runtime.StringFormatSpec)">
            <summary>
            Returns the digits for the format spec, no sign is included.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Operations.IDelegateConvertible">
            <summary>
            Interface used for things which can convert to delegates w/o code gen.  Currently
            this is just non-overloaded builtin functions and bound builtin functions.  Avoiding
            the code gen is not only nice for compilation but it also enables delegates to be added
            in C# and removed in Python.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.DoubleOps.DoubleToFormatString(IronPython.Runtime.CodeContext,System.Double,IronPython.Runtime.StringFormatSpec)">
            <summary>
            Returns the digits for the format spec, no sign is included.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Operations.InstanceOps">
             <summary>
             InstanceOps contains methods that get added to CLS types depending on what
             methods and constructors they define. These have not been added directly to
             PythonType since they need to be added conditionally.
             
             Possibilities include:
             
                 __new__, one of 3 __new__ sets can be added:
                     DefaultNew - This is the __new__ used for a PythonType (list, dict, object, etc...) that
                         has only 1 default public constructor that takes no parameters.  These types are 
                         mutable types, and __new__ returns a new instance of the type, and __init__ can be used
                         to re-initialize the types.  This __new__ allows an unlimited number of arguments to
                         be passed if a non-default __init__ is also defined.
            
                     NonDefaultNew - This is used when a type has more than one constructor, or only has one
                         that takes more than zero parameters.  This __new__ does not allow an arbitrary # of
                         extra arguments.
             
                     DefaultNewCls - This is the default new used for CLS types that have only a single ctor
                         w/ an arbitray number of arguments.  This constructor allows setting of properties
                         based upon an extra set of kw-args, e.g.: System.Windows.Forms.Button(Text='abc').  It
                         is only used on non-Python types.
             
                 __init__:
                     For types that do not define __init__ we have an __init__ function that takes an
                     unlimited number of arguments and does nothing.  All types share the same reference
                     to 1 instance of this.
             
                 next: Defined when a type is an enumerator to expose the Python iter protocol.
             
             
                 repr: Added for types that override ToString
             
                 get: added for types that implement IDescriptor
             </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.InstanceOps.DynamicDir(IronPython.Runtime.CodeContext,System.Dynamic.IDynamicMetaObjectProvider)">
            <summary>
            __dir__(self) -> Returns the list of members defined on a foreign IDynamicMetaObjectProvider.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.InstanceOps.EnterMethod(System.IDisposable)">
            <summary>
            Provides the implementation of __enter__ for objects which implement IDisposable.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.InstanceOps.ExitMethod(System.IDisposable,System.Object,System.Object,System.Object)">
            <summary>
            Provides the implementation of __exit__ for objects which implement IDisposable.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.InstanceOps.IsStaticTypeMemberInAll(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.String,System.Object@)">
            <summary>
            Determines if a type member can be imported.  This is used to treat static types like modules.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsGenericMethod``1(IronPython.Runtime.CodeContext,System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Implements __contains__ for types implementing IEnumerable of T.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsMethod(IronPython.Runtime.CodeContext,System.Collections.IEnumerable,System.Object)">
            <summary>
            Implements __contains__ for types implementing IEnumerable
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsGenericMethodIEnumerator``1(IronPython.Runtime.CodeContext,System.Collections.Generic.IEnumerator{``0},``0)">
            <summary>
            Implements __contains__ for types implementing IEnumerable of T.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsMethodIEnumerator(IronPython.Runtime.CodeContext,System.Collections.IEnumerator,System.Object)">
            <summary>
            Implements __contains__ for types implementing IEnumerable
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.InstanceOps.SerializeReduce(IronPython.Runtime.CodeContext,System.Object,System.Int32)">
            <summary>
            Implements __reduce_ex__ for .NET types which are serializable.  This uses the .NET
            serializer to get a string of raw data which can be serialized.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Operations.ObjectOps">
            <summary>
            Contains Python extension methods that are added to object
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Operations.ObjectOps._nativelyPickleableTypes">
            <summary> Types for which the pickle module has built-in support (from PEP 307 case 2)  </summary>
        </member>
        <member name="F:IronPython.Runtime.Operations.ObjectOps.__class__">
            <summary>
            __class__, a custom slot so that it works for both objects and types.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__delattr__(IronPython.Runtime.CodeContext,System.Object,System.String)">
            <summary>
            Removes an attribute from the provided member
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__hash__(System.Object)">
            <summary>
            Returns the hash code of the given object
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__getattribute__(IronPython.Runtime.CodeContext,System.Object,System.String)">
            <summary>
            Gets the specified attribute from the object without running any custom lookup behavior
            (__getattr__ and __getattribute__)
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__init__(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Initializes the object.  The base class does nothing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__init__(IronPython.Runtime.CodeContext,System.Object,System.Object[])">
            <summary>
            Initializes the object.  The base class does nothing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__init__(IronPython.Runtime.CodeContext,System.Object,System.Collections.Generic.IDictionary{System.Object,System.Object},System.Object[])">
            <summary>
            Initializes the object.  The base class does nothing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__new__(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType)">
            <summary>
            Creates a new instance of the type
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__new__(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Object[])">
            <summary>
            Creates a new instance of the type
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__new__(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Collections.Generic.IDictionary{System.Object,System.Object},System.Object[])">
            <summary>
            Creates a new instance of the type
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__reduce__(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Runs the pickle protocol
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__reduce_ex__(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Runs the pickle protocol
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__reduce_ex__(IronPython.Runtime.CodeContext,System.Object,System.Object)">
            <summary>
            Runs the pickle protocol
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__repr__(System.Object)">
            <summary>
            Returns the code representation of the object.  The default implementation returns
            a string which consists of the type and a unique numerical identifier.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__setattr__(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object)">
            <summary>
            Sets an attribute on the object without running any custom object defined behavior.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__sizeof__(System.Object)">
            <summary>
            Returns the number of bytes of memory required to allocate the object.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.__str__(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Returns a friendly string representation of the object. 
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.GetInitializedSlotValues(System.Object)">
            <summary>
            Return a dict that maps slot names to slot values, but only include slots that have been assigned to.
            Looks up slots in base types as well as the current type.
            
            Sort-of Python equivalent (doesn't look up base slots, while the real code does):
              return dict([(slot, getattr(self, slot)) for slot in type(self).__slots__ if hasattr(self, slot)])
            
            Return null if the object has no __slots__, or empty dict if it has __slots__ but none are initialized.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.ReduceProtocol0(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Implements the default __reduce_ex__ method as specified by PEP 307 case 2 (new-style instance, protocol 0 or 1)
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.FindClosestNonPythonBase(IronPython.Runtime.Types.PythonType)">
            <summary>
            Returns the closest base class (in terms of MRO) that isn't defined in Python code
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.ObjectOps.ReduceProtocol2(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Implements the default __reduce_ex__ method as specified by PEP 307 case 3 (new-style instance, protocol 2)
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Operations.PythonOps">
            <summary>
            Contains functions that are called directly from
            generated code to perform low-level runtime functionality.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeDictFromItems(System.Object[])">
            <summary>
            Creates a new dictionary extracting the keys and values from the
            provided data array.  Keys/values are adjacent in the array with
            the value coming first.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeHomogeneousDictFromItems(System.Object[])">
            <summary>
            Creates a new dictionary extracting the keys and values from the
            provided data array.  Keys/values are adjacent in the array with
            the value coming first.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MultiplySequence``1(IronPython.Runtime.Operations.PythonOps.MultiplySequenceWorker{``0},``0,IronPython.Runtime.Index,System.Boolean)">
            <summary>
            Wraps up all the semantics of multiplying sequences so that all of our sequences
            don't duplicate the same logic.  When multiplying sequences we need to deal with
            only multiplying by valid sequence types (ints, not floats), support coercion
            to integers if the type supports it, not multiplying by None, and getting the
            right semantics for multiplying by negative numbers and 1 (w/ and w/o subclasses).
            
            This function assumes that it is only called for case where count is not implicitly
            coercible to int so that check is skipped.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.CallWithContextAndThis(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object[])">
            <summary>
            Supports calling of functions that require an explicit 'this'
            Currently, we check if the function object implements the interface 
            that supports calling with 'this'. If not, the 'this' object is dropped
            and a normal call is made.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.CheckInitializedAttribute(System.Object,System.Object,System.String)">
            <summary>
            Called from generated code emitted by NewTypeMaker.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.GetUserDescriptor(System.Object,System.Object,System.Object)">
            <summary>
            Handles the descriptor protocol for user-defined objects that may implement __get__
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.TrySetUserDescriptor(System.Object,System.Object,System.Object)">
            <summary>
            Handles the descriptor protocol for user-defined objects that may implement __set__
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.TryDeleteUserDescriptor(System.Object,System.Object)">
            <summary>
            Handles the descriptor protocol for user-defined objects that may implement __delete__
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.RaiseAssertionError(IronPython.Runtime.CodeContext)">
            <summary>
            Python runtime helper for raising assertions. Used by AssertStatement.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.RaiseAssertionError(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Python runtime helper for raising assertions. Used by AssertStatement.
            </summary>
            <param name="msg">Object representing the assertion message</param>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeList">
            <summary>
            Python runtime helper to create instance of Python List object.
            </summary>
            <returns>New instance of List</returns>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeList(System.Object[])">
            <summary>
            Python runtime helper to create a populated instance of Python List object.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeListNoCopy(System.Object[])">
            <summary>
            Python runtime helper to create a populated instance of Python List object w/o
            copying the array contents.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeListFromSequence(System.Object)">
            <summary>
            Python runtime helper to create a populated instance of Python List object.
            
            List is populated by arbitrary user defined object.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeEmptyList(System.Int32)">
            <summary>
            Python runtime helper to create an instance of Python List object.
            
            List has the initial provided capacity.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeTuple(System.Object[])">
            <summary>
            Python runtime helper to create an instance of Tuple
            </summary>
            <param name="items"></param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeTupleFromSequence(System.Object)">
            <summary>
            Python runtime helper to create an instance of Tuple
            </summary>
            <param name="items"></param>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.GetEnumeratorValues(IronPython.Runtime.CodeContext,System.Object,System.Int32)">
            <summary>
            Python Runtime Helper for enumerator unpacking (tuple assignments, ...)
            Creates enumerator from the input parameter e, and then extracts 
            expected number of values, returning them as array
            
            If the input is a Python tuple returns the tuples underlying data array.  Callers
            should not mutate the resulting tuple.
            </summary>
            <param name="context">The code context of the AST getting enumerator values.</param>
            <param name="e">object to enumerate</param>
            <param name="expected">expected number of objects to extract from the enumerator</param>
            <returns>
            array of objects (.Lengh == expected) if exactly expected objects are in the enumerator.
            Otherwise throws exception
            </returns>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeSlice(System.Object,System.Object,System.Object)">
            <summary>
            Python runtime helper to create instance of Slice object
            </summary>
            <param name="start">Start of the slice.</param>
            <param name="stop">End of the slice.</param>
            <param name="step">Step of the slice.</param>
            <returns>Slice</returns>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.PrintNewline(IronPython.Runtime.CodeContext)">
            <summary>
            Prints newline into default standard output
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.PrintNewlineWithDest(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Prints newline into specified destination. Sets softspace property to false.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.PrintComma(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Prints value into default standard output with Python comma semantics.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.PrintCommaWithDest(IronPython.Runtime.CodeContext,System.Object,System.Object)">
            <summary>
            Prints value into specified destination with Python comma semantics.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.PrintExpressionValue(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Called from generated code when we are supposed to print an expression value
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.ImportTop(IronPython.Runtime.CodeContext,System.String,System.Int32)">
            <summary>
            Called from generated code for:
            
            import spam.eggs
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.ImportBottom(IronPython.Runtime.CodeContext,System.String,System.Int32)">
            <summary>
            Python helper method called from generated code for:
            
            import spam.eggs as ham
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.ImportWithNames(IronPython.Runtime.CodeContext,System.String,System.String[],System.Int32)">
            <summary>
            Called from generated code for:
            
            from spam import eggs1, eggs2 
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.ImportFrom(IronPython.Runtime.CodeContext,System.Object,System.String)">
            <summary>
            Imports one element from the module in the context of:
            
            from module import a, b, c, d
            
            Called repeatedly for all elements being imported (a, b, c, d above)
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.ImportStar(IronPython.Runtime.CodeContext,System.String,System.Int32)">
            <summary>
            Called from generated code for:
            
            from spam import *
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.UnqualifiedExec(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Unqualified exec statement support.
            A Python helper which will be called for the statement:
            
            exec code
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.QualifiedExec(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.PythonDictionary,System.Object)">
            <summary>
            Qualified exec statement support,
            Python helper which will be called for the statement:
            
            exec code in globals [, locals ]
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.BuildExceptionInfo(IronPython.Runtime.CodeContext,System.Exception)">
            <summary>
            Called from generated code at the start of a catch block.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.GetExceptionInfo(IronPython.Runtime.CodeContext)">
            <summary>
            Get an exception tuple for the "current" exception. This is used for sys.exc_info()
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.GetExceptionInfoLocal(IronPython.Runtime.CodeContext,System.Exception)">
            <summary>
            Get an exception tuple for a given exception. This is like the inverse of MakeException.
            </summary>
            <param name="context">the code context</param>
            <param name="ex">the exception to create a tuple for.</param>
            <returns>a tuple of (type, value, traceback)</returns>
            <remarks>This is called directly by the With statement so that it can get an exception tuple
            in its own private except handler without disturbing the thread-wide sys.exc_info(). </remarks>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeRethrownException(IronPython.Runtime.CodeContext)">
            <summary>
            helper function for re-raised exceptions.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeRethrowExceptionWorker(System.Exception)">
            <summary>
            helper function for re-raised exception.
            This entry point is used by 'raise' inside 'with' statement
            </summary>
            <param name="e"></param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeException(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object)">
            <summary>
            helper function for non-re-raise exceptions.
            
            type is the type of exception to throw or an instance.  If it 
            is an instance then value should be null.  
            
            If type is a type then value can either be an instance of type,
            a Tuple, or a single value.  This case is handled by EC.CreateThrowable.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.ExtractAnyArgument(IronPython.Runtime.PythonFunction,System.String,System.Int32,IronPython.Runtime.List,System.Collections.IDictionary)">
            <summary>
            Extracts an argument from either the dictionary or params
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.InitializeUserTypeSlots(IronPython.Runtime.Types.PythonType)">
            <summary>
            Creates a new array the values set to Uninitialized.Instance.  The array
            is large enough to hold for all of the slots allocated for the type and
            its sub types.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.IsNumericObject(System.Object)">
            <summary>
            Helper to determine if the value is a simple numeric type (int or big int or bool) - used for OldInstance
            deprecated form of slicing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.IsNumericType(System.Type)">
            <summary>
            Helper to determine if the type is a simple numeric type (int or big int or bool) - used for OldInstance
            deprecated form of slicing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.IsNonExtensibleNumericType(System.Type)">
            <summary>
            Helper to determine if the type is a simple numeric type (int or big int or bool) but not a subclass
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.NormalizeBigInteger(System.Object,System.Numerics.BigInteger,System.Nullable{System.Int32}@)">
            <summary>
            For slicing.  Fixes up a BigInteger and returns an integer w/ the length of the
            object added if the value is negative.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.GetLengthOnce(System.Object,System.Nullable{System.Int32}@)">
            <summary>
            For slicing.  Gets the length of the object, used to only get the length once.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.CheckTypeVersion(System.Object,System.Int32)">
            <summary>
            Helper method for DynamicSite rules that check the version of their dynamic object
            TODO - Remove this method for more direct field accesses
            </summary>
            <param name="o"></param>
            <param name="version"></param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.TestBoundBuiltinFunction(IronPython.Runtime.Types.BuiltinFunction,System.Object)">
            <summary>
            Called from generated code.  Gets a builtin function and the BuiltinFunctionData associated
            with the object.  Tests to see if the function is bound and has the same data for the generated
            rule.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.ConvertFromObject``1(System.Object)">
            <summary>
            Convert object to a given type. This code is equivalent to NewTypeMaker.EmitConvertFromObject
            except that it happens at runtime instead of compile time.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.DefineDynamicAssembly(System.Reflection.AssemblyName,System.Reflection.Emit.AssemblyBuilderAccess)">
            <summary>
            Provides access to AppDomain.DefineDynamicAssembly which cannot be called from a DynamicMethod
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeNewCustomDelegate(System.Type[])">
            <summary>
            Generates a new delegate type.  The last type in the array is the return type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeNewCustomDelegate(System.Type[],System.Nullable{System.Runtime.InteropServices.CallingConvention})">
            <summary>
            Generates a new delegate type.  The last type in the array is the return type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.InitializeModule(System.Reflection.Assembly,System.String,System.String[])">
            <summary>
            Provides the entry point for a compiled module.  The stub exe calls into InitializeModule which
            does the actual work of adding references and importing the main module.  Upon completion it returns
            the exit code that the program reported via SystemExit or 0.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.InitializeModuleEx(System.Reflection.Assembly,System.String,System.String[],System.Boolean)">
            <summary>
            Provides the entry point for a compiled module.  The stub exe calls into InitializeModule which
            does the actual work of adding references and importing the main module.  Upon completion it returns
            the exit code that the program reported via SystemExit or 0.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.RemoveName(IronPython.Runtime.CodeContext,System.String)">
            <summary>
            Called from generated code, helper to remove a name
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.LookupName(IronPython.Runtime.CodeContext,System.String)">
            <summary>
            Called from generated code, helper to do name lookup
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.SetName(IronPython.Runtime.CodeContext,System.String,System.Object)">
            <summary>
            Called from generated code, helper to do name assignment
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.ToPython(System.IntPtr)">
            <summary>
            Returns an IntPtr in the proper way to CPython - an int or a Python long
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeExceptionTypeError(System.Object,System.Boolean)">
            <summary>
            Create at TypeError exception for when Raise() can't create the exception requested.  
            </summary>
            <param name="type">original type of exception requested</param>
            <returns>a TypeEror exception</returns>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonOps.GetDynamicStackFrames(System.Exception)">
            <summary>
            Gets a list of DynamicStackFrames for the given exception.  These stack frames
            can be programmatically inspected to understand the frames the exception crossed
            through including Python frames.
            
            Dynamic stack frames are not preserved when an exception crosses an app domain
            boundary.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Operations.UnicodeHelper">
            <summary>
            Helper clas for calls to unicode(...).  We generate code which checks if unicode
            is str and if it is we redirect those calls to the unicode function defined on this
            class.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonTypeOps.GetInitMethod(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Object)">
            <summary>
            Looks up __init__ avoiding calls to __getattribute__ and handling both
            new-style and old-style classes in the MRO.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonTypeOps.GetBuiltinFunction(System.Type,System.String,System.String,System.Nullable{IronPython.Runtime.Types.FunctionType},System.Reflection.MemberInfo[])">
            <summary>
            Gets a builtin function for the given declaring type and member infos.
            
            Given the same inputs this always returns the same object ensuring there's only 1 builtinfunction
            for each .NET method.
            
            This method takes both a cacheName and a pythonName.  The cache name is the real method name.  The pythonName
            is the name of the method as exposed to Python.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonTypeOps.IsMethodAlwaysVisible(System.Type,System.Reflection.MemberInfo[])">
            <summary>
            Checks to see if the provided members are always visible for the given type.
            
            This filters out methods such as GetHashCode and Equals on standard .NET 
            types that we expose directly as Python types (e.g. object, string, etc...).
            
            It also filters out the base helper overrides that are added for supporting
            super calls on user defined types.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonTypeOps.IsStaticFunction(System.Type,System.Reflection.MethodInfo)">
            <summary>
            a function is static if it's a static .NET method and it's defined on the type or is an extension method 
            with StaticExtensionMethod decoration.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.PythonTypeOps.EnsureBaseType(IronPython.Runtime.PythonTuple)">
            <summary>
            If we have only interfaces, we'll need to insert object's base
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Operations.ExtensibleString">
            <summary>
            ExtensibleString is the base class that is used for types the user defines
            that derive from string.  It carries along with it the string's value and
            our converter recognizes it as a string.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Operations.StringOps">
            <summary>
            StringOps is the static class that contains the methods defined on strings, i.e. 'abc'
            
            Here we define all of the methods that a Python user would see when doing dir('abc').
            If the user is running in a CLS aware context they will also see all of the methods
            defined in the CLS System.String type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.StringOps.capitalize(System.String)">
            <summary>
            Returns a copy of this string converted to uppercase
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.StringOps.istitle(System.String)">
            <summary>
            return true if self is a titlecased string and there is at least one
            character in self; also, uppercase characters may only follow uncased
            characters (e.g. whitespace) and lowercase characters only cased ones.
            return false otherwise.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.StringOps.join(System.String,System.Object)">
            <summary>
            Return a string which is the concatenation of the strings 
            in the sequence seq. The separator between elements is the 
            string providing this method
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.StringOps.format(IronPython.Runtime.CodeContext,System.String,System.Object[])">
            <summary>
            Replaces each replacement field in the string with the provided arguments.
            
            replacement_field =  "{" field_name ["!" conversion] [":" format_spec] "}"
            field_name        =  (identifier | integer) ("." identifier | "[" element_index "]")*
            
            format_spec: [[fill]align][sign][#][0][width][,][.precision][type]
            
            Conversion can be 'r' for repr or 's' for string.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.StringOps.format(IronPython.Runtime.CodeContext,System.String,System.Collections.Generic.IDictionary{System.Object,System.Object},System.Object[])">
            <summary>
            Replaces each replacement field in the string with the provided arguments.
            
            replacement_field =  "{" field_name ["!" conversion] [":" format_spec] "}"
            field_name        =  (identifier | integer) ("." identifier | "[" element_index "]")*
            
            format_spec: [[fill]align][sign][#][0][width][.precision][type]
            
            Conversion can be 'r' for repr or 's' for string.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.StringOps.GetStartingOffset(System.Text.Encoding,System.Byte[])">
            <summary>
            Gets the starting offset checking to see if the incoming bytes already include a preamble.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Operations.StringOps.PythonEncoderFallbackBuffer">
            When encoding or decoding strings if an error occurs CPython supports several different
            behaviors, in addition it supports user-extensible behaviors as well.  For the default
            behavior we're ok - both of us support throwing and replacing.  For custom behaviors
            we define a single fallback for decoding and encoding that calls the python function to do
            the replacement.
            
            When we do the replacement we call the provided handler w/ a UnicodeEncodeError or UnicodeDecodeError
            object which contains:
                    encoding    (string, the encoding the user requested)
                    end         (the end of the invalid characters)
                    object      (the original string being decoded)
                    reason      (the error, e.g. 'unexpected byte code', not sure of others)
                    start       (the start of the invalid sequence)
                    
            The decoder returns a tuple of (unicode, int) where unicode is the replacement string
            and int is an index where encoding should continue.
        </member>
        <member name="M:IronPython.Runtime.Operations.TypeGroupOps.GetItem(Microsoft.Scripting.Actions.TypeGroup,IronPython.Runtime.Types.PythonType[])">
            <summary>
            Indexer for generic parameter resolution.  We bind to one of the generic versions
            available in this type collision.  A user can also do someType[()] to force to
            bind to the non-generic version, but we will always present the non-generic version
            when no bindings are available.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Operations.UserTypeOps.ToStringHelper(IronPython.Runtime.Types.IPythonObject)">
            <summary>
            Object.ToString() displays the CLI type name.  But we want to display the class name (e.g.
            '&lt;foo object at 0x000000000000002C&gt;' unless we've overridden __repr__ but not __str__ in 
            which case we'll display the result of __repr__.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Operations.UserTypeDebugView">
            <summary>
            Provides a debug view for user defined types.  This class is declared as public
            because it is referred to from generated code.  You should not use this class.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Profiler">
            <summary>
            Manages the acquisition of profiling data for a single ScriptRuntime
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Profiler.GetProfiler(IronPython.Runtime.PythonContext)">
            <summary>
            Get the unique Profiler instance for this ScriptRuntime
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Profiler.GetProfilerIndex(System.Reflection.MethodBase)">
            <summary>
            Given a MethodBase, return an index into the array of perf data.  Treat each
            CLR method as unique.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Profiler.GetProfilerIndex(System.String)">
            <summary>
            Given the unique name of something we're profiling, return an index into the array of perf data.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Profiler.GetNewProfilerIndex(System.String)">
            <summary>
            Add a new profiler entry. Not all names are unique.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Profiler.GetProfile(System.Boolean)">
            <summary>
            Gets the current summary of profile data
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Profiler.Reset">
            <summary>
            Resets the current summary of profile data back to zero
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Profiler.AddProfiling(System.Linq.Expressions.Expression,System.Linq.Expressions.ParameterExpression,System.String,System.Boolean)">
            <summary>
            Adds profiling calls to a Python method.
            Calculates both the time spent only in this method
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Profiler.AddProfiling(System.Linq.Expressions.Expression,System.Reflection.MethodBase)">
            <summary>
            Wraps a call to a MethodInfo with profiling capture for that MethodInfo
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Profiler.Data">
            <summary>
            Encapsulates profiler data to return to clients
            </summary>
        </member>
        <member name="T:IronPython.Runtime.ProfilerTreatsAsExternalAttribute">
            <summary>
            Marks that this built-in method should be treated as external by the profiler.
            When placed on a call emitted into a Python method, all the time spent in this
            call will still show up in its parent's inclusive time, but will not be
            part of its exclusive time.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.PythonAsciiEncoding">
            <summary>
            Simple implementation of ASCII encoding/decoding.  The default instance (PythonAsciiEncoding.Instance) is
            setup to always convert even values outside of the ASCII range.  The EncoderFallback/DecoderFallbacks can
            be replaced with versions that will throw exceptions instead though.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.PythonBuffer.BufferMeta">
            <summary>
            A DynamicMetaObject which is just used to support custom conversions to COM.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.IPythonArray">
            <summary>
            A marker interface so we can recognize and access sequence members on our array objects.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonContext.NewObject">
            <summary> stored for copy_reg module, used for reduce protocol </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonContext.PythonReconstructor">
            <summary> stored for copy_reg module, used for reduce protocol </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.#ctor(Microsoft.Scripting.Runtime.ScriptDomainManager,System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Creates a new PythonContext not bound to Engine.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.RecursionLimit">
            <summary>
            Gets or sets the maximum depth of function calls.  Equivalent to sys.getrecursionlimit
            and sys.setrecursionlimit.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.MainThread">
            <summary>
            Gets or sets the main thread which should be interupted by thread.interrupt_main
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.HasModuleState(System.Object)">
            <summary>
            Checks to see if module state has the current value stored already.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.GetModuleState(System.Object)">
            <summary>
            Gets per-runtime state used by a module.  The module should have a unique key for
            each piece of state it needs to store.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.SetModuleState(System.Object,System.Object)">
            <summary>
            Sets per-runtime state used by a module.  The module should have a unique key for
            each piece of state it needs to store.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.GetSetModuleState(System.Object,System.Object)">
            <summary>
            Sets per-runtime state used by a module and returns the previous value.  The module
            should have a unique key for each piece of state it needs to store.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.GetOrCreateModuleState``1(System.Object,System.Func{``0})">
            <summary>
            Sets per-runtime state used by a module and returns the previous value.  The module
            should have a unique key for each piece of state it needs to store.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.InitializeSystemState">
            <summary>
            Initializes the sys module on startup.  Called both to load and reload sys
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.ReadOneLine(System.IO.StreamReader,System.Int32@)">
            <summary>
            Reads one line keeping track of the # of bytes read
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.HookAssemblyResolve">
            <summary>
            We use Assembly.LoadFile to load assemblies from a path specified by the script (in LoadAssemblyFromFileWithPath).
            However, when the CLR loader tries to resolve any of assembly references, it will not be able to
            find the dependencies, unless we can hook into the CLR loader.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.GetPythonService(Microsoft.Scripting.Hosting.ScriptEngine)">
            <summary>
            Returns (and creates if necessary) the PythonService that is associated with this PythonContext.
            
            The PythonService is used for providing remoted convenience helpers for the DLR hosting APIs.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.DefaultEncoding">
            <summary>
            Gets or sets the default encoding for this system state / engine.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.BuiltinModules">
            <summary>
            Dictionary from name to type of all known built-in module names.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.BuiltinModuleNames">
            <summary>
            Dictionary from type to name of all built-in modules.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.BuiltinModuleInstance">
            <summary>
            TODO: Remove me, or stop caching built-ins.  This is broken if the user changes __builtin__
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.GetMemberNames(System.Object)">
            <summary>
            Gets the member names associated with the object
            TODO: Move "GetMemberNames" functionality into MetaObject implementations
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.ErrorHandlers">
            <summary> Dictionary of error handlers for string codecs. </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.SearchFunctions">
            <summary> Table of functions used for looking for additional codecs. </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.GetGenericSiteStorage``1">
            <summary>
            Gets a SiteLocalStorage when no call site is available.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.Operation(IronPython.Runtime.Binding.PythonOperationKind,System.Object,System.Object)">
            <summary>
            Invokes the specified operation on the provided arguments and returns the new resulting value.
            
            operation is usually a value from StandardOperators (standard CLR/DLR operator) or 
            OperatorStrings (a Python specific operator)
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.SharedContext">
            <summary>
            Returns a shared code context for the current PythonContext.  This shared
            context can be used for performing general operations which usually
            require a CodeContext.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.SharedOverloadResolverFactory">
            <summary>
            Returns an overload resolver for the current PythonContext.  The overload
            resolver will flow the shared context through as it's CodeContext.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonContext.SharedClsContext">
            <summary>
            Returns a shared code context for the current PythonContext.  This shared
            context can be used for doing lookups which need to occur as if they
            happened in a module which has done "import clr".
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.GetSetCommandDispatcher(System.Action{System.Action})">
            <summary>
            Sets the current command dispatcher for the Python command line.  The previous dispatcher
            is returned.  Null can be passed to remove the current command dispatcher.
            
            The command dispatcher will be called with a delegate to be executed.  The command dispatcher
            should invoke the target delegate in the desired context.
            
            A common use for this is to enable running all REPL commands on the UI thread while the REPL
            continues to run on a non-UI thread.
            
            The ipy.exe REPL will call into PythonContext.DispatchCommand to dispatch each execution to
            the correct thread.  Other REPLs can do the same to support this functionality as well.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.DispatchCommand(System.Action)">
            <summary>
            Dispatches the command to the current command dispatcher.  If there is no current command
            dispatcher the command is executed immediately on the current thread.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.GetComparer(System.Object,System.Type)">
            <summary>
            Gets a function which can be used for comparing two values.  If cmp is not null
            then the comparison will use the provided comparison function.  Otherwise
            it will use the normal Python semantics.
            
            If type is null then a generic comparison function is returned.  If type is 
            not null a comparison function is returned that's used for just that type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.Collect(System.Int32)">
            <summary>
            Performs a GC collection including the possibility of freeing weak data structures held onto by the Python runtime.
            </summary>
            <param name="generation"></param>
        </member>
        <member name="M:IronPython.Runtime.PythonContext.GetPythonContext(System.Dynamic.DynamicMetaObjectBinder)">
            <summary>
            Gets a PythonContext given a DynamicMetaObjectBinder.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.UnaryOperators">
            <summary>
            List of unary operators which we have sites for to enable fast dispatch that
            doesn't collide with other operators.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DictionaryKeyEnumerator">
            <summary>
            Note: 
              IEnumerator innerEnum = Dictionary&lt;K,V&gt;.KeysCollections.GetEnumerator();
              innerEnum.MoveNext() will throw InvalidOperation even if the values get changed,
              which is supported in python
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DictionaryValueEnumerator">
            <summary>
            Note: 
              IEnumerator innerEnum = Dictionary&lt;K,V&gt;.KeysCollections.GetEnumerator();
              innerEnum.MoveNext() will throw InvalidOperation even if the values get changed,
              which is supported in python
            </summary>
        </member>
        <member name="T:IronPython.Runtime.DictionaryItemEnumerator">
            <summary>
            Note: 
              IEnumerator innerEnum = Dictionary&lt;K,V&gt;.KeysCollections.GetEnumerator();
              innerEnum.MoveNext() will throw InvalidOperation even if the values get changed,
              which is supported in python
            </summary>
        </member>
        <member name="T:IronPython.Runtime.PythonDynamicStackFrame">
            <summary>
            A DynamicStackFrame which has Python specific data.  Currently this
            includes the code context which may provide access to locals and the
            function code object which is needed to build frame objects from.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonDynamicStackFrame.CodeContext">
            <summary>
            Gets the code context of the function.
            
            If the function included a call to locals() or the FullFrames
            option is enabled then the code context includes all local variables.
            
            Null if deserialized.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonDynamicStackFrame.Code">
            <summary>
            Gets the code object for this frame.  This is used in creating
            the trace back. Null if deserialized.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonFile.SetMode(IronPython.Runtime.CodeContext,System.Boolean)">
            <summary>
            Sets the mode to text or binary.  Returns true if previously set to text, false if previously set to binary.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonFile.truncate">
            <summary>
            Truncates the file to the current length as indicated by tell().
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonFile.truncate(System.Int64)">
            <summary>
            Truncates the file to the specified length.
            </summary>
            <param name="size"></param>
        </member>
        <member name="T:IronPython.Runtime.PythonFunction">
            <summary>
            Created for a user-defined function.  
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonFunction.#ctor(IronPython.Runtime.CodeContext,IronPython.Runtime.FunctionCode,IronPython.Runtime.PythonDictionary,System.String,IronPython.Runtime.PythonTuple,IronPython.Runtime.PythonTuple)">
            <summary>
            Python ctor - maps to function.__new__
            
            y = func(x.__code__, globals(), 'foo', None, (a, ))
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonFunction.Context">
            <summary>
            The parent CodeContext in which this function was declared.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonFunction.FunctionCompatibility">
            <summary>
            Captures the # of args and whether we have kw / arg lists.  This
            enables us to share sites for simple calls (calls that don't directly
            provide named arguments or the list/dict params).
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonFunction.CalculatedCachedCompat">
            <summary>
            Calculates the _compat value which is used for call-compatibility checks
            for simple calls.  Whenver any of the dependent values are updated this
            must be called again.
            
            The dependent values include:
                _nparams - this is readonly, and never requies an update
                _defaults - the user can mutate this (func_defaults) and that forces
                            an update
                expand dict/list - based on nparams and flags, both read-only
                
            Bits are allocated as:
                00003fff - Normal argument count
                0fffb000 - Default count
                10000000 - unused
                20000000 - expand list
                40000000 - expand dict
                80000000 - unused
                
            Enforce recursion is added at runtime.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonFunction.IsGeneratorWithExceptionHandling">
            <summary>
            Generators w/ exception handling need to have some data stored
            on them so that we appropriately set/restore the exception state.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonFunction.FunctionID">
            <summary>
            Returns an ID for the function if one has been assigned, or zero if the
            function has not yet required the use of an ID.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonFunction.ExpandListPosition">
            <summary>
            Gets the position for the expand list argument or -1 if the function doesn't have an expand list parameter.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonFunction.ExpandDictPosition">
            <summary>
            Gets the position for the expand dictionary argument or -1 if the function doesn't have an expand dictionary parameter.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonFunction.NormalArgumentCount">
            <summary>
            Gets the number of normal (not params or kw-params) parameters.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonFunction.ExtraArguments">
            <summary>
            Gets the number of extra arguments (params or kw-params)
            </summary>
        </member>
        <member name="T:IronPython.Runtime.PythonHiddenAttribute">
            <summary>
            Marks a member as being hidden from Python code.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.PythonHiddenBaseClassAttribute">
            <summary>
            Marks a class as being hidden from the Python hierarchy.  This is applied to the base class
            and then all derived types will not see the base class in their hierarchy and will not be
            able to access members declaredo on the base class.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.PythonModule">
            <summary>
            Python module.  Stores classes, functions, and data.  Usually a module
            is created by importing a file or package from disk.  But a module can also
            be directly created by calling the module type and providing a name or
            optionally a documentation string.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonModule.#ctor(IronPython.Runtime.PythonContext,Microsoft.Scripting.Runtime.Scope)">
            <summary>
            Creates a new module backed by a Scope.  Used for creating modules for foreign Scope's.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonModule.#ctor(IronPython.Runtime.PythonDictionary)">
            <summary>
            Creates a new PythonModule with the specified dictionary.
            
            Used for creating modules for builtin modules which don't have any code associated with them.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.PythonModuleAttribute">
            <summary>
            This assembly-level attribute specifies which types in the engine represent built-in Python modules.
            
            Members of a built-in module type should all be static as an instance is never created.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonModuleAttribute.#ctor(System.String,System.Type,System.PlatformID[])">
            <summary>
            Creates a new PythonModuleAttribute that can be used to specify a built-in module that exists
            within an assembly.
            </summary>
            <param name="name">The built-in module name</param>
            <param name="type">The type that implements the built-in module.</param>
            <param name="validPlatforms">The valid platform identifiers for this module.</param>
        </member>
        <member name="P:IronPython.Runtime.PythonModuleAttribute.Name">
            <summary>
            The built-in module name
            </summary>
        </member>
        <member name="P:IronPython.Runtime.PythonModuleAttribute.Type">
            <summary>
            The type that implements the built-in module
            </summary>
        </member>
        <member name="T:IronPython.Runtime.PythonNarrowing">
            <summary>
            Provides human readable names for how Python maps the various DLR NarrowingLevel's.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonNarrowing.None">
            <summary>
            No narrowing conversions are performed
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonNarrowing.BinaryOperator">
            <summary>
            Double/Single to Decimal
            PythonTuple to Array
            Generic conversions
            BigInteger to Int64
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonNarrowing.IndexOperator">
            <summary>
            Numeric conversions excluding from floating point values
            Boolean conversions
            Delegate conversions
            Enumeration conversions
            </summary>
        </member>
        <member name="F:IronPython.Runtime.PythonNarrowing.All">
            <summary>
            Enables Python protocol conversions (__int__, etc...)
            </summary>
        </member>
        <member name="T:IronPython.Runtime.PythonScopeExtension">
            <summary>
            Provides storage of IronPython specific data in the DLR Scope ScopeExtension.
            
            This enables IronPython to track code compilation flags such as from __future__
            flags and import clr flags across multiple executions of user-provided scopes.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.PythonTuple.ToArray">
            <summary>
            Return a copy of this tuple's data array.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.TupleEnumerator">
            <summary>
            public class to get optimized
            </summary>
        </member>
        <member name="T:IronPython.Runtime.PythonTypeAttribute">
             <summary>
             Marks a type as being a PythonType for purposes of member lookup, creating instances, etc...  
             
             If defined a PythonType will use __new__ / __init__ when creating instances.  This allows the
             object to match the native Python behavior such as returning cached values from __new__ or
             supporting initialization to run multiple times via __init__.
            
             The attribute also allows you to specify an alternate type name.  This allows the .NET name to
             be different from the Python name so they can follow .NET naming conventions.
             
             Types defining this attribute also don't show CLR methods such as Equals, GetHashCode, etc... until
             the user has done an import clr.
             </summary>
        </member>
        <member name="T:IronPython.Runtime.ScopeDictionaryStorage">
            <summary>
            Provides dictionary based storage which is backed by a Scope object.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.SequenceTypeInfoAttribute">
            <summary>
            Provides more specific type information for Python lists which are not strongly typed.
            
            This attribute can be applied to fields, parameters, proeprties, and return values.  It can be
            inspected to get type information about the types of the values of the expected 
            list or the returned list.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.SetCollection">
            <summary>
            Mutable set class
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetCollection.update(System.Object)">
            <summary>
            Appends an IEnumerable to an existing set
            </summary>
        </member>
        <member name="T:IronPython.Runtime.FrozenSetCollection">
            <summary>
            Immutable set class
            </summary>
        </member>
        <member name="T:IronPython.Runtime.SetIterator">
            <summary>
            Iterator over sets
            </summary>
        </member>
        <member name="T:IronPython.Runtime.SetStorage">
            <summary>
            General-purpose storage used for Python sets and frozensets.
            
            The set storage is thread-safe for multiple readers or writers.
            
            Mutations to the set involve a simple locking strategy of locking on the SetStorage object
            itself to ensure mutual exclusion.
            
            Reads against the set happen lock-free. When the set is mutated, it adds or removes buckets
            in an atomic manner so that the readers will see a consistent picture as if the read
            occurred either before or after the mutation.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.#ctor">
            <summary>
            Creates a new set storage with no buckets
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.#ctor(System.Int32)">
            <summary>
            Creates a new set storage with no buckets
            </summary>
        </member>
        <member name="P:IronPython.Runtime.SetStorage.Count">
            <summary>
            Returns the number of items currently in the set
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.Add(System.Object)">
            <summary>
            Adds a new item to the set, unless an equivalent item is already present
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.AddWorker(IronPython.Runtime.SetStorage.Bucket[],System.Object,System.Int32,System.Func{System.Object,System.Object,System.Boolean},System.Int32@)">
            <summary>
            Static helper which adds the given non-null item with a precomputed hash code. Returns
            true if the item was added, false if it was already present in the set.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.AddOrRemoveWorker(System.Object,System.Int32)">
            <summary>
            Lock-free helper on a non-null item with a pre-calculated hash code. Removes the item
            if it is present in the set, otherwise adds it.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.Clear">
            <summary>
            Clears the contents of the set
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.Clone">
            <summary>
            Clones the set, returning a new SetStorage object
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.Contains(System.Object)">
            <summary>
            Checks to see if the given item exists in the set
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.ContainsAlwaysHash(System.Object)">
            <summary>
            Checks to see if the given item exists in the set, and tries to hash it even
            if it is known not to be in the set.
            </summary>
            <param name="item"></param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.CopyTo(IronPython.Runtime.SetStorage)">
            <summary>
            Adds items from this set into the other set
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.Pop(System.Object@)">
            <summary>
            Removes the first set element in the iteration order.
            </summary>
            <returns>true if an item was removed, false if the set was empty</returns>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.Remove(System.Object)">
            <summary>
            Removes an item from the set and returns true if it was present, otherwise returns
            false
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.RemoveAlwaysHash(System.Object)">
            <summary>
            Removes an item from the set and returns true if it was removed. The item will always
            be hashed, throwing if it is unhashable - even if the set has no buckets.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.RemoveItem(System.Object)">
            <summary>
            Lock-free helper to remove a non-null item
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.IsDisjoint(IronPython.Runtime.SetStorage)">
            <summary>
            Determines whether the current set shares no elements with the given set
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.IsSubset(IronPython.Runtime.SetStorage)">
            <summary>
            Determines whether the current set is a subset of the given set
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.IsStrictSubset(IronPython.Runtime.SetStorage)">
            <summary>
            Determines whether the current set is a strict subset of the given set
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.UnionUpdate(IronPython.Runtime.SetStorage)">
            <summary>
            Mutates this set to contain its union with 'other'. The caller must lock the current
            set if synchronization is desired.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.IntersectionUpdate(IronPython.Runtime.SetStorage)">
            <summary>
            Mutates this set to contain its intersection with 'other'. The caller must lock the
            current set if synchronization is desired.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.SymmetricDifferenceUpdate(IronPython.Runtime.SetStorage)">
            <summary>
            Mutates this set to contain its symmetric difference with 'other'. The caller must
            lock the current set if synchronization is desired.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.DifferenceUpdate(IronPython.Runtime.SetStorage)">
            <summary>
            Mutates this set to contain its difference with 'other'. The caller must lock the
            current set if synchronization is desired.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.Union(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
            <summary>
            Computes the union of self and other, returning an entirely new set. This method is
            thread-safe and makes no modifications to self or other.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.Intersection(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
            <summary>
            Computes the intersection of self and other, returning an entirely new set. This
            method is thread-safe and makes no modifications to self or other.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.SymmetricDifference(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
            <summary>
            Computes the symmetric difference of self and other, returning an entirely new set.
            This method is thread-safe and makes no modifications to self or other.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.Difference(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
            <summary>
            Computes the difference of self and other, returning an entirely new set. This
            method is thread-safe and makes no modifications to self or other.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.SetStorage.Bucket">
            <summary>
            Used to store a single hashed item.
            
            Bucket is not serializable because it stores the computed hash code, which could change
            between serialization and deserialization.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.Hash(System.Object)">
            <summary>
            Helper to hash the given item w/ support for null
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.SortBySize(IronPython.Runtime.SetStorage@,IronPython.Runtime.SetStorage@)">
            <summary>
            Helper which ensures that the first argument x requires the least work to enumerate
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.GetItems(System.Object)">
            <summary>
            A factory which creates a SetStorage object from any Python iterable. It extracts
            the underlying storage of a set or frozen set without copying, which is left to the
            caller if necessary.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.GetItems(System.Object,IronPython.Runtime.SetStorage@)">
            <summary>
            A factory which creates a SetStorage object from any Python iterable. It extracts
            the underlying storage of a set or frozen set without copying, which is left to the
            caller if necessary.
            Returns true if the given object was a set or frozen set, false otherwise.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.GetFrozenItems(System.Object)">
            <summary>
            A factory which creates a SetStorage object from any Python iterable. It extracts
            the underlying storage of a set or frozen set, copying in the former case, to return
            a SetStorage object that is guaranteed not to receive any outside mutations.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.GetItemsIfSet(System.Object,IronPython.Runtime.SetStorage@)">
            <summary>
            Extracts the SetStorage object from o if it is a set or frozenset and returns true.
            Otherwise returns false.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.SetStorage.GetHashableSetIfSet(System.Object@)">
            <summary>
            Creates a hashable set from the given set, or does nothing if the given object 
            is not a set.
            </summary>
            <returns>True if o is a set or frozenset, false otherwise</returns>
        </member>
        <member name="T:IronPython.Runtime.SiteLocalStorage`1">
            <summary>
            Provides storage which is flowed into a callers site.  The same storage object is 
            flowed for multiple calls enabling the callee to cache data that can be re-used
            across multiple calls.
            
            Data is a public field so that this works properly with DynamicSite's as the reference
            type (and EnsureInitialize)
            </summary>
        </member>
        <member name="T:IronPython.Runtime.StringFormatSpec">
            <summary>
            Provides a representation and parsing for the default formatting specification.  This is used
            by object.__format__, int.__format__, long.__format__, and float.__format__ to do the common
            format spec parsing.
            
            The default specification is:
            
            format_spec =  [[fill]align][sign][#][0][width][,][.precision][type]
            fill        =  a character other than }
            align       =  "&lt;" | "&gt;" | "=" | "^"
            sign        =  "+" | "-" | " "
            width       =  integer
            precision   =  integer
            type        =  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "x" | "X" | "%"
            </summary>
        </member>
        <member name="M:IronPython.Runtime.StringFormatSpec.FromString(System.String)">
            <summary>
            Parses a format spec and returns a new StringFormatSpec object.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.StringFormatter">
            <summary>
            StringFormatter provides Python's % style string formatting services.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.StringFormatter.ReadMappingKey">
            <summary>
            Read a possible mapping key for %(key)s. 
            </summary>
            <returns>The key name enclosed between the '%(key)s', 
            or null if there are no paranthesis such as '%s'.</returns>
        </member>
        <member name="M:IronPython.Runtime.StringFormatter.AppendBase(System.Char,System.Int32)">
            <summary>
            AppendBase appends an integer at the specified radix doing all the
            special forms for Python.  We have a copy and paste version of this
            for BigInteger below that should be kept in sync.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.StringFormatter.AppendBaseBigInt(System.Numerics.BigInteger,System.Char,System.Int32)">
            <summary>
            BigInteger version of AppendBase.  Should be kept in sync w/ AppendBase
            </summary>
        </member>
        <member name="T:IronPython.Runtime.SysModuleDictionaryStorage">
            <summary>
            Optimized storage for setting exc_type, exc_value, and exc_traceback.
            
            This optimization can go away in Python 3.0 when these attributes are no longer used.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.BuiltinFunction">
            <summary>
            BuiltinFunction represents any standard CLR function exposed to Python.
            This is used for both methods on standard Python types such as list or tuple
            and for methods from arbitrary .NET assemblies.
            
            All calls are made through the optimizedTarget which is created lazily.
            
            TODO: Back BuiltinFunction's by MethodGroup's.
            </summary>    
        </member>
        <member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeFunction(System.String,System.Reflection.MethodBase[],System.Type)">
            <summary>
            Creates a new builtin function for a static .NET function.  This is used for module methods
            and well-known __new__ methods.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeMethod(System.String,System.Reflection.MethodBase[],System.Type,IronPython.Runtime.Types.FunctionType)">
            <summary>
            Creates a built-in function for a .NET method declared on a type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.BuiltinFunction.#ctor(System.Object,IronPython.Runtime.Types.BuiltinFunction.BuiltinFunctionData)">
            <summary>
            Creates a bound built-in function.  The instance may be null for built-in functions
            accessed for None.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeGenericMethod(System.Type[])">
            <summary>
            Returns a BuiltinFunction bound to the provided type arguments.  Returns null if the binding
            cannot be performed.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.BuiltinFunction.GetDescriptor">
            <summary>
            Returns a descriptor for the built-in function if one is
            neededed
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.BuiltinFunction.Targets">
            <summary>
            Gets the target methods that we'll be calling.  
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.BuiltinFunction.IsAlwaysVisible">
            <summary>
            True if the method should be visible to non-CLS opt-in callers
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeBoundFunctionTest(System.Linq.Expressions.Expression)">
            <summary>
            Makes a test for the built-in function against the private _data 
            which is unique per built-in function.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeBuiltinFunctionCall(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[],System.Boolean,System.Dynamic.BindingRestrictions,System.Func{System.Dynamic.DynamicMetaObject[],IronPython.Runtime.Types.BuiltinFunction.BindingResult})">
            <summary>
            Helper for generating the call to a builtin function.  This is used for calls from built-in method
            descriptors and built-in functions w/ and w/o a bound instance.  
            
            This provides all sorts of common checks on top of the call while the caller provides a delegate
            to do the actual call.  The common checks include:
                check for generic-only methods
                reversed operator support
                transforming arguments so the default binder can understand them (currently user defined mapping types to PythonDictionary)
                returning NotImplemented from binary operators
                Warning when calling certain built-in functions
                
            </summary>
            <param name="call">The call binder we're doing the call for</param>
            <param name="codeContext">An expression which points to the code context</param>
            <param name="function">the meta object for the built in function</param>
            <param name="hasSelf">true if we're calling with an instance</param>
            <param name="args">The arguments being passed to the function</param>
            <param name="functionRestriction">A restriction for the built-in function, method desc, etc...</param>
            <param name="bind">A delegate to perform the actual call to the method.</param>
        </member>
        <member name="P:IronPython.Runtime.Types.BuiltinFunction.Overloads">
            <summary>
            Provides (for reflected methods) a mapping from a signature to the exact target
            which takes this signature.
            signature with syntax like the following:
               someClass.SomeMethod.Overloads[str, int]("Foo", 123)
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.BuiltinFunction.OverloadDictionary">
            <summary>
            Gets the overload dictionary for the logical function.  These overloads
            are never bound to an instance.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.BuiltinFunction.BindingSelf">
            <summary>
            Returns the instance used for binding.  This differs on module functions implemented
            using instance methods so the built-in functions there don't expose the instance.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.GenericBuiltinFunction">
            <summary>
            A custom built-in function which supports indexing 
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.GenericBuiltinFunction.Item(System.Object[])">
            <summary>
            Use indexing on generic methods to provide a new reflected method with targets bound with
            the supplied type arguments.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.BuiltinFunctionOverloadMapper.FindMatchingTargets(System.Type[],System.Collections.Generic.IList{System.Reflection.MethodBase},System.Boolean)">
            <summary>
            Find matching overloads by checking signature against available targets
            </summary>
            <param name="sig">Given signature</param>
            <param name="targets">List of possible targets</param>
            <param name="removeCodeContext">If set to true, the method will check whether the first paramter of the
            target is of the type CodeContext and removes it</param>
            <returns>Possible overloads</returns>
        </member>
        <member name="M:IronPython.Runtime.Types.BuiltinFunctionOverloadMapper.ThrowOverloadException(System.Type[],System.Collections.Generic.IList{System.Reflection.MethodBase})">
            <summary>
            Throws a formatted exception if no overload matchs.
            </summary>
            <param name="sig">Passed signature which should be used</param>
            <param name="targets">Given targets, which does not fit to the signature</param>
            <example>
            <code language="cs" title="Cause overload exceptiob"><![CDATA[
            # Will cause an exception:
            from System import Convert, Double
            Convert.ToInt32.Overloads[Double, Double](24)
            ]]></code>
            </example>
        </member>
        <member name="T:IronPython.Runtime.Types.CustomAttributeTracker">
            <summary>
            Provides a CustomTracker which handles special fields which have custom
            behavior on get/set.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.CustomInstanceDictionaryStorage">
            <summary>
            Provides custom, versioned, dictionary access for instances.  Used for both
            new-style and old-style instances.
            
            Each class can allocate a version for instance storage using the 
            CustomInstanceDictionaryStorage.AllocateInstance method.  The version allocated
            is dependent upon the names which are likely to appear in the instance 
            dictionary.  Currently these names are calculated by collecting the names
            that are assigned to during the __init__ method and combining these with
            all such names in the types MRO.
            
            When creating the dictionary for storing instance values the class can then create
            a PythonDictionary backed by a CustomInstanceDictionaryStorage with it's
            version.  When doing a get/set optimized code can then be produced that
            verifies we have CustomInstanceDictionaryStorage and it has the 
            correct version.  If we have a matching dictionary then gets/sets can turn
            into simple array accesses rather than dictionary gets/sets.  For programs
            which access a large number of instance variables this can dramatically
            speed up the program.
            
            TODO: Should we attempt to unify all versions which share the same keys?
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.DocBuilder.GetOverloadDoc(System.Reflection.MethodBase,System.String,System.Int32,System.Boolean)">
            <summary>
            Creates a DLR OverloadDoc object which describes information about this overload.
            </summary>
            <param name="info">The method to document</param>
            <param name="name">The name of the method if it should override the name in the MethodBase</param>
            <param name="endParamSkip">Parameters to skip at the end - used for removing the value on a setter method</param>
            <param name="includeSelf">true to include self on instance methods</param>
        </member>
        <member name="M:IronPython.Runtime.Types.DocBuilder.AppendTypeFormat(System.Type,System.Text.StringBuilder,System.Reflection.ParameterInfo)">
            <summary>
            Converts a Type object into a string suitable for lookup in the help file.  All generic types are
            converted down to their generic type definition.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.DocBuilder.GetXPathDocument(System.Reflection.Assembly)">
            <summary>
            Gets the XPathDocument for the specified assembly, or null if one is not available.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDoc(System.Reflection.MethodBase,System.String@,System.String@,System.Collections.Generic.List{System.Collections.Generic.KeyValuePair{System.String,System.String}}@)">
            <summary>
            Gets the Xml documentation for the specified MethodBase.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDoc(System.Type,System.String@)">
            <summary>
            Gets the Xml documentation for the specified Type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDocForProperty(System.Type,System.String,System.String@,System.String@)">
            <summary>
            Gets the Xml documentation for the specified Field.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDoc(System.Reflection.EventInfo,System.String@,System.String@)">
            <summary>
            Gets the Xml documentation for the specified Field.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.DocBuilder.XmlToString(System.Xml.XPath.XPathNodeIterator)">
            <summary>
            Converts the XML as stored in the config file into a human readable string.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.DynamicBaseTypeAttribute">
            <summary>
            Marks a type as being a suitable type to be used for user-defined classes.
            
            The requirements for this are that a type has to follow the patterns
            that NewTypeMaker derived types follow.  This includes:
                The type's constructors must all take PythonType as the 1st parameter
                    which sets the underlying type for the actual object
                The type needs to implement IPythonObject
                Dictionary-based storage needs to be provided for setting individual members
                Virtual methods exposed to Python need to support checking the types dictionary for invocations
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.FunctionType">
            <summary>
            Represents a set of attributes that different functions can have.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Types.FunctionType.None">
            <summary>No flags have been set </summary>
        </member>
        <member name="F:IronPython.Runtime.Types.FunctionType.Function">
            <summary>This is a function w/ no instance pointer </summary>
        </member>
        <member name="F:IronPython.Runtime.Types.FunctionType.Method">
            <summary>This is a method that requires an instance</summary>
        </member>
        <member name="F:IronPython.Runtime.Types.FunctionType.FunctionMethodMask">
            <summary>Built-in functions can encapsulate both methods and functions, in which case both bits are set</summary>
        </member>
        <member name="F:IronPython.Runtime.Types.FunctionType.AlwaysVisible">
            <summary>True is the function/method should be visible from pure-Python code</summary>
        </member>
        <member name="F:IronPython.Runtime.Types.FunctionType.ReversedOperator">
            <summary>True if this is a __r*__ method for a CLS overloaded operator method</summary>
        </member>
        <member name="F:IronPython.Runtime.Types.FunctionType.BinaryOperator">
            <summary>
            This method represents a binary operator method for a CLS overloaded operator method.
            
            Being a binary operator causes the following special behaviors to kick in:
                A failed binding at call time returns NotImplemented instead of raising an exception
                A reversed operator will automatically be created if:
                    1. The parameters are both of the instance type
                    2. The parameters are in reversed order (other, this)
                    
            This enables simple .NET operator methods to be mapped into the Python semantics.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Types.FunctionType.ModuleMethod">
            <summary>
            A method declared on a built-in module
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.InstanceCreator">
            <summary>
            Base class for helper which creates instances.  We have two derived types: One for user
            defined types which prepends the type before calling, and one for .NET types which
            doesn't prepend the type.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.IPythonObject">
            <summary>
            This interface is used for implementing parts of the IronPython type system.  It
            is not intended for consumption from user programs.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.IPythonObject.SetDict(IronPython.Runtime.PythonDictionary)">
            <summary>
            Thread-safe dictionary set.  Returns the dictionary set or the previous value if already set or 
            null if the dictionary set isn't supported.
            </summary>
            <param name="dict"></param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Types.IPythonObject.ReplaceDict(IronPython.Runtime.PythonDictionary)">
            <summary>
            Dictionary replacement.  Returns true if replaced, false if the dictionary set isn't supported.
            </summary>
            <param name="dict"></param>
            <returns></returns>
        </member>
        <member name="T:IronPython.Runtime.Types.Mro">
             <summary>
             Calculates the method resolution order for a Python class
             the rules are:
                  If A is a subtype of B, then A has precedence (A > B)
                  If C appears before D in the list of bases then C > D
                  If E > F in one __mro__ then E > F in all __mro__'s for our subtype
             
             class A(object): pass
             class B(object): pass
             class C(B): pass
             class N(A,B,C): pass         # illegal
            
             This is because:
                  C.__mro__ == (C, B, object)
                  N.__mro__ == (N, A, B, C, object)
             which would conflict, but:
            
             N(B,A) is ok  (N, B, a, object)
             N(C, B, A) is ok (N, C, B, A, object)
            
             Calculates a C3 MRO as described in "The Python 2.3 Method Resolution Order"
             plus support for old-style classes.
             
             We build up a list of our base classes MRO's plus our base classes themselves.
             We go through the list in order.  Look at the 1st class in the current list, and
             if it's not the non-first class in any other list then remove it from all the lists
             and append it to the mro.  Otherwise continue to the next list.  If all the classes at
             the start are no-good then the MRO is bad and we throw. 
             
             For old-style classes if the old-style class is the only one in the list of bases add
             it as a depth-first old-style MRO, otherwise compute a new-style mro for all the classes 
             and use that.
             </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.Mro.Calculate(IronPython.Runtime.Types.PythonType,System.Collections.Generic.IList{IronPython.Runtime.Types.PythonType},System.Boolean)">
            <summary>
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.NameConverter">
            <summary>
            Contains helper methods for converting C# names into Python names.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.NewTypeInfo">
            <summary>
            TypeInfo captures the minimal CLI information required by NewTypeMaker for a Python object
            that inherits from a CLI type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeInfo.GetTypeInfo(System.String,IronPython.Runtime.PythonTuple)">
            <summary>
            "bases" contains a set of PythonTypes. These can include types defined in Python (say cpy1, cpy2),
            CLI types (say cCLI1, cCLI2), and CLI interfaces (say iCLI1, iCLI2). Here are some
            examples of how this works:
            
            (bases)                      => baseType,        {interfaceTypes}
            
            (cpy1)                       => System.Object,   {}
            (cpy1, cpy2)                 => System.Object,   {}
            (cpy1, cCLI1, iCLI1, iCLI2)  => cCLI1,           {iCLI1, iCLI2}
            [some type that satisfies the line above] => 
                                            cCLI1,           {iCLI1, iCLI2}
            (cCLI1, cCLI2)               => error
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeInfo.GetPythonTypes(System.String,System.Collections.Generic.ICollection{System.Object})">
            <summary>
            Filters out old-classes and throws if any non-types are included, returning a
            yielding the remaining PythonType objects.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.NewTypeMaker">
            <summary>
            Python class hierarchy is represented using the __class__ field in the object. It does not 
            use the CLI type system for pure Python types. However, Python types which inherit from a 
            CLI type, or from a builtin Python type which is implemented in the engine by a CLI type,
            do have to use the CLI type system to interoperate with the CLI world. This means that 
            objects of different Python types, but with the same CLI base type, can use the same CLI type - 
            they will just have different values for the __class__ field.
            
            The easiest way to inspect the functionality implemented by NewTypeMaker is to persist the
            generated IL using "ipy.exe -X:SaveAssemblies", and then inspect the
            persisted IL using ildasm.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.LoadNewTypes(System.Reflection.Assembly)">
            <summary>
            Loads any available new types from the provided assembly and makes them
            available via the GetNewType API.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.IsInstanceType(System.Type)">
            <summary>
            Is this a type used for instances Python types (and not for the types themselves)?
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.GetOriginalIndex(System.Reflection.ParameterInfo[],Microsoft.Scripting.Generation.ParameterInfoWrapper[],System.Int32)">
            <summary>
            Gets the position for the parameter which we are overriding.
            </summary>
            <param name="pis"></param>
            <param name="overrideParams"></param>
            <param name="i"></param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.DefineHelperInterface(System.Type)">
            <summary>
            Defines an interface on the type that forwards all calls
            to a helper method in UserType.  The method names all will
            have Helper appended to them to get the name for UserType.  The 
            UserType version should take 1 extra parameter (self).
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.OverrideMethods(System.Type,System.Collections.Generic.Dictionary{System.String,System.String[]})">
            <summary>
            Overrides methods - this includes all accessible virtual methods as well as protected non-virtual members
            including statics and non-statics.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitBaseMethodDispatch(System.Reflection.MethodInfo,Microsoft.Scripting.Generation.ILGen)">
            <summary>
            Loads all the incoming arguments and forwards them to mi which
            has the same signature and then returns the result
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitBaseClassCallCheckForProperties(Microsoft.Scripting.Generation.ILGen,System.Reflection.MethodInfo,System.String)">
            <summary>
            Emits code to check if the class has overridden this specific
            function.  For example:
            
            MyDerivedType.SomeVirtualFunction = ...
                or
            
            class MyDerivedType(MyBaseType):
                def SomeVirtualFunction(self, ...):
            
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitConvertFromObject(Microsoft.Scripting.Generation.ILGen,System.Type)">
            <summary>
            Emit code to convert object to a given type. This code is semantically equivalent
            to PythonBinder.EmitConvertFromObject, except this version accepts ILGen whereas
            PythonBinder accepts Compiler. The Binder will chagne soon and the two will merge.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitBaseClassCallCheckForEvents(Microsoft.Scripting.Generation.ILGen,System.Reflection.MethodInfo,System.String)">
            <summary>
            Emits code to check if the class has overridden this specific
            function.  For example:
            
            MyDerivedType.SomeVirtualFunction = ...
                or
            
            class MyDerivedType(MyBaseType):
                def SomeVirtualFunction(self, ...):
            
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitNonInheritedMethodLookup(System.String,Microsoft.Scripting.Generation.ILGen)">
            <summary>
            Emits the call to lookup a member defined in the user's type.  Returns
            the local which stores the resulting value and leaves a value on the
            stack indicating the success of the lookup.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.CreateSuperCallHelper(System.Reflection.MethodInfo)">
            <summary>
            Creates a method for doing a base method dispatch.  This is used to support
            super(type, obj) calls.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitClrCallStub(Microsoft.Scripting.Generation.ILGen,System.Reflection.MethodInfo,System.Reflection.Emit.LocalBuilder)">
            <summary>
            Generates stub to receive the CLR call and then call the dynamic language code.
            This code is same as StubGenerator.cs in the Microsoft.Scripting, except it
            accepts ILGen instead of Compiler.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.NewTypeMaker.GetOverriddenMethods(System.Type,System.String)">
            <summary>
            Called from PythonTypeOps - the BuiltinFunction._function lock must be held.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.ReturnFixer">
            <summary>
            Same as the DLR ReturnFixer, but accepts lower level constructs,
            such as LocalBuilder, ParameterInfos and ILGen.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.OldInstance.Dictionary">
            <summary>
            Returns the dictionary used to store state for this object
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.OperatorMapping">
            <summary>
            OperatorMapping provides a mapping from DLR operators to their associated .NET methods.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.OperatorMapping.GetOperatorMapping(IronPython.Runtime.Binding.PythonOperationKind)">
            <summary>
            Given an operator returns the OperatorMapping associated with the operator or null
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.OperatorMapping.Operator">
            <summary>
            The operator the OperatorMapping provides info for.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.OperatorMapping.Name">
            <summary>
            The primary method name associated with the method.  This method name is
            usally in the form of op_Operator (e.g. op_Addition).
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.OperatorMapping.AlternateName">
            <summary>
            The secondary method name associated with the method.  This method name is
            usually a standard .NET method name with pascal casing (e.g. Add).
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.OperatorMapping.AlternateExpectedType">
            <summary>
            The return type that must match for the alternate operator to be valid.
            
            This is available alternate operators don't have special names and therefore
            could be confused for a normal method which isn't fulfilling the contract.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonSiteCache">
            <summary>
            Cached CallSites.  User types are cached on the PythonType and System types are cached on the
            PythonContext to avoid cross-runtime contamination due to the binder on the site.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonType">
            <summary>
            Represents a PythonType.  Instances of PythonType are created via PythonTypeBuilder.  
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Types.PythonType._fastBindCtors">
            <summary>
            Provides delegates that will invoke a parameterless type ctor.  The first key provides
            the dictionary for a specific type, the 2nd key provides the delegate for a specific
            call site type used in conjunction w/ our IFastInvokable implementation.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Types.PythonType._userTypeCtors">
            <summary>
            Shared built-in functions for creating instances of user defined types.  Because all
            types w/ the same UnderlyingSystemType share the same constructors these can be
            shared across multiple types.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,IronPython.Runtime.PythonDictionary)">
            <summary>
            Creates a new type for a user defined type.  The name, base classes (a tuple of type
            objects), and a dictionary of members is provided.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,IronPython.Runtime.PythonDictionary,System.String)">
            <summary>
            Creates a new type for a user defined type.  The name, base classes (a tuple of type
            objects), and a dictionary of members is provided.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(System.Type)">
            <summary>
            Creates a new PythonType object which is backed by the specified .NET type for
            storage.  The type is considered a system type which can not be modified
            by the user.
            </summary>
            <param name="underlyingSystemType"></param>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.PythonType,System.String,System.Func{System.String,System.Exception})">
            <summary>
            Creates a new PythonType which is a subclass of the specified PythonType.
            
            Used for runtime defined new-style classes which require multiple inheritance.  The
            primary example of this is the exception system.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.PythonType[],System.String)">
            <summary>
            Creates a new PythonType which is a subclass of the specified PythonTypes.
            
            Used for runtime defined new-style classes which require multiple inheritance.  The
            primary example of this is the exception system.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.PythonType[],System.Type,System.String,System.Func{System.String,System.Exception})">
            <summary>
            Creates a new PythonType which is a subclass of the specified PythonTypes.
            
            Used for runtime defined new-style classes which require multiple inheritance.  The
            primary example of this is the exception system.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
            <summary>
            Creates a new PythonType which is a subclass of the specified PythonType.
            
            Used for runtime defined new-style classes which require multiple inheritance.  The
            primary example of this is the exception system.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType[],System.String,System.String,System.String)">
            <summary>
            Creates a new PythonType which is a subclass of the specified PythonTypes.
            
            Used for runtime defined new-style classes which require multiple inheritance.  The
            primary example of this is the exception system.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType[],System.Type,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
            <summary>
            Creates a new PythonType which is a subclass of the specified PythonTypes.
            
            Used for runtime defined new-style classes which require multiple inheritance.  The
            primary example of this is the exception system.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.OldClass)">
            <summary>
            Creates a new PythonType object which represents an Old-style class.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Types.PythonType.TypeFlagHeapType">
            <summary>
            Used in copy_reg which is the only consumer of __flags__ in the standard library.
            
            Set if the type is user defined
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Types.PythonType.TypeFlagAbstractMethodsDefined">
            <summary>
            Set if the type has __abstractmethods__ defined
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.IsIterable(IronPython.Runtime.CodeContext)">
            <summary>
            Check whether the current type is iterabel
            </summary>
            <param name="context"></param>
            <returns>True if it is iterable</returns>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.__instancecheck__(System.Object)">
            <summary>
            Returns true if the specified object is an instance of this type.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonType.Name">
            <summary>
            Gets the name of the dynamic type
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonType.ResolutionOrder">
            <summary>
            Gets the resolution order used for attribute lookup
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.GetPythonType(System.Type)">
            <summary>
            Gets the dynamic type that corresponds with the provided static type. 
            
            Returns null if no type is available.  TODO: In the future this will
            always return a PythonType created by the DLR.
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.SetPythonType(System.Type,IronPython.Runtime.Types.PythonType)">
            <summary>
            Sets the python type that corresponds with the provided static type.
            
            This is used for built-in types which have a metaclass.  Currently
            only used by ctypes.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext)">
            <summary>
            Allocates the storage for the instance running the .NET constructor.  This provides
            the creation functionality for __new__ implementations.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Allocates the storage for the instance running the .NET constructor.  This provides
            the creation functionality for __new__ implementations.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object,System.Object)">
            <summary>
            Allocates the storage for the instance running the .NET constructor.  This provides
            the creation functionality for __new__ implementations.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object)">
            <summary>
            Allocates the storage for the instance running the .NET constructor.  This provides
            the creation functionality for __new__ implementations.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object[])">
            <summary>
            Allocates the storage for the instance running the .NET constructor.  This provides
            the creation functionality for __new__ implementations.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object[],System.String[])">
            <summary>
            Allocates the storage for the instance running the .NET constructor.  This provides
            the creation functionality for __new__ implementations.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonType.UnderlyingSystemType">
            <summary>
            Gets the underlying system type that is backing this type.  All instances of this
            type are an instance of the underlying system type.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonType.ExtensionType">
            <summary>
            Gets the extension type for this type.  The extension type provides
            a .NET type which can be inherited from to extend sealed classes
            or value types which Python allows inheritance from.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonType.BaseTypes">
            <summary>
            Gets the base types from which this type inherits.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.IsSubclassOf(IronPython.Runtime.Types.PythonType)">
            <summary>
            Returns true if this type is a subclass of other
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonType.IsSystemType">
            <summary>
            True if the type is a system type.  A system type is a type which represents an
            underlying .NET type and not a subtype of one of these types.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.TryLookupSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
            <summary>
            Looks up a slot on the dynamic type
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.TryResolveSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
            <summary>
            Searches the resolution order for a slot matching by name
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.TryResolveMixedSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
            <summary>
            Searches the resolution order for a slot matching by name.
            
            Includes searching for methods in old-style classes
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.AddSlot(System.String,IronPython.Runtime.Types.PythonTypeSlot)">
            <summary>
            Internal helper to add a new slot to the type
            </summary>
            <param name="name"></param>
            <param name="slot"></param>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.TryGetMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
            <summary>
            Gets a value from a dynamic type and any sub-types.  Values are stored in slots (which serve as a level of 
            indirection).  This searches the types resolution order and returns the first slot that
            contains the value.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.TryGetNonCustomMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
            <summary>
            Attempts to lookup a member w/o using the customizer.  Equivelent to object.__getattribute__
            but it doens't throw an exception.
            </summary>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.TryGetBoundMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
            <summary>
            Gets a value from a dynamic type and any sub-types.  Values are stored in slots (which serve as a level of 
            indirection).  This searches the types resolution order and returns the first slot that
            contains the value.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.TryGetNonCustomBoundMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
            <summary>
            Attempts to lookup a member w/o using the customizer.
            </summary>
            <returns></returns>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.TrySetMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object)">
            <summary>
            Sets a value on an instance.  If a slot is available in the most derived type the slot
            is set there, otherwise the value is stored directly in the instance.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.TrySetNonCustomMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object)">
            <summary>
            Attempst to set a value w/o going through the customizer.
            
            This enables languages to provide the "base" implementation for setting attributes
            so that the customizer can call back here.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.GetMemberNames(IronPython.Runtime.CodeContext)">
            <summary>
            Returns a list of all slot names for the type and any subtypes.
            </summary>
            <param name="context">The context that is doing the inquiry of InvariantContext.Instance.</param>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.GetMemberNames(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Returns a list of all slot names for the type, any subtypes, and the instance.
            </summary>
            <param name="context">The context that is doing the inquiry of InvariantContext.Instance.</param>
            <param name="self">the instance to get instance members from, or null.</param>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.AddUserTypeMembers(IronPython.Runtime.CodeContext,System.Collections.Generic.Dictionary{System.String,System.String},IronPython.Runtime.Types.PythonType,IronPython.Runtime.List)">
            <summary>
            Adds members from a user defined type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.AddInstanceMembers(System.Object,System.Collections.Generic.Dictionary{System.String,System.String},IronPython.Runtime.List)">
            <summary>
            Adds members from a user defined type instance
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.__clrtype__">
            <summary>
            Gets the .NET type which is used for instances of the Python type.
            
            When overridden by a metaclass enables a customization of the .NET type which
            is used for instances of the Python type.  Meta-classes can construct custom
            types at runtime which include new .NET methods, fields, custom attributes or
            other features to better interoperate with .NET.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.InitializeSystemType">
            <summary>
            Initializes a PythonType that represents a standard .NET type.  The same .NET type
            can be shared with the Python type system.  For example object, string, int,
            etc... are all the same types.  
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.AddSystemConstructors">
            <summary>
            Creates a __new__ method for the type.  If the type defines interesting constructors
            then the __new__ method will call that.  Otherwise if it has only a single argless
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.GetNextVersion">
            <summary>
            This will return a unique integer for every version of every type in the system.
            This means that DynamicSite code can generate a check to see if it has the correct
            PythonType and version with a single integer compare.
            
            TODO - This method and related code should fail gracefully on overflow.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.AddSubType(IronPython.Runtime.Types.PythonType)">
            <summary>
            Internal helper function to add a subtype
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonType.SubTypes">
            <summary>
            Gets a list of weak references to all the subtypes of this class.  May return null
            if there are no subtypes of the class.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Types.PythonType.PythonTypeAttributes.SystemCtor">
            <summary>
            The type has a ctor which does not accept PythonTypes.  This is used
            for user defined types which implement __clrtype__
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.GetSharedWeakReference">
            <summary>
            Returns a CLR WeakReference object to this PythonType that can be shared
            between anyone who needs a weak reference to the type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.IronPython#Runtime#Binding#IFastInvokable#MakeInvokeBinding``1(System.Runtime.CompilerServices.CallSite{``0},IronPython.Runtime.Binding.PythonInvokeBinder,IronPython.Runtime.CodeContext,System.Object[])">
            <summary>
            Implements fast binding for user defined types.  This ensures that common highly dynamic
            scenarios will run fast (for instance creating new types repeatedly and only creating a limited
            number of instances of them).  It also gives better code sharing amongst different subclasses
            of the same types and improved startup time due to reduced code generation.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonType.FastBindingBuilderBase">
            <summary>
            Base class for doing fast type invoke binding.  Subclasses are created using
            reflection once during the binding.  The subclasses can then proceed to do
            the binding w/o using reflection.  Otherwise we'd have lots more reflection
            calls which would slow the binding up.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonType.FastBindingBuilderBase.GetOrCreateFastNew">
            <summary>
            Gets or creates delegate for calling the constructor function.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.LateBoundInitBinder">
            <summary>
            Used when a type overrides __new__ with a Python function or other object
            that can return an arbitrary value.  If the return value is not the same type
            as the type which had __new__ then we need to lookup __init__ on the type
            and invoke it.  Also handles initialization for finalization when __del__
            is defined for the same reasons.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.LateBoundInitBinder.Bind(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
            <summary>
            target is the newly initialized value.
            args are the arguments to be passed to __init__
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeDictSlot">
            <summary>
            Provides a slot object for the dictionary to allow setting of the dictionary.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo">
            <summary>
            Helpers for interacting w/ .NET types.  This includes:
            
                Member resolution via GetMember/GetMembers.  This performs a member lookup which includes the registered
                    extension types in the PythonBinder.  Internally the class has many MemberResolver's which provide
                    the various resolution behaviors.  
                
                Cached member access - this is via static classes such as Object and provides various MemberInfo's so we're
                    not constantly looking up via reflection.
            </summary>
        </member>
        <member name="F:IronPython.Runtime.Types.PythonTypeInfo._resolvers">
            <summary> list of resolvers which we run to resolve items </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMemberAll(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
            <summary>
            Gets the statically known member from the type with the specific name.  Searches the entire type hierarchy to find the specified member.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMembersAll(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
            <summary>
            Gets all the statically known members from the specified type.  Searches the entire type hierarchy to get all possible members.
            
            The result may include multiple resolution.  It is the callers responsibility to only treat the 1st one by name as existing.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMember(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
            <summary>
            Gets the statically known member from the type with the specific name.  Searches only the specified type to find the member.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMembers(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
            <summary>
            Gets all the statically known members from the specified type.  Searches only the specified type to find the members.
            
            The result may include multiple resolution.  It is the callers responsibility to only treat the 1st one by name as existing.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver">
            <summary>
            Abstract class used for resolving members.  This provides two methods of member look.  The first is looking
            up a single member by name.  The other is getting all of the members.
            
            There are various subclasses of this which have different methods of resolving the members.  The primary
            function of the resolvers are to provide the name->value lookup.  They also need to provide a simple name
            enumerator.  The enumerator is kept simple because it's allowed to return duplicate names as well as return
            names of members that don't exist.  The base MemberResolver will then verify their existance as well as 
            filter duplicates.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver.ResolveMember(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
            <summary>
            Looks up an individual member and returns a MemberGroup with the given members.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver.ResolveMembers(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
            <summary>
            Returns a list of members that exist on the type.  The ResolvedMember structure indicates both
            the name and provides the MemberGroup.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver.GetCandidateNames(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
            <summary>
            Returns a list of possible members which could exist.  ResolveMember needs to be called to verify their existance. Duplicate
            names can also be returned.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.OneOffResolver">
            <summary>
            One off resolver for various special methods which are known by name.  A delegate is provided to provide the actual member which
            will be resolved.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.StandardResolver">
            <summary>
            Standard resolver for looking up .NET members.  Uses reflection to get the members by name.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.EqualityResolver">
            <summary>
            Resolves methods mapped to __eq__ and __ne__ from IStructuralEquatable.Equals
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.ComparisonResolver">
            <summary>
            Resolves methods mapped to __gt__, __lt__, __ge__, __le__, as well as providing an alternate resolution
            for __eq__ and __ne__, from the comparable type's CompareTo method.
            
            This should be run after the EqualityResolver.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.OperatorResolver">
            <summary>
            Resolves methods mapped to __*__ methods automatically from the .NET operator.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.OperatorResolver.FilterAlternateMethods(IronPython.Runtime.Types.OperatorMapping,Microsoft.Scripting.Actions.MemberGroup)">
            <summary>
            Filters alternative methods out that don't match the expected signature and therefore
            are just sharing a common method name.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.OperatorResolver.FilterObjectEquality(Microsoft.Scripting.Actions.MemberGroup)">
            <summary>
            Removes Object.Equals methods as we never return these for PythonOperationKind.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.PrivateBindingResolver">
            <summary>
            Provides bindings to private members when that global option is enabled.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.ProtectedMemberResolver">
            <summary>
            Provides resolutions for protected members that haven't yet been
            subclassed by NewTypeMaker.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MakeResolverTable">
            <summary>
            Creates the resolver table which includes all the possible resolutions.
            </summary>
            <returns></returns>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.ComplexResolver">
            <summary>
            Provides a resolution for __complex__
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.FloatResolver">
            <summary>
            Provides a resolution for __float__
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.IntResolver">
            <summary>
            Provides a resolution for __int__
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.BigIntegerResolver">
            <summary>
            Provides a resolution for __long__
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.GetItemResolver">
            <summary>
            Provides a resolution for __getitem__
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.SetItemResolver">
            <summary>
            Provides a resolution for __setitem__
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.StringResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
            <summary>
            Provides a resolution for __str__.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.ReprResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
            <summary>
            Provides a resolution for __repr__
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.TypeOverridesMethod(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type,System.String)">
            <summary>
            Helper to see if the type explicitly overrides the method.  This ignores members
            defined on object.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.HashResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
            <summary>
            Provides a resolution for __hash__ looking for IStructuralEquatable.GetHashCode.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.NewResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
            <summary>
            Provides a resolution for __new__.  For standard .NET types __new__ resolves to their
            constructor.  For Python types they inherit __new__ from their base class.
            
            TODO: Can we just always fallback to object.__new__?  If not why not?
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.NextResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
            <summary>
            Provides a resolution for next
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.LengthResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
            <summary>
            Provides a resolution for __len__
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.IterResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
            <summary>
            Provides a resolution for __iter__
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.FallbackInequalityResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
            <summary>
            Looks for an Equals overload defined on the type and if one is present binds __ne__ to an
            InstanceOps helper.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.ContainsResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
            <summary>
            Provides an implementation of __contains__.  We can pull contains from:
                ICollection of T which defines Contains directly
                IList which defines Contains directly
                IDictionary which defines Contains directly
                IDictionary of K,V which defines Contains directly
                IEnumerable of K which we have an InstaceOps helper for
                IEnumerable which we have an instance ops helper for
                IEnumerator of K which we have an InstanceOps helper for
                IEnumerator which we have an instance ops helper for
                
            String is ignored here because it defines __contains__ via extension methods already.
                
            The lookup is well ordered and not dependent upon the order of values returned by reflection.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetEnumeratorContains(System.Type,System.Collections.Generic.IList{System.Type},System.Collections.Generic.List{Microsoft.Scripting.Actions.MemberTracker}@,System.Boolean@,System.Type,System.Type,System.String)">
            <summary>
            Helper for IEnumerable/IEnumerator __contains__ 
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.MemberBinder">
            <summary>
            Base class used for resolving a name into a member on the type.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberBinder.GetBaseInstanceMethod(System.Type,System.String[])">
            <summary>
            Gets an instance op method for the given type and name.
            
            Instance ops methods appaer on the base most class that's required to expose it.  So
            if we have: Array[int], Array, object we'd only add an instance op method to Array and
            Array[int] inherits it.  It's obviously not on object because if it was there we'd just
            put the method in ObjectOps.
            
            Therefore the different binders expose this at the appropriate times.  
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.ResolveBinder">
            <summary>
            MemberBinder which searches the entire type hierarchy and their extension types to find a member.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.LookupBinder">
            <summary>
            MemberBinder which searches only the current type and it's extension types to find a member.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMemberGroup(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
            <summary>
            Primary worker for getting the member(s) associated with a single name.  Can be called with different MemberBinder's to alter the
            scope of the search.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetResolvedMembers(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
            <summary>
            Primary worker for returning a list of all members in a type.  Can be called with different MemberBinder's to alter the scope
            of the search.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetInstanceOpsMethod(System.Type,System.String[])">
            <summary>
            Helper to get a MemberGroup for methods declared on InstanceOps
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.FindCastMethod(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type,System.Collections.Generic.List{System.Type})">
            <summary>
            Helper to get the proper typecasting method, according to the following precedence rules:
            
            1. Strongest (most specific) declaring type
            2. Strongest (most specific) parameter type
            3. Type of conversion
                i.  Implicit
                ii. Explicit
            4. Return type (order specified in toTypes)
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MakeConversionResolver(System.Collections.Generic.List{System.Type})">
            <summary>
            Helper for creating a typecast resolver
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MakeIndexerResolver(System.Boolean)">
            <summary>
            Helper for creating __getitem__/__setitem__ resolvers
            </summary>
            <param name="set">false for a getter, true for a setter</param>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.IncludeOperatorMethod(System.Type,IronPython.Runtime.Binding.PythonOperationKind)">
            <summary>
            Filters out methods which are present on standard .NET types but shouldn't be there in Python
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.FilterFieldAndEvent(Microsoft.Scripting.Actions.MemberGroup)">
            <summary>
            When private binding is enabled we can have a collision between the private Event
            and private field backing the event.  We filter this out and favor the event.
            
            This matches the v1.0 behavior of private binding.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.ProtectedOnly(System.Reflection.MemberInfo)">
            <summary>
            Filters down to include only protected methods
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.FilterForwardReverseMethods(System.String,Microsoft.Scripting.Actions.MemberGroup,System.Type,IronPython.Runtime.Binding.PythonOperationKind)">
            <summary>
            If an operator is a reverisble operator (e.g. addition) then we need to filter down to just the forward/reverse
            versions of the .NET method.  For example consider:
            
                String.op_Multiplication(int, string)
                String.op_Multiplication(string, int)
                
            If this method were defined on string it defines that you can do:
                2 * 'abc'
              or:
                'abc' * 2
                
            either of which will produce 'abcabc'.  The 1st form is considered the reverse form because it is declared on string
            but takes a non-string for the 1st argument.  The 2nd is considered the forward form because it takes a string as the
            1st argument.
            
            When dynamically dispatching for 2 * 'abc' we'll first try __mul__ on int, which will fail with a string argument.  Then we'll try
            __rmul__ on a string which will succeed and dispatch to the (int, string) overload.
            
            For multiplication in this case it's not too interesting because it's commutative.  For addition this might be more interesting
            if, for example, we had unicode and ASCII strings.  In that case Unicode strings would define addition taking both unicode and
            ASCII strings in both forms.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.AreTypesCompatible(System.Type,System.Type)">
            <summary>
            Checks to see if the parameter type and the declaring type are compatible to determine
            if an operator is forward or reverse.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.IsPythonRecognizedOperator(System.String)">
            <summary>
            Checks to see if this is an operator method which Python recognizes.  For example
            op_Comma is not recognized by Python and therefore should exposed to the user as
            a method that is callable by name.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.PythonTypeSlot">
            <summary>
            A TypeSlot is an item that gets stored in a type's dictionary.  Slots provide an 
            opportunity to customize access at runtime when a value is get or set from a dictionary.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeSlot.TryGetValue(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.Types.PythonType,System.Object@)">
            <summary>
            Gets the value stored in the slot for the given instance binding it to an instance if one is provided and
            the slot binds to instances.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeSlot.TrySetValue(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.Types.PythonType,System.Object)">
            <summary>
            Sets the value of the slot for the given instance.
            </summary>
            <returns>true if the value was set, false if it can't be set</returns>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeSlot.TryDeleteValue(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.Types.PythonType)">
            <summary>
            Deletes the value stored in the slot from the instance.
            </summary>
            <returns>true if the value was deleted, false if it can't be deleted</returns>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonTypeSlot.CanOptimizeGets">
            <summary>
            True if generating code for gets can result in more optimal accesses.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.PythonTypeSlot.MakeGetExpression(IronPython.Runtime.Binding.PythonBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject,IronPython.Runtime.Binding.ConditionalBuilder)">
            <summary>
            Gets an expression which is used for accessing this slot.  If the slot lookup fails the error expression
            is used again.
            
            The default implementation just calls the TryGetValue method.  Subtypes of PythonTypeSlot can override
            this and provide a more optimal implementation.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.PythonTypeSlot.GetAlwaysSucceeds">
            <summary>
            True if TryGetValue will always succeed, false if it may fail.
            
            This is used to optimize away error generation code.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.ReflectedEvent">
            <summary>
            The unbound representation of an event property
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.ReflectedEvent.BoundEvent">
            <summary>
            BoundEvent is the object that gets returned when the user gets an event object.  An
            BoundEvent tracks where the event was received from and is used to verify we get
            a proper add when dealing w/ statics events.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.ReflectedExtensionProperty">
            <summary>
            Represents a ReflectedProperty created for an extension method.  Logically the property is an
            instance property but the method implementing it is static.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.ReflectedField.GetValue(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Convenience function for users to call directly
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.ReflectedField.SetValue(IronPython.Runtime.CodeContext,System.Object,System.Object)">
            <summary>
            This function can be used to set a field on a value type without emitting a warning. Otherwise it is provided only to have symmetry with properties which have GetValue/SetValue for supporting explicitly implemented interfaces.
            
            Setting fields on value types usually warns because it can silently fail to update the value you expect.  For example consider this example where Point is a value type with the public fields X and Y:
            
            arr = System.Array.CreateInstance(Point, 10)
            arr[0].X = 42
            print arr[0].X
            
            prints 0.  This is because reading the value from the array creates a copy of the value.  Setting the value then mutates the copy and the array does not get updated.  The same problem exists when accessing members of a class.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.ReflectedGetterSetter">
            <summary>
            Base class for properties backed by methods.  These include our slot properties,
            indexers, and normal properties.  This class provides the storage of these as well
            as the storage of our optimized getter/setter methods, documentation for the property,
            etc...
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.ReflectedIndexer">
            <summary>
            Provides access to non-default .NET indexers (aka properties w/ parameters).
            
            C# doesn't support these, but both COM and VB.NET do.  The types dictionary
            gets populated w/a ReflectedGetterSetter indexer which is a descriptor.  Getting
            the descriptor returns a bound indexer.  The bound indexer supports indexing.
            We support multiple indexer parameters via expandable tuples.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.ReflectedProperty.CanOptimizeGets">
            <summary>
            True if generating code for gets can result in more optimal accesses.
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.ReflectedProperty.GetValue(IronPython.Runtime.CodeContext,System.Object)">
            <summary>
            Convenience function for users to call directly
            </summary>
        </member>
        <member name="M:IronPython.Runtime.Types.ReflectedProperty.SetValue(IronPython.Runtime.CodeContext,System.Object,System.Object)">
            <summary>
            Convenience function for users to call directly
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.ReflectedSlotProperty">
            <summary>
            Represents a member of a user-defined type which defines __slots__.  The names listed in
            __slots__ have storage allocated for them with the type and provide fast get/set access.
            </summary>
        </member>
        <member name="P:IronPython.Runtime.Types.ReflectedSlotProperty.Index">
            <summary>
            Gets the index into the object array to be used for the slot storage.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.ResolvedMember">
            <summary>
            Couples a MemberGroup and the name which produces the member group together
            </summary>
        </member>
        <member name="T:IronPython.Runtime.Types.SlotFieldAttribute">
            <summary>
            Represents an ops-extension which adds a new slot.  The slot can have arbitrary
            get/set behavior above and beyond normal .NET methods or properties.  This is
            typically in regards to how it processes access from instances or subtypes.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.WeakRefTracker">
            <summary>
            single finalizable instance used to track and deliver all the 
            callbacks for a single object that has been weakly referenced by
            one or more references and proxies.  The reference to this object
            is held in objects that implement IWeakReferenceable.
            </summary>
        </member>
        <member name="T:IronPython.Runtime.InstanceFinalizer">
            <summary>
            Finalizable object used to hook up finalization calls for OldInstances.
            
            We create one of these each time an object w/ a finalizer gets created.  The
            only reference to this object is the instance so when that goes out of context
            this does as well and this will get finalized.  
            </summary>
        </member>
        <member name="T:IronPython.Runtime.WrapperDescriptorAttribute">
            <summary>
            Marks a method/field/property as being a wrapper descriptor.  A wrapper desriptor
            is a member defined on PythonType but is available both for type and other
            instances of type.  For example type.__bases__.
            </summary>
        </member>
        <member name="T:IronPython.BytesConversionAttribute">
            <summary>
            For IList<byte/> arguments: Marks that the argument is typed to accept a bytes or
            bytearray object.  This attribute disallows passing a Python list object and
            auto-applying our generic conversion.  It also enables conversion of a string to
            a IList of byte in IronPython 2.6.
            
            For string arguments: Marks that the argument is typed to accept a bytes object
            as well. (2.6 only)
            </summary>
        </member>
        <member name="T:IronPython.DictionaryTypeInfoAttribute">
            <summary>
            Provides more specific type information for Python dictionaries which are not strongly typed.
            
            This attribute can be applied to fields, parameters, proeprties, and return values.  It can be
            inspected to get type information about the types of the keys and values of the expected 
            dictionary or the returned dictionary.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.Arguments">
            <summary>
            Gets the collection of command line arguments.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.Optimize">
            <summary>
             Should we strip out all doc strings (the -O command line option).
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.StripDocStrings">
            <summary>
             Should we strip out all doc strings (the -OO command line option).
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.WarningFilters">
            <summary>
             List of -W (warning filter) options collected from the command line.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.WarnPython30">
            <summary>
            Enables warnings related to Python 3.0 features.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.Python30">
            <summary>
            Enables 3.0 features that are implemented in IronPython.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.Debug">
            <summary>
            Enables debugging support.  When enabled a .NET debugger can be attached
            to the process to step through Python code.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.Inspect">
            <summary>
            Enables inspect mode.  After running the main module the REPL will be started
            within that modules context.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.NoUserSite">
            <summary>
            Suppresses addition of the user site directory.  This is ignored by IronPython
            except for updating sys.flags.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.NoSite">
            <summary>
            Disables import site on startup.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.IgnoreEnvironment">
            <summary>
            Ignore environment variables that configure the IronPython context.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.Verbose">
            <summary>
            Enables the verbose option which traces import statements.  This is ignored by IronPython
            except for setting sys.flags.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.RecursionLimit">
            <summary>
            Sets the maximum recursion depth.  Setting to Int32.MaxValue will disable recursion
            enforcement.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.Frames">
            <summary>
            Makes available sys._getframe.  Local variables will not be available in frames unless the
            function calls locals(), dir(), vars(), etc...  For ensuring locals are always available use
            the FullFrames option.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.FullFrames">
            <summary>
            Makes available sys._getframe.  All locals variables will live on the heap (for a considerable
            performance cost) enabling introspection of all code.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.Tracing">
            <summary>
            Tracing is always available.  Without this option tracing is only enabled when sys.settrace
            is called. This means code that was already running before sys.settrace will not be debuggable.
            
            With this option pdb.set_trace and pdb.post_mortem will always work properly.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.IndentationInconsistencySeverity">
            <summary> 
            Severity of a warning that indentation is formatted inconsistently.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.DivisionOptions">
            <summary>
            The division options (old, new, warn, warnall)
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.LightweightScopes">
            <summary>
            Forces all code to be compiled in a mode in which the code can be reliably collected by the CLR.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.EnableProfiler">
            <summary>
            Enable profiling code
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.NoDebug">
            <summary>
            Returns a regular expression of Python files which should not be emitted in debug mode.
            </summary>
        </member>
        <member name="P:IronPython.PythonOptions.PythonVersion">
            <summary>
            Gets the CPython version which IronPython will emulate.  Currently limited
            to either 2.6 or 3.0.
            </summary>
        </member>
    </members>
</doc>