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

Large files files are truncated, but you can click here to view the full file

/* ****************************************************************************
 *
 * Copyright (c) Microsoft Corporation. 
 *
 * This source code is subject to terms and conditions of the Apache License, Version 2.0. A 
 * copy of the license can be found in the License.html file at the root of this distribution. If 
 * you cannot locate the  Apache License, Version 2.0, please send an email to 
 * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound 
 * by the terms of the Apache License, Version 2.0.
 *
 * You must not remove this notice, or any other, from this software.
 *
 *
 * ***************************************************************************/

using System;

#if !FEATURE_CORE_DLR
namespace Microsoft.Scripting.Ast {
#else
namespace System.Linq.Expressions {
#endif

    internal static partial class Strings {
        private static string FormatString(string format, params object[] args) {
            return string.Format(System.Globalization.CultureInfo.CurrentCulture, format, args);
        }
    }
    
    #region Generated Exception Factory

    // *** BEGIN GENERATED CODE ***
    // generated by function: gen_expr_factory_core from: generate_exception_factory.py

    /// <summary>
    ///    Strongly-typed and parameterized string factory.
    /// </summary>

    internal static partial class Strings {
        /// <summary>
        /// A string like  "Method precondition violated"
        /// </summary>
        internal static string MethodPreconditionViolated {
            get {
                return "Method precondition violated";
            }
        }

        /// <summary>
        /// A string like  "Invalid argument value"
        /// </summary>
        internal static string InvalidArgumentValue {
            get {
                return "Invalid argument value";
            }
        }

        /// <summary>
        /// A string like  "Non-empty collection required"
        /// </summary>
        internal static string NonEmptyCollectionRequired {
            get {
                return "Non-empty collection required";
            }
        }

        /// <summary>
        /// A string like  "Argument count must be greater than number of named arguments."
        /// </summary>
        internal static string ArgCntMustBeGreaterThanNameCnt {
            get {
                return "Argument count must be greater than number of named arguments.";
            }
        }

        /// <summary>
        /// A string like  "reducible nodes must override Expression.Reduce()"
        /// </summary>
        internal static string ReducibleMustOverrideReduce {
            get {
                return "reducible nodes must override Expression.Reduce()";
            }
        }

        /// <summary>
        /// A string like  "node cannot reduce to itself or null"
        /// </summary>
        internal static string MustReduceToDifferent {
            get {
                return "node cannot reduce to itself or null";
            }
        }

        /// <summary>
        /// A string like  "cannot assign from the reduced node type to the original node type"
        /// </summary>
        internal static string ReducedNotCompatible {
            get {
                return "cannot assign from the reduced node type to the original node type";
            }
        }

        /// <summary>
        /// A string like  "Setter must have parameters."
        /// </summary>
        internal static string SetterHasNoParams {
            get {
                return "Setter must have parameters.";
            }
        }

        /// <summary>
        /// A string like  "Property cannot have a managed pointer type."
        /// </summary>
        internal static string PropertyCannotHaveRefType {
            get {
                return "Property cannot have a managed pointer type.";
            }
        }

        /// <summary>
        /// A string like  "Indexing parameters of getter and setter must match."
        /// </summary>
        internal static string IndexesOfSetGetMustMatch {
            get {
                return "Indexing parameters of getter and setter must match.";
            }
        }

        /// <summary>
        /// A string like  "Accessor method should not have VarArgs."
        /// </summary>
        internal static string AccessorsCannotHaveVarArgs {
            get {
                return "Accessor method should not have VarArgs.";
            }
        }

        /// <summary>
        /// A string like  "Accessor indexes cannot be passed ByRef."
        /// </summary>
        internal static string AccessorsCannotHaveByRefArgs {
            get {
                return "Accessor indexes cannot be passed ByRef.";
            }
        }

        /// <summary>
        /// A string like  "Bounds count cannot be less than 1"
        /// </summary>
        internal static string BoundsCannotBeLessThanOne {
            get {
                return "Bounds count cannot be less than 1";
            }
        }

        /// <summary>
        /// A string like  "type must not be ByRef"
        /// </summary>
        internal static string TypeMustNotBeByRef {
            get {
                return "type must not be ByRef";
            }
        }

        /// <summary>
        /// A string like  "Type doesn't have constructor with a given signature"
        /// </summary>
        internal static string TypeDoesNotHaveConstructorForTheSignature {
            get {
                return "Type doesn't have constructor with a given signature";
            }
        }

        /// <summary>
        /// A string like  "Count must be non-negative."
        /// </summary>
        internal static string CountCannotBeNegative {
            get {
                return "Count must be non-negative.";
            }
        }

        /// <summary>
        /// A string like  "arrayType must be an array type"
        /// </summary>
        internal static string ArrayTypeMustBeArray {
            get {
                return "arrayType must be an array type";
            }
        }

