mcs/class/dlr/Runtime/Microsoft.Scripting.Core/Utils/ExceptionFactory.Generated.cs

   1 /* ****************************************************************************
   2  *
   3  * Copyright (c) Microsoft Corporation.
   4  *
   5  * This source code is subject to terms and conditions of the Microsoft Public License. A
   6  * copy of the license can be found in the License.html file at the root of this distribution. If
   7  * you cannot locate the  Microsoft Public License, please send an email to
   8  * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
   9  * by the terms of the Microsoft Public License.
  10  *
  11  * You must not remove this notice, or any other, from this software.
  12  *
  13  *
  14  * ***************************************************************************/
  15 using System; using Microsoft;
  16
  17
  18 #if CODEPLEX_40
  19 namespace System.Linq.Expressions {
  20 #else
  21 namespace Microsoft.Linq.Expressions {
  22 #endif
  23
  24     internal static partial class Strings {
  25         private static string FormatString(string format, params object[] args) {
  26             return string.Format(System.Globalization.CultureInfo.CurrentCulture, format, args);
  27         }
  28     }
  29
  30     #region Generated Exception Factory
  31
  32     // *** BEGIN GENERATED CODE ***
  33     // generated by function: gen_expr_factory_core from: generate_exception_factory.py
  34
  35     /// <summary>
  36     ///    Strongly-typed and parameterized string factory.
  37     /// </summary>
  38
  39     internal static partial class Strings {
  40         /// <summary>
  41         /// A string like  "Method precondition violated"
  42         /// </summary>
  43         internal static string MethodPreconditionViolated {
  44             get {
  45                 return "Method precondition violated";
  46             }
  47         }
  48
  49         /// <summary>
  50         /// A string like  "Invalid argument value"
  51         /// </summary>
  52         internal static string InvalidArgumentValue {
  53             get {
  54                 return "Invalid argument value";
  55             }
  56         }
  57
  58         /// <summary>
  59         /// A string like  "Non-empty collection required"
  60         /// </summary>
  61         internal static string NonEmptyCollectionRequired {
  62             get {
  63                 return "Non-empty collection required";
  64             }
  65         }
  66
  67         /// <summary>
  68         /// A string like  "Argument count must be greater than number of named arguments."
  69         /// </summary>
  70         internal static string ArgCntMustBeGreaterThanNameCnt {
  71             get {
  72                 return "Argument count must be greater than number of named arguments.";
  73             }
  74         }
  75
  76         /// <summary>
  77         /// A string like  "reducible nodes must override Expression.Reduce()"
  78         /// </summary>
  79         internal static string ReducibleMustOverrideReduce {
  80             get {
  81                 return "reducible nodes must override Expression.Reduce()";
  82             }
  83         }
  84
  85         /// <summary>
  86         /// A string like  "node cannot reduce to itself or null"
  87         /// </summary>
  88         internal static string MustReduceToDifferent {
  89             get {
  90                 return "node cannot reduce to itself or null";
  91             }
  92         }
  93
  94         /// <summary>
  95         /// A string like  "cannot assign from the reduced node type to the original node type"
  96         /// </summary>
  97         internal static string ReducedNotCompatible {
  98             get {
  99                 return "cannot assign from the reduced node type to the original node type";
 100             }
 101         }
 102
 103         /// <summary>
 104         /// A string like  "Setter must have parameters."
 105         /// </summary>
 106         internal static string SetterHasNoParams {
 107             get {
 108                 return "Setter must have parameters.";
 109             }
 110         }
 111
 112         /// <summary>
 113         /// A string like  "Property cannot have a managed pointer type."
 114         /// </summary>
 115         internal static string PropertyCannotHaveRefType {
 116             get {
 117                 return "Property cannot have a managed pointer type.";
 118             }
 119         }
 120
 121         /// <summary>
 122         /// A string like  "Indexing parameters of getter and setter must match."
 123         /// </summary>
 124         internal static string IndexesOfSetGetMustMatch {
 125             get {
 126                 return "Indexing parameters of getter and setter must match.";
 127             }
 128         }
 129
 130         /// <summary>
 131         /// A string like  "Accessor method should not have VarArgs."
 132         /// </summary>
 133         internal static string AccessorsCannotHaveVarArgs {
 134             get {
 135                 return "Accessor method should not have VarArgs.";
 136             }
 137         }
 138
 139         /// <summary>
 140         /// A string like  "Accessor indexes cannot be passed ByRef."
 141         /// </summary>
 142         internal static string AccessorsCannotHaveByRefArgs {
 143             get {
 144                 return "Accessor indexes cannot be passed ByRef.";
 145             }
 146         }
 147
 148         /// <summary>
 149         /// A string like  "Bounds count cannot be less than 1"
 150         /// </summary>
 151         internal static string BoundsCannotBeLessThanOne {
 152             get {
 153                 return "Bounds count cannot be less than 1";
 154             }
 155         }
 156
 157         /// <summary>
 158         /// A string like  "type must not be ByRef"
 159         /// </summary>
 160         internal static string TypeMustNotBeByRef {
 161             get {
 162                 return "type must not be ByRef";
 163             }
 164         }
 165
 166         /// <summary>
 167         /// A string like  "Type doesn't have constructor with a given signature"
 168         /// </summary>
 169         internal static string TypeDoesNotHaveConstructorForTheSignature {
 170             get {
 171                 return "Type doesn't have constructor with a given signature";
 172             }
 173         }
 174
 175         /// <summary>
 176         /// A string like  "Count must be non-negative."
 177         /// </summary>
 178         internal static string CountCannotBeNegative {
 179             get {
 180                 return "Count must be non-negative.";
 181             }
 182         }
 183
 184         /// <summary>
 185         /// A string like  "arrayType must be an array type"
 186         /// </summary>
 187         internal static string ArrayTypeMustBeArray {
 188             get {
 189                 return "arrayType must be an array type";
 190             }
 191         }
 192
 193         /// <summary>
 194         /// A string like  "Setter should have void type."
 195         /// </summary>
 196         internal static string SetterMustBeVoid {
 197             get {
 198                 return "Setter should have void type.";
 199             }
 200         }
 201
 202         /// <summary>
 203         /// A string like  "Property type must match the value type of setter"
 204         /// </summary>
 205         internal static string PropertyTyepMustMatchSetter {
 206             get {
 207                 return "Property type must match the value type of setter";
 208             }
 209         }
 210
 211         /// <summary>
 212         /// A string like  "Both accessors must be static."
 213         /// </summary>
 214         internal static string BothAccessorsMustBeStatic {
 215             get {
 216                 return "Both accessors must be static.";
 217             }
 218         }
 219
 220         /// <summary>
 221         /// A string like  "Static field requires null instance, non-static field requires non-null instance."
 222         /// </summary>
 223         internal static string OnlyStaticFieldsHaveNullInstance {
 224             get {
 225                 return "Static field requires null instance, non-static field requires non-null instance.";
 226             }
 227         }
 228
 229         /// <summary>
 230         /// A string like  "Static property requires null instance, non-static property requires non-null instance."
 231         /// </summary>
 232         internal static string OnlyStaticPropertiesHaveNullInstance {
 233             get {
 234                 return "Static property requires null instance, non-static property requires non-null instance.";
 235             }
 236         }
 237
 238         /// <summary>
 239         /// A string like  "Static method requires null instance, non-static method requires non-null instance."
 240         /// </summary>
 241         internal static string OnlyStaticMethodsHaveNullInstance {
 242             get {
 243                 return "Static method requires null instance, non-static method requires non-null instance.";
 244             }
 245         }
 246
 247         /// <summary>
 248         /// A string like  "Property cannot have a void type."
 249         /// </summary>
 250         internal static string PropertyTypeCannotBeVoid {
 251             get {
 252                 return "Property cannot have a void type.";
 253             }
 254         }
 255
 256         /// <summary>
 257         /// A string like  "Can only unbox from an object or interface type to a value type."
 258         /// </summary>
 259         internal static string InvalidUnboxType {
 260             get {
 261                 return "Can only unbox from an object or interface type to a value type.";
 262             }
 263         }
 264
 265         /// <summary>
 266         /// A string like  "Expression must be readable"
 267         /// </summary>
 268         internal static string ExpressionMustBeReadable {
 269             get {
 270                 return "Expression must be readable";
 271             }
 272         }
 273
 274         /// <summary>
 275         /// A string like  "Expression must be writeable"
 276         /// </summary>
 277         internal static string ExpressionMustBeWriteable {
 278             get {
 279                 return "Expression must be writeable";
 280             }
 281         }
 282
 283         /// <summary>
 284         /// A string like  "Argument must not have a value type."
 285         /// </summary>
 286         internal static string ArgumentMustNotHaveValueType {
 287             get {
 288                 return "Argument must not have a value type.";
 289             }
 290         }
 291
 292         /// <summary>
 293         /// A string like  "must be reducible node"
 294         /// </summary>
 295         internal static string MustBeReducible {
 296             get {
 297                 return "must be reducible node";
 298             }
 299         }
 300
 301         /// <summary>
 302         /// A string like  "All test values must have the same type."
 303         /// </summary>
 304         internal static string AllTestValuesMustHaveSameType {
 305             get {
 306                 return "All test values must have the same type.";
 307             }
 308         }
 309
 310         /// <summary>
 311         /// A string like  "All case bodies and the default body must have the same type."
 312         /// </summary>
 313         internal static string AllCaseBodiesMustHaveSameType {
 314             get {
 315                 return "All case bodies and the default body must have the same type.";
 316             }
 317         }
 318
 319         /// <summary>
 320         /// A string like  "Default body must be supplied if case bodies are not System.Void."
 321         /// </summary>
 322         internal static string DefaultBodyMustBeSupplied {
 323             get {
 324                 return "Default body must be supplied if case bodies are not System.Void.";
 325             }
 326         }
 327
 328         /// <summary>
 329         /// A string like  "MethodBuilder does not have a valid TypeBuilder"
 330         /// </summary>
 331         internal static string MethodBuilderDoesNotHaveTypeBuilder {
 332             get {
 333                 return "MethodBuilder does not have a valid TypeBuilder";
 334             }
 335         }
 336
 337         /// <summary>
 338         /// A string like  "Type must be derived from System.Delegate"
 339         /// </summary>
 340         internal static string TypeMustBeDerivedFromSystemDelegate {
 341             get {
 342                 return "Type must be derived from System.Delegate";
 343             }
 344         }
 345
 346         /// <summary>
 347         /// A string like  "Argument type cannot be void"
 348         /// </summary>
 349         internal static string ArgumentTypeCannotBeVoid {
 350             get {
 351                 return "Argument type cannot be void";
 352             }
 353         }
 354
 355         /// <summary>
 356         /// A string like  "Label type must be System.Void if an expression is not supplied"
 357         /// </summary>
 358         internal static string LabelMustBeVoidOrHaveExpression {
 359             get {
 360                 return "Label type must be System.Void if an expression is not supplied";
 361             }
 362         }
 363
 364         /// <summary>
 365         /// A string like  "Type must be System.Void for this label argument"
 366         /// </summary>
 367         internal static string LabelTypeMustBeVoid {
 368             get {
 369                 return "Type must be System.Void for this label argument";
 370             }
 371         }
 372
 373         /// <summary>
 374         /// A string like  "Quoted expression must be a lambda"
 375         /// </summary>
 376         internal static string QuotedExpressionMustBeLambda {
 377             get {
 378                 return "Quoted expression must be a lambda";
 379             }
 380         }
 381
 382         /// <summary>
 383         /// A string like  "Variable '{0}' uses unsupported type '{1}'. Reference types are not supported for variables."
 384         /// </summary>
 385         internal static string VariableMustNotBeByRef(object p0, object p1) {
 386             return FormatString("Variable '{0}' uses unsupported type '{1}'. Reference types are not supported for variables.", p0, p1);
 387         }
 388
 389         /// <summary>
 390         /// A string like  "Found duplicate parameter '{0}'. Each ParameterExpression in the list must be a unique object."
 391         /// </summary>
 392         internal static string DuplicateVariable(object p0) {
 393             return FormatString("Found duplicate parameter '{0}'. Each ParameterExpression in the list must be a unique object.", p0);
 394         }
 395
 396         /// <summary>
 397         /// A string like  "Start and End must be well ordered"
 398         /// </summary>
 399         internal static string StartEndMustBeOrdered {
 400             get {
 401                 return "Start and End must be well ordered";
 402             }
 403         }
 404
 405         /// <summary>
 406         /// A string like  "fault cannot be used with catch or finally clauses"
 407         /// </summary>
 408         internal static string FaultCannotHaveCatchOrFinally {
 409             get {
 410                 return "fault cannot be used with catch or finally clauses";
 411             }
 412         }
 413
 414         /// <summary>
 415         /// A string like  "try must have at least one catch, finally, or fault clause"
 416         /// </summary>
 417         internal static string TryMustHaveCatchFinallyOrFault {
 418             get {
 419                 return "try must have at least one catch, finally, or fault clause";
 420             }
 421         }
 422
 423         /// <summary>
 424         /// A string like  "Body of catch must have the same type as body of try."
 425         /// </summary>
 426         internal static string BodyOfCatchMustHaveSameTypeAsBodyOfTry {
 427             get {
 428                 return "Body of catch must have the same type as body of try.";
 429             }
 430         }
 431
 432         /// <summary>
 433         /// A string like  "Extension node must override the property {0}."
 434         /// </summary>
 435         internal static string ExtensionNodeMustOverrideProperty(object p0) {
 436             return FormatString("Extension node must override the property {0}.", p0);
 437         }
 438
 439         /// <summary>
 440         /// A string like  "User-defined operator method '{0}' must be static."
 441         /// </summary>
 442         internal static string UserDefinedOperatorMustBeStatic(object p0) {
 443             return FormatString("User-defined operator method '{0}' must be static.", p0);
 444         }
 445
 446         /// <summary>
 447         /// A string like  "User-defined operator method '{0}' must not be void."
 448         /// </summary>
 449         internal static string UserDefinedOperatorMustNotBeVoid(object p0) {
 450             return FormatString("User-defined operator method '{0}' must not be void.", p0);
 451         }
 452
 453         /// <summary>
 454         /// A string like  "No coercion operator is defined between types '{0}' and '{1}'."
 455         /// </summary>
 456         internal static string CoercionOperatorNotDefined(object p0, object p1) {
 457             return FormatString("No coercion operator is defined between types '{0}' and '{1}'.", p0, p1);
 458         }
 459
 460         /// <summary>
 461         /// A string like  "The result type '{0}' of the dynamic binding produced by binder '{1}' is not compatible with the result type '{2}' expected by the call site."
 462         /// </summary>
 463         internal static string DynamicBinderResultNotAssignable(object p0, object p1, object p2) {
 464             return FormatString("The result type '{0}' of the dynamic binding produced by binder '{1}' is not compatible with the result type '{2}' expected by the call site.", p0, p1, p2);
 465         }
 466
 467         /// <summary>
 468         /// A string like  "The result type '{0}' of the dynamic binding produced by the object with type '{1}' for the binder '{2}' is not compatible with the result type '{3}' expected by the call site."
 469         /// </summary>
 470         internal static string DynamicObjectResultNotAssignable(object p0, object p1, object p2, object p3) {
 471             return FormatString("The result type '{0}' of the dynamic binding produced by the object with type '{1}' for the binder '{2}' is not compatible with the result type '{3}' expected by the call site.", p0, p1, p2, p3);
 472         }
 473
 474         /// <summary>
 475         /// A string like  "The result of the dynamic binding produced by the object with type '{0}' for the binder '{1}' needs at least one restriction."
 476         /// </summary>
 477         internal static string DynamicBindingNeedsRestrictions(object p0, object p1) {
 478             return FormatString("The result of the dynamic binding produced by the object with type '{0}' for the binder '{1}' needs at least one restriction.", p0, p1);
 479         }
 480
 481         /// <summary>
 482         /// A string like  "The result type '{0}' of the binder '{1}' is not compatible with the result type '{2}' expected by the call site."
 483         /// </summary>
 484         internal static string BinderNotCompatibleWithCallSite(object p0, object p1, object p2) {
 485             return FormatString("The result type '{0}' of the binder '{1}' is not compatible with the result type '{2}' expected by the call site.", p0, p1, p2);
 486         }
 487
 488         /// <summary>
 489         /// A string like  "The unary operator {0} is not defined for the type '{1}'."
 490         /// </summary>
 491         internal static string UnaryOperatorNotDefined(object p0, object p1) {
 492             return FormatString("The unary operator {0} is not defined for the type '{1}'.", p0, p1);
 493         }
 494
 495         /// <summary>
 496         /// A string like  "The binary operator {0} is not defined for the types '{1}' and '{2}'."
 497         /// </summary>
 498         internal static string BinaryOperatorNotDefined(object p0, object p1, object p2) {
 499             return FormatString("The binary operator {0} is not defined for the types '{1}' and '{2}'.", p0, p1, p2);
 500         }
 501
 502         /// <summary>
 503         /// A string like  "Reference equality is not defined for the types '{0}' and '{1}'."
 504         /// </summary>
 505         internal static string ReferenceEqualityNotDefined(object p0, object p1) {
 506             return FormatString("Reference equality is not defined for the types '{0}' and '{1}'.", p0, p1);
 507         }
 508
 509         /// <summary>
 510         /// A string like  "The operands for operator '{0}' do not match the parameters of method '{1}'."
 511         /// </summary>
 512         internal static string OperandTypesDoNotMatchParameters(object p0, object p1) {
 513             return FormatString("The operands for operator '{0}' do not match the parameters of method '{1}'.", p0, p1);
 514         }
 515
 516         /// <summary>
 517         /// A string like  "The return type of overload method for operator '{0}' does not match the parameter type of conversion method '{1}'."
 518         /// </summary>
 519         internal static string OverloadOperatorTypeDoesNotMatchConversionType(object p0, object p1) {
 520             return FormatString("The return type of overload method for operator '{0}' does not match the parameter type of conversion method '{1}'.", p0, p1);
 521         }
 522
 523         /// <summary>
 524         /// A string like  "Conversion is not supported for arithmetic types without operator overloading."
 525         /// </summary>
 526         internal static string ConversionIsNotSupportedForArithmeticTypes {
 527             get {
 528                 return "Conversion is not supported for arithmetic types without operator overloading.";
 529             }
 530         }
 531
 532         /// <summary>
 533         /// A string like  "Argument must be array"
 534         /// </summary>
 535         internal static string ArgumentMustBeArray {
 536             get {
 537                 return "Argument must be array";
 538             }
 539         }
 540
 541         /// <summary>
 542         /// A string like  "Argument must be boolean"
 543         /// </summary>
 544         internal static string ArgumentMustBeBoolean {
 545             get {
 546                 return "Argument must be boolean";
 547             }
 548         }
 549
 550         /// <summary>
 551         /// A string like  "The user-defined equality method '{0}' must return a boolean value."
 552         /// </summary>
 553         internal static string EqualityMustReturnBoolean(object p0) {
 554             return FormatString("The user-defined equality method '{0}' must return a boolean value.", p0);
 555         }
 556
 557         /// <summary>
 558         /// A string like  "Argument must be either a FieldInfo or PropertyInfo"
 559         /// </summary>
 560         internal static string ArgumentMustBeFieldInfoOrPropertInfo {
 561             get {
 562                 return "Argument must be either a FieldInfo or PropertyInfo";
 563             }
 564         }
 565
 566         /// <summary>
 567         /// A string like  "Argument must be either a FieldInfo, PropertyInfo or MethodInfo"
 568         /// </summary>
 569         internal static string ArgumentMustBeFieldInfoOrPropertInfoOrMethod {
 570             get {
 571                 return "Argument must be either a FieldInfo, PropertyInfo or MethodInfo";
 572             }
 573         }
 574
 575         /// <summary>
 576         /// A string like  "Argument must be an instance member"
 577         /// </summary>
 578         internal static string ArgumentMustBeInstanceMember {
 579             get {
 580                 return "Argument must be an instance member";
 581             }
 582         }
 583
 584         /// <summary>
 585         /// A string like  "Argument must be of an integer type"
 586         /// </summary>
 587         internal static string ArgumentMustBeInteger {
 588             get {
 589                 return "Argument must be of an integer type";
 590             }
 591         }
 592
 593         /// <summary>
 594         /// A string like  "Argument for array index must be of type Int32"
 595         /// </summary>
 596         internal static string ArgumentMustBeArrayIndexType {
 597             get {
 598                 return "Argument for array index must be of type Int32";
 599             }
 600         }
 601
 602         /// <summary>
 603         /// A string like  "Argument must be single dimensional array type"
 604         /// </summary>
 605         internal static string ArgumentMustBeSingleDimensionalArrayType {
 606             get {
 607                 return "Argument must be single dimensional array type";
 608             }
 609         }
 610
 611         /// <summary>
 612         /// A string like  "Argument types do not match"
 613         /// </summary>
 614         internal static string ArgumentTypesMustMatch {
 615             get {
 616                 return "Argument types do not match";
 617             }
 618         }
 619
 620         /// <summary>
 621         /// A string like  "Cannot auto initialize elements of value type through property '{0}', use assignment instead"
 622         /// </summary>
 623         internal static string CannotAutoInitializeValueTypeElementThroughProperty(object p0) {
 624             return FormatString("Cannot auto initialize elements of value type through property '{0}', use assignment instead", p0);
 625         }
 626
 627         /// <summary>
 628         /// A string like  "Cannot auto initialize members of value type through property '{0}', use assignment instead"
 629         /// </summary>
 630         internal static string CannotAutoInitializeValueTypeMemberThroughProperty(object p0) {
 631             return FormatString("Cannot auto initialize members of value type through property '{0}', use assignment instead", p0);
 632         }
 633
 634         /// <summary>
 635         /// A string like  "The type used in TypeAs Expression must be of reference or nullable type, {0} is neither"
 636         /// </summary>
 637         internal static string IncorrectTypeForTypeAs(object p0) {
 638             return FormatString("The type used in TypeAs Expression must be of reference or nullable type, {0} is neither", p0);
 639         }
 640
 641         /// <summary>
 642         /// A string like  "Coalesce used with type that cannot be null"
 643         /// </summary>
 644         internal static string CoalesceUsedOnNonNullType {
 645             get {
 646                 return "Coalesce used with type that cannot be null";
 647             }
 648         }
 649
 650         /// <summary>
 651         /// A string like  "An expression of type '{0}' cannot be used to initialize an array of type '{1}'"
 652         /// </summary>
 653         internal static string ExpressionTypeCannotInitializeArrayType(object p0, object p1) {
 654             return FormatString("An expression of type '{0}' cannot be used to initialize an array of type '{1}'", p0, p1);
 655         }
 656
 657         /// <summary>
 658         /// A string like  "Expression of type '{0}' cannot be used for constructor parameter of type '{1}'"
 659         /// </summary>
 660         internal static string ExpressionTypeDoesNotMatchConstructorParameter(object p0, object p1) {
 661             return FormatString("Expression of type '{0}' cannot be used for constructor parameter of type '{1}'", p0, p1);
 662         }
 663
 664         /// <summary>
 665         /// A string like  " Argument type '{0}' does not match the corresponding member type '{1}'"
 666         /// </summary>
 667         internal static string ArgumentTypeDoesNotMatchMember(object p0, object p1) {
 668             return FormatString(" Argument type '{0}' does not match the corresponding member type '{1}'", p0, p1);
 669         }
 670
 671         /// <summary>
 672         /// A string like  " The member '{0}' is not declared on type '{1}' being created"
 673         /// </summary>
 674         internal static string ArgumentMemberNotDeclOnType(object p0, object p1) {
 675             return FormatString(" The member '{0}' is not declared on type '{1}' being created", p0, p1);
 676         }
 677
 678         /// <summary>
 679         /// A string like  "Expression of type '{0}' cannot be used for parameter of type '{1}' of method '{2}'"
 680         /// </summary>
 681         internal static string ExpressionTypeDoesNotMatchMethodParameter(object p0, object p1, object p2) {
 682             return FormatString("Expression of type '{0}' cannot be used for parameter of type '{1}' of method '{2}'", p0, p1, p2);
 683         }
 684
 685         /// <summary>
 686         /// A string like  "Expression of type '{0}' cannot be used for parameter of type '{1}'"
 687         /// </summary>
 688         internal static string ExpressionTypeDoesNotMatchParameter(object p0, object p1) {
 689             return FormatString("Expression of type '{0}' cannot be used for parameter of type '{1}'", p0, p1);
 690         }
 691
 692         /// <summary>
 693         /// A string like  "Expression of type '{0}' cannot be used for return type '{1}'"
 694         /// </summary>
 695         internal static string ExpressionTypeDoesNotMatchReturn(object p0, object p1) {
 696             return FormatString("Expression of type '{0}' cannot be used for return type '{1}'", p0, p1);
 697         }
 698
 699         /// <summary>
 700         /// A string like  "Expression of type '{0}' cannot be used for assignment to type '{1}'"
 701         /// </summary>
 702         internal static string ExpressionTypeDoesNotMatchAssignment(object p0, object p1) {
 703             return FormatString("Expression of type '{0}' cannot be used for assignment to type '{1}'", p0, p1);
 704         }
 705
 706         /// <summary>
 707         /// A string like  "Expression of type '{0}' cannot be used for label of type '{1}'"
 708         /// </summary>
 709         internal static string ExpressionTypeDoesNotMatchLabel(object p0, object p1) {
 710             return FormatString("Expression of type '{0}' cannot be used for label of type '{1}'", p0, p1);
 711         }
 712
 713         /// <summary>
 714         /// A string like  "Expression of type '{0}' cannot be invoked"
 715         /// </summary>
 716         internal static string ExpressionTypeNotInvocable(object p0) {
 717             return FormatString("Expression of type '{0}' cannot be invoked", p0);
 718         }
 719
 720         /// <summary>
 721         /// A string like  "Field '{0}' is not defined for type '{1}'"
 722         /// </summary>
 723         internal static string FieldNotDefinedForType(object p0, object p1) {
 724             return FormatString("Field '{0}' is not defined for type '{1}'", p0, p1);
 725         }
 726
 727         /// <summary>
 728         /// A string like  "Instance field '{0}' is not defined for type '{1}'"
 729         /// </summary>
 730         internal static string InstanceFieldNotDefinedForType(object p0, object p1) {
 731             return FormatString("Instance field '{0}' is not defined for type '{1}'", p0, p1);
 732         }
 733
 734         /// <summary>
 735         /// A string like  "Field '{0}.{1}' is not defined for type '{2}'"
 736         /// </summary>
 737         internal static string FieldInfoNotDefinedForType(object p0, object p1, object p2) {
 738             return FormatString("Field '{0}.{1}' is not defined for type '{2}'", p0, p1, p2);
 739         }
 740
 741         /// <summary>
 742         /// A string like  "Incorrect number of indexes"
 743         /// </summary>
 744         internal static string IncorrectNumberOfIndexes {
 745             get {
 746                 return "Incorrect number of indexes";
 747             }
 748         }
 749
 750         /// <summary>
 751         /// A string like  "Incorrect number of arguments supplied for lambda invocation"
 752         /// </summary>
 753         internal static string IncorrectNumberOfLambdaArguments {
 754             get {
 755                 return "Incorrect number of arguments supplied for lambda invocation";
 756             }
 757         }
 758
 759         /// <summary>
 760         /// A string like  "Incorrect number of parameters supplied for lambda declaration"
 761         /// </summary>
 762         internal static string IncorrectNumberOfLambdaDeclarationParameters {
 763             get {
 764                 return "Incorrect number of parameters supplied for lambda declaration";
 765             }
 766         }
 767
 768         /// <summary>
 769         /// A string like  "Incorrect number of arguments supplied for call to method '{0}'"
 770         /// </summary>
 771         internal static string IncorrectNumberOfMethodCallArguments(object p0) {
 772             return FormatString("Incorrect number of arguments supplied for call to method '{0}'", p0);
 773         }
 774
 775         /// <summary>
 776         /// A string like  "Incorrect number of arguments for constructor"
 777         /// </summary>
 778         internal static string IncorrectNumberOfConstructorArguments {
 779             get {
 780                 return "Incorrect number of arguments for constructor";
 781             }
 782         }
 783
 784         /// <summary>
 785         /// A string like  " Incorrect number of members for constructor"
 786         /// </summary>
 787         internal static string IncorrectNumberOfMembersForGivenConstructor {
 788             get {
 789                 return " Incorrect number of members for constructor";
 790             }
 791         }
 792
 793         /// <summary>
 794         /// A string like  "Incorrect number of arguments for the given members "
 795         /// </summary>
 796         internal static string IncorrectNumberOfArgumentsForMembers {
 797             get {
 798                 return "Incorrect number of arguments for the given members ";
 799             }
 800         }
 801
 802         /// <summary>
 803         /// A string like  "Lambda type parameter must be derived from System.Delegate"
 804         /// </summary>
 805         internal static string LambdaTypeMustBeDerivedFromSystemDelegate {
 806             get {
 807                 return "Lambda type parameter must be derived from System.Delegate";
 808             }
 809         }
 810
 811         /// <summary>
 812         /// A string like  "Member '{0}' not field or property"
 813         /// </summary>
 814         internal static string MemberNotFieldOrProperty(object p0) {
 815             return FormatString("Member '{0}' not field or property", p0);
 816         }
 817
 818         /// <summary>
 819         /// A string like  "Method {0} contains generic parameters"
 820         /// </summary>
 821         internal static string MethodContainsGenericParameters(object p0) {
 822             return FormatString("Method {0} contains generic parameters", p0);
 823         }
 824
 825         /// <summary>
 826         /// A string like  "Method {0} is a generic method definition"
 827         /// </summary>
 828         internal static string MethodIsGeneric(object p0) {
 829             return FormatString("Method {0} is a generic method definition", p0);
 830         }
 831
 832         /// <summary>
 833         /// A string like  "The method '{0}.{1}' is not a property accessor"
 834         /// </summary>
 835         internal static string MethodNotPropertyAccessor(object p0, object p1) {
 836             return FormatString("The method '{0}.{1}' is not a property accessor", p0, p1);
 837         }
 838
 839         /// <summary>
 840         /// A string like  "The property '{0}' has no 'get' accessor"
 841         /// </summary>
 842         internal static string PropertyDoesNotHaveGetter(object p0) {
 843             return FormatString("The property '{0}' has no 'get' accessor", p0);
 844         }
 845
 846         /// <summary>
 847         /// A string like  "The property '{0}' has no 'set' accessor"
 848         /// </summary>
 849         internal static string PropertyDoesNotHaveSetter(object p0) {
 850             return FormatString("The property '{0}' has no 'set' accessor", p0);
 851         }
 852
 853         /// <summary>
 854         /// A string like  "The property '{0}' has no 'get' or 'set' accessors"
 855         /// </summary>
 856         internal static string PropertyDoesNotHaveAccessor(object p0) {
 857             return FormatString("The property '{0}' has no 'get' or 'set' accessors", p0);
 858         }
 859
 860         /// <summary>
 861         /// A string like  "'{0}' is not a member of type '{1}'"
 862         /// </summary>
 863         internal static string NotAMemberOfType(object p0, object p1) {
 864             return FormatString("'{0}' is not a member of type '{1}'", p0, p1);
 865         }
 866
 867         /// <summary>
 868         /// A string like  "The operator '{0}' is not implemented for type '{1}'"
 869         /// </summary>
 870         internal static string OperatorNotImplementedForType(object p0, object p1) {
 871             return FormatString("The operator '{0}' is not implemented for type '{1}'", p0, p1);
 872         }
 873
 874         /// <summary>
 875         /// A string like  "ParameterExpression of type '{0}' cannot be used for delegate parameter of type '{1}'"
 876         /// </summary>
 877         internal static string ParameterExpressionNotValidAsDelegate(object p0, object p1) {
 878             return FormatString("ParameterExpression of type '{0}' cannot be used for delegate parameter of type '{1}'", p0, p1);
 879         }
 880
 881         /// <summary>
 882         /// A string like  "Property '{0}' is not defined for type '{1}'"
 883         /// </summary>
 884         internal static string PropertyNotDefinedForType(object p0, object p1) {
 885             return FormatString("Property '{0}' is not defined for type '{1}'", p0, p1);
 886         }
 887
 888         /// <summary>
 889         /// A string like  "Instance property '{0}' is not defined for type '{1}'"
 890         /// </summary>
 891         internal static string InstancePropertyNotDefinedForType(object p0, object p1) {
 892             return FormatString("Instance property '{0}' is not defined for type '{1}'", p0, p1);
 893         }
 894
 895         /// <summary>
 896         /// A string like  "Instance property '{0}' that takes no argument is not defined for type '{1}'"
 897         /// </summary>
 898         internal static string InstancePropertyWithoutParameterNotDefinedForType(object p0, object p1) {
 899             return FormatString("Instance property '{0}' that takes no argument is not defined for type '{1}'", p0, p1);
 900         }
 901
 902         /// <summary>
 903         /// A string like  "Instance property '{0}{1}' is not defined for type '{2}'"
 904         /// </summary>
 905         internal static string InstancePropertyWithSpecifiedParametersNotDefinedForType(object p0, object p1, object p2) {
 906             return FormatString("Instance property '{0}{1}' is not defined for type '{2}'", p0, p1, p2);
 907         }
 908
 909         /// <summary>
 910         /// A string like  "Method '{0}' declared on type '{1}' cannot be called with instance of type '{2}'"
 911         /// </summary>
 912         internal static string InstanceAndMethodTypeMismatch(object p0, object p1, object p2) {
 913             return FormatString("Method '{0}' declared on type '{1}' cannot be called with instance of type '{2}'", p0, p1, p2);
 914         }
 915
 916         /// <summary>
 917         /// A string like  "Type {0} contains generic parameters"
 918         /// </summary>
 919         internal static string TypeContainsGenericParameters(object p0) {
 920             return FormatString("Type {0} contains generic parameters", p0);
 921         }
 922
 923         /// <summary>
 924         /// A string like  "Type {0} is a generic type definition"
 925         /// </summary>
 926         internal static string TypeIsGeneric(object p0) {
 927             return FormatString("Type {0} is a generic type definition", p0);
 928         }
 929
 930         /// <summary>
 931         /// A string like  "Type '{0}' does not have a default constructor"
 932         /// </summary>
 933         internal static string TypeMissingDefaultConstructor(object p0) {
 934             return FormatString("Type '{0}' does not have a default constructor", p0);
 935         }
 936
 937         /// <summary>
 938         /// A string like  "List initializers must contain at least one initializer"
 939         /// </summary>
 940         internal static string ListInitializerWithZeroMembers {
 941             get {
 942                 return "List initializers must contain at least one initializer";
 943             }
 944         }
 945
 946         /// <summary>
 947         /// A string like  "Element initializer method must be named 'Add'"
 948         /// </summary>
 949         internal static string ElementInitializerMethodNotAdd {
 950             get {
 951                 return "Element initializer method must be named 'Add'";
 952             }
 953         }
 954
 955         /// <summary>
 956         /// A string like  "Parameter '{0}' of element initializer method '{1}' must not be a pass by reference parameter"
 957         /// </summary>
 958         internal static string ElementInitializerMethodNoRefOutParam(object p0, object p1) {
 959             return FormatString("Parameter '{0}' of element initializer method '{1}' must not be a pass by reference parameter", p0, p1);
 960         }
 961
 962         /// <summary>
 963         /// A string like  "Element initializer method must have at least 1 parameter"
 964         /// </summary>
 965         internal static string ElementInitializerMethodWithZeroArgs {
 966             get {
 967                 return "Element initializer method must have at least 1 parameter";
 968             }
 969         }
 970
 971         /// <summary>
 972         /// A string like  "Element initializer method must be an instance method"
 973         /// </summary>
 974         internal static string ElementInitializerMethodStatic {
 975             get {
 976                 return "Element initializer method must be an instance method";
 977             }
 978         }
 979
 980         /// <summary>
 981         /// A string like  "Type '{0}' is not IEnumerable"
 982         /// </summary>
 983         internal static string TypeNotIEnumerable(object p0) {
 984             return FormatString("Type '{0}' is not IEnumerable", p0);
 985         }
 986
 987         /// <summary>
 988         /// A string like  "Type parameter is {0}. Expected a delegate."
 989         /// </summary>
 990         internal static string TypeParameterIsNotDelegate(object p0) {
 991             return FormatString("Type parameter is {0}. Expected a delegate.", p0);
 992         }
 993
 994         /// <summary>
 995         /// A string like  "Unexpected coalesce operator."
 996         /// </summary>
 997         internal static string UnexpectedCoalesceOperator {
 998             get {
 999                 return "Unexpected coalesce operator.";
1000             }
1001         }
1002
1003         /// <summary>
1004         /// A string like  "Cannot cast from type '{0}' to type '{1}"
1005         /// </summary>
1006         internal static string InvalidCast(object p0, object p1) {
1007             return FormatString("Cannot cast from type '{0}' to type '{1}", p0, p1);
1008         }
1009
1010         /// <summary>
1011         /// A string like  "Unhandled binary: {0}"
1012         /// </summary>
1013         internal static string UnhandledBinary(object p0) {
1014             return FormatString("Unhandled binary: {0}", p0);
1015         }
1016
1017         /// <summary>
1018         /// A string like  "Unhandled binding "
1019         /// </summary>
1020         internal static string UnhandledBinding {
1021             get {
1022                 return "Unhandled binding ";
1023             }
1024         }
1025
1026         /// <summary>
1027         /// A string like  "Unhandled Binding Type: {0}"
1028         /// </summary>
1029         internal static string UnhandledBindingType(object p0) {
1030             return FormatString("Unhandled Binding Type: {0}", p0);
1031         }
1032
1033         /// <summary>
1034         /// A string like  "Unhandled convert: {0}"
1035         /// </summary>
1036         internal static string UnhandledConvert(object p0) {
1037             return FormatString("Unhandled convert: {0}", p0);
1038         }
1039
1040         /// <summary>
1041         /// A string like  "Unhandled Expression Type: {0}"
1042         /// </summary>
1043         internal static string UnhandledExpressionType(object p0) {
1044             return FormatString("Unhandled Expression Type: {0}", p0);
1045         }
1046
1047         /// <summary>
1048         /// A string like  "Unhandled unary: {0}"
1049         /// </summary>
1050         internal static string UnhandledUnary(object p0) {
1051             return FormatString("Unhandled unary: {0}", p0);
1052         }
1053
1054         /// <summary>
1055         /// A string like  "Unknown binding type"
1056         /// </summary>
1057         internal static string UnknownBindingType {
1058             get {
1059                 return "Unknown binding type";
1060             }
1061         }
1062
1063         /// <summary>
1064         /// A string like  "The user-defined operator method '{1}' for operator '{0}' must have identical parameter and return types."
1065         /// </summary>
1066         internal static string UserDefinedOpMustHaveConsistentTypes(object p0, object p1) {
1067             return FormatString("The user-defined operator method '{1}' for operator '{0}' must have identical parameter and return types.", p0, p1);
1068         }
1069
1070         /// <summary>
1071         /// A string like  "The user-defined operator method '{1}' for operator '{0}' must return the same type as its parameter or a derived type."
1072         /// </summary>
1073         internal static string UserDefinedOpMustHaveValidReturnType(object p0, object p1) {
1074             return FormatString("The user-defined operator method '{1}' for operator '{0}' must return the same type as its parameter or a derived type.", p0, p1);
1075         }
1076
1077         /// <summary>
1078         /// A string like  "The user-defined operator method '{1}' for operator '{0}' must have associated boolean True and False operators."
1079         /// </summary>
1080         internal static string LogicalOperatorMustHaveBooleanOperators(object p0, object p1) {
1081             return FormatString("The user-defined operator method '{1}' for operator '{0}' must have associated boolean True and False operators.", p0, p1);
1082         }
1083
1084         /// <summary>
1085         /// A string like  "No method '{0}' exists on type '{1}'."
1086         /// </summary>
1087         internal static string MethodDoesNotExistOnType(object p0, object p1) {
1088             return FormatString("No method '{0}' exists on type '{1}'.", p0, p1);
1089         }
1090
1091         /// <summary>
1092         /// A string like  "No method '{0}' on type '{1}' is compatible with the supplied arguments."
1093         /// </summary>
1094         internal static string MethodWithArgsDoesNotExistOnType(object p0, object p1) {
1095             return FormatString("No method '{0}' on type '{1}' is compatible with the supplied arguments.", p0, p1);
1096         }
1097
1098         /// <summary>
1099         /// A string like  "No generic method '{0}' on type '{1}' is compatible with the supplied type arguments and arguments. No type arguments should be provided if the method is non-generic. "
1100         /// </summary>
1101         internal static string GenericMethodWithArgsDoesNotExistOnType(object p0, object p1) {
1102             return FormatString("No generic method '{0}' on type '{1}' is compatible with the supplied type arguments and arguments. No type arguments should be provided if the method is non-generic. ", p0, p1);
1103         }
1104
1105         /// <summary>
1106         /// A string like  "More than one method '{0}' on type '{1}' is compatible with the supplied arguments."
1107         /// </summary>
1108         internal static string MethodWithMoreThanOneMatch(object p0, object p1) {
1109             return FormatString("More than one method '{0}' on type '{1}' is compatible with the supplied arguments.", p0, p1);
1110         }
1111
1112         /// <summary>
1113         /// A string like  "More than one property '{0}' on type '{1}' is compatible with the supplied arguments."
1114         /// </summary>
1115         internal static string PropertyWithMoreThanOneMatch(object p0, object p1) {
1116             return FormatString("More than one property '{0}' on type '{1}' is compatible with the supplied arguments.", p0, p1);
1117         }
1118
1119         /// <summary>
1120         /// A string like  "An incorrect number of type args were specified for the declaration of a Func type."
1121         /// </summary>
1122         internal static string IncorrectNumberOfTypeArgsForFunc {
1123             get {
1124                 return "An incorrect number of type args were specified for the declaration of a Func type.";
1125             }
1126         }
1127
1128         /// <summary>
1129         /// A string like  "An incorrect number of type args were specified for the declaration of an Action type."
1130         /// </summary>
1131         internal static string IncorrectNumberOfTypeArgsForAction {
1132             get {
1133                 return "An incorrect number of type args were specified for the declaration of an Action type.";
1134             }
1135         }
1136
1137         /// <summary>
1138         /// A string like  "Argument type cannot be System.Void."
1139         /// </summary>
1140         internal static string ArgumentCannotBeOfTypeVoid {
1141             get {
1142                 return "Argument type cannot be System.Void.";
1143             }
1144         }
1145
1146         /// <summary>
1147         /// A string like  "More than one key matching '{0}' was found in the ExpandoObject."
1148         /// </summary>
1149         internal static string AmbiguousMatchInExpandoObject(object p0) {
1150             return FormatString("More than one key matching '{0}' was found in the ExpandoObject.", p0);
1151         }
1152
1153         /// <summary>
1154         /// A string like  "An element with the same key '{0}' already exists in the ExpandoObject."
1155         /// </summary>
1156         internal static string SameKeyExistsInExpando(object p0) {
1157             return FormatString("An element with the same key '{0}' already exists in the ExpandoObject.", p0);
1158         }
1159
1160         /// <summary>
1161         /// A string like  "The specified key '{0}' does not exist in the ExpandoObject."
1162         /// </summary>
1163         internal static string KeyDoesNotExistInExpando(object p0) {
1164             return FormatString("The specified key '{0}' does not exist in the ExpandoObject.", p0);
1165         }
1166
1167         /// <summary>
1168         /// A string like  "No or Invalid rule produced"
1169         /// </summary>
1170         internal static string NoOrInvalidRuleProduced {
1171             get {
1172                 return "No or Invalid rule produced";
1173             }
1174         }
1175
1176         /// <summary>
1177         /// A string like  "First argument of delegate must be CallSite"
1178         /// </summary>
1179         internal static string FirstArgumentMustBeCallSite {
1180             get {
1181                 return "First argument of delegate must be CallSite";
1182             }
1183         }
1184
1185         /// <summary>
1186         /// A string like  "Bind cannot return null."
1187         /// </summary>
1188         internal static string BindingCannotBeNull {
1189             get {
1190                 return "Bind cannot return null.";
1191             }
1192         }
1193
1194         /// <summary>
1195         /// A string like  "Invalid operation: '{0}'"
1196         /// </summary>
1197         internal static string InvalidOperation(object p0) {
1198             return FormatString("Invalid operation: '{0}'", p0);
1199         }
1200
1201         /// <summary>
1202         /// A string like  "{0} must be greater than or equal to {1}"
1203         /// </summary>
1204         internal static string OutOfRange(object p0, object p1) {
1205             return FormatString("{0} must be greater than or equal to {1}", p0, p1);
1206         }
1207
1208         /// <summary>
1209         /// A string like  "Queue empty."
1210         /// </summary>
1211         internal static string QueueEmpty {
1212             get {
1213                 return "Queue empty.";
1214             }
1215         }
1216
1217         /// <summary>
1218         /// A string like  "Cannot redefine label '{0}' in an inner block."
1219         /// </summary>
1220         internal static string LabelTargetAlreadyDefined(object p0) {
1221             return FormatString("Cannot redefine label '{0}' in an inner block.", p0);
1222         }
1223
1224         /// <summary>
1225         /// A string like  "Cannot jump to undefined label '{0}'."
1226         /// </summary>
1227         internal static string LabelTargetUndefined(object p0) {
1228             return FormatString("Cannot jump to undefined label '{0}'.", p0);
1229         }
1230
1231         /// <summary>
1232         /// A string like  "Control cannot leave a finally block."
1233         /// </summary>
1234         internal static string ControlCannotLeaveFinally {
1235             get {
1236                 return "Control cannot leave a finally block.";
1237             }
1238         }
1239
1240         /// <summary>
1241         /// A string like  "Control cannot leave a filter test."
1242         /// </summary>
1243         internal static string ControlCannotLeaveFilterTest {
1244             get {
1245                 return "Control cannot leave a filter test.";
1246             }
1247         }
1248
1249         /// <summary>
1250         /// A string like  "Cannot jump to ambiguous label '{0}'."
1251         /// </summary>
1252         internal static string AmbiguousJump(object p0) {
1253             return FormatString("Cannot jump to ambiguous label '{0}'.", p0);
1254         }
1255
1256         /// <summary>
1257         /// A string like  "Control cannot enter a try block."
1258         /// </summary>
1259         internal static string ControlCannotEnterTry {
1260             get {
1261                 return "Control cannot enter a try block.";
1262             }
1263         }
1264
1265         /// <summary>
1266         /// A string like  "Control cannot enter an expression--only statements can be jumped into."
1267         /// </summary>
1268         internal static string ControlCannotEnterExpression {
1269             get {
1270                 return "Control cannot enter an expression--only statements can be jumped into.";
1271             }
1272         }
1273
1274         /// <summary>
1275         /// A string like  "Cannot jump to non-local label '{0}' with a value. Only jumps to labels defined in outer blocks can pass values."
1276         /// </summary>
1277         internal static string NonLocalJumpWithValue(object p0) {
1278             return FormatString("Cannot jump to non-local label '{0}' with a value. Only jumps to labels defined in outer blocks can pass values.", p0);
1279         }
1280
1281         /// <summary>
1282         /// A string like  "Extension should have been reduced."
1283         /// </summary>
1284         internal static string ExtensionNotReduced {
1285             get {
1286                 return "Extension should have been reduced.";
1287             }
1288         }
1289
1290         /// <summary>
1291         /// A string like  "CompileToMethod cannot compile constant '{0}' because it is a non-trivial value, such as a live object. Instead, create an expression tree that can construct this value."
1292         /// </summary>
1293         internal static string CannotCompileConstant(object p0) {
1294             return FormatString("CompileToMethod cannot compile constant '{0}' because it is a non-trivial value, such as a live object. Instead, create an expression tree that can construct this value.", p0);
1295         }
1296
1297         /// <summary>
1298         /// A string like  "Dynamic expressions are not supported by CompileToMethod. Instead, create an expression tree that uses System.Runtime.CompilerServices.CallSite."
1299         /// </summary>
1300         internal static string CannotCompileDynamic {
1301             get {
1302                 return "Dynamic expressions are not supported by CompileToMethod. Instead, create an expression tree that uses System.Runtime.CompilerServices.CallSite.";
1303             }
1304         }
1305
1306         /// <summary>
1307         /// A string like  "Invalid lvalue for assignment: {0}."
1308         /// </summary>
1309         internal static string InvalidLvalue(object p0) {
1310             return FormatString("Invalid lvalue for assignment: {0}.", p0);
1311         }
1312
1313         /// <summary>
1314         /// A string like  "Invalid member type: {0}."
1315         /// </summary>
1316         internal static string InvalidMemberType(object p0) {
1317             return FormatString("Invalid member type: {0}.", p0);
1318         }
1319
1320         /// <summary>
1321         /// A string like  "unknown lift type: '{0}'."
1322         /// </summary>
1323         internal static string UnknownLiftType(object p0) {
1324             return FormatString("unknown lift type: '{0}'.", p0);
1325         }
1326
1327         /// <summary>
1328         /// A string like  "Invalid output directory."
1329         /// </summary>
1330         internal static string InvalidOutputDir {
1331             get {
1332                 return "Invalid output directory.";
1333             }
1334         }
1335
1336         /// <summary>
1337         /// A string like  "Invalid assembly name or file extension."
1338         /// </summary>
1339         internal static string InvalidAsmNameOrExtension {
1340             get {
1341                 return "Invalid assembly name or file extension.";
1342             }
1343         }
1344
1345         /// <summary>
1346         /// A string like  "Collection is read-only."
1347         /// </summary>
1348         internal static string CollectionReadOnly {
1349             get {
1350                 return "Collection is read-only.";
1351             }
1352         }
1353
1354         /// <summary>
1355         /// A string like  "Cannot create instance of {0} because it contains generic parameters"
1356         /// </summary>
1357         internal static string IllegalNewGenericParams(object p0) {
1358             return FormatString("Cannot create instance of {0} because it contains generic parameters", p0);
1359         }
1360
1361         /// <summary>
1362         /// A string like  "variable '{0}' of type '{1}' referenced from scope '{2}', but it is not defined"
1363         /// </summary>
1364         internal static string UndefinedVariable(object p0, object p1, object p2) {
1365             return FormatString("variable '{0}' of type '{1}' referenced from scope '{2}', but it is not defined", p0, p1, p2);
1366         }
1367
1368         /// <summary>
1369         /// A string like  "Cannot close over byref parameter '{0}' referenced in lambda '{1}'"
1370         /// </summary>
1371         internal static string CannotCloseOverByRef(object p0, object p1) {
1372             return FormatString("Cannot close over byref parameter '{0}' referenced in lambda '{1}'", p0, p1);
1373         }
1374
1375         /// <summary>
1376         /// A string like  "Unexpected VarArgs call to method '{0}'"
1377         /// </summary>
1378         internal static string UnexpectedVarArgsCall(object p0) {
1379             return FormatString("Unexpected VarArgs call to method '{0}'", p0);
1380         }
1381
1382         /// <summary>
1383         /// A string like  "Rethrow statement is valid only inside a Catch block."
1384         /// </summary>
1385         internal static string RethrowRequiresCatch {
1386             get {
1387                 return "Rethrow statement is valid only inside a Catch block.";
1388             }
1389         }
1390
1391         /// <summary>
1392         /// A string like  "Try expression is not allowed inside a filter body."
1393         /// </summary>
1394         internal static string TryNotAllowedInFilter {
1395             get {
1396                 return "Try expression is not allowed inside a filter body.";
1397             }
1398         }
1399
1400         /// <summary>
1401         /// A string like  "When called from '{0}', rewriting a node of type '{1}' must return a non-null value of the same type. Alternatively, override '{2}' and change it to not visit children of this type."
1402         /// </summary>
1403         internal static string MustRewriteToSameNode(object p0, object p1, object p2) {
1404             return FormatString("When called from '{0}', rewriting a node of type '{1}' must return a non-null value of the same type. Alternatively, override '{2}' and change it to not visit children of this type.", p0, p1, p2);
1405         }
1406
1407         /// <summary>
1408         /// A string like  "Rewriting child expression from type '{0}' to type '{1}' is not allowed, because it would change the meaning of the operation. If this is intentional, override '{2}' and change it to allow this rewrite."
1409         /// </summary>
1410         internal static string MustRewriteChildToSameType(object p0, object p1, object p2) {
1411             return FormatString("Rewriting child expression from type '{0}' to type '{1}' is not allowed, because it would change the meaning of the operation. If this is intentional, override '{2}' and change it to allow this rewrite.", p0, p1, p2);
1412         }
1413
1414         /// <summary>
1415         /// A string like  "Rewritten expression calls operator method '{0}', but the original node had no operator method. If this is is intentional, override '{1}' and change it to allow this rewrite."
1416         /// </summary>
1417         internal static string MustRewriteWithoutMethod(object p0, object p1) {
1418             return FormatString("Rewritten expression calls operator method '{0}', but the original node had no operator method. If this is is intentional, override '{1}' and change it to allow this rewrite.", p0, p1);
1419         }
1420
1421         /// <summary>
1422         /// A string like  "The value null is not of type '{0}' and cannot be used in this collection."
1423         /// </summary>
1424         internal static string InvalidNullValue(object p0) {
1425             return FormatString("The value null is not of type '{0}' and cannot be used in this collection.", p0);
1426         }
1427
1428         /// <summary>
1429         /// A string like  "The value '{0}' is not of type '{1}' and cannot be used in this collection."
1430         /// </summary>
1431         internal static string InvalidObjectType(object p0, object p1) {
1432             return FormatString("The value '{0}' is not of type '{1}' and cannot be used in this collection.", p0, p1);
1433         }
1434
1435         /// <summary>
1436         /// A string like  "TryExpression is not supported as an argument to method '{0}' because it has an argument with by-ref type. Construct the tree so the TryExpression is not nested inside of this expression."
1437         /// </summary>
1438         internal static string TryNotSupportedForMethodsWithRefArgs(object p0) {
1439             return FormatString("TryExpression is not supported as an argument to method '{0}' because it has an argument with by-ref type. Construct the tree so the TryExpression is not nested inside of this expression.", p0);
1440         }
1441
1442         /// <summary>
1443         /// A string like  "TryExpression is not supported as a child expression when accessing a member on type '{0}' because it is a value type. Construct the tree so the TryExpression is not nested inside of this expression."
1444         /// </summary>
1445         internal static string TryNotSupportedForValueTypeInstances(object p0) {
1446             return FormatString("TryExpression is not supported as a child expression when accessing a member on type '{0}' because it is a value type. Construct the tree so the TryExpression is not nested inside of this expression.", p0);
1447         }
1448
1449         /// <summary>
1450         /// A string like  "Collection was modified; enumeration operation may not execute."
1451         /// </summary>
1452         internal static string CollectionModifiedWhileEnumerating {
1453             get {
1454                 return "Collection was modified; enumeration operation may not execute.";
1455             }
1456         }
1457
1458         /// <summary>
1459         /// A string like  "Enumeration has either not started or has already finished."
1460         /// </summary>
1461         internal static string EnumerationIsDone {
1462             get {
1463                 return "Enumeration has either not started or has already finished.";
1464             }
1465         }
1466
1467         /// <summary>
1468         /// A string like  "Dynamic operations can only be performed in homogenous AppDomain."
1469         /// </summary>
1470         internal static string HomogenousAppDomainRequired {
1471             get {
1472                 return "Dynamic operations can only be performed in homogenous AppDomain.";
1473             }
1474         }
1475
1476         /// <summary>
1477         /// A string like  "Test value of type '{0}' cannot be used for the comparison method parameter of type '{1}'"
1478         /// </summary>
1479         internal static string TestValueTypeDoesNotMatchComparisonMethodParameter(object p0, object p1) {
1480             return FormatString("Test value of type '{0}' cannot be used for the comparison method parameter of type '{1}'", p0, p1);
1481         }
1482
1483         /// <summary>
1484         /// A string like  "Switch value of type '{0}' cannot be used for the comparison method parameter of type '{1}'"
1485         /// </summary>
1486         internal static string SwitchValueTypeDoesNotMatchComparisonMethodParameter(object p0, object p1) {
1487             return FormatString("Switch value of type '{0}' cannot be used for the comparison method parameter of type '{1}'", p0, p1);
1488         }
1489
1490         /// <summary>
1491         /// A string like  "An IDynamicMetaObjectProvider {0} created an invalid DynamicMetaObject instance."
1492         /// </summary>
1493         internal static string InvalidMetaObjectCreated(object p0) {
1494             return FormatString("An IDynamicMetaObjectProvider {0} created an invalid DynamicMetaObject instance.", p0);
1495         }
1496
1497     }
1498     /// <summary>
1499     ///    Strongly-typed and parameterized exception factory.
1500     /// </summary>
1501
1502     internal static partial class Error {
1503         /// <summary>
1504         /// ArgumentException with message like "Variable '{0}' uses unsupported type '{1}'. Reference types are not supported for variables."
1505         /// </summary>
1506         internal static Exception VariableMustNotBeByRef(object p0, object p1) {
1507             return new ArgumentException(Strings.VariableMustNotBeByRef(p0, p1));
1508         }
1509
1510         /// <summary>
1511         /// ArgumentException with message like "Found duplicate parameter '{0}'. Each ParameterExpression in the list must be a unique object."
1512         /// </summary>
1513         internal static Exception DuplicateVariable(object p0) {
1514             return new ArgumentException(Strings.DuplicateVariable(p0));
1515         }
1516
1517         /// <summary>
1518         /// ArgumentException with message like "Start and End must be well ordered"
1519         /// </summary>
1520         internal static Exception StartEndMustBeOrdered() {
1521             return new ArgumentException(Strings.StartEndMustBeOrdered);
1522         }
1523
1524         /// <summary>
1525         /// ArgumentException with message like "fault cannot be used with catch or finally clauses"
1526         /// </summary>
1527         internal static Exception FaultCannotHaveCatchOrFinally() {
1528             return new ArgumentException(Strings.FaultCannotHaveCatchOrFinally);
1529         }
1530
1531         /// <summary>
1532         /// ArgumentException with message like "try must have at least one catch, finally, or fault clause"
1533         /// </summary>
1534         internal static Exception TryMustHaveCatchFinallyOrFault() {
1535             return new ArgumentException(Strings.TryMustHaveCatchFinallyOrFault);
1536         }
1537
1538         /// <summary>
1539         /// ArgumentException with message like "Body of catch must have the same type as body of try."
1540         /// </summary>
1541         internal static Exception BodyOfCatchMustHaveSameTypeAsBodyOfTry() {
1542             return new ArgumentException(Strings.BodyOfCatchMustHaveSameTypeAsBodyOfTry);
1543         }
1544
1545         /// <summary>
1546         /// InvalidOperationException with message like "Extension node must override the property {0}."
1547         /// </summary>
1548         internal static Exception ExtensionNodeMustOverrideProperty(object p0) {
1549             return new InvalidOperationException(Strings.ExtensionNodeMustOverrideProperty(p0));
1550         }
1551
1552         /// <summary>
1553         /// ArgumentException with message like "User-defined operator method '{0}' must be static."
1554         /// </summary>
1555         internal static Exception UserDefinedOperatorMustBeStatic(object p0) {
1556             return new ArgumentException(Strings.UserDefinedOperatorMustBeStatic(p0));
1557         }
1558
1559         /// <summary>
1560         /// ArgumentException with message like "User-defined operator method '{0}' must not be void."
1561         /// </summary>
1562         internal static Exception UserDefinedOperatorMustNotBeVoid(object p0) {
1563             return new ArgumentException(Strings.UserDefinedOperatorMustNotBeVoid(p0));
1564         }
1565
1566         /// <summary>
1567         /// InvalidOperationException with message like "No coercion operator is defined between types '{0}' and '{1}'."
1568         /// </summary>
1569         internal static Exception CoercionOperatorNotDefined(object p0, object p1) {
1570             return new InvalidOperationException(Strings.CoercionOperatorNotDefined(p0, p1));
1571         }
1572
1573         /// <summary>
1574         /// InvalidCastException with message like "The result type '{0}' of the dynamic binding produced by binder '{1}' is not compatible with the result type '{2}' expected by the call site."
1575         /// </summary>
1576         internal static Exception DynamicBinderResultNotAssignable(object p0, object p1, object p2) {
1577             return new InvalidCastException(Strings.DynamicBinderResultNotAssignable(p0, p1, p2));
1578         }
1579
1580         /// <summary>
1581         /// InvalidCastException with message like "The result type '{0}' of the dynamic binding produced by the object with type '{1}' for the binder '{2}' is not compatible with the result type '{3}' expected by the call site."
1582         /// </summary>
1583         internal static Exception DynamicObjectResultNotAssignable(object p0, object p1, object p2, object p3) {
1584             return new InvalidCastException(Strings.DynamicObjectResultNotAssignable(p0, p1, p2, p3));
1585         }
1586
1587         /// <summary>
1588         /// InvalidOperationException with message like "The result of the dynamic binding produced by the object with type '{0}' for the binder '{1}' needs at least one restriction."
1589         /// </summary>
1590         internal static Exception DynamicBindingNeedsRestrictions(object p0, object p1) {
1591             return new InvalidOperationException(Strings.DynamicBindingNeedsRestrictions(p0, p1));
1592         }
1593
1594         /// <summary>
1595         /// InvalidOperationException with message like "The result type '{0}' of the binder '{1}' is not compatible with the result type '{2}' expected by the call site."
1596         /// </summary>
1597         internal static Exception BinderNotCompatibleWithCallSite(object p0, object p1, object p2) {
1598             return new InvalidOperationException(Strings.BinderNotCompatibleWithCallSite(p0, p1, p2));
1599         }
1600
1601         /// <summary>
1602         /// InvalidOperationException with message like "The unary operator {0} is not defined for the type '{1}'."
1603         /// </summary>
1604         internal static Exception UnaryOperatorNotDefined(object p0, object p1) {
1605             return new InvalidOperationException(Strings.UnaryOperatorNotDefined(p0, p1));
1606         }
1607
1608         /// <summary>
1609         /// InvalidOperationException with message like "The binary operator {0} is not defined for the types '{1}' and '{2}'."
1610         /// </summary>
1611         internal static Exception BinaryOperatorNotDefined(object p0, object p1, object p2) {
1612             return new InvalidOperationException(Strings.BinaryOperatorNotDefined(p0, p1, p2));
1613         }
1614
1615         /// <summary>
1616         /// InvalidOperationException with message like "Reference equality is not defined for the types '{0}' and '{1}'."
1617         /// </summary>
1618         internal static Exception ReferenceEqualityNotDefined(object p0, object p1) {
1619             return new InvalidOperationException(Strings.ReferenceEqualityNotDefined(p0, p1));
1620         }
1621
1622         /// <summary>
1623         /// InvalidOperationException with message like "The operands for operator '{0}' do not match the parameters of method '{1}'."
1624         /// </summary>
1625         internal static Exception OperandTypesDoNotMatchParameters(object p0, object p1) {
1626             return new InvalidOperationException(Strings.OperandTypesDoNotMatchParameters(p0, p1));
1627         }
1628
1629         /// <summary>
1630         /// InvalidOperationException with message like "The return type of overload method for operator '{0}' does not match the parameter type of conversion method '{1}'."
1631         /// </summary>
1632         internal static Exception OverloadOperatorTypeDoesNotMatchConversionType(object p0, object p1) {
1633             return new InvalidOperationException(Strings.OverloadOperatorTypeDoesNotMatchConversionType(p0, p1));
1634         }
1635
1636         /// <summary>
1637         /// InvalidOperationException with message like "Conversion is not supported for arithmetic types without operator overloading."
1638         /// </summary>
1639         internal static Exception ConversionIsNotSupportedForArithmeticTypes() {
1640             return new InvalidOperationException(Strings.ConversionIsNotSupportedForArithmeticTypes);
1641         }
1642
1643         /// <summary>
1644         /// ArgumentException with message like "Argument must be array"
1645         /// </summary>
1646         internal static Exception ArgumentMustBeArray() {
1647             return new ArgumentException(Strings.ArgumentMustBeArray);
1648         }
1649
1650         /// <summary>
1651         /// ArgumentException with message like "Argument must be boolean"
1652         /// </summary>
1653         internal static Exception ArgumentMustBeBoolean() {
1654             return new ArgumentException(Strings.ArgumentMustBeBoolean);
1655         }
1656
1657         /// <summary>
1658         /// ArgumentException with message like "The user-defined equality method '{0}' must return a boolean value."
1659         /// </summary>
1660         internal static Exception EqualityMustReturnBoolean(object p0) {
1661             return new ArgumentException(Strings.EqualityMustReturnBoolean(p0));
1662         }
1663
1664         /// <summary>
1665         /// ArgumentException with message like "Argument must be either a FieldInfo or PropertyInfo"
1666         /// </summary>
1667         internal static Exception ArgumentMustBeFieldInfoOrPropertInfo() {
1668             return new ArgumentException(Strings.ArgumentMustBeFieldInfoOrPropertInfo);
1669         }
1670
1671         /// <summary>
1672         /// ArgumentException with message like "Argument must be either a FieldInfo, PropertyInfo or MethodInfo"
1673         /// </summary>
1674         internal static Exception ArgumentMustBeFieldInfoOrPropertInfoOrMethod() {
1675             return new ArgumentException(Strings.ArgumentMustBeFieldInfoOrPropertInfoOrMethod);
1676         }
1677
1678         /// <summary>
1679         /// ArgumentException with message like "Argument must be an instance member"
1680         /// </summary>
1681         internal static Exception ArgumentMustBeInstanceMember() {
1682             return new ArgumentException(Strings.ArgumentMustBeInstanceMember);
1683         }
1684
1685         /// <summary>
1686         /// ArgumentException with message like "Argument must be of an integer type"
1687         /// </summary>
1688         internal static Exception ArgumentMustBeInteger() {
1689             return new ArgumentException(Strings.ArgumentMustBeInteger);
1690         }
1691
1692         /// <summary>
1693         /// ArgumentException with message like "Argument for array index must be of type Int32"
1694         /// </summary>
1695         internal static Exception ArgumentMustBeArrayIndexType() {
1696             return new ArgumentException(Strings.ArgumentMustBeArrayIndexType);
1697         }
1698
1699         /// <summary>
1700         /// ArgumentException with message like "Argument must be single dimensional array type"
1701         /// </summary>
1702         internal static Exception ArgumentMustBeSingleDimensionalArrayType() {
1703             return new ArgumentException(Strings.ArgumentMustBeSingleDimensionalArrayType);
1704         }
1705
1706         /// <summary>
1707         /// ArgumentException with message like "Argument types do not match"
1708         /// </summary>
1709         internal static Exception ArgumentTypesMustMatch() {
1710             return new ArgumentException(Strings.ArgumentTypesMustMatch);
1711         }
1712
1713         /// <summary>
1714         /// InvalidOperationException with message like "Cannot auto initialize elements of value type through property '{0}', use assignment instead"
1715         /// </summary>
1716         internal static Exception CannotAutoInitializeValueTypeElementThroughProperty(object p0) {
1717             return new InvalidOperationException(Strings.CannotAutoInitializeValueTypeElementThroughProperty(p0));
1718         }
1719
1720         /// <summary>
1721         /// InvalidOperationException with message like "Cannot auto initialize members of value type through property '{0}', use assignment instead"
1722         /// </summary>
1723         internal static Exception CannotAutoInitializeValueTypeMemberThroughProperty(object p0) {
1724             return new InvalidOperationException(Strings.CannotAutoInitializeValueTypeMemberThroughProperty(p0));
1725         }
1726
1727         /// <summary>
1728         /// ArgumentException with message like "The type used in TypeAs Expression must be of reference or nullable type, {0} is neither"
1729         /// </summary>
1730         internal static Exception IncorrectTypeForTypeAs(object p0) {
1731             return new ArgumentException(Strings.IncorrectTypeForTypeAs(p0));
1732         }
1733
1734         /// <summary>
1735         /// InvalidOperationException with message like "Coalesce used with type that cannot be null"
1736         /// </summary>
1737         internal static Exception CoalesceUsedOnNonNullType() {
1738             return new InvalidOperationException(Strings.CoalesceUsedOnNonNullType);
1739         }
1740
1741         /// <summary>
1742         /// InvalidOperationException with message like "An expression of type '{0}' cannot be used to initialize an array of type '{1}'"
1743         /// </summary>
1744         internal static Exception ExpressionTypeCannotInitializeArrayType(object p0, object p1) {
1745             return new InvalidOperationException(Strings.ExpressionTypeCannotInitializeArrayType(p0, p1));
1746         }
1747
1748         /// <summary>
1749         /// ArgumentException with message like "Expression of type '{0}' cannot be used for constructor parameter of type '{1}'"
1750         /// </summary>
1751         internal static Exception ExpressionTypeDoesNotMatchConstructorParameter(object p0, object p1) {
1752             return new ArgumentException(Strings.ExpressionTypeDoesNotMatchConstructorParameter(p0, p1));
1753         }
1754
1755         /// <summary>
1756         /// ArgumentException with message like " Argument type '{0}' does not match the corresponding member type '{1}'"
1757         /// </summary>
1758         internal static Exception ArgumentTypeDoesNotMatchMember(object p0, object p1) {
1759             return new ArgumentException(Strings.ArgumentTypeDoesNotMatchMember(p0, p1));
1760         }
1761
1762         /// <summary>
1763         /// ArgumentException with message like " The member '{0}' is not declared on type '{1}' being created"
1764         /// </summary>
1765         internal static Exception ArgumentMemberNotDeclOnType(object p0, object p1) {
1766             return new ArgumentException(Strings.ArgumentMemberNotDeclOnType(p0, p1));
1767         }
1768
1769         /// <summary>
1770         /// ArgumentException with message like "Expression of type '{0}' cannot be used for parameter of type '{1}' of method '{2}'"
1771         /// </summary>
1772         internal static Exception ExpressionTypeDoesNotMatchMethodParameter(object p0, object p1, object p2) {
1773             return new ArgumentException(Strings.ExpressionTypeDoesNotMatchMethodParameter(p0, p1, p2));
1774         }
1775
1776         /// <summary>
1777         /// ArgumentException with message like "Expression of type '{0}' cannot be used for parameter of type '{1}'"
1778         /// </summary>
1779         internal static Exception ExpressionTypeDoesNotMatchParameter(object p0, object p1) {
1780             return new ArgumentException(Strings.ExpressionTypeDoesNotMatchParameter(p0, p1));
1781         }
1782
1783         /// <summary>
1784         /// ArgumentException with message like "Expression of type '{0}' cannot be used for return type '{1}'"
1785         /// </summary>
1786         internal static Exception ExpressionTypeDoesNotMatchReturn(object p0, object p1) {
1787             return new ArgumentException(Strings.ExpressionTypeDoesNotMatchReturn(p0, p1));
1788         }
1789
1790         /// <summary>
1791         /// ArgumentException with message like "Expression of type '{0}' cannot be used for assignment to type '{1}'"
1792         /// </summary>
1793         internal static Exception ExpressionTypeDoesNotMatchAssignment(object p0, object p1) {
1794             return new ArgumentException(Strings.ExpressionTypeDoesNotMatchAssignment(p0, p1));
1795         }
1796
1797         /// <summary>
1798         /// ArgumentException with message like "Expression of type '{0}' cannot be used for label of type '{1}'"
1799         /// </summary>
1800         internal static Exception ExpressionTypeDoesNotMatchLabel(object p0, object p1) {
1801             return new ArgumentException(Strings.ExpressionTypeDoesNotMatchLabel(p0, p1));
1802         }
1803
1804         /// <summary>
1805         /// ArgumentException with message like "Expression of type '{0}' cannot be invoked"
1806         /// </summary>
1807         internal static Exception ExpressionTypeNotInvocable(object p0) {
1808             return new ArgumentException(Strings.ExpressionTypeNotInvocable(p0));
1809         }
1810
1811         /// <summary>
1812         /// ArgumentException with message like "Field '{0}' is not defined for type '{1}'"
1813         /// </summary>
1814         internal static Exception FieldNotDefinedForType(object p0, object p1) {
1815             return new ArgumentException(Strings.FieldNotDefinedForType(p0, p1));
1816         }
1817
1818         /// <summary>
1819         /// ArgumentException with message like "Instance field '{0}' is not defined for type '{1}'"
1820         /// </summary>
1821         internal static Exception InstanceFieldNotDefinedForType(object p0, object p1) {
1822             return new ArgumentException(Strings.InstanceFieldNotDefinedForType(p0, p1));
1823         }
1824
1825         /// <summary>
1826         /// ArgumentException with message like "Field '{0}.{1}' is not defined for type '{2}'"
1827         /// </summary>
1828         internal static Exception FieldInfoNotDefinedForType(object p0, object p1, object p2) {
1829             return new ArgumentException(Strings.FieldInfoNotDefinedForType(p0, p1, p2));
1830         }
1831
1832         /// <summary>
1833         /// ArgumentException with message like "Incorrect number of indexes"
1834         /// </summary>
1835         internal static Exception IncorrectNumberOfIndexes() {
1836             return new ArgumentException(Strings.IncorrectNumberOfIndexes);
1837         }
1838
1839         /// <summary>
1840         /// InvalidOperationException with message like "Incorrect number of arguments supplied for lambda invocation"
1841         /// </summary>
1842         internal static Exception IncorrectNumberOfLambdaArguments() {
1843             return new InvalidOperationException(Strings.IncorrectNumberOfLambdaArguments);
1844         }
1845
1846         /// <summary>
1847         /// ArgumentException with message like "Incorrect number of parameters supplied for lambda declaration"
1848         /// </summary>
1849         internal static Exception IncorrectNumberOfLambdaDeclarationParameters() {
1850             return new ArgumentException(Strings.IncorrectNumberOfLambdaDeclarationParameters);
1851         }
1852
1853         /// <summary>
1854         /// ArgumentException with message like "Incorrect number of arguments supplied for call to method '{0}'"
1855         /// </summary>
1856         internal static Exception IncorrectNumberOfMethodCallArguments(object p0) {
1857             return new ArgumentException(Strings.IncorrectNumberOfMethodCallArguments(p0));
1858         }
1859
1860         /// <summary>
1861         /// ArgumentException with message like "Incorrect number of arguments for constructor"
1862         /// </summary>
1863         internal static Exception IncorrectNumberOfConstructorArguments() {
1864             return new ArgumentException(Strings.IncorrectNumberOfConstructorArguments);
1865         }
1866
1867         /// <summary>
1868         /// ArgumentException with message like " Incorrect number of members for constructor"
1869         /// </summary>
1870         internal static Exception IncorrectNumberOfMembersForGivenConstructor() {
1871             return new ArgumentException(Strings.IncorrectNumberOfMembersForGivenConstructor);
1872         }
1873
1874         /// <summary>
1875         /// ArgumentException with message like "Incorrect number of arguments for the given members "
1876         /// </summary>
1877         internal static Exception IncorrectNumberOfArgumentsForMembers() {
1878             return new ArgumentException(Strings.IncorrectNumberOfArgumentsForMembers);
1879         }
1880
1881         /// <summary>
1882         /// ArgumentException with message like "Lambda type parameter must be derived from System.Delegate"
1883         /// </summary>
1884         internal static Exception LambdaTypeMustBeDerivedFromSystemDelegate() {
1885             return new ArgumentException(Strings.LambdaTypeMustBeDerivedFromSystemDelegate);
1886         }
1887
1888         /// <summary>
1889         /// ArgumentException with message like "Member '{0}' not field or property"
1890         /// </summary>
1891         internal static Exception MemberNotFieldOrProperty(object p0) {
1892             return new ArgumentException(Strings.MemberNotFieldOrProperty(p0));
1893         }
1894
1895         /// <summary>
1896         /// ArgumentException with message like "Method {0} contains generic parameters"
1897         /// </summary>
1898         internal static Exception MethodContainsGenericParameters(object p0) {
1899             return new ArgumentException(Strings.MethodContainsGenericParameters(p0));
1900         }
1901
1902         /// <summary>
1903         /// ArgumentException with message like "Method {0} is a generic method definition"
1904         /// </summary>
1905         internal static Exception MethodIsGeneric(object p0) {
1906             return new ArgumentException(Strings.MethodIsGeneric(p0));
1907         }
1908
1909         /// <summary>
1910         /// ArgumentException with message like "The method '{0}.{1}' is not a property accessor"
1911         /// </summary>
1912         internal static Exception MethodNotPropertyAccessor(object p0, object p1) {
1913             return new ArgumentException(Strings.MethodNotPropertyAccessor(p0, p1));
1914         }
1915
1916         /// <summary>
1917         /// ArgumentException with message like "The property '{0}' has no 'get' accessor"
1918         /// </summary>
1919         internal static Exception PropertyDoesNotHaveGetter(object p0) {
1920             return new ArgumentException(Strings.PropertyDoesNotHaveGetter(p0));
1921         }
1922
1923         /// <summary>
1924         /// ArgumentException with message like "The property '{0}' has no 'set' accessor"
1925         /// </summary>
1926         internal static Exception PropertyDoesNotHaveSetter(object p0) {
1927             return new ArgumentException(Strings.PropertyDoesNotHaveSetter(p0));
1928         }
1929
1930         /// <summary>
1931         /// ArgumentException with message like "The property '{0}' has no 'get' or 'set' accessors"
1932         /// </summary>
1933         internal static Exception PropertyDoesNotHaveAccessor(object p0) {
1934             return new ArgumentException(Strings.PropertyDoesNotHaveAccessor(p0));
1935         }
1936
1937         /// <summary>
1938         /// ArgumentException with message like "'{0}' is not a member of type '{1}'"
1939         /// </summary>
1940         internal static Exception NotAMemberOfType(object p0, object p1) {
1941             return new ArgumentException(Strings.NotAMemberOfType(p0, p1));
1942         }
1943
1944         /// <summary>
1945         /// NotImplementedException with message like "The operator '{0}' is not implemented for type '{1}'"
1946         /// </summary>
1947         internal static Exception OperatorNotImplementedForType(object p0, object p1) {
1948             return new NotImplementedException(Strings.OperatorNotImplementedForType(p0, p1));
1949         }
1950
1951         /// <summary>
1952         /// ArgumentException with message like "ParameterExpression of type '{0}' cannot be used for delegate parameter of type '{1}'"
1953         /// </summary>
1954         internal static Exception ParameterExpressionNotValidAsDelegate(object p0, object p1) {
1955             return new ArgumentException(Strings.ParameterExpressionNotValidAsDelegate(p0, p1));
1956         }
1957
1958         /// <summary>
1959         /// ArgumentException with message like "Property '{0}' is not defined for type '{1}'"
1960         /// </summary>
1961         internal static Exception PropertyNotDefinedForType(object p0, object p1) {
1962             return new ArgumentException(Strings.PropertyNotDefinedForType(p0, p1));
1963         }
1964
1965         /// <summary>
1966         /// ArgumentException with message like "Instance property '{0}' is not defined for type '{1}'"
1967         /// </summary>
1968         internal static Exception InstancePropertyNotDefinedForType(object p0, object p1) {
1969             return new ArgumentException(Strings.InstancePropertyNotDefinedForType(p0, p1));
1970         }
1971
1972         /// <summary>
1973         /// ArgumentException with message like "Instance property '{0}' that takes no argument is not defined for type '{1}'"
1974         /// </summary>
1975         internal static Exception InstancePropertyWithoutParameterNotDefinedForType(object p0, object p1) {
1976             return new ArgumentException(Strings.InstancePropertyWithoutParameterNotDefinedForType(p0, p1));
1977         }
1978
1979         /// <summary>
1980         /// ArgumentException with message like "Instance property '{0}{1}' is not defined for type '{2}'"
1981         /// </summary>
1982         internal static Exception InstancePropertyWithSpecifiedParametersNotDefinedForType(object p0, object p1, object p2) {
1983             return new ArgumentException(Strings.InstancePropertyWithSpecifiedParametersNotDefinedForType(p0, p1, p2));
1984         }
1985
1986         /// <summary>
1987         /// ArgumentException with message like "Method '{0}' declared on type '{1}' cannot be called with instance of type '{2}'"
1988         /// </summary>
1989         internal static Exception InstanceAndMethodTypeMismatch(object p0, object p1, object p2) {
1990             return new ArgumentException(Strings.InstanceAndMethodTypeMismatch(p0, p1, p2));
1991         }
1992
1993         /// <summary>
1994         /// ArgumentException with message like "Type {0} contains generic parameters"
1995         /// </summary>
1996         internal static Exception TypeContainsGenericParameters(object p0) {
1997             return new ArgumentException(Strings.TypeContainsGenericParameters(p0));
1998         }
1999
2000         /// <summary>
2001         /// ArgumentException with message like "Type {0} is a generic type definition"
2002         /// </summary>
2003         internal static Exception TypeIsGeneric(object p0) {
2004             return new ArgumentException(Strings.TypeIsGeneric(p0));
2005         }
2006
2007         /// <summary>
2008         /// ArgumentException with message like "Type '{0}' does not have a default constructor"
2009         /// </summary>
2010         internal static Exception TypeMissingDefaultConstructor(object p0) {
2011             return new ArgumentException(Strings.TypeMissingDefaultConstructor(p0));
2012         }
2013
2014         /// <summary>
2015         /// ArgumentException with message like "List initializers must contain at least one initializer"
2016         /// </summary>
2017         internal static Exception ListInitializerWithZeroMembers() {
2018             return new ArgumentException(Strings.ListInitializerWithZeroMembers);
2019         }
2020
2021         /// <summary>
2022         /// ArgumentException with message like "Element initializer method must be named 'Add'"
2023         /// </summary>
2024         internal static Exception ElementInitializerMethodNotAdd() {
2025             return new ArgumentException(Strings.ElementInitializerMethodNotAdd);
2026         }
2027
2028         /// <summary>
2029         /// ArgumentException with message like "Parameter '{0}' of element initializer method '{1}' must not be a pass by reference parameter"
2030         /// </summary>
2031         internal static Exception ElementInitializerMethodNoRefOutParam(object p0, object p1) {
2032             return new ArgumentException(Strings.ElementInitializerMethodNoRefOutParam(p0, p1));
2033         }
2034
2035         /// <summary>
2036         /// ArgumentException with message like "Element initializer method must have at least 1 parameter"
2037         /// </summary>
2038         internal static Exception ElementInitializerMethodWithZeroArgs() {
2039             return new ArgumentException(Strings.ElementInitializerMethodWithZeroArgs);
2040         }
2041
2042         /// <summary>
2043         /// ArgumentException with message like "Element initializer method must be an instance method"
2044         /// </summary>
2045         internal static Exception ElementInitializerMethodStatic() {
2046             return new ArgumentException(Strings.ElementInitializerMethodStatic);
2047         }
2048
2049         /// <summary>
2050         /// ArgumentException with message like "Type '{0}' is not IEnumerable"
2051         /// </summary>
2052         internal static Exception TypeNotIEnumerable(object p0) {
2053             return new ArgumentException(Strings.TypeNotIEnumerable(p0));
2054         }
2055
2056         /// <summary>
2057         /// InvalidOperationException with message like "Type parameter is {0}. Expected a delegate."
2058         /// </summary>
2059         internal static Exception TypeParameterIsNotDelegate(object p0) {
2060             return new InvalidOperationException(Strings.TypeParameterIsNotDelegate(p0));
2061         }
2062
2063         /// <summary>
2064         /// InvalidOperationException with message like "Unexpected coalesce operator."
2065         /// </summary>
2066         internal static Exception UnexpectedCoalesceOperator() {
2067             return new InvalidOperationException(Strings.UnexpectedCoalesceOperator);
2068         }
2069
2070         /// <summary>
2071         /// InvalidOperationException with message like "Cannot cast from type '{0}' to type '{1}"
2072         /// </summary>
2073         internal static Exception InvalidCast(object p0, object p1) {
2074             return new InvalidOperationException(Strings.InvalidCast(p0, p1));
2075         }
2076
2077         /// <summary>
2078         /// ArgumentException with message like "Unhandled binary: {0}"
2079         /// </summary>
2080         internal static Exception UnhandledBinary(object p0) {
2081             return new ArgumentException(Strings.UnhandledBinary(p0));
2082         }
2083
2084         /// <summary>
2085         /// ArgumentException with message like "Unhandled binding "
2086         /// </summary>
2087         internal static Exception UnhandledBinding() {
2088             return new ArgumentException(Strings.UnhandledBinding);
2089         }
2090
2091         /// <summary>
2092         /// ArgumentException with message like "Unhandled Binding Type: {0}"
2093         /// </summary>
2094         internal static Exception UnhandledBindingType(object p0) {
2095             return new ArgumentException(Strings.UnhandledBindingType(p0));
2096         }
2097
2098         /// <summary>
2099         /// ArgumentException with message like "Unhandled convert: {0}"
2100         /// </summary>
2101         internal static Exception UnhandledConvert(object p0) {
2102             return new ArgumentException(Strings.UnhandledConvert(p0));
2103         }
2104
2105         /// <summary>
2106         /// ArgumentException with message like "Unhandled Expression Type: {0}"
2107         /// </summary>
2108         internal static Exception UnhandledExpressionType(object p0) {
2109             return new ArgumentException(Strings.UnhandledExpressionType(p0));
2110         }
2111
2112         /// <summary>
2113         /// ArgumentException with message like "Unhandled unary: {0}"
2114         /// </summary>
2115         internal static Exception UnhandledUnary(object p0) {
2116             return new ArgumentException(Strings.UnhandledUnary(p0));
2117         }
2118
2119         /// <summary>
2120         /// ArgumentException with message like "Unknown binding type"
2121         /// </summary>
2122         internal static Exception UnknownBindingType() {
2123             return new ArgumentException(Strings.UnknownBindingType);
2124         }
2125
2126         /// <summary>
2127         /// ArgumentException with message like "The user-defined operator method '{1}' for operator '{0}' must have identical parameter and return types."
2128         /// </summary>
2129         internal static Exception UserDefinedOpMustHaveConsistentTypes(object p0, object p1) {
2130             return new ArgumentException(Strings.UserDefinedOpMustHaveConsistentTypes(p0, p1));
2131         }
2132
2133         /// <summary>
2134         /// ArgumentException with message like "The user-defined operator method '{1}' for operator '{0}' must return the same type as its parameter or a derived type."
2135         /// </summary>
2136         internal static Exception UserDefinedOpMustHaveValidReturnType(object p0, object p1) {
2137             return new ArgumentException(Strings.UserDefinedOpMustHaveValidReturnType(p0, p1));
2138         }
2139
2140         /// <summary>
2141         /// ArgumentException with message like "The user-defined operator method '{1}' for operator '{0}' must have associated boolean True and False operators."
2142         /// </summary>
2143         internal static Exception LogicalOperatorMustHaveBooleanOperators(object p0, object p1) {
2144             return new ArgumentException(Strings.LogicalOperatorMustHaveBooleanOperators(p0, p1));
2145         }
2146
2147         /// <summary>
2148         /// InvalidOperationException with message like "No method '{0}' exists on type '{1}'."
2149         /// </summary>
2150         internal static Exception MethodDoesNotExistOnType(object p0, object p1) {
2151             return new InvalidOperationException(Strings.MethodDoesNotExistOnType(p0, p1));
2152         }
2153
2154         /// <summary>
2155         /// InvalidOperationException with message like "No method '{0}' on type '{1}' is compatible with the supplied arguments."
2156         /// </summary>
2157         internal static Exception MethodWithArgsDoesNotExistOnType(object p0, object p1) {
2158             return new InvalidOperationException(Strings.MethodWithArgsDoesNotExistOnType(p0, p1));
2159         }
2160
2161         /// <summary>
2162         /// InvalidOperationException with message like "No generic method '{0}' on type '{1}' is compatible with the supplied type arguments and arguments. No type arguments should be provided if the method is non-generic. "
2163         /// </summary>
2164         internal static Exception GenericMethodWithArgsDoesNotExistOnType(object p0, object p1) {
2165             return new InvalidOperationException(Strings.GenericMethodWithArgsDoesNotExistOnType(p0, p1));
2166         }
2167
2168         /// <summary>
2169         /// InvalidOperationException with message like "More than one method '{0}' on type '{1}' is compatible with the supplied arguments."
2170         /// </summary>
2171         internal static Exception MethodWithMoreThanOneMatch(object p0, object p1) {
2172             return new InvalidOperationException(Strings.MethodWithMoreThanOneMatch(p0, p1));
2173         }
2174
2175         /// <summary>
2176         /// InvalidOperationException with message like "More than one property '{0}' on type '{1}' is compatible with the supplied arguments."
2177         /// </summary>
2178         internal static Exception PropertyWithMoreThanOneMatch(object p0, object p1) {
2179             return new InvalidOperationException(Strings.PropertyWithMoreThanOneMatch(p0, p1));
2180         }
2181
2182         /// <summary>
2183         /// ArgumentException with message like "An incorrect number of type args were specified for the declaration of a Func type."
2184         /// </summary>
2185         internal static Exception IncorrectNumberOfTypeArgsForFunc() {
2186             return new ArgumentException(Strings.IncorrectNumberOfTypeArgsForFunc);
2187         }
2188
2189         /// <summary>
2190         /// ArgumentException with message like "An incorrect number of type args were specified for the declaration of an Action type."
2191         /// </summary>
2192         internal static Exception IncorrectNumberOfTypeArgsForAction() {
2193             return new ArgumentException(Strings.IncorrectNumberOfTypeArgsForAction);
2194         }
2195
2196         /// <summary>
2197         /// ArgumentException with message like "Argument type cannot be System.Void."
2198         /// </summary>
2199         internal static Exception ArgumentCannotBeOfTypeVoid() {
2200             return new ArgumentException(Strings.ArgumentCannotBeOfTypeVoid);
2201         }
2202
2203         /// <summary>
2204         /// System.Reflection.AmbiguousMatchException with message like "More than one key matching '{0}' was found in the ExpandoObject."
2205         /// </summary>
2206         internal static Exception AmbiguousMatchInExpandoObject(object p0) {
2207             return new System.Reflection.AmbiguousMatchException(Strings.AmbiguousMatchInExpandoObject(p0));
2208         }
2209
2210         /// <summary>
2211         /// ArgumentException with message like "An element with the same key '{0}' already exists in the ExpandoObject."
2212         /// </summary>
2213         internal static Exception SameKeyExistsInExpando(object p0) {
2214             return new ArgumentException(Strings.SameKeyExistsInExpando(p0));
2215         }
2216
2217         /// <summary>
2218         /// System.Collections.Generic.KeyNotFoundException with message like "The specified key '{0}' does not exist in the ExpandoObject."
2219         /// </summary>
2220         internal static Exception KeyDoesNotExistInExpando(object p0) {
2221             return new System.Collections.Generic.KeyNotFoundException(Strings.KeyDoesNotExistInExpando(p0));
2222         }
2223
2224         /// <summary>
2225         /// InvalidOperationException with message like "No or Invalid rule produced"
2226         /// </summary>
2227         internal static Exception NoOrInvalidRuleProduced() {
2228             return new InvalidOperationException(Strings.NoOrInvalidRuleProduced);
2229         }
2230
2231         /// <summary>
2232         /// ArgumentException with message like "First argument of delegate must be CallSite"
2233         /// </summary>
2234         internal static Exception FirstArgumentMustBeCallSite() {
2235             return new ArgumentException(Strings.FirstArgumentMustBeCallSite);
2236         }
2237
2238         /// <summary>
2239         /// InvalidOperationException with message like "Bind cannot return null."
2240         /// </summary>
2241         internal static Exception BindingCannotBeNull() {
2242             return new InvalidOperationException(Strings.BindingCannotBeNull);
2243         }
2244
2245         /// <summary>
2246         /// ArgumentException with message like "Invalid operation: '{0}'"
2247         /// </summary>
2248         internal static Exception InvalidOperation(object p0) {
2249             return new ArgumentException(Strings.InvalidOperation(p0));
2250         }
2251
2252         /// <summary>
2253         /// ArgumentOutOfRangeException with message like "{0} must be greater than or equal to {1}"
2254         /// </summary>
2255         internal static Exception OutOfRange(object p0, object p1) {
2256             return new ArgumentOutOfRangeException(Strings.OutOfRange(p0, p1));
2257         }
2258
2259         /// <summary>
2260         /// InvalidOperationException with message like "Queue empty."
2261         /// </summary>
2262         internal static Exception QueueEmpty() {
2263             return new InvalidOperationException(Strings.QueueEmpty);
2264         }
2265
2266         /// <summary>
2267         /// InvalidOperationException with message like "Cannot redefine label '{0}' in an inner block."
2268         /// </summary>
2269         internal static Exception LabelTargetAlreadyDefined(object p0) {
2270             return new InvalidOperationException(Strings.LabelTargetAlreadyDefined(p0));
2271         }
2272
2273         /// <summary>
2274         /// InvalidOperationException with message like "Cannot jump to undefined label '{0}'."
2275         /// </summary>
2276         internal static Exception LabelTargetUndefined(object p0) {
2277             return new InvalidOperationException(Strings.LabelTargetUndefined(p0));
2278         }
2279
2280         /// <summary>
2281         /// InvalidOperationException with message like "Control cannot leave a finally block."
2282         /// </summary>
2283         internal static Exception ControlCannotLeaveFinally() {
2284             return new InvalidOperationException(Strings.ControlCannotLeaveFinally);
2285         }
2286
2287         /// <summary>
2288         /// InvalidOperationException with message like "Control cannot leave a filter test."
2289         /// </summary>
2290         internal static Exception ControlCannotLeaveFilterTest() {
2291             return new InvalidOperationException(Strings.ControlCannotLeaveFilterTest);
2292         }
2293
2294         /// <summary>
2295         /// InvalidOperationException with message like "Cannot jump to ambiguous label '{0}'."
2296         /// </summary>
2297         internal static Exception AmbiguousJump(object p0) {
2298             return new InvalidOperationException(Strings.AmbiguousJump(p0));
2299         }
2300
2301         /// <summary>
2302         /// InvalidOperationException with message like "Control cannot enter a try block."
2303         /// </summary>
2304         internal static Exception ControlCannotEnterTry() {
2305             return new InvalidOperationException(Strings.ControlCannotEnterTry);
2306         }
2307
2308         /// <summary>
2309         /// InvalidOperationException with message like "Control cannot enter an expression--only statements can be jumped into."
2310         /// </summary>
2311         internal static Exception ControlCannotEnterExpression() {
2312             return new InvalidOperationException(Strings.ControlCannotEnterExpression);
2313         }
2314
2315         /// <summary>
2316         /// InvalidOperationException with message like "Cannot jump to non-local label '{0}' with a value. Only jumps to labels defined in outer blocks can pass values."
2317         /// </summary>
2318         internal static Exception NonLocalJumpWithValue(object p0) {
2319             return new InvalidOperationException(Strings.NonLocalJumpWithValue(p0));
2320         }
2321
2322         /// <summary>
2323         /// InvalidOperationException with message like "Extension should have been reduced."
2324         /// </summary>
2325         internal static Exception ExtensionNotReduced() {
2326             return new InvalidOperationException(Strings.ExtensionNotReduced);
2327         }
2328
2329         /// <summary>
2330         /// InvalidOperationException with message like "CompileToMethod cannot compile constant '{0}' because it is a non-trivial value, such as a live object. Instead, create an expression tree that can construct this value."
2331         /// </summary>
2332         internal static Exception CannotCompileConstant(object p0) {
2333             return new InvalidOperationException(Strings.CannotCompileConstant(p0));
2334         }
2335
2336         /// <summary>
2337         /// NotSupportedException with message like "Dynamic expressions are not supported by CompileToMethod. Instead, create an expression tree that uses System.Runtime.CompilerServices.CallSite."
2338         /// </summary>
2339         internal static Exception CannotCompileDynamic() {
2340             return new NotSupportedException(Strings.CannotCompileDynamic);
2341         }
2342
2343         /// <summary>
2344         /// InvalidOperationException with message like "Invalid lvalue for assignment: {0}."
2345         /// </summary>
2346         internal static Exception InvalidLvalue(object p0) {
2347             return new InvalidOperationException(Strings.InvalidLvalue(p0));
2348         }
2349
2350         /// <summary>
2351         /// InvalidOperationException with message like "Invalid member type: {0}."
2352         /// </summary>
2353         internal static Exception InvalidMemberType(object p0) {
2354             return new InvalidOperationException(Strings.InvalidMemberType(p0));
2355         }
2356
2357         /// <summary>
2358         /// InvalidOperationException with message like "unknown lift type: '{0}'."
2359         /// </summary>
2360         internal static Exception UnknownLiftType(object p0) {
2361             return new InvalidOperationException(Strings.UnknownLiftType(p0));
2362         }
2363
2364         /// <summary>
2365         /// ArgumentException with message like "Invalid output directory."
2366         /// </summary>
2367         internal static Exception InvalidOutputDir() {
2368             return new ArgumentException(Strings.InvalidOutputDir);
2369         }
2370
2371         /// <summary>
2372         /// ArgumentException with message like "Invalid assembly name or file extension."
2373         /// </summary>
2374         internal static Exception InvalidAsmNameOrExtension() {
2375             return new ArgumentException(Strings.InvalidAsmNameOrExtension);
2376         }
2377
2378         /// <summary>
2379         /// NotSupportedException with message like "Collection is read-only."
2380         /// </summary>
2381         internal static Exception CollectionReadOnly() {
2382             return new NotSupportedException(Strings.CollectionReadOnly);
2383         }
2384
2385         /// <summary>
2386         /// ArgumentException with message like "Cannot create instance of {0} because it contains generic parameters"
2387         /// </summary>
2388         internal static Exception IllegalNewGenericParams(object p0) {
2389             return new ArgumentException(Strings.IllegalNewGenericParams(p0));
2390         }
2391
2392         /// <summary>
2393         /// InvalidOperationException with message like "variable '{0}' of type '{1}' referenced from scope '{2}', but it is not defined"
2394         /// </summary>
2395         internal static Exception UndefinedVariable(object p0, object p1, object p2) {
2396             return new InvalidOperationException(Strings.UndefinedVariable(p0, p1, p2));
2397         }
2398
2399         /// <summary>
2400         /// InvalidOperationException with message like "Cannot close over byref parameter '{0}' referenced in lambda '{1}'"
2401         /// </summary>
2402         internal static Exception CannotCloseOverByRef(object p0, object p1) {
2403             return new InvalidOperationException(Strings.CannotCloseOverByRef(p0, p1));
2404         }
2405
2406         /// <summary>
2407         /// InvalidOperationException with message like "Unexpected VarArgs call to method '{0}'"
2408         /// </summary>
2409         internal static Exception UnexpectedVarArgsCall(object p0) {
2410             return new InvalidOperationException(Strings.UnexpectedVarArgsCall(p0));
2411         }
2412
2413         /// <summary>
2414         /// InvalidOperationException with message like "Rethrow statement is valid only inside a Catch block."
2415         /// </summary>
2416         internal static Exception RethrowRequiresCatch() {
2417             return new InvalidOperationException(Strings.RethrowRequiresCatch);
2418         }
2419
2420         /// <summary>
2421         /// InvalidOperationException with message like "Try expression is not allowed inside a filter body."
2422         /// </summary>
2423         internal static Exception TryNotAllowedInFilter() {
2424             return new InvalidOperationException(Strings.TryNotAllowedInFilter);
2425         }
2426
2427         /// <summary>
2428         /// InvalidOperationException with message like "When called from '{0}', rewriting a node of type '{1}' must return a non-null value of the same type. Alternatively, override '{2}' and change it to not visit children of this type."
2429         /// </summary>
2430         internal static Exception MustRewriteToSameNode(object p0, object p1, object p2) {
2431             return new InvalidOperationException(Strings.MustRewriteToSameNode(p0, p1, p2));
2432         }
2433
2434         /// <summary>
2435         /// InvalidOperationException with message like "Rewriting child expression from type '{0}' to type '{1}' is not allowed, because it would change the meaning of the operation. If this is intentional, override '{2}' and change it to allow this rewrite."
2436         /// </summary>
2437         internal static Exception MustRewriteChildToSameType(object p0, object p1, object p2) {
2438             return new InvalidOperationException(Strings.MustRewriteChildToSameType(p0, p1, p2));
2439         }
2440
2441         /// <summary>
2442         /// InvalidOperationException with message like "Rewritten expression calls operator method '{0}', but the original node had no operator method. If this is is intentional, override '{1}' and change it to allow this rewrite."
2443         /// </summary>
2444         internal static Exception MustRewriteWithoutMethod(object p0, object p1) {
2445             return new InvalidOperationException(Strings.MustRewriteWithoutMethod(p0, p1));
2446         }
2447
2448         /// <summary>
2449         /// ArgumentNullException with message like "The value null is not of type '{0}' and cannot be used in this collection."
2450         /// </summary>
2451         internal static Exception InvalidNullValue(object p0) {
2452             return new ArgumentNullException(Strings.InvalidNullValue(p0));
2453         }
2454
2455         /// <summary>
2456         /// ArgumentException with message like "The value '{0}' is not of type '{1}' and cannot be used in this collection."
2457         /// </summary>
2458         internal static Exception InvalidObjectType(object p0, object p1) {
2459             return new ArgumentException(Strings.InvalidObjectType(p0, p1));
2460         }
2461
2462         /// <summary>
2463         /// NotSupportedException with message like "TryExpression is not supported as an argument to method '{0}' because it has an argument with by-ref type. Construct the tree so the TryExpression is not nested inside of this expression."
2464         /// </summary>
2465         internal static Exception TryNotSupportedForMethodsWithRefArgs(object p0) {
2466             return new NotSupportedException(Strings.TryNotSupportedForMethodsWithRefArgs(p0));
2467         }
2468
2469         /// <summary>
2470         /// NotSupportedException with message like "TryExpression is not supported as a child expression when accessing a member on type '{0}' because it is a value type. Construct the tree so the TryExpression is not nested inside of this expression."
2471         /// </summary>
2472         internal static Exception TryNotSupportedForValueTypeInstances(object p0) {
2473             return new NotSupportedException(Strings.TryNotSupportedForValueTypeInstances(p0));
2474         }
2475
2476         /// <summary>
2477         /// InvalidOperationException with message like "Collection was modified; enumeration operation may not execute."
2478         /// </summary>
2479         internal static Exception CollectionModifiedWhileEnumerating() {
2480             return new InvalidOperationException(Strings.CollectionModifiedWhileEnumerating);
2481         }
2482
2483         /// <summary>
2484         /// InvalidOperationException with message like "Enumeration has either not started or has already finished."
2485         /// </summary>
2486         internal static Exception EnumerationIsDone() {
2487             return new InvalidOperationException(Strings.EnumerationIsDone);
2488         }
2489
2490         /// <summary>
2491         /// InvalidOperationException with message like "Dynamic operations can only be performed in homogenous AppDomain."
2492         /// </summary>
2493         internal static Exception HomogenousAppDomainRequired() {
2494             return new InvalidOperationException(Strings.HomogenousAppDomainRequired);
2495         }
2496
2497         /// <summary>
2498         /// ArgumentException with message like "Test value of type '{0}' cannot be used for the comparison method parameter of type '{1}'"
2499         /// </summary>
2500         internal static Exception TestValueTypeDoesNotMatchComparisonMethodParameter(object p0, object p1) {
2501             return new ArgumentException(Strings.TestValueTypeDoesNotMatchComparisonMethodParameter(p0, p1));
2502         }
2503
2504         /// <summary>
2505         /// ArgumentException with message like "Switch value of type '{0}' cannot be used for the comparison method parameter of type '{1}'"
2506         /// </summary>
2507         internal static Exception SwitchValueTypeDoesNotMatchComparisonMethodParameter(object p0, object p1) {
2508             return new ArgumentException(Strings.SwitchValueTypeDoesNotMatchComparisonMethodParameter(p0, p1));
2509         }
2510
2511         /// <summary>
2512         /// InvalidOperationException with message like "An IDynamicMetaObjectProvider {0} created an invalid DynamicMetaObject instance."
2513         /// </summary>
2514         internal static Exception InvalidMetaObjectCreated(object p0) {
2515             return new InvalidOperationException(Strings.InvalidMetaObjectCreated(p0));
2516         }
2517
2518     }
2519
2520     // *** END GENERATED CODE ***
2521
2522     #endregion
2523
2524 }