Enum sway_error::error::CompileError

source ·

pub enum CompileError {
Show 179 variants    UnknownVariable {
        var_name: Ident,
        span: Span,
    },
    UnknownVariablePath {
        var_name: Ident,
        span: Span,
    },
    UnknownFunction {
        name: Ident,
        span: Span,
    },
    NotAVariable {
        name: Ident,
        what_it_is: &'static str,
        span: Span,
    },
    NotAFunction {
        name: String,
        span: Span,
        what_it_is: &'static str,
    },
    Unimplemented(&'static str, Span),
    UnimplementedWithHelp(&'static str, &'static str, Span),
    TypeError(TypeError),
    ParseError {
        span: Span,
        err: String,
    },
    Internal(&'static str, Span),
    InternalOwned(String, Span),
    InvalidByteLiteralLength {
        byte_length: usize,
        span: Span,
    },
    ExpectedExprAfterOp {
        op: String,
        span: Span,
    },
    ExpectedOp {
        op: String,
        span: Span,
    },
    MultipleContracts(Span),
    MultipleScripts(Span),
    MultiplePredicates(Span),
    NoPredicateMainFunction(Span),
    PredicateMainDoesNotReturnBool(Span),
    NoScriptMainFunction(Span),
    MultipleDefinitionsOfFunction {
        name: Ident,
        span: Span,
    },
    ReassignmentToNonVariable {
        name: Ident,
        kind: &'static str,
        span: Span,
    },
    AssignmentToNonMutable {
        name: Ident,
        span: Span,
    },
    MethodRequiresMutableSelf {
        method_name: Ident,
        variable_name: Ident,
        span: Span,
    },
    MutableParameterNotSupported {
        param_name: Ident,
        span: Span,
    },
    ImmutableArgumentToMutableParameter {
        span: Span,
    },
    RefMutableNotAllowedInContractAbi {
        param_name: Ident,
        span: Span,
    },
    AssociatedFunctionCalledAsMethod {
        fn_name: Ident,
        span: Span,
    },
    TypeParameterNotInTypeScope {
        name: Ident,
        span: Span,
        comma_separated_generic_params: String,
        fn_name: Ident,
        args: String,
    },
    MultipleImmediates(Span),
    MismatchedTypeInInterfaceSurface {
        interface_name: InterfaceName,
        span: Span,
        given: String,
        expected: String,
    },
    NotATrait {
        span: Span,
        name: Ident,
    },
    UnknownTrait {
        span: Span,
        name: Ident,
    },
    FunctionNotAPartOfInterfaceSurface {
        name: Ident,
        interface_name: InterfaceName,
        span: Span,
    },
    MissingInterfaceSurfaceMethods {
        missing_functions: String,
        span: Span,
    },
    IncorrectNumberOfTypeArguments {
        given: usize,
        expected: usize,
        span: Span,
    },
    DoesNotTakeTypeArguments {
        name: Ident,
        span: Span,
    },
    DoesNotTakeTypeArgumentsAsPrefix {
        name: Ident,
        span: Span,
    },
    TypeArgumentsNotAllowed {
        span: Span,
    },
    NeedsTypeArguments {
        name: Ident,
        span: Span,
    },
    StructNotFound {
        name: Ident,
        span: Span,
    },
    EnumNotFound {
        name: Ident,
        span: Span,
    },
    DeclaredNonStructAsStruct {
        name: Ident,
        span: Span,
    },
    AccessedFieldOfNonStruct {
        field_name: Ident,
        name: Ident,
        span: Span,
    },
    MethodOnNonValue {
        name: Ident,
        thing: Ident,
        span: Span,
    },
    StructMissingField {
        field_name: Ident,
        struct_name: Ident,
        span: Span,
    },
    StructDoesNotHaveField {
        field_name: Ident,
        struct_name: Ident,
        span: Span,
    },
    MethodNotFound {
        method_name: Ident,
        type_name: String,
        span: Span,
    },
    ModuleNotFound {
        span: Span,
        name: String,
    },
    FieldAccessOnNonStruct {
        actually: String,
        span: Span,
    },
    NotATuple {
        name: String,
        span: Span,
        actually: String,
    },
    NotIndexable {
        name: String,
        span: Span,
        actually: String,
    },
    NotAnEnum {
        name: String,
        span: Span,
        actually: String,
    },
    NotAStruct {
        span: Span,
        actually: String,
    },
    DeclIsNotAnEnum {
        actually: String,
        span: Span,
    },
    DeclIsNotAStruct {
        actually: String,
        span: Span,
    },
    DeclIsNotAFunction {
        actually: String,
        span: Span,
    },
    DeclIsNotAVariable {
        actually: String,
        span: Span,
    },
    DeclIsNotAnAbi {
        actually: String,
        span: Span,
    },
    DeclIsNotATrait {
        actually: String,
        span: Span,
    },
    DeclIsNotAnImplTrait {
        actually: String,
        span: Span,
    },
    DeclIsNotATraitFn {
        actually: String,
        span: Span,
    },
    DeclIsNotStorage {
        actually: String,
        span: Span,
    },
    DeclIsNotAConstant {
        actually: String,
        span: Span,
    },
    FieldNotFound {
        field_name: Ident,
        available_fields: String,
        struct_name: Ident,
        span: Span,
    },
    SymbolNotFound {
        name: Ident,
        span: Span,
    },
    ImportPrivateSymbol {
        name: Ident,
        span: Span,
    },
    NoElseBranch {
        span: Span,
        type: String,
    },
    UnqualifiedSelfType {
        span: Span,
    },
    NotAType {
        span: Span,
        name: String,
        actually_is: &'static str,
    },
    MissingEnumInstantiator {
        span: Span,
    },
    PathDoesNotReturn {
        span: Span,
        ty: String,
        function_name: Ident,
    },
    ExpectedImplicitReturnFromBlockWithType {
        span: Span,
        ty: String,
    },
    ExpectedImplicitReturnFromBlock {
        span: Span,
    },
    UnknownRegister {
        span: Span,
        initialized_registers: String,
    },
    MissingImmediate {
        span: Span,
    },
    InvalidImmediateValue {
        span: Span,
    },
    InvalidAssemblyMismatchedReturn {
        span: Span,
    },
    UnknownEnumVariant {
        enum_name: Ident,
        variant_name: Ident,
        span: Span,
    },
    UnrecognizedOp {
        op_name: Ident,
        span: Span,
    },
    UnableToInferGeneric {
        ty: String,
        span: Span,
    },
    UnconstrainedGenericParameter {
        ty: String,
        span: Span,
    },
    TraitConstraintNotSatisfied {
        ty: String,
        trait_name: String,
        span: Span,
    },
    Immediate06TooLarge {
        val: u64,
        span: Span,
    },
    Immediate12TooLarge {
        val: u64,
        span: Span,
    },
    Immediate18TooLarge {
        val: u64,
        span: Span,
    },
    Immediate24TooLarge {
        val: u64,
        span: Span,
    },
    IncorrectNumberOfAsmRegisters {
        span: Span,
        expected: usize,
        received: usize,
    },
    UnnecessaryImmediate {
        span: Span,
    },
    AmbiguousPath {
        span: Span,
    },
    InvalidStrType {
        raw: String,
        span: Span,
    },
    UnknownType {
        span: Span,
    },
    UnknownTypeName {
        name: String,
        span: Span,
    },
    TooManyInstructions {
        span: Span,
    },
    FileNotFound {
        span: Span,
        file_path: String,
    },
    FileCouldNotBeRead {
        span: Span,
        file_path: String,
        stringified_error: String,
    },
    ImportMustBeLibrary {
        span: Span,
    },
    MoreThanOneEnumInstantiator {
        span: Span,
        ty: String,
    },
    UnnecessaryEnumInstantiator {
        span: Span,
    },
    UnitVariantWithParenthesesEnumInstantiator {
        span: Span,
        ty: String,
    },
    TraitNotFound {
        name: String,
        span: Span,
    },
    InvalidExpressionOnLhs {
        span: Span,
    },
    TooManyArgumentsForFunction {
        span: Span,
        method_name: Ident,
        dot_syntax_used: bool,
        expected: usize,
        received: usize,
    },
    TooFewArgumentsForFunction {
        span: Span,
        method_name: Ident,
        dot_syntax_used: bool,
        expected: usize,
        received: usize,
    },
    MissingParenthesesForFunction {
        span: Span,
        method_name: Ident,
    },
    InvalidAbiType {
        span: Span,
    },
    NotAnAbi {
        span: Span,
        actually_is: &'static str,
    },
    ImplAbiForNonContract {
        span: Span,
        ty: String,
    },
    ConflictingImplsForTraitAndType {
        trait_name: String,
        type_implementing_for: String,
        second_impl_span: Span,
    },
    DuplicateMethodsDefinedForType {
        func_name: String,
        type_implementing_for: String,
        span: Span,
    },
    IncorrectNumberOfInterfaceSurfaceFunctionParameters {
        fn_name: Ident,
        interface_name: InterfaceName,
        num_parameters: usize,
        provided_parameters: usize,
        span: Span,
    },
    ArgumentParameterTypeMismatch {
        span: Span,
        should_be: String,
        provided: String,
    },
    RecursiveCall {
        fn_name: Ident,
        span: Span,
    },
    RecursiveCallChain {
        fn_name: Ident,
        call_chain: String,
        span: Span,
    },
    RecursiveType {
        name: Ident,
        span: Span,
    },
    RecursiveTypeChain {
        name: Ident,
        type_chain: String,
        span: Span,
    },
    TypeWithUnknownSize {
        span: Span,
    },
    InfiniteDependencies {
        file_path: String,
        span: Span,
    },
    GMFromExternalContext {
        span: Span,
    },
    MintFromExternalContext {
        span: Span,
    },
    BurnFromExternalContext {
        span: Span,
    },
    ContractStorageFromExternalContext {
        span: Span,
    },
    InvalidOpcodeFromPredicate {
        opcode: String,
        span: Span,
    },
    InvalidBackwardJumpFromPredicate {
        opcode: String,
        span: Span,
    },
    ArrayOutOfBounds {
        index: u64,
        count: u64,
        span: Span,
    },
    TupleIndexOutOfBounds {
        index: usize,
        count: usize,
        span: Span,
    },
    ShadowsOtherSymbol {
        name: Ident,
    },
    GenericShadowsGeneric {
        name: Ident,
    },
    MatchWrongType {
        expected: String,
        span: Span,
    },
    MatchExpressionNonExhaustive {
        missing_patterns: String,
        span: Span,
    },
    MatchStructPatternMissingFields {
        missing_fields: Vec<String>,
        span: Span,
    },
    StorageAccessMismatch {
        attrs: String,
        span: Span,
    },
    TraitDeclPureImplImpure {
        fn_name: Ident,
        interface_name: InterfaceName,
        attrs: String,
        span: Span,
    },
    TraitImplPurityMismatch {
        fn_name: Ident,
        interface_name: InterfaceName,
        attrs: String,
        span: Span,
    },
    ImpureInNonContract {
        span: Span,
    },
    ImpureInPureContext {
        storage_op: &'static str,
        attrs: String,
        span: Span,
    },
    ParameterRefMutabilityMismatch {
        span: Span,
    },
    IntegerTooLarge {
        span: Span,
        ty: String,
    },
    IntegerTooSmall {
        span: Span,
        ty: String,
    },
    IntegerContainsInvalidDigit {
        span: Span,
        ty: String,
    },
    AsteriskWithAlias {
        span: Span,
    },
    AbiAsSupertrait {
        span: Span,
    },
    SupertraitImplRequired {
        supertrait_name: String,
        trait_name: Ident,
        span: Span,
    },
    IfLetNonEnum {
        span: Span,
    },
    ContractCallParamRepeated {
        param_name: String,
        span: Span,
    },
    UnrecognizedContractParam {
        param_name: String,
        span: Span,
    },
    CallParamForNonContractCallMethod {
        span: Span,
    },
    StorageFieldDoesNotExist {
        name: Ident,
        span: Span,
    },
    NoDeclaredStorage {
        span: Span,
    },
    MultipleStorageDeclarations {
        span: Span,
    },
    InvalidStorageOnlyTypeDecl {
        ty: String,
        span: Span,
    },
    InvalidVariableName {
        name: Ident,
        span: Span,
    },
    UnexpectedDeclaration {
        decl_type: &'static str,
        span: Span,
    },
    ContractAddressMustBeKnown {
        span: Span,
    },
    ConvertParseTree {
        error: ConvertParseTreeError,
    },
    Lex {
        error: LexError,
    },
    Parse {
        error: ParseError,
    },
    WhereClauseNotYetSupported {
        span: Span,
    },
    NonConstantDeclValue {
        span: Span,
    },
    StorageDeclarationInNonContract {
        program_kind: String,
        span: Span,
    },
    IntrinsicUnsupportedArgType {
        name: String,
        span: Span,
        hint: Hint,
    },
    IntrinsicIncorrectNumArgs {
        name: String,
        expected: u64,
        span: Span,
    },
    IntrinsicIncorrectNumTArgs {
        name: String,
        expected: u64,
        span: Span,
    },
    BreakOutsideLoop {
        span: Span,
    },
    ContinueOutsideLoop {
        span: Span,
    },
    ConfigTimeConstantNotAConstDecl {
        span: Span,
    },
    ConfigTimeConstantNotALiteral {
        span: Span,
    },
    TypeNotAllowedInContractStorage {
        ty: String,
        span: Span,
    },
    RefMutableNotAllowedInMain {
        param_name: Ident,
        span: Span,
    },
    PointerReturnNotAllowedInMain {
        span: Span,
    },
    NestedSliceReturnNotAllowedInMain {
        span: Span,
    },
    InitializedRegisterReassignment {
        name: String,
        span: Span,
    },
    DisallowedControlFlowInstruction {
        name: String,
        span: Span,
    },
    CallingPrivateLibraryMethod {
        name: String,
        span: Span,
    },
    DisallowedWhileInPredicate {
        span: Span,
    },
    CoinsPassedToNonPayableMethod {
        fn_name: Ident,
        span: Span,
    },
    TraitImplPayabilityMismatch {
        fn_name: Ident,
        interface_name: InterfaceName,
        missing_impl_attribute: bool,
        span: Span,
    },
    ConfigurableInLibrary {
        span: Span,
    },
    NameDefinedMultipleTimes {
        name: String,
        span: Span,
    },
}