        /// <summary>
        /// A string like  "Setter should have void type."
        /// </summary>
        internal static string SetterMustBeVoid {
            get {
                return "Setter should have void type.";
            }
        }

        /// <summary>
        /// A string like  "Property type must match the value type of setter"
        /// </summary>
        internal static string PropertyTyepMustMatchSetter {
            get {
                return "Property type must match the value type of setter";
            }
        }

        /// <summary>
        /// A string like  "Both accessors must be static."
        /// </summary>
        internal static string BothAccessorsMustBeStatic {
            get {
                return "Both accessors must be static.";
            }
        }

        /// <summary>
        /// A string like  "Static field requires null instance, non-static field requires non-null instance."
        /// </summary>
        internal static string OnlyStaticFieldsHaveNullInstance {
            get {
                return "Static field requires null instance, non-static field requires non-null instance.";
            }
        }

        /// <summary>
        /// A string like  "Static property requires null instance, non-static property requires non-null instance."
        /// </summary>
        internal static string OnlyStaticPropertiesHaveNullInstance {
            get {
                return "Static property requires null instance, non-static property requires non-null instance.";
            }
        }

        /// <summary>
        /// A string like  "Static method requires null instance, non-static method requires non-null instance."
        /// </summary>
        internal static string OnlyStaticMethodsHaveNullInstance {
            get {
                return "Static method requires null instance, non-static method requires non-null instance.";
            }
        }

        /// <summary>
        /// A string like  "Property cannot have a void type."
        /// </summary>
        internal static string PropertyTypeCannotBeVoid {
            get {
                return "Property cannot have a void type.";
            }
        }

        /// <summary>
        /// A string like  "Can only unbox from an object or interface type to a value type."
        /// </summary>
        internal static string InvalidUnboxType {
            get {
                return "Can only unbox from an object or interface type to a value type.";
            }
        }

        /// <summary>
        /// A string like  "Expression must be readable"
        /// </summary>
        internal static string ExpressionMustBeReadable {
            get {
                return "Expression must be readable";
            }
        }

        /// <summary>
        /// A string like  "Expression must be writeable"
        /// </summary>
        internal static string ExpressionMustBeWriteable {
            get {
                return "Expression must be writeable";
            }
        }

        /// <summary>
        /// A string like  "Argument must not have a value type."
        /// </summary>
        internal static string ArgumentMustNotHaveValueType {
            get {
                return "Argument must not have a value type.";
            }
        }

        /// <summary>
        /// A string like  "must be reducible node"
        /// </summary>
        internal static string MustBeReducible {
            get {
                return "must be reducible node";
            }
        }

        /// <summary>
        /// A string like  "All test values must have the same type."
        /// </summary>
        internal static string AllTestValuesMustHaveSameType {
            get {
                return "All test values must have the same type.";
            }
        }

        /// <summary>
        /// A string like  "All case bodies and the default body must have the same type."
        /// </summary>
        internal static string AllCaseBodiesMustHaveSameType {
            get {
                return "All case bodies and the default body must have the same type.";
            }
        }

        /// <summary>
        /// A string like  "Default body must be supplied if case bodies are not System.Void."
        /// </summary>
        internal static string DefaultBodyMustBeSupplied {
            get {
                return "Default body must be supplied if case bodies are not System.Void.";
            }
        }

        /// <summary>
        /// A string like  "MethodBuilder does not have a valid TypeBuilder"
        /// </summary>
        internal static string MethodBuilderDoesNotHaveTypeBuilder {
            get {
                return "MethodBuilder does not have a valid TypeBuilder";
            }
        }

        /// <summary>
        /// A string like  "Type must be derived from System.Delegate"
        /// </summary>
        internal static string TypeMustBeDerivedFromSystemDelegate {
            get {
                return "Type must be derived from System.Delegate";
            }
        }

        /// <summary>
        /// A string like  "Argument type cannot be void"
        /// </summary>
        internal static string ArgumentTypeCannotBeVoid {
            get {
                return "Argument type cannot be void";
            }
        }

        /// <summary>
        /// A string like  "Label type must be System.Void if an expression is not supplied"
        /// </summary>
        internal static string LabelMustBeVoidOrHaveExpression {
            get {
                return "Label type must be System.Void if an expression is not supplied";
            }
        }

        /// <summary>
        /// A string like  "Type must be System.Void for this label argument"
        /// </summary>
        internal static string LabelTypeMustBeVoid {
            get {
                return "Type must be System.Void for this label argument";
            }
        }

        /// <summary>
        /// A string like  "Quoted expression must be a lambda"
        /// </summary>
        internal static string QuotedExpressionMustBeLambda {
            get {
                return "Quoted expression must be a lambda";
            }
        }

        /// <summary>
        /// A string like  "Variable '{0}' uses unsupported type '{1}'. Reference types are not supported for variables."
        /// </summary>
        internal static string VariableMustNotBeByRef(object p0, object p1) {
            return FormatString("Variable '{0}' uses unsupported type '{1}'. Reference types are not supported for variables.", p0, p1);
        }

