unity-python/IronPython-2.7.10/Microsoft.Dynamic.xml at master · exodrifter/unity-python · GitHub

This repository was archived by the owner on Mar 9, 2026. It is now read-only.

History

7431 lines (7298 loc) · 404 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

<?xml version="1.0"?>

<doc>

<name>Microsoft.Dynamic</name>

</assembly>

Provides binding semantics for a language. This include conversions as well as support

for producing rules for actions. These optimized rules are used for calling methods,

performing operators, and getting members using the ActionBinder's conversion semantics.

</summary>

</member>

Determines if the binder should allow access to non-public members.

By default the binder does not allow access to non-public members. Base classes

can inherit and override this value to customize whether or not private binding

is available.

</summary>

</member>

Converts an object at runtime into the specified type.

</summary>

</member>

Determines if a conversion exists from fromType to toType at the specified narrowing level.

toNotNullable is true if the target variable doesn't allow null values.

</summary>

</member>

Provides ordering for two parameter types if there is no conversion between the two parameter types.

</summary>

</member>

Converts the provided expression to the given type. The expression is safe to evaluate multiple times.

</summary>

</member>

Gets the members that are visible from the provided type of the specified name.

The default implemetnation first searches the type, then the flattened heirachy of the type, and then

registered extension methods.

</summary>

</member>

Called when a set is attempting to assign to a field or property from a derived class through the base class.

The default behavior is to allow the assignment.

</summary>

</member>

Creates an ErrorInfo object when a static property is accessed from an instance member. The default behavior is throw

an exception indicating that static members properties be accessed via an instance. Languages can override this to

customize the exception, message, or to produce an ErrorInfo object which reads or writes to the property being accessed.

</summary>

<param name="tracker">The static property being accessed through an instance</param>

<param name="isAssignment">True if the user is assigning to the property, false if the user is reading from the property</param>

<param name="parameters">The parameters being used to access the property. This includes the instance as the first entry, any index parameters, and the

value being assigned as the last entry if isAssignment is true.</param>

</member>

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.

Deprecated, use the non-generic version instead

</summary>

</member>

Gets the extension members of the given name from the provided type. Base classes are also

searched for their extension members. Once any of the types in the inheritance hierarchy

provide an extension member the search is stopped.

</summary>

</member>

Gets the extension members of the given name from the provided type. Subclasses of the

type and their extension members are not searched.

</summary>

</member>

Provides an opportunity for languages to replace all MemberTracker's with their own type.

Alternatlely a language can expose MemberTracker's directly.

</summary>

<param name="memberTracker">The member which is being returned to the user.</param>

<param name="type">Tthe type which the memberTrack was accessed from</param>

</member>

TODO: Alternatively, it should be sufficient to remember indices for this, list, dict and block.

</summary>

</member>

Convention for an individual argument at a callsite.

Multiple different callsites can match against a single declaration.

Some argument kinds can be "unrolled" into multiple arguments, such as list and dictionary.

</summary>

</member>

Simple unnamed positional argument.

In Python: foo(1,2,3) are all simple arguments.

</summary>

</member>

Argument with associated name at the callsite

In Python: foo(a=1)

</summary>

</member>

Argument containing a list of arguments.

In Python: foo(*(1,2*2,3)) would match 'def foo(a,b,c)' with 3 declared arguments such that (a,b,c)=(1,4,3).

it could also match 'def foo(*l)' with 1 declared argument such that l=(1,4,3)

</summary>

</member>

Argument containing a dictionary of named arguments.

In Python: foo(**{'a':1, 'b':2})

</summary>

</member>

Richly represents the signature of a callsite.

</summary>

</member>

Array of additional meta information about the arguments, such as named arguments.

Null for a simple signature that's just an expression list. eg: foo(a*b,c,d)

</summary>

</member>

Number of arguments in the signature.

</summary>

</member>

All arguments are unnamed and matched by position.

</summary>

</member>

True if the OldCallAction includes an ArgumentInfo of ArgumentKind.Dictionary or ArgumentKind.Named.

</summary>

</member>

