mcs/class/dlr/Runtime/Microsoft.Dynamic/Utils/ExceptionFactory.Generated.cs

   1 /* ****************************************************************************
   2  *
   3  * Copyright (c) Microsoft Corporation.
   4  *
   5  * This source code is subject to terms and conditions of the Apache License, Version 2.0. 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  Apache License, Version 2.0, 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 Apache License, Version 2.0.
  10  *
  11  * You must not remove this notice, or any other, from this software.
  12  *
  13  *
  14  * ***************************************************************************/
  15
  16 using System;
  17
  18 namespace Microsoft.Scripting {
  19
  20     internal static partial class Strings {
  21         private static string FormatString(string format, params object[] args) {
  22             return string.Format(System.Globalization.CultureInfo.CurrentCulture, format, args);
  23         }
  24     }
  25
  26     #region Generated Microsoft.Scripting Exception Factory
  27
  28     // *** BEGIN GENERATED CODE ***
  29     // generated by function: gen_expr_factory_scripting from: generate_exception_factory.py
  30
  31     /// <summary>
  32     ///    Strongly-typed and parameterized string factory.
  33     /// </summary>
  34
  35     internal static partial class Strings {
  36         /// <summary>
  37         /// A string like  "Cannot access member {1} declared on type {0} because the type contains generic parameters."
  38         /// </summary>
  39         internal static string InvalidOperation_ContainsGenericParameters(object p0, object p1) {
  40             return FormatString("Cannot access member {1} declared on type {0} because the type contains generic parameters.", p0, p1);
  41         }
  42
  43         /// <summary>
  44         /// A string like  "Type '{0}' is missing or cannot be loaded."
  45         /// </summary>
  46         internal static string MissingType(object p0) {
  47             return FormatString("Type '{0}' is missing or cannot be loaded.", p0);
  48         }
  49
  50         /// <summary>
  51         /// A string like  "static property "{0}" of "{1}" can only be read through a type, not an instance"
  52         /// </summary>
  53         internal static string StaticAccessFromInstanceError(object p0, object p1) {
  54             return FormatString("static property \"{0}\" of \"{1}\" can only be read through a type, not an instance", p0, p1);
  55         }
  56
  57         /// <summary>
  58         /// A string like  "static property "{0}" of "{1}" can only be assigned to through a type, not an instance"
  59         /// </summary>
  60         internal static string StaticAssignmentFromInstanceError(object p0, object p1) {
  61             return FormatString("static property \"{0}\" of \"{1}\" can only be assigned to through a type, not an instance", p0, p1);
  62         }
  63
  64         /// <summary>
  65         /// A string like  "Method precondition violated"
  66         /// </summary>
  67         internal static string MethodPreconditionViolated {
  68             get {
  69                 return "Method precondition violated";
  70             }
  71         }
  72
  73         /// <summary>
  74         /// A string like  "Invalid argument value"
  75         /// </summary>
  76         internal static string InvalidArgumentValue {
  77             get {
  78                 return "Invalid argument value";
  79             }
  80         }
  81
  82         /// <summary>
  83         /// A string like  "Non-empty string required"
  84         /// </summary>
  85         internal static string NonEmptyStringRequired {
  86             get {
  87                 return "Non-empty string required";
  88             }
  89         }
  90
  91         /// <summary>
  92         /// A string like  "Non-empty collection required"
  93         /// </summary>
  94         internal static string NonEmptyCollectionRequired {
  95             get {
  96                 return "Non-empty collection required";
  97             }
  98         }
  99
 100         /// <summary>
 101         /// A string like  "must by an Exception instance"
 102         /// </summary>
 103         internal static string MustBeExceptionInstance {
 104             get {
 105                 return "must by an Exception instance";
 106             }
 107         }
 108
 109         /// <summary>
 110         /// A string like  "Type of test must be bool"
 111         /// </summary>
 112         internal static string TypeOfTestMustBeBool {
 113             get {
 114                 return "Type of test must be bool";
 115             }
 116         }
 117
 118         /// <summary>
 119         /// A string like  "Type of the expression must be bool"
 120         /// </summary>
 121         internal static string TypeOfExpressionMustBeBool {
 122             get {
 123                 return "Type of the expression must be bool";
 124             }
 125         }
 126
 127         /// <summary>
 128         /// A string like  "Empty string is not a valid path."
 129         /// </summary>
 130         internal static string EmptyStringIsInvalidPath {
 131             get {
 132                 return "Empty string is not a valid path.";
 133             }
 134         }
 135
 136         /// <summary>
 137         /// A string like  "Invalid delegate type (Invoke method not found)."
 138         /// </summary>
 139         internal static string InvalidDelegate {
 140             get {
 141                 return "Invalid delegate type (Invoke method not found).";
 142             }
 143         }
 144
 145         /// <summary>
 146         /// A string like  "expected only static property"
 147         /// </summary>
 148         internal static string ExpectedStaticProperty {
 149             get {
 150                 return "expected only static property";
 151             }
 152         }
 153
 154         /// <summary>
 155         /// A string like  "Property doesn't exist on the provided type"
 156         /// </summary>
 157         internal static string PropertyDoesNotExist {
 158             get {
 159                 return "Property doesn't exist on the provided type";
 160             }
 161         }
 162
 163         /// <summary>
 164         /// A string like  "Field doesn't exist on provided type"
 165         /// </summary>
 166         internal static string FieldDoesNotExist {
 167             get {
 168                 return "Field doesn't exist on provided type";
 169             }
 170         }
 171
 172         /// <summary>
 173         /// A string like  "Type doesn't have constructor with a given signature"
 174         /// </summary>
 175         internal static string TypeDoesNotHaveConstructorForTheSignature {
 176             get {
 177                 return "Type doesn't have constructor with a given signature";
 178             }
 179         }
 180
 181         /// <summary>
 182         /// A string like  "Type doesn't have a method with a given name."
 183         /// </summary>
 184         internal static string TypeDoesNotHaveMethodForName {
 185             get {
 186                 return "Type doesn't have a method with a given name.";
 187             }
 188         }
 189
 190         /// <summary>
 191         /// A string like  "Type doesn't have a method with a given name and signature."
 192         /// </summary>
 193         internal static string TypeDoesNotHaveMethodForNameSignature {
 194             get {
 195                 return "Type doesn't have a method with a given name and signature.";
 196             }
 197         }
 198
 199         /// <summary>
 200         /// A string like  "Count must be non-negative."
 201         /// </summary>
 202         internal static string CountCannotBeNegative {
 203             get {
 204                 return "Count must be non-negative.";
 205             }
 206         }
 207
 208         /// <summary>
 209         /// A string like  "arrayType must be an array type"
 210         /// </summary>
 211         internal static string ArrayTypeMustBeArray {
 212             get {
 213                 return "arrayType must be an array type";
 214             }
 215         }
 216
 217         /// <summary>
 218         /// A string like  "Either code or target must be specified."
 219         /// </summary>
 220         internal static string MustHaveCodeOrTarget {
 221             get {
 222                 return "Either code or target must be specified.";
 223             }
 224         }
 225
 226         /// <summary>
 227         /// A string like  "Type parameter is {0}. Expected a delegate."
 228         /// </summary>
 229         internal static string TypeParameterIsNotDelegate(object p0) {
 230             return FormatString("Type parameter is {0}. Expected a delegate.", p0);
 231         }
 232
 233         /// <summary>
 234         /// A string like  "Cannot cast from type '{0}' to type '{1}"
 235         /// </summary>
 236         internal static string InvalidCast(object p0, object p1) {
 237             return FormatString("Cannot cast from type '{0}' to type '{1}", p0, p1);
 238         }
 239
 240         /// <summary>
 241         /// A string like  "unknown member type: '{0}'. "
 242         /// </summary>
 243         internal static string UnknownMemberType(object p0) {
 244             return FormatString("unknown member type: '{0}'. ", p0);
 245         }
 246
 247         /// <summary>
 248         /// A string like  "RuleBuilder can only be used with delegates whose first argument is CallSite."
 249         /// </summary>
 250         internal static string FirstArgumentMustBeCallSite {
 251             get {
 252                 return "RuleBuilder can only be used with delegates whose first argument is CallSite.";
 253             }
 254         }
 255
 256         /// <summary>
 257         /// A string like  "no instance for call."
 258         /// </summary>
 259         internal static string NoInstanceForCall {
 260             get {
 261                 return "no instance for call.";
 262             }
 263         }
 264
 265         /// <summary>
 266         /// A string like  "Missing Test."
 267         /// </summary>
 268         internal static string MissingTest {
 269             get {
 270                 return "Missing Test.";
 271             }
 272         }
 273
 274         /// <summary>
 275         /// A string like  "Missing Target."
 276         /// </summary>
 277         internal static string MissingTarget {
 278             get {
 279                 return "Missing Target.";
 280             }
 281         }
 282
 283         /// <summary>
 284         /// A string like  "The operation requires a non-generic type for {0}, but this represents generic types only"
 285         /// </summary>
 286         internal static string NonGenericWithGenericGroup(object p0) {
 287             return FormatString("The operation requires a non-generic type for {0}, but this represents generic types only", p0);
 288         }
 289
 290         /// <summary>
 291         /// A string like  "Invalid operation: '{0}'"
 292         /// </summary>
 293         internal static string InvalidOperation(object p0) {
 294             return FormatString("Invalid operation: '{0}'", p0);
 295         }
 296
 297         /// <summary>
 298         /// A string like  "Finally already defined."
 299         /// </summary>
 300         internal static string FinallyAlreadyDefined {
 301             get {
 302                 return "Finally already defined.";
 303             }
 304         }
 305
 306         /// <summary>
 307         /// A string like  "Can not have fault and finally."
 308         /// </summary>
 309         internal static string CannotHaveFaultAndFinally {
 310             get {
 311                 return "Can not have fault and finally.";
 312             }
 313         }
 314
 315         /// <summary>
 316         /// A string like  "Fault already defined."
 317         /// </summary>
 318         internal static string FaultAlreadyDefined {
 319             get {
 320                 return "Fault already defined.";
 321             }
 322         }
 323
 324         /// <summary>
 325         /// A string like  "Cannot create default value for type {0}."
 326         /// </summary>
 327         internal static string CantCreateDefaultTypeFor(object p0) {
 328             return FormatString("Cannot create default value for type {0}.", p0);
 329         }
 330
 331         /// <summary>
 332         /// A string like  "Unhandled convert: {0}"
 333         /// </summary>
 334         internal static string UnhandledConvert(object p0) {
 335             return FormatString("Unhandled convert: {0}", p0);
 336         }
 337
 338         /// <summary>
 339         /// A string like  "{0}.{1} has no publiclly visible method."
 340         /// </summary>
 341         internal static string NoCallableMethods(object p0, object p1) {
 342             return FormatString("{0}.{1} has no publiclly visible method.", p0, p1);
 343         }
 344
 345         /// <summary>
 346         /// A string like  "Global/top-level local variable names must be unique."
 347         /// </summary>
 348         internal static string GlobalsMustBeUnique {
 349             get {
 350                 return "Global/top-level local variable names must be unique.";
 351             }
 352         }
 353
 354         /// <summary>
 355         /// A string like  "Generating code from non-serializable CallSiteBinder."
 356         /// </summary>
 357         internal static string GenNonSerializableBinder {
 358             get {
 359                 return "Generating code from non-serializable CallSiteBinder.";
 360             }
 361         }
 362
 363         /// <summary>
 364         /// A string like  "pecified path is invalid."
 365         /// </summary>
 366         internal static string InvalidPath {
 367             get {
 368                 return "pecified path is invalid.";
 369             }
 370         }
 371
 372         /// <summary>
 373         /// A string like  "Dictionaries are not hashable."
 374         /// </summary>
 375         internal static string DictionaryNotHashable {
 376             get {
 377                 return "Dictionaries are not hashable.";
 378             }
 379         }
 380
 381         /// <summary>
 382         /// A string like  "language already registered."
 383         /// </summary>
 384         internal static string LanguageRegistered {
 385             get {
 386                 return "language already registered.";
 387             }
 388         }
 389
 390         /// <summary>
 391         /// A string like  "The method or operation is not implemented."
 392         /// </summary>
 393         internal static string MethodOrOperatorNotImplemented {
 394             get {
 395                 return "The method or operation is not implemented.";
 396             }
 397         }
 398
 399         /// <summary>
 400         /// A string like  "No exception."
 401         /// </summary>
 402         internal static string NoException {
 403             get {
 404                 return "No exception.";
 405             }
 406         }
 407
 408         /// <summary>
 409         /// A string like  "Extension type {0} must be public."
 410         /// </summary>
 411         internal static string ExtensionMustBePublic(object p0) {
 412             return FormatString("Extension type {0} must be public.", p0);
 413         }
 414
 415         /// <summary>
 416         /// A string like  "Already initialized."
 417         /// </summary>
 418         internal static string AlreadyInitialized {
 419             get {
 420                 return "Already initialized.";
 421             }
 422         }
 423
 424         /// <summary>
 425         /// A string like  "CreateScopeExtension must return a scope extension."
 426         /// </summary>
 427         internal static string MustReturnScopeExtension {
 428             get {
 429                 return "CreateScopeExtension must return a scope extension.";
 430             }
 431         }
 432
 433         /// <summary>
 434         /// A string like  "Invalid number of parameters for the service."
 435         /// </summary>
 436         internal static string InvalidParamNumForService {
 437             get {
 438                 return "Invalid number of parameters for the service.";
 439             }
 440         }
 441
 442         /// <summary>
 443         /// A string like  "Invalid type of argument {0}; expecting {1}."
 444         /// </summary>
 445         internal static string InvalidArgumentType(object p0, object p1) {
 446             return FormatString("Invalid type of argument {0}; expecting {1}.", p0, p1);
 447         }
 448
 449         /// <summary>
 450         /// A string like  "Cannot change non-caching value."
 451         /// </summary>
 452         internal static string CannotChangeNonCachingValue {
 453             get {
 454                 return "Cannot change non-caching value.";
 455             }
 456         }
 457
 458         /// <summary>
 459         /// A string like  "Field {0} is read-only"
 460         /// </summary>
 461         internal static string FieldReadonly(object p0) {
 462             return FormatString("Field {0} is read-only", p0);
 463         }
 464
 465         /// <summary>
 466         /// A string like  "Property {0} is read-only"
 467         /// </summary>
 468         internal static string PropertyReadonly(object p0) {
 469             return FormatString("Property {0} is read-only", p0);
 470         }
 471
 472         /// <summary>
 473         /// A string like  "Expected event from {0}.{1}, got event from {2}.{3}."
 474         /// </summary>
 475         internal static string UnexpectedEvent(object p0, object p1, object p2, object p3) {
 476             return FormatString("Expected event from {0}.{1}, got event from {2}.{3}.", p0, p1, p2, p3);
 477         }
 478
 479         /// <summary>
 480         /// A string like  "expected bound event, got {0}."
 481         /// </summary>
 482         internal static string ExpectedBoundEvent(object p0) {
 483             return FormatString("expected bound event, got {0}.", p0);
 484         }
 485
 486         /// <summary>
 487         /// A string like  "Expected type {0}, got {1}."
 488         /// </summary>
 489         internal static string UnexpectedType(object p0, object p1) {
 490             return FormatString("Expected type {0}, got {1}.", p0, p1);
 491         }
 492
 493         /// <summary>
 494         /// A string like  "can only write to member {0}."
 495         /// </summary>
 496         internal static string MemberWriteOnly(object p0) {
 497             return FormatString("can only write to member {0}.", p0);
 498         }
 499
 500         /// <summary>
 501         /// A string like  "No code to compile."
 502         /// </summary>
 503         internal static string NoCodeToCompile {
 504             get {
 505                 return "No code to compile.";
 506             }
 507         }
 508
 509         /// <summary>
 510         /// A string like  "Invalid stream type: {0}."
 511         /// </summary>
 512         internal static string InvalidStreamType(object p0) {
 513             return FormatString("Invalid stream type: {0}.", p0);
 514         }
 515
 516         /// <summary>
 517         /// A string like  "Queue empty."
 518         /// </summary>
 519         internal static string QueueEmpty {
 520             get {
 521                 return "Queue empty.";
 522             }
 523         }
 524
 525         /// <summary>
 526         /// A string like  "Enumeration has not started. Call MoveNext."
 527         /// </summary>
 528         internal static string EnumerationNotStarted {
 529             get {
 530                 return "Enumeration has not started. Call MoveNext.";
 531             }
 532         }
 533
 534         /// <summary>
 535         /// A string like  "Enumeration already finished."
 536         /// </summary>
 537         internal static string EnumerationFinished {
 538             get {
 539                 return "Enumeration already finished.";
 540             }
 541         }
 542
 543         /// <summary>
 544         /// A string like  "can't add another casing for identifier {0}"
 545         /// </summary>
 546         internal static string CantAddCasing(object p0) {
 547             return FormatString("can't add another casing for identifier {0}", p0);
 548         }
 549
 550         /// <summary>
 551         /// A string like  "can't add new identifier {0}"
 552         /// </summary>
 553         internal static string CantAddIdentifier(object p0) {
 554             return FormatString("can't add new identifier {0}", p0);
 555         }
 556
 557         /// <summary>
 558         /// A string like  "Type '{0}' doesn't provide a suitable public constructor or its implementation is faulty: {1}"
 559         /// </summary>
 560         internal static string InvalidCtorImplementation(object p0, object p1) {
 561             return FormatString("Type '{0}' doesn't provide a suitable public constructor or its implementation is faulty: {1}", p0, p1);
 562         }
 563
 564         /// <summary>
 565         /// A string like  "Invalid output directory."
 566         /// </summary>
 567         internal static string InvalidOutputDir {
 568             get {
 569                 return "Invalid output directory.";
 570             }
 571         }
 572
 573         /// <summary>
 574         /// A string like  "Invalid assembly name or file extension."
 575         /// </summary>
 576         internal static string InvalidAsmNameOrExtension {
 577             get {
 578                 return "Invalid assembly name or file extension.";
 579             }
 580         }
 581
 582         /// <summary>
 583         /// A string like  "Cannot emit constant {0} ({1})"
 584         /// </summary>
 585         internal static string CanotEmitConstant(object p0, object p1) {
 586             return FormatString("Cannot emit constant {0} ({1})", p0, p1);
 587         }
 588
 589         /// <summary>
 590         /// A string like  "No implicit cast from {0} to {1}"
 591         /// </summary>
 592         internal static string NoImplicitCast(object p0, object p1) {
 593             return FormatString("No implicit cast from {0} to {1}", p0, p1);
 594         }
 595
 596         /// <summary>
 597         /// A string like  "No explicit cast from {0} to {1}"
 598         /// </summary>
 599         internal static string NoExplicitCast(object p0, object p1) {
 600             return FormatString("No explicit cast from {0} to {1}", p0, p1);
 601         }
 602
 603         /// <summary>
 604         /// A string like  "name '{0}' not defined"
 605         /// </summary>
 606         internal static string NameNotDefined(object p0) {
 607             return FormatString("name '{0}' not defined", p0);
 608         }
 609
 610         /// <summary>
 611         /// A string like  "No default value for a given type."
 612         /// </summary>
 613         internal static string NoDefaultValue {
 614             get {
 615                 return "No default value for a given type.";
 616             }
 617         }
 618
 619         /// <summary>
 620         /// A string like  "Specified language provider type is not registered."
 621         /// </summary>
 622         internal static string UnknownLanguageProviderType {
 623             get {
 624                 return "Specified language provider type is not registered.";
 625             }
 626         }
 627
 628         /// <summary>
 629         /// A string like  "can't read from property"
 630         /// </summary>
 631         internal static string CantReadProperty {
 632             get {
 633                 return "can't read from property";
 634             }
 635         }
 636
 637         /// <summary>
 638         /// A string like  "can't write to property"
 639         /// </summary>
 640         internal static string CantWriteProperty {
 641             get {
 642                 return "can't write to property";
 643             }
 644         }
 645
 646         /// <summary>
 647         /// A string like  "Cannot create instance of {0} because it contains generic parameters"
 648         /// </summary>
 649         internal static string IllegalNew_GenericParams(object p0) {
 650             return FormatString("Cannot create instance of {0} because it contains generic parameters", p0);
 651         }
 652
 653         /// <summary>
 654         /// A string like  "Non-verifiable assembly generated: {0}:\nAssembly preserved as {1}\nError text:\n{2}\n"
 655         /// </summary>
 656         internal static string VerificationException(object p0, object p1, object p2) {
 657             return FormatString("Non-verifiable assembly generated: {0}:\nAssembly preserved as {1}\nError text:\n{2}\n", p0, p1, p2);
 658         }
 659
 660     }
 661     /// <summary>
 662     ///    Strongly-typed and parameterized exception factory.
 663     /// </summary>
 664
 665     internal static partial class Error {
 666         /// <summary>
 667         /// ArgumentException with message like "Either code or target must be specified."
 668         /// </summary>
 669         internal static Exception MustHaveCodeOrTarget() {
 670             return new ArgumentException(Strings.MustHaveCodeOrTarget);
 671         }
 672
 673         /// <summary>
 674         /// InvalidOperationException with message like "Type parameter is {0}. Expected a delegate."
 675         /// </summary>
 676         internal static Exception TypeParameterIsNotDelegate(object p0) {
 677             return new InvalidOperationException(Strings.TypeParameterIsNotDelegate(p0));
 678         }
 679
 680         /// <summary>
 681         /// InvalidOperationException with message like "Cannot cast from type '{0}' to type '{1}"
 682         /// </summary>
 683         internal static Exception InvalidCast(object p0, object p1) {
 684             return new InvalidOperationException(Strings.InvalidCast(p0, p1));
 685         }
 686
 687         /// <summary>
 688         /// InvalidOperationException with message like "unknown member type: '{0}'. "
 689         /// </summary>
 690         internal static Exception UnknownMemberType(object p0) {
 691             return new InvalidOperationException(Strings.UnknownMemberType(p0));
 692         }
 693
 694         /// <summary>
 695         /// InvalidOperationException with message like "RuleBuilder can only be used with delegates whose first argument is CallSite."
 696         /// </summary>
 697         internal static Exception FirstArgumentMustBeCallSite() {
 698             return new InvalidOperationException(Strings.FirstArgumentMustBeCallSite);
 699         }
 700
 701         /// <summary>
 702         /// InvalidOperationException with message like "no instance for call."
 703         /// </summary>
 704         internal static Exception NoInstanceForCall() {
 705             return new InvalidOperationException(Strings.NoInstanceForCall);
 706         }
 707
 708         /// <summary>
 709         /// InvalidOperationException with message like "Missing Test."
 710         /// </summary>
 711         internal static Exception MissingTest() {
 712             return new InvalidOperationException(Strings.MissingTest);
 713         }
 714
 715         /// <summary>
 716         /// InvalidOperationException with message like "Missing Target."
 717         /// </summary>
 718         internal static Exception MissingTarget() {
 719             return new InvalidOperationException(Strings.MissingTarget);
 720         }
 721
 722         /// <summary>
 723         /// TypeLoadException with message like "The operation requires a non-generic type for {0}, but this represents generic types only"
 724         /// </summary>
 725         internal static Exception NonGenericWithGenericGroup(object p0) {
 726             return new TypeLoadException(Strings.NonGenericWithGenericGroup(p0));
 727         }
 728
 729         /// <summary>
 730         /// ArgumentException with message like "Invalid operation: '{0}'"
 731         /// </summary>
 732         internal static Exception InvalidOperation(object p0) {
 733             return new ArgumentException(Strings.InvalidOperation(p0));
 734         }
 735
 736         /// <summary>
 737         /// InvalidOperationException with message like "Finally already defined."
 738         /// </summary>
 739         internal static Exception FinallyAlreadyDefined() {
 740             return new InvalidOperationException(Strings.FinallyAlreadyDefined);
 741         }
 742
 743         /// <summary>
 744         /// InvalidOperationException with message like "Can not have fault and finally."
 745         /// </summary>
 746         internal static Exception CannotHaveFaultAndFinally() {
 747             return new InvalidOperationException(Strings.CannotHaveFaultAndFinally);
 748         }
 749
 750         /// <summary>
 751         /// InvalidOperationException with message like "Fault already defined."
 752         /// </summary>
 753         internal static Exception FaultAlreadyDefined() {
 754             return new InvalidOperationException(Strings.FaultAlreadyDefined);
 755         }
 756
 757         /// <summary>
 758         /// ArgumentException with message like "Cannot create default value for type {0}."
 759         /// </summary>
 760         internal static Exception CantCreateDefaultTypeFor(object p0) {
 761             return new ArgumentException(Strings.CantCreateDefaultTypeFor(p0));
 762         }
 763
 764         /// <summary>
 765         /// ArgumentException with message like "Unhandled convert: {0}"
 766         /// </summary>
 767         internal static Exception UnhandledConvert(object p0) {
 768             return new ArgumentException(Strings.UnhandledConvert(p0));
 769         }
 770
 771         /// <summary>
 772         /// InvalidOperationException with message like "{0}.{1} has no publiclly visible method."
 773         /// </summary>
 774         internal static Exception NoCallableMethods(object p0, object p1) {
 775             return new InvalidOperationException(Strings.NoCallableMethods(p0, p1));
 776         }
 777
 778         /// <summary>
 779         /// ArgumentException with message like "Global/top-level local variable names must be unique."
 780         /// </summary>
 781         internal static Exception GlobalsMustBeUnique() {
 782             return new ArgumentException(Strings.GlobalsMustBeUnique);
 783         }
 784
 785         /// <summary>
 786         /// ArgumentException with message like "Generating code from non-serializable CallSiteBinder."
 787         /// </summary>
 788         internal static Exception GenNonSerializableBinder() {
 789             return new ArgumentException(Strings.GenNonSerializableBinder);
 790         }
 791
 792         /// <summary>
 793         /// ArgumentException with message like "pecified path is invalid."
 794         /// </summary>
 795         internal static Exception InvalidPath() {
 796             return new ArgumentException(Strings.InvalidPath);
 797         }
 798
 799         /// <summary>
 800         /// ArgumentTypeException with message like "Dictionaries are not hashable."
 801         /// </summary>
 802         internal static Exception DictionaryNotHashable() {
 803             return new ArgumentTypeException(Strings.DictionaryNotHashable);
 804         }
 805
 806         /// <summary>
 807         /// InvalidOperationException with message like "language already registered."
 808         /// </summary>
 809         internal static Exception LanguageRegistered() {
 810             return new InvalidOperationException(Strings.LanguageRegistered);
 811         }
 812
 813         /// <summary>
 814         /// NotImplementedException with message like "The method or operation is not implemented."
 815         /// </summary>
 816         internal static Exception MethodOrOperatorNotImplemented() {
 817             return new NotImplementedException(Strings.MethodOrOperatorNotImplemented);
 818         }
 819
 820         /// <summary>
 821         /// InvalidOperationException with message like "No exception."
 822         /// </summary>
 823         internal static Exception NoException() {
 824             return new InvalidOperationException(Strings.NoException);
 825         }
 826
 827         /// <summary>
 828         /// ArgumentException with message like "Extension type {0} must be public."
 829         /// </summary>
 830         internal static Exception ExtensionMustBePublic(object p0) {
 831             return new ArgumentException(Strings.ExtensionMustBePublic(p0));
 832         }
 833
 834         /// <summary>
 835         /// InvalidOperationException with message like "Already initialized."
 836         /// </summary>
 837         internal static Exception AlreadyInitialized() {
 838             return new InvalidOperationException(Strings.AlreadyInitialized);
 839         }
 840
 841         /// <summary>
 842         /// InvalidImplementationException with message like "CreateScopeExtension must return a scope extension."
 843         /// </summary>
 844         internal static Exception MustReturnScopeExtension() {
 845             return new InvalidImplementationException(Strings.MustReturnScopeExtension);
 846         }
 847
 848         /// <summary>
 849         /// ArgumentException with message like "Invalid number of parameters for the service."
 850         /// </summary>
 851         internal static Exception InvalidParamNumForService() {
 852             return new ArgumentException(Strings.InvalidParamNumForService);
 853         }
 854
 855         /// <summary>
 856         /// ArgumentException with message like "Invalid type of argument {0}; expecting {1}."
 857         /// </summary>
 858         internal static Exception InvalidArgumentType(object p0, object p1) {
 859             return new ArgumentException(Strings.InvalidArgumentType(p0, p1));
 860         }
 861
 862         /// <summary>
 863         /// ArgumentException with message like "Cannot change non-caching value."
 864         /// </summary>
 865         internal static Exception CannotChangeNonCachingValue() {
 866             return new ArgumentException(Strings.CannotChangeNonCachingValue);
 867         }
 868
 869         /// <summary>
 870         /// MissingMemberException with message like "Field {0} is read-only"
 871         /// </summary>
 872         internal static Exception FieldReadonly(object p0) {
 873             return new MissingMemberException(Strings.FieldReadonly(p0));
 874         }
 875
 876         /// <summary>
 877         /// MissingMemberException with message like "Property {0} is read-only"
 878         /// </summary>
 879         internal static Exception PropertyReadonly(object p0) {
 880             return new MissingMemberException(Strings.PropertyReadonly(p0));
 881         }
 882
 883         /// <summary>
 884         /// ArgumentException with message like "Expected event from {0}.{1}, got event from {2}.{3}."
 885         /// </summary>
 886         internal static Exception UnexpectedEvent(object p0, object p1, object p2, object p3) {
 887             return new ArgumentException(Strings.UnexpectedEvent(p0, p1, p2, p3));
 888         }
 889
 890         /// <summary>
 891         /// ArgumentTypeException with message like "expected bound event, got {0}."
 892         /// </summary>
 893         internal static Exception ExpectedBoundEvent(object p0) {
 894             return new ArgumentTypeException(Strings.ExpectedBoundEvent(p0));
 895         }
 896
 897         /// <summary>
 898         /// ArgumentTypeException with message like "Expected type {0}, got {1}."
 899         /// </summary>
 900         internal static Exception UnexpectedType(object p0, object p1) {
 901             return new ArgumentTypeException(Strings.UnexpectedType(p0, p1));
 902         }
 903
 904         /// <summary>
 905         /// MemberAccessException with message like "can only write to member {0}."
 906         /// </summary>
 907         internal static Exception MemberWriteOnly(object p0) {
 908             return new MemberAccessException(Strings.MemberWriteOnly(p0));
 909         }
 910
 911         /// <summary>
 912         /// InvalidOperationException with message like "No code to compile."
 913         /// </summary>
 914         internal static Exception NoCodeToCompile() {
 915             return new InvalidOperationException(Strings.NoCodeToCompile);
 916         }
 917
 918         /// <summary>
 919         /// ArgumentException with message like "Invalid stream type: {0}."
 920         /// </summary>
 921         internal static Exception InvalidStreamType(object p0) {
 922             return new ArgumentException(Strings.InvalidStreamType(p0));
 923         }
 924
 925         /// <summary>
 926         /// InvalidOperationException with message like "Queue empty."
 927         /// </summary>
 928         internal static Exception QueueEmpty() {
 929             return new InvalidOperationException(Strings.QueueEmpty);
 930         }
 931
 932         /// <summary>
 933         /// InvalidOperationException with message like "Enumeration has not started. Call MoveNext."
 934         /// </summary>
 935         internal static Exception EnumerationNotStarted() {
 936             return new InvalidOperationException(Strings.EnumerationNotStarted);
 937         }
 938
 939         /// <summary>
 940         /// InvalidOperationException with message like "Enumeration already finished."
 941         /// </summary>
 942         internal static Exception EnumerationFinished() {
 943             return new InvalidOperationException(Strings.EnumerationFinished);
 944         }
 945
 946         /// <summary>
 947         /// InvalidOperationException with message like "can't add another casing for identifier {0}"
 948         /// </summary>
 949         internal static Exception CantAddCasing(object p0) {
 950             return new InvalidOperationException(Strings.CantAddCasing(p0));
 951         }
 952
 953         /// <summary>
 954         /// InvalidOperationException with message like "can't add new identifier {0}"
 955         /// </summary>
 956         internal static Exception CantAddIdentifier(object p0) {
 957             return new InvalidOperationException(Strings.CantAddIdentifier(p0));
 958         }
 959
 960         /// <summary>
 961         /// ArgumentException with message like "Invalid output directory."
 962         /// </summary>
 963         internal static Exception InvalidOutputDir() {
 964             return new ArgumentException(Strings.InvalidOutputDir);
 965         }
 966
 967         /// <summary>
 968         /// ArgumentException with message like "Invalid assembly name or file extension."
 969         /// </summary>
 970         internal static Exception InvalidAsmNameOrExtension() {
 971             return new ArgumentException(Strings.InvalidAsmNameOrExtension);
 972         }
 973
 974         /// <summary>
 975         /// ArgumentException with message like "Cannot emit constant {0} ({1})"
 976         /// </summary>
 977         internal static Exception CanotEmitConstant(object p0, object p1) {
 978             return new ArgumentException(Strings.CanotEmitConstant(p0, p1));
 979         }
 980
 981         /// <summary>
 982         /// ArgumentException with message like "No implicit cast from {0} to {1}"
 983         /// </summary>
 984         internal static Exception NoImplicitCast(object p0, object p1) {
 985             return new ArgumentException(Strings.NoImplicitCast(p0, p1));
 986         }
 987
 988         /// <summary>
 989         /// ArgumentException with message like "No explicit cast from {0} to {1}"
 990         /// </summary>
 991         internal static Exception NoExplicitCast(object p0, object p1) {
 992             return new ArgumentException(Strings.NoExplicitCast(p0, p1));
 993         }
 994
 995         /// <summary>
 996         /// MissingMemberException with message like "name '{0}' not defined"
 997         /// </summary>
 998         internal static Exception NameNotDefined(object p0) {
 999             return new MissingMemberException(Strings.NameNotDefined(p0));
1000         }
1001
1002         /// <summary>
1003         /// ArgumentException with message like "No default value for a given type."
1004         /// </summary>
1005         internal static Exception NoDefaultValue() {
1006             return new ArgumentException(Strings.NoDefaultValue);
1007         }
1008
1009         /// <summary>
1010         /// ArgumentException with message like "Specified language provider type is not registered."
1011         /// </summary>
1012         internal static Exception UnknownLanguageProviderType() {
1013             return new ArgumentException(Strings.UnknownLanguageProviderType);
1014         }
1015
1016         /// <summary>
1017         /// InvalidOperationException with message like "can't read from property"
1018         /// </summary>
1019         internal static Exception CantReadProperty() {
1020             return new InvalidOperationException(Strings.CantReadProperty);
1021         }
1022
1023         /// <summary>
1024         /// InvalidOperationException with message like "can't write to property"
1025         /// </summary>
1026         internal static Exception CantWriteProperty() {
1027             return new InvalidOperationException(Strings.CantWriteProperty);
1028         }
1029
1030         /// <summary>
1031         /// ArgumentException with message like "Cannot create instance of {0} because it contains generic parameters"
1032         /// </summary>
1033         internal static Exception IllegalNew_GenericParams(object p0) {
1034             return new ArgumentException(Strings.IllegalNew_GenericParams(p0));
1035         }
1036
1037         /// <summary>
1038         /// System.Security.VerificationException with message like "Non-verifiable assembly generated: {0}:\nAssembly preserved as {1}\nError text:\n{2}\n"
1039         /// </summary>
1040         internal static Exception VerificationException(object p0, object p1, object p2) {
1041             return new System.Security.VerificationException(Strings.VerificationException(p0, p1, p2));
1042         }
1043
1044     }
1045
1046     // *** END GENERATED CODE ***
1047
1048     #endregion
1049
1050 }