        /// <summary>
        /// A string like  "Found duplicate parameter '{0}'. Each ParameterExpression in the list must be a unique object."
        /// </summary>
        internal static string DuplicateVariable(object p0) {
            return FormatString("Found duplicate parameter '{0}'. Each ParameterExpression in the list must be a unique object.", p0);
        }

        /// <summary>
        /// A string like  "Start and End must be well ordered"
        /// </summary>
        internal static string StartEndMustBeOrdered {
            get {
                return "Start and End must be well ordered";
            }
        }

        /// <summary>
        /// A string like  "fault cannot be used with catch or finally clauses"
        /// </summary>
        internal static string FaultCannotHaveCatchOrFinally {
            get {
                return "fault cannot be used with catch or finally clauses";
            }
        }

        /// <summary>
        /// A string like  "try must have at least one catch, finally, or fault clause"
        /// </summary>
        internal static string TryMustHaveCatchFinallyOrFault {
            get {
                return "try must have at least one catch, finally, or fault clause";
            }
        }

        /// <summary>
        /// A string like  "Body of catch must have the same type as body of try."
        /// </summary>
        internal static string BodyOfCatchMustHaveSameTypeAsBodyOfTry {
            get {
                return "Body of catch must have the same type as body of try.";
            }
        }

        /// <summary>
        /// A string like  "Extension node must override the property {0}."
        /// </summary>
        internal static string ExtensionNodeMustOverrideProperty(object p0) {
            return FormatString("Extension node must override the property {0}.", p0);
        }

        /// <summary>
        /// A string like  "User-defined operator method '{0}' must be static."
        /// </summary>
        internal static string UserDefinedOperatorMustBeStatic(object p0) {
            return FormatString("User-defined operator method '{0}' must be static.", p0);
        }

        /// <summary>
        /// A string like  "User-defined operator method '{0}' must not be void."
        /// </summary>
        internal static string UserDefinedOperatorMustNotBeVoid(object p0) {
            return FormatString("User-defined operator method '{0}' must not be void.", p0);
        }

        /// <summary>
        /// A string like  "No coercion operator is defined between types '{0}' and '{1}'."
        /// </summary>
        internal static string CoercionOperatorNotDefined(object p0, object p1) {
            return FormatString("No coercion operator is defined between types '{0}' and '{1}'.", p0, p1);
        }

        /// <summary>
        /// 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."
        /// </summary>
        internal static string DynamicBinderResultNotAssignable(object p0, object p1, object p2) {
            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);
        }

        /// <summary>
        /// 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."
        /// </summary>
        internal static string DynamicObjectResultNotAssignable(object p0, object p1, object p2, object p3) {
            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);
        }