Gets the number of positional arguments the user provided at the call site.

</summary>

</member>

Gets the index into _args array indicating the first post-splat argument or -1 of there are no splatted arguments.

For call site f(a,b,*c,d) and preSplatLimit == 1 and postSplatLimit == 2

args would be (a,b,c[0],c[n-2],c[n-1],d) with splat index 3, where n = c.Count.

</summary>

</member>

The number of arguments not counting the collapsed ones.

</summary>

</member>

Gets the number of hidden arguments (used for error reporting).

</summary>

</member>

Gets the total number of visible arguments passed to the call site including collapsed ones.

</summary>

</member>

Binds named arguments to the parameters. Returns a permutation of indices that captures the relationship between

named arguments and their corresponding parameters. Checks for duplicate and unbound named arguments.

Ensures that for all i: namedArgs[i] binds to parameters[args.Length + bindingPermutation[i]]

</summary>

</member>

ArgBuilder provides an argument value used by the MethodBinder. One ArgBuilder exists for each

physical parameter defined on a method.

Contrast this with ParameterWrapper which represents the logical argument passed to the method.

</summary>

</member>

Gets the priority.

</summary>

</member>

The number of actual arguments consumed by this builder.

</summary>

</member>

Provides the Expression which provides the value to be passed to the argument.

If <c>null</c> is returned the argument is skipped (not passed to the callee).

</summary>

</member>

Returns the type required for the argument or null if the ArgBuilder

does not consume a type.

</summary>

</member>

Provides an Expression which will update the provided value after a call to the method. May

return null if no update is required.

</summary>

</member>

If the argument produces a return value (e.g. a ref or out value) this provides

the additional value to be returned.

</summary>

</member>

An assignable value that is passed to a byref parameter

After the call it will contain the updated value

</summary>

</member>

Indicates the specific type of failure, if any, from binding to a method.

</summary>

</member>

The binding succeeded. Only one method was applicable or had the best conversion.

</summary>

</member>

More than one method was applicable for the provided parameters and no method was considered the best.

</summary>

</member>

There are no overloads that match the number of parameters required for the call

</summary>

</member>

None of the target method(s) can successfully be called. The failure can be due to:

1. Arguments could not be successfully converted for the call

2. Keyword arguments could not be assigned to positional arguments

3. Keyword arguments could be assigned but would result in an argument being assigned

multiple times (keyword and positional arguments conflit or dupliate keyword arguments).

</summary>

</member>

Actual arguments cannot be constructed.

</summary>

</member>

No method is callable. For example, all methods have an unbound generic parameter.

</summary>

</member>

Encapsulates the result of an attempt to bind to one or methods using the OverloadResolver.

Users should first check the Result property to see if the binding was successful or

to determine the specific type of failure that occured. If the binding was successful

MakeExpression can then be called to create an expression which calls the method.

If the binding was a failure callers can then create a custom error message based upon

the reason the call failed.

</summary>

</member>

Creates a new BindingTarget when the method binding has succeeded.

</summary>

</member>

Creates a new BindingTarget when the method binding has failed due to an incorrect argument count

</summary>

</member>

Creates a new BindingTarget when the method binding has failued due to

one or more parameters which could not be converted.

</summary>

</member>

Creates a new BindingTarget when the match was ambiguous

</summary>

</member>

Other failure.

</summary>

</member>

Gets the result of the attempt to bind.

</summary>

</member>

Gets an Expression which calls the binding target if the method binding succeeded.

Throws InvalidOperationException if the binding failed.

</summary>

</member>

Returns the method if the binding succeeded, or null if no method was applicable.

</summary>

</member>

Returns the selected overload if the binding succeeded, or null if no one was applicable.

</summary>

</member>

Gets the name of the method as supplied to the OverloadResolver.

</summary>

</member>

Returns the MethodTarget if the binding succeeded, or null if no method was applicable.

</summary>

</member>

Returns the methods which don't have any matches or null if Result == BindingResult.AmbiguousMatch

</summary>

</member>

Returns the methods and their associated conversion failures if Result == BindingResult.CallFailure.

</summary>

</member>

Returns the acceptable number of arguments which can be passed to the method if Result == BindingResult.IncorrectArgumentCount.

</summary>

</member>

Returns the total number of arguments provided to the call. 0 if the call succeeded or failed for a reason other

than argument count mismatch.

</summary>

</member>

Gets the MetaObjects which we originally did binding against in their restricted form.

The members of the array correspond to each of the arguments. All members of the array

have a value.

</summary>

</member>

Returns the return type of the binding, or null if no method was applicable.

</summary>

</member>

Gets the NarrowingLevel of the method if the call succeeded.

If the call failed returns NarrowingLevel.None.

</summary>

</member>

Returns true if the binding was succesful, false if it failed.

This is an alias for BindingTarget.Result == BindingResult.Success.

</summary>

</member>

Represents the reason why a call to a specific method could not be performed by the OverloadResolver.

The reason for the failure is specified by the CallFailureReason property. Once this property

has been consulted the other properties can be consulted for more detailed information regarding

the failure.

If reason is ConversionFailure the ConversionResults property will be non-null.

If reason is UnassignableKeyword the KeywordArguments property will be non-null and include

the keywords which could not be assigned.

If reason is DuplicateKeyword the KeywordArguments property will be non-null and include

the keywords which were duplicated (either by the keywords themselves or by positional

arguments).

MethodTarget is always set and indicates the method which failed to bind.

</summary>

</member>

Gets the MethodTarget which the call failed for.

</summary>

</member>

Gets the reason for the call failure which determines the other

properties of the CallFailure which should be consulted.

</summary>

</member>

Gets a list of ConversionResult's for each parameter indicating

whether the conversion was successful or failed and the types

being converted.

</summary>

</member>

Gets the list of keyword arguments that were either dupliated or

unassignable.

</summary>

</member>

Default value, their was no CallFailure.

</summary>

</member>

One of more parameters failed to be converted

</summary>

</member>

One or more keyword arguments could not be successfully assigned to a positional argument

</summary>

</member>

One or more keyword arguments were duplicated or would have taken the spot of a

provided positional argument.

</summary>

</member>

Type arguments could not be inferred

</summary>

</member>

Represents a collection of MethodCandidate's which all accept the

same number of logical parameters. For example a params method

and a method with 3 parameters would both be a CandidateSet for 3 parameters.

</summary>

</member>

Represents information about a failure to convert an argument from one

type to another.

</summary>

</member>

Value of the argument or null if it is not available.

</summary>

</member>

Argument actual type or its limit type if the value not known.

DynamicNull if the argument value is null.

</summary>

</member>

ArgBuilder which provides a default parameter value for a method call.

</summary>

</member>

The number of actual arguments consumed by this builder.

</summary>

</member>

ArgBuilder which provides a value for a keyword argument.

The KeywordArgBuilder calculates its position at emit time using it's initial

offset within the keyword arguments, the number of keyword arguments, and the

total number of arguments provided by the user. It then delegates to an

underlying ArgBuilder which only receives the single correct argument.

Delaying the calculation of the position to emit time allows the method binding to be

done without knowing the exact the number of arguments provided by the user. Hence,

the method binder can be dependent only on the set of method overloads and keyword names,

but not the user arguments. While the number of user arguments could be determined

upfront, the current MethodBinder does not have this design.

</summary>

</member>

The underlying builder should expect a single parameter as KeywordArgBuilder is responsible

for calculating the correct parameter to use

</summary>

</member>

Updates fields/properties of the returned value with unused keyword parameters.

</summary>

</member>

MethodCandidate represents the different possible ways of calling a method or a set of method overloads.

A single method can result in multiple MethodCandidates. Some reasons include:

- Every optional parameter or parameter with a default value will result in a candidate

- The presence of ref and out parameters will add a candidate for languages which want to return the updated values as return values.

- ArgumentKind.List and ArgumentKind.Dictionary can result in a new candidate per invocation since the list might be different every time.

Each MethodCandidate represents the parameter type for the candidate using ParameterWrapper.

</summary>