        /// <summary>
        /// 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."
        /// </summary>
        internal static string DynamicBindingNeedsRestrictions(object p0, object p1) {
            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);
        }

        /// <summary>
        /// A string like  "The result type '{0}' of the binder '{1}' is not compatible with the result type '{2}' expected by the call site."
        /// </summary>
        internal static string BinderNotCompatibleWithCallSite(object p0, object p1, object p2) {
            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);
        }

        /// <summary>
        /// A string like  "The unary operator {0} is not defined for the type '{1}'."
        /// </summary>
        internal static string UnaryOperatorNotDefined(object p0, object p1) {
            return FormatString("The unary operator {0} is not defined for the type '{1}'.", p0, p1);
        }

        /// <summary>
        /// A string like  "The binary operator {0} is not defined for the types '{1}' and '{2}'."
        /// </summary>
        internal static string BinaryOperatorNotDefined(object p0, object p1, object p2) {
            return FormatString("The binary operator {0} is not defined for the types '{1}' and '{2}'.", p0, p1, p2);
        }

        /// <summary>
        /// A string like  "Reference equality is not defined for the types '{0}' and '{1}'."
        /// </summary>
        internal static string ReferenceEqualityNotDefined(object p0, object p1) {
            return FormatString("Reference equality is not defined for the types '{0}' and '{1}'.", p0, p1);
        }

        /// <summary>
        /// A string like  "The operands for operator '{0}' do not match the parameters of method '{1}'."
        /// </summary>
        internal static string OperandTypesDoNotMatchParameters(object p0, object p1) {
            return FormatString("The operands for operator '{0}' do not match the parameters of method '{1}'.", p0, p1);
        }

        /// <summary>
        /// A string like  "The return type of overload method for operator '{0}' does not match the parameter type of conversion method '{1}'."
        /// </summary>
        internal static string OverloadOperatorTypeDoesNotMatchConversionType(object p0, object p1) {
            return FormatString("The return type of overload method for operator '{0}' does not match the parameter type of conversion method '{1}'.", p0, p1);
        }

        /// <summary>
        /// A string like  "Conversion is not supported for arithmetic types without operator overloading."
        /// </summary>
        internal static string ConversionIsNotSupportedForArithmeticTypes {
            get {
                return "Conversion is not supported for arithmetic types without operator overloading.";
            }
        }

        /// <summary>
        /// A string like  "Argument must be array"
        /// </summary>
        internal static string ArgumentMustBeArray {
            get {
                return "Argument must be array";
            }
        }

        /// <summary>
        /// A string like  "Argument must be boolean"
        /// </summary>
        internal static string ArgumentMustBeBoolean {
            get {
                return "Argument must be boolean";
            }
        }

        /// <summary>
        /// A string like  "The user-defined equality method '{0}' must return a boolean value."
        /// </summary>
        internal static string EqualityMustReturnBoolean(object p0) {
            return FormatString("The user-defined equality method '{0}' must return a boolean value.", p0);
        }

        /// <summary>
        /// A string like  "Argument must be either a FieldInfo or PropertyInfo"
        /// </summary>
        internal static string ArgumentMustBeFieldInfoOrPropertInfo {
            get {
                return "Argument must be either a FieldInfo or PropertyInfo";
            }
        }

        /// <summary>
        /// A string like  "Argument must be either a FieldInfo, PropertyInfo or MethodInfo"
        /// </summary>
        internal static string ArgumentMustBeFieldInfoOrPropertInfoOrMethod {
            get {
                return "Argument must be either a FieldInfo, PropertyInfo or MethodInfo";
            }
        }

        /// <summary>
        /// A string like  "Argument must be an instance member"
        /// </summary>
        internal static string ArgumentMustBeInstanceMember {
            get {
                return "Argument must be an instance member";
            }
        }

        /// <summary>
        /// A string like  "Argument must be of an integer type"
        /// </summary>
        internal static string ArgumentMustBeInteger {
            get {
                return "Argument must be of an integer type";
            }
        }

        /// <summary>
        /// A string like  "Argument for array index must be of type Int32"
        /// </summary>
        internal static string ArgumentMustBeArrayIndexType {
            get {
                return "Argument for array index must be of type Int32";
            }
        }

        /// <summary>
        /// A string like  "Argument must be single dimensional array type"
        /// </summary>
        internal static string ArgumentMustBeSingleDimensionalArrayType {
            get {
                return "Argument must be single dimensional array type";
            }
        }

        /// <summary>
        /// A string like  "Argument types do not match"
        /// </summary>
        internal static string ArgumentTypesMustMatch {
            get {
                return "Argument types do not match";
            }
        }

        /// <summary>
        /// A string like  "Cannot auto initialize elements of value type through property '{0}', use assignment instead"
        /// </summary>
        internal static string CannotAutoInitializeValueTypeElementThroughProperty(object p0) {
            return FormatString("Cannot auto initialize elements of value type through property '{0}', use assignment instead", p0);
        }

        /// <summary>
        /// A string like  "Cannot auto initialize members of value type through property '{0}', use assignment instead"
        /// </summary>
        internal static string CannotAutoInitializeValueTypeMemberThroughProperty(object p0) {
            return FormatString("Cannot auto initialize members of value type through property '{0}', use assignment instead", p0);
        }

        /// <summary>
        /// A string like  "The type used in TypeAs Expression must be of reference or nullable type, {0} is neither"
        /// </summary>
        internal static string IncorrectTypeForTypeAs(object p0) {
            return FormatString("The type used in TypeAs Expression must be of reference or nullable type, {0} is neither", p0);
        }

        /// <summary>
        /// A string like  "Coalesce used with type that cannot be null"
        /// </summary>
        internal static string CoalesceUsedOnNonNullType {
            get {
                return "Coalesce used with type that cannot be null";
            }
        }

        /// <summary>
        /// A string like  "An expression of type '{0}' cannot be used to initialize an array of type '{1}'"
        /// </summary>
        internal static string ExpressionTypeCannotInitializeArrayType(object p0, object p1) {
            return FormatString("An expression of type '{0}' cannot be used to initialize an array of type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Expression of type '{0}' cannot be used for constructor parameter of type '{1}'"
        /// </summary>
        internal static string ExpressionTypeDoesNotMatchConstructorParameter(object p0, object p1) {
            return FormatString("Expression of type '{0}' cannot be used for constructor parameter of type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  " Argument type '{0}' does not match the corresponding member type '{1}'"
        /// </summary>
        internal static string ArgumentTypeDoesNotMatchMember(object p0, object p1) {
            return FormatString(" Argument type '{0}' does not match the corresponding member type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  " The member '{0}' is not declared on type '{1}' being created"
        /// </summary>
        internal static string ArgumentMemberNotDeclOnType(object p0, object p1) {
            return FormatString(" The member '{0}' is not declared on type '{1}' being created", p0, p1);
        }

        /// <summary>
        /// A string like  "Expression of type '{0}' cannot be used for parameter of type '{1}' of method '{2}'"
        /// </summary>
        internal static string ExpressionTypeDoesNotMatchMethodParameter(object p0, object p1, object p2) {
            return FormatString("Expression of type '{0}' cannot be used for parameter of type '{1}' of method '{2}'", p0, p1, p2);
        }

        /// <summary>
        /// A string like  "Expression of type '{0}' cannot be used for parameter of type '{1}'"
        /// </summary>
        internal static string ExpressionTypeDoesNotMatchParameter(object p0, object p1) {
            return FormatString("Expression of type '{0}' cannot be used for parameter of type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Expression of type '{0}' cannot be used for return type '{1}'"
        /// </summary>
        internal static string ExpressionTypeDoesNotMatchReturn(object p0, object p1) {
            return FormatString("Expression of type '{0}' cannot be used for return type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Expression of type '{0}' cannot be used for assignment to type '{1}'"
        /// </summary>
        internal static string ExpressionTypeDoesNotMatchAssignment(object p0, object p1) {
            return FormatString("Expression of type '{0}' cannot be used for assignment to type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Expression of type '{0}' cannot be used for label of type '{1}'"
        /// </summary>
        internal static string ExpressionTypeDoesNotMatchLabel(object p0, object p1) {
            return FormatString("Expression of type '{0}' cannot be used for label of type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Expression of type '{0}' cannot be invoked"
        /// </summary>
        internal static string ExpressionTypeNotInvocable(object p0) {
            return FormatString("Expression of type '{0}' cannot be invoked", p0);
        }

        /// <summary>
        /// A string like  "Field '{0}' is not defined for type '{1}'"
        /// </summary>
        internal static string FieldNotDefinedForType(object p0, object p1) {
            return FormatString("Field '{0}' is not defined for type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Instance field '{0}' is not defined for type '{1}'"
        /// </summary>
        internal static string InstanceFieldNotDefinedForType(object p0, object p1) {
            return FormatString("Instance field '{0}' is not defined for type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Field '{0}.{1}' is not defined for type '{2}'"
        /// </summary>
        internal static string FieldInfoNotDefinedForType(object p0, object p1, object p2) {
            return FormatString("Field '{0}.{1}' is not defined for type '{2}'", p0, p1, p2);
        }

        /// <summary>
        /// A string like  "Incorrect number of indexes"
        /// </summary>
        internal static string IncorrectNumberOfIndexes {
            get {
                return "Incorrect number of indexes";
            }
        }

        /// <summary>
        /// A string like  "Incorrect number of arguments supplied for lambda invocation"
        /// </summary>
        internal static string IncorrectNumberOfLambdaArguments {
            get {
                return "Incorrect number of arguments supplied for lambda invocation";
            }
        }

        /// <summary>
        /// A string like  "Incorrect number of parameters supplied for lambda declaration"
        /// </summary>
        internal static string IncorrectNumberOfLambdaDeclarationParameters {
            get {
                return "Incorrect number of parameters supplied for lambda declaration";
            }
        }

        /// <summary>
        /// A string like  "Incorrect number of arguments supplied for call to method '{0}'"
        /// </summary>
        internal static string IncorrectNumberOfMethodCallArguments(object p0) {
            return FormatString("Incorrect number of arguments supplied for call to method '{0}'", p0);
        }

        /// <summary>
        /// A string like  "Incorrect number of arguments for constructor"
        /// </summary>
        internal static string IncorrectNumberOfConstructorArguments {
            get {
                return "Incorrect number of arguments for constructor";
            }
        }

        /// <summary>
        /// A string like  " Incorrect number of members for constructor"
        /// </summary>
        internal static string IncorrectNumberOfMembersForGivenConstructor {
            get {
                return " Incorrect number of members for constructor";
            }
        }

        /// <summary>
        /// A string like  "Incorrect number of arguments for the given members "
        /// </summary>
        internal static string IncorrectNumberOfArgumentsForMembers {
            get {
                return "Incorrect number of arguments for the given members ";
            }
        }

        /// <summary>
        /// A string like  "Lambda type parameter must be derived from System.Delegate"
        /// </summary>
        internal static string LambdaTypeMustBeDerivedFromSystemDelegate {
            get {
                return "Lambda type parameter must be derived from System.Delegate";
            }
        }

        /// <summary>
        /// A string like  "Member '{0}' not field or property"
        /// </summary>
        internal static string MemberNotFieldOrProperty(object p0) {
            return FormatString("Member '{0}' not field or property", p0);
        }

        /// <summary>
        /// A string like  "Method {0} contains generic parameters"
        /// </summary>
        internal static string MethodContainsGenericParameters(object p0) {
            return FormatString("Method {0} contains generic parameters", p0);
        }

        /// <summary>
        /// A string like  "Method {0} is a generic method definition"
        /// </summary>
        internal static string MethodIsGeneric(object p0) {
            return FormatString("Method {0} is a generic method definition", p0);
        }

        /// <summary>
        /// A string like  "The method '{0}.{1}' is not a property accessor"
        /// </summary>
        internal static string MethodNotPropertyAccessor(object p0, object p1) {
            return FormatString("The method '{0}.{1}' is not a property accessor", p0, p1);
        }

        /// <summary>
        /// A string like  "The property '{0}' has no 'get' accessor"
        /// </summary>
        internal static string PropertyDoesNotHaveGetter(object p0) {
            return FormatString("The property '{0}' has no 'get' accessor", p0);
        }

        /// <summary>
        /// A string like  "The property '{0}' has no 'set' accessor"
        /// </summary>
        internal static string PropertyDoesNotHaveSetter(object p0) {
            return FormatString("The property '{0}' has no 'set' accessor", p0);
        }

        /// <summary>
        /// A string like  "The property '{0}' has no 'get' or 'set' accessors"
        /// </summary>
        internal static string PropertyDoesNotHaveAccessor(object p0) {
            return FormatString("The property '{0}' has no 'get' or 'set' accessors", p0);
        }

        /// <summary>
        /// A string like  "'{0}' is not a member of type '{1}'"
        /// </summary>
        internal static string NotAMemberOfType(object p0, object p1) {
            return FormatString("'{0}' is not a member of type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "The operator '{0}' is not implemented for type '{1}'"
        /// </summary>
        internal static string OperatorNotImplementedForType(object p0, object p1) {
            return FormatString("The operator '{0}' is not implemented for type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "ParameterExpression of type '{0}' cannot be used for delegate parameter of type '{1}'"
        /// </summary>
        internal static string ParameterExpressionNotValidAsDelegate(object p0, object p1) {
            return FormatString("ParameterExpression of type '{0}' cannot be used for delegate parameter of type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Property '{0}' is not defined for type '{1}'"
        /// </summary>
        internal static string PropertyNotDefinedForType(object p0, object p1) {
            return FormatString("Property '{0}' is not defined for type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Instance property '{0}' is not defined for type '{1}'"
        /// </summary>
        internal static string InstancePropertyNotDefinedForType(object p0, object p1) {
            return FormatString("Instance property '{0}' is not defined for type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Instance property '{0}' that takes no argument is not defined for type '{1}'"
        /// </summary>
        internal static string InstancePropertyWithoutParameterNotDefinedForType(object p0, object p1) {
            return FormatString("Instance property '{0}' that takes no argument is not defined for type '{1}'", p0, p1);
        }

        /// <summary>
        /// A string like  "Instance property '{0}{1}' is not defined for type '{2}'"
        /// </summary>
        internal static string InstancePropertyWithSpecifiedParametersNotDefinedForType(object p0, object p1, object p2) {
            return FormatString("Instance property '{0}{1}' is not defined for type '{2}'", p0, p1, p2);
        }

        /// <summary>
        /// A string like  "Method '{0}' declared on type '{1}' cannot be called with instance of type '{2}'"
        /// </summary>
        internal static string InstanceAndMethodTypeMismatch(object p0, object p1, object p2) {
            return FormatString("Method '{0}' declared on type '{1}' cannot be called with instance of type '{2}'", p0, p1, p2);
        }

        /// <summary>
        /// A string like  "Type {0} contains generic parameters"
        /// </summary>
        internal static string TypeContainsGenericParameters(object p0) {
            return FormatString("Type {0} contains generic parameters", p0);
        }

        /// <summary>
        /// A string like  "Type {0} is a generic type definition"
        /// </summary>
        internal static string TypeIsGeneric(object p0) {
            return FormatString("Type {0} is a generic type definition", p0);
        }

        /// <summary>
        /// A string like  "Type '{0}' does not have a default constructor"
        /// </summary>
        internal static string TypeMissingDefaultConstructor(object p0) {
            return FormatString("Type '{0}' does not have a default constructor", p0);
        }

        /// <summary>
        /// A string like  "List initializers must contain at least one initializer"
        /// </summary>
        internal static string ListInitializerWithZeroMembers {
            get {
                return "List initializers must contain at least one initializer";
            }
        }

        /// <summary>
        /// A string like  "Element initializer method must be named 'Add'"
        /// </summary>
        internal static string ElementInitializerMethodNotAdd {
            get {
                return "Element initializer method must be named 'Add'";
            }
        }

        /// <summary>
        /// A string like  "Parameter '{0}' of element initializer method '{1}' must not be a pass by reference parameter"
        /// </summary>
        internal static string ElementInitializerMethodNoRefOutParam(object p0, object p1) {
            return FormatString("Parameter '{0}' of element initializer method '{1}' must not be a pass by reference parameter", p0, p1);
        }

        /// <summary>
        /// A string like  "Element initializer method must have at least 1 parameter"
        /// </summary>
        internal static string ElementInitializerMethodWithZeroArgs {
            get {
                return "Element initializer method must have at least 1 parameter";
            }
        }

        /// <summary>
        /// A string like  "Element initializer method must be an instance method"
        /// </summary>
        internal static string ElementInitializerMethodStatic {
            get {
                return "Element initializer method must be an instance method";
            }
        }

        /// <summary>
        /// A string like  "Type '{0}' is not IEnumerable"
        /// </summary>
        internal static string TypeNotIEnumerable(object p0) {
            return FormatString("Type '{0}' is not IEnumerable", p0);
        }

        /// <summary>
        /// A string like  "Type parameter is {0}. Expected a delegate."
        /// </summary>
        internal static string TypeParameterIsNotDelegate(object p0) {
            return FormatString("Type parameter is {0}. Expected a delegate.", p0);
        }

        /// <summary>
        /// A string like  "Unexpected coalesce operator."
        /// </summary>
        internal static string UnexpectedCoalesceOperator {
            get {
                return "Unexpected coalesce operator.";
            }
        }

        /// <summary>
        /// A string like  "Cannot cast from type '{0}' to type '{1}"
        /// </summary>
        internal static string InvalidCast(object p0, object p1) {
            return FormatString("Cannot cast from type '{0}' to type '{1}", p0, p1);
        }

        /// <summary>
        /// A string like  "Unhandled binary: {0}"
        /// </summary>
        internal static string UnhandledBinary(object p0) {
            return FormatString("Unhandled binary: {0}", p0);
        }

        /// <summary>
        /// A string like  "Unhandled binding "
        /// </summary>
        internal static string UnhandledBinding {
            get {
                return "Unhandled binding ";
            }
        }

        /// <summary>
        /// A string like  "Unhandled Binding Type: {0}"
        /// </summary>
        internal static string UnhandledBindingType(object p0) {
            return FormatString("Unhandled Binding Type: {0}", p0);
        }

        /// <summary>
        /// A string like  "Unhandled convert: {0}"
        /// </summary>
        internal static string UnhandledConvert(object p0) {
            return FormatString("Unhandled convert: {0}", p0);
        }

        /// <summary>
        /// A string like  "Unhandled Expression Type: {0}"
        /// </summary>
        internal static string UnhandledExpressionType(object p0) {
            return FormatString("Unhandled Expression Type: {0}", p0);
        }

        /// <summary>
        /// A string like  "Unhandled unary: {0}"
        /// </summary>
        internal static string UnhandledUnary(object p0) {
            return FormatString("Unhandled unary: {0}", p0);
        }

        /// <summary>
        /// A string like  "Unknown binding type"
        /// </summary>
        internal static string UnknownBindingType {
            get {
                return "Unknown binding type";
            }
        }

        /// <summary>
        /// A string like  "The user-defined operator method '{1}' for operator '{0}' must have identical parameter and return types."
        /// </summary>
        internal static string UserDefinedOpMustHaveConsistentTypes(object p0, object p1) {
            return FormatString("The user-defined operator method '{1}' for operator '{0}' must have identical parameter and return types.", p0, p1);
        }

        /// <summary>
        /// A string like  "The user-defined operator method '{1}' for operator '{0}' must return the same type as its parameter or a derived type."
        /// </summary>
        internal static string UserDefinedOpMustHaveValidReturnType(object p0, object p1) {
            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);
        }

        /// <summary>
        /// A string like  "The user-defined operator method '{1}' for operator '{0}' must have associated boolean True and False operators."
        /// </summary>
        internal static string LogicalOperatorMustHaveBooleanOperators(object p0, object p1) {
            return FormatString("The user-defined operator method '{1}' for operator '{0}' must have associated boolean True and False operators.", p0, p1);
        }

        /// <summary>
        /// A string like  "No method '{0}' exists on type '{1}'."
        /// </summary>
        internal static string MethodDoesNotExistOnType(object p0, object p1) {
            return FormatString("No method '{0}' exists on type '{1}'.", p0, p1);
        }

        /// <summary>
        /// A string like  "No method '{0}' on type '{1}' is compatible with the supplied arguments."
        /// </summary>
        internal static string MethodWithArgsDoesNotExistOnType(object p0, object p1) {
            return FormatString("No method '{0}' on type '{1}' is compatible with the supplied arguments.", p0, p1);
        }

        /// <summary>
        /// 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. "
        /// </summary>
        internal static string GenericMethodWithArgsDoesNotExistOnType(object p0, object p1) {
            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);
        }

        /// <summary>
        /// A string like  "More than one method '{0}' on type '{1}' is compatible with the supplied arguments."
        /// </summary>
        internal static string MethodWithMoreThanOneMatch(object p0, object p1) {
            return FormatString("More than one method '{0}' on type '{1}' is compatible with the supplied arguments.", p0, p1);
        }

        /// <summary>
        /// A string like  "More than one property '{0}' on type '{1}' is compatible with the supplied arguments."
        /// </summary>
        internal static string PropertyWithMoreThanOneMatch(object p0, object p1) {
            return FormatString("More than one property '{0}' on type '{1}' is compatible with the supplied arguments.", p0, p1);
        }

        /// <summary>
        /// A string like  "An incorrect number of type args were specified for the declaration of a Func type."
        /// </summary>
        internal static string IncorrectNumberOfTypeArgsForFunc {
            get {
                return "An incorrect number of type args were specified for the declaration of a Func type.";
            }
        }

        /// <summary>
        /// A string like  "An incorrect number of type args were specified for the declaration of an Action type."
        /// </summary>
        internal static string IncorrectNumberOfTypeArgsForAction {
            get {
                return "An incorrect number of type args were specified for the declaration of an Action type.";
            }
        }

        /// <summary>
        /// A string like  "Argument type cannot be System.Void."
        /// </summary>
        internal static string ArgumentCannotBeOfTypeVoid {
            get {
                return "Argument type cannot be System.Void.";
            }
        }

        /// <summary>
        /// A string like  "More than one key matching '{0}' was found in the ExpandoObject."
        /// </summary>
        internal static string AmbiguousMatchInExpandoObject(object p0) {
            return FormatString("More than one key matching '{0}' was found in the ExpandoObject.", p0);
        }

        /// <summary>
        /// A string like  "An element with the same key '{0}' already exists in the ExpandoObject."
        /// </summary>
        internal static string SameKeyExistsInExpando(object p0) {
            return FormatString("An element with the same key '{0}' already exists in the ExpandoObject.", p0);
        }

        /// <summary>
        /// A string like  "The specified key '{0}' does not exist in the ExpandoObject."
        /// </summary>
        internal static string KeyDoesNotExistInExpando(object p0) {
            return FormatString("The specified key '{0}' does not exist in the ExpandoObject.", p0);
        }

        /// <summary>
        /// A string like  "No or Invalid rule produced"
        /// </summary>
        internal static string NoOrInvalidRuleProduced {
            get {
                return "No or Invalid rule produced";
            }
        }

        /// <summary>
        /// A string like  "First argument of delegate must be CallSite"
        /// </summary>
        internal static string FirstArgumentMustBeCallSite {
            get {
                return "First argument of delegate must be CallSite";
            }
        }

        /// <summary>
        /// A string like  "Bind cannot return null."
        /// </summary>
        internal static string BindingCannotBeNull {
            get {
                return "Bind cannot return null.";
            }
        }

        /// <summary>
        /// A string like  "Invalid operation: '{0}'"
        /// </summary>
        internal static string InvalidOperation(object p0) {
            return FormatString("Invalid operation: '{0}'", p0);
        }

        /// <summary>
        /// A string like  "{0} must be greater than or equal to {1}"
        /// </summary>
        internal static string OutOfRange(object p0, object p1) {
            return FormatString("{0} must be greater than or equal to {1}", p0, p1);
        }

        /// <summary>
        /// A string like  "Queue empty."
        /// </summary>
        internal static string QueueEmpty {
            get {
                return "Queue empty.";
            }
        }

        /// <summary>
        /// A string like  "Cannot redefine label '{0}' in an inner block."
        /// </summary>
        internal static string LabelTargetAlreadyDefined(object p0) {
            return FormatString("Cannot redefine label '{0}' in an inner block.", p0);
        }

        /// <summary>
        /// A string like  "Cannot jump to undefined label '{0}'."
        /// </summary>
        internal static string LabelTargetUndefined(object p0) {
            return FormatString("Cannot jump to undefined label '{0}'.", p0);
        }

        /// <summary>
        /// A string like  "Control cannot leave a finally block."
        /// </summary>
        internal static string ControlCannotLeaveFinally {
            get {
                return "Control cannot leave a finally block.";
            }
        }

        /// <summary>
        /// A string like  "Control cannot leave a filter test."
        /// </summary>
        internal static string ControlCannotLeaveFilterTest {
            get {
                return "Control cannot leave a filter test.";
            }
        }

        /// <summary>
        /// A string like  "Cannot jump to ambiguous label '{0}'."
        /// </summary>
        internal static string AmbiguousJump(object p0) {
            return FormatString("Cannot jump to ambiguous label '{0}'.", p0);
        }

        /// <summary>
        /// A string like  "Control cannot enter a try block."
        /// </summary>
        internal static string ControlCannotEnterTry {
            get {
                return "Control cannot enter a try block.";
            }
        }

        /// <summary>
        /// A string like  "Control cannot enter an expression--only statements can be jumped into."
        /// </summary>
        …

Large files files are truncated, but you can click here to view the full file