</member>

Builds a new MethodCandidate which takes count arguments and the provided list of keyword arguments.

The basic idea here is to figure out which parameters map to params or a dictionary params and

fill in those spots w/ extra ParameterWrapper's.

</summary>

</member>

Narrowing conversions are conversions that cannot be proved to always succeed, conversions that are

known to possibly lose information, and conversions across domains of types sufficiently different

to merit narrowing notation like casts.

Its upto every language to define the levels for conversions. The narrowling levels can be used by

for method overload resolution, where the overload is based on the parameter types (and not the number

of parameters).

</summary>

</member>

Conversions at this level do not do any narrowing. Typically, this will include

implicit numeric conversions, Type.IsAssignableFrom, StringBuilder to string, etc.

</summary>

</member>

Language defined prefered narrowing conversion. First level that introduces narrowing

conversions.

</summary>

</member>

Language defined preferred narrowing conversion. Second level that introduces narrowing

conversions and should have more conversions than One.

</summary>

</member>

Language defined preferred narrowing conversion. Third level that introduces narrowing

conversions and should have more conversions that Two.

</summary>

</member>

A somewhat meaningful conversion is possible, but it will quite likely be lossy.

For eg. BigInteger to an Int32, Boolean to Int32, one-char string to a char,

larger number type to a smaller numeric type (where there is no overflow), etc

</summary>

</member>

Builds the argument for an out argument when not passed a StrongBox. The out parameter

is returned as an additional return value.

</summary>

</member>

Defines a method overload abstraction for the purpose of overload resolution.

It provides the overload resolver the metadata it needs to perform the resolution.

</summary>

WARNING: This is a temporary API that will undergo breaking changes in future versions.

</remarks>

</member>

Null for constructors.

</summary>

</member>

The method arity can vary, i.e. the method has params array or params dict parameters.

</summary>

</member>

Represents a method overload that is bound to a <see cref="T:System.Reflection.MethodBase"/>.

</summary>

Not thread safe.

WARNING: This is a temporary API that will undergo breaking changes in future versions.

</remarks>

</member>

Provides binding and overload resolution to .NET methods.

MethodBinder's can be used for:

generating new AST code for calling a method

calling a method via reflection at runtime

(not implemented) performing an abstract call

MethodBinder's support default arguments, optional arguments, by-ref (in and out), and keyword arguments.

Implementation Details:

The MethodBinder works by building up a CandidateSet for each number of effective arguments that can be

passed to a set of overloads. For example a set of overloads such as:

foo(object a, object b, object c)

foo(int a, int b)

would have 2 target sets - one for 3 parameters and one for 2 parameters. For parameter arrays

we fallback and create the appropriately sized CandidateSet on demand.

Each CandidateSet consists of a set of MethodCandidate's. Each MethodCandidate knows the flattened

parameters that could be received. For example for a function such as:

foo(params int[] args)

When this method is in a CandidateSet of size 3 the MethodCandidate takes 3 parameters - all of them

ints; if it's in a CandidateSet of size 4 it takes 4 parameters. Effectively a MethodCandidate is

a simplified view that allows all arguments to be treated as required positional arguments.

Each MethodCandidate in turn refers to a MethodTarget. The MethodTarget is composed of a set

of ArgBuilder's and a ReturnBuilder which know how to consume the positional arguments and pass

them to the appropriate argument of the destination method. This includes routing keyword

arguments to the correct position, providing the default values for optional arguments, etc...

After binding is finished the MethodCandidates are thrown away and a BindingTarget is returned.

The BindingTarget indicates whether the binding was successful and if not any additional information

that should be reported to the user about the failed binding. It also exposes the MethodTarget which

allows consumers to get the flattened list of required parameters for the call. MethodCandidates

are not exposed and are an internal implementation detail of the MethodBinder.

</summary>

</member>

Resolves a method overload and returns back a BindingTarget.

The BindingTarget can then be tested for the success or particular type of

failure that prevents the method from being called. If successfully bound the BindingTarget

contains a list of argument meta-objects with additional restrictions that ensure the selection

of the particular overload.

</summary>

</member>

Checks to see if the language allows named arguments to be bound to instance fields or

properties and turned into setters. By default this is only allowed on contructors.

</summary>

</member>

Gets an expression that evaluates to the result of GetByRefArray operation.

</summary>

</member>

Allow to bind an array/dictionary instance or a null reference to params array/dictionary parameter.

</summary>

</member>

Called before arguments binding.

</summary>

A bitmask that indicates (set bits) the parameters that were mapped by this method.

A default mapping will be constructed for the remaining parameters (cleared bits).

</returns>

</member>

Return null if arguments cannot be constructed and overload resolution should produce an error.

</summary>

</member>

Determines whether given overloads are overloaded on index-th parameter (the types of the index-th parameters are the same).

</summary>

</member>

Selects the best (of two) candidates for conversion from actualType

</summary>

</member>

Provides ordering for two parameter types if there is no conversion between the two parameter types.

</summary>

</member>

The method is called each time an item of lazily splatted argument is needed.

</summary>

</member>

Gets the next argument to consume.

</summary>

</member>

Maps out parameters to return args and ref parameters to ones that don't accept StrongBox.

</summary>

</member>

ParameterWrapper represents the logical view of a parameter. For eg. the byref-reduced signature

of a method with byref parameters will be represented using a ParameterWrapper of the underlying

element type, since the logical view of the byref-reduced signature is that the argument will be

passed by value (and the updated value is included in the return value).

Contrast this with ArgBuilder which represents the real physical argument passed to the method.

</summary>

</member>

ParameterInfo is not available.

</summary>

</member>

True if the wrapper represents a params-array parameter (false for parameters created by expansion of a params-array).

</summary>

</member>

True if the wrapper represents a params-dict parameter (false for parameters created by expansion of a params-dict).

</summary>

</member>

Creates a parameter that represents an expanded item of params-array.

</summary>

</member>

Builds the parameter for a params dictionary argument - this collects all the extra name/value

pairs provided to the function into a SymbolDictionary which is passed to the function.

</summary>

</member>

An argument that the user wants to explicitly pass by-reference (with copy-in copy-out semantics).

The user passes a StrongBox[T] object whose value will get updated when the call returns.

</summary>

</member>

True if there are restrictions beyond just simple type restrictions

</summary>

</member>

Creates a ReturnBuilder

</summary>

<param name="returnType">the type the ReturnBuilder will leave on the stack</param>

</member>

Builds a parameter for a reference argument when a StrongBox has not been provided. The

updated return value is returned as one of the resulting return values.

</summary>

</member>

SimpleArgBuilder produces the value produced by the user as the argument value. It

also tracks information about the original parameter and is used to create extended

methods for params arrays and param dictionary functions.

</summary>

</member>

Parameter info is not available for this argument.

</summary>

</member>

Type and whether the parameter is a params-array or params-dictionary is derived from info.

</summary>

</member>

Gets the index of actual argument expression.

</summary>

</member>

Gets the generic arguments for method based upon the constraints discovered during

type inference. Returns null if not all generic arguments had their types inferred.

</summary>

</member>

Creates a new set of arg builders for the given generic method definition which target the new

parameters.

</summary>

</member>

Creates a new list of ParameterWrappers for the generic method replacing the old parameters with the new ones.

</summary>

</member>

Gets the generic type arguments sorted so that the type arguments

that are depended upon by other type arguments are sorted before

their dependencies.

</summary>

</member>

Checks to see if the x type parameter is dependent upon the y type parameter.

</summary>

</member>

Builds a mapping based upon generic parameter constraints between related generic

parameters. This is then used to sort the generic parameters so that we can process

the least dependent parameters first. For example given the method:

void Foo{T0, T1}(T0 x, T1 y) where T0 : T1

We need to first infer the type information for T1 before we infer the type information

for T0 so that we can ensure the constraints are correct.

</summary>

</member>

Returns a mapping from generic type parameter to the input DMOs which map to it.

</summary>

</member>

Adds any additional ArgumentInputs entries for the given object and parameter type.

</summary>

</member>

Walks the nested generic hierarchy to construct all of the generic parameters referred

to by this type. For example if getting the generic parameters for the x parameter on

the method:

void Foo{T0, T1}(Dictionary{T0, T1} x);

We would add both typeof(T0) and typeof(T1) to the list of generic arguments.

</summary>

</member>

Maps a single type parameter to the possible parameters and DynamicMetaObjects

we can get inference from. For example for the signature:

void Foo{T0, T1}(T0 x, T1 y, IList{T1} z);

We would have one ArgumentInput for T0 which holds onto the DMO providing the argument

value for x. We would also have one ArgumentInput for T1 which holds onto the 2 DMOs

for y and z. Associated with y would be a GenericParameterInferer and associated with

z would be a ConstructedParameterInferer.

</summary>

</member>

Provides generic type inference for a single parameter.

</summary>

For example:

M{T}(T x)

M{T}(IList{T} x)

M{T}(ref T x)

M{T}(T[] x)

M{T}(ref Dictionary{T,T}[] x)

</remarks>

</member>

Provides generic type inference for a single parameter.

</summary>

For example:

M{T}(T x)

M{T}(IList{T} x)

M{T}(ref T x)

M{T}(T[] x)

M{T}(ref Dictionary{T,T}[] x)

</remarks>

</member>

Checks if the constraints are violated by the given input for the specified generic method parameter.

This method must be supplied with a mapping for any dependent generic method type parameters which

this one can be constrained to. For example for the signature "void Foo{T0, T1}(T0 x, T1 y) where T0 : T1".

we cannot know if the constraints are violated unless we know what we have calculated T1 to be.

</summary>

</member>

Finds all occurences of <c>genericParameter</c> in <c>openType</c> and the corresponding concrete types in <c>closedType</c>.

Returns true iff all occurences of the generic parameter in the open type correspond to the same concrete type in the closed type

and this type satisfies given <c>constraints</c>. Returns the concrete type in <c>match</c> if so.

</summary>

</member>

Implemented by DynamicMetaObject subclasses when the associated object

can participate in generic method type inference. This interface

is used when the inference engine is attempting to perform type inference

for a parameter which is typed to a delegate type.

</summary>

</member>

Returns the type inferred for parameterType when performing

inference for a conversion to delegateType.

</summary>

</member>

Provides information about the result of a custom object which dynamically infers back types.

Currently only used for invokable objects to feedback the types for a delegate type.

</summary>

</member>

A tree rewriter which will find dynamic sites which consume dynamic sites and

turn them into a single combo dynamic site. The combo dynamic site will then run the

individual meta binders and produce the resulting code in a single dynamic site.

</summary>

</member>

A reducible node which we use to generate the combo dynamic sites. Each time we encounter

a dynamic site we replace it with a ComboDynamicSiteExpression. When a child of a dynamic site

turns out to be a ComboDynamicSiteExpression we will then merge the child with the parent updating

the binding mapping info. If any of the inputs cause side effects then we'll stop the combination.

</summary>

</member>

A binder which can combine multiple binders into a single dynamic site. The creator

of this needs to perform the mapping of parameters, constants, and sub-site expressions

and provide a List of BinderMappingInfo representing this data. From there the ComboBinder

just processes the list to create the resulting code.

</summary>

</member>

Provides a mapping for inputs of combo action expressions. The input can map

to either an input of the new dynamic site, an input of a previous DynamicExpression,

or a ConstantExpression which has been pulled out of the dynamic site arguments.

</summary>

</member>

Contains the mapping information for a single Combo Binder. This includes the original

meta-binder and the mapping of parameters, sub-sites, and constants into the binding.

</summary>

</member>

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>

View remainder of file in raw view

unity-python/IronPython-2.7.10/Microsoft.Dynamic.xml at master · exodrifter/unity-python · GitHub

Navigation Menu

Expand file tree

Breadcrumbs

Microsoft.Dynamic.xml

Latest commit

History

Breadcrumbs

Microsoft.Dynamic.xml

File metadata and controls

Footer

Footer navigation