{-# LANGUAGE CPP #-}

{-# LANGUAGE DataKinds #-}

{-# LANGUAGE DeriveAnyClass #-}

{-# LANGUAGE DeriveGeneric #-}

{-# LANGUAGE DeriveTraversable #-}

{-# LANGUAGE DerivingStrategies #-}

{-# LANGUAGE DuplicateRecordFields #-}

{-# LANGUAGE FlexibleInstances #-}

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

{-# LANGUAGE KindSignatures #-}

{-# LANGUAGE MultiParamTypeClasses #-}

{-# LANGUAGE QuantifiedConstraints #-}

{-# LANGUAGE StandaloneDeriving #-}

{-# LANGUAGE TemplateHaskell #-}

{-# LANGUAGE TypeApplications #-}

{-# LANGUAGE TypeOperators #-}

{-# LANGUAGE UndecidableInstances #-}

{-# OPTIONS_GHC -fno-warn-unused-imports #-}

module Language.Python.AST (module Language.Python.AST, getTestCorpusDir) where

import qualified AST.Parse

import qualified AST.Token

import qualified AST.Traversable1.Class

import qualified AST.Unmarshal

import qualified Data.Foldable

import qualified Data.List as Data.OldList

import qualified Data.Maybe as GHC.Maybe

import qualified Data.Text.Internal

import qualified Data.Traversable

import qualified GHC.Base

import qualified GHC.Generics

import qualified GHC.Records

import qualified GHC.Show

import qualified TreeSitter.Node

import TreeSitter.Python (getTestCorpusDir)

import qualified Prelude as GHC.Classes

debugSymbolNames :: [GHC.Base.String]

debugSymbolNames = debugSymbolNames_0

debugSymbolNames_0 :: [GHC.Base.String]

debugSymbolNames_0 =

[ "end",

"identifier",

"_import",

"_.",

"_from",

"___future__",

"_(",

"_)",

"_,",

"_as",

"_*",

"_print",

"_>>",

"_assert",

"_:=",

"_return",

"_del",

"_raise",

"_pass",

"_break",

"_continue",

"_if",

"_:",

"_elif",

"_else",

"_async",

"_for",

"_in",

"_while",

"_try",

"_except",

"_finally",

"_with",

"_def",

"_->",

"_=",

"_**",

"_global",

"_nonlocal",

"_exec",

"_class",

"_@",

"_not",

"_and",

"_or",

"_+",

"_-",

"_/",

"_%",

"_//",

"_|",

"_&",

"_^",

"_<<",

"_~",

"_<",

"_<=",

"_==",

"_!=",

"_>=",

"_>",

"_<>",

"_is",

"_lambda",

"_+=",

"_-=",

"_*=",

"_/=",

"_@=",

"_//=",

"_%=",

"_**=",

"_>>=",

"_<<=",

"_&=",

"_^=",

"_|=",

"_yield",

"_[",

"_]",

"ellipsis",

"_{",

"_}",

"escape_sequence",

"_not_escape_sequence",

"_format_specifier_token1",

"type_conversion",

"integer",

"float",

"true",

"false",

"none",

"_await",

"comment",

"_semicolon",

"_newline",

"_indent",

"_dedent",

"_\"",

"_string_content",

"_\"",

"module",

"_statement",

"_simple_statements",

"import_statement",

"import_prefix",

"relative_import",

"future_import_statement",

"import_from_statement",

"_import_list",

"aliased_import",

"wildcard_import",

"print_statement",

"chevron",

"assert_statement",

"expression_statement",

"named_expression",

"return_statement",

"delete_statement",

"raise_statement",

"pass_statement",

"break_statement",

"continue_statement",

"if_statement",

"elif_clause",

"else_clause",

"for_statement",

"while_statement",

"try_statement",

"except_clause",

"finally_clause",

"with_statement",

"with_item",

"function_definition",

"parameters",

"lambda_parameters",

"_parameters",

"default_parameter",

"typed_default_parameter",

"list_splat",

"dictionary_splat",

"global_statement",

"nonlocal_statement",

"exec_statement",

"class_definition",

"parenthesized_expression",

"argument_list",

"decorated_definition",

"decorator",

"block",

"variables",

"expression_list",

"dotted_name",

"_expression_within_for_in_clause",

"_expression",

"_primary_expression",

"not_operator",

"boolean_operator",

"binary_operator",

"unary_operator",

"comparison_operator",

"lambda",

"lambda",

"assignment",

"augmented_assignment",

"_right_hand_side",

"yield",

"attribute",

"subscript",

"slice",

"call",

"typed_parameter",

"type",

"keyword_argument",

"list",

"_comprehension_clauses",

"list_comprehension",

"dictionary",

"dictionary_comprehension",

"pair",

"set",

"set_comprehension",

"parenthesized_expression",

"tuple",

"generator_expression",

"for_in_clause",

"if_clause",

"conditional_expression",

"concatenated_string",

"string",

"interpolation",

"format_specifier",

"format_expression",

"await",

"_module_repeat1",

"__simple_statements_repeat1",

"_import_prefix_repeat1",

"__import_list_repeat1",

"_print_statement_repeat1",

"_assert_statement_repeat1",

"_if_statement_repeat1",

"_try_statement_repeat1",

"_with_statement_repeat1",

"__parameters_repeat1",

"_global_statement_repeat1",

"_argument_list_repeat1",

"_decorated_definition_repeat1",

"_variables_repeat1",

"_dotted_name_repeat1",

"_comparison_operator_repeat1",

"_subscript_repeat1",

"_list_repeat1",

"__comprehension_clauses_repeat1",

"_dictionary_repeat1",

"_tuple_repeat1",

"_for_in_clause_repeat1",

"_concatenated_string_repeat1",

"_string_repeat1",

"_format_specifier_repeat1"

]

newtype CompoundStatement a = CompoundStatement {getCompoundStatement :: ((ClassDefinition GHC.Generics.:+: DecoratedDefinition GHC.Generics.:+: ForStatement GHC.Generics.:+: FunctionDefinition GHC.Generics.:+: IfStatement GHC.Generics.:+: TryStatement GHC.Generics.:+: WhileStatement GHC.Generics.:+: WithStatement) a)}

deriving newtype (AST.Unmarshal.SymbolMatching)

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_1.

AST.Traversable1.Class.Traversable1 a_1

)

instance GHC.Records.HasField "ann" (CompoundStatement a_2) a_2 where

getField = AST.Unmarshal.gann GHC.Base.. getCompoundStatement

deriving instance GHC.Classes.Eq a_3 => GHC.Classes.Eq (CompoundStatement a_3)

deriving instance GHC.Classes.Ord a_4 => GHC.Classes.Ord (CompoundStatement a_4)

deriving instance GHC.Show.Show a_5 => GHC.Show.Show (CompoundStatement a_5)

instance AST.Unmarshal.Unmarshal CompoundStatement

instance Data.Foldable.Foldable CompoundStatement where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor CompoundStatement where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable CompoundStatement where

traverse = AST.Traversable1.Class.traverseDefault1

newtype Expression a = Expression {getExpression :: ((PrimaryExpression GHC.Generics.:+: Await GHC.Generics.:+: BooleanOperator GHC.Generics.:+: ComparisonOperator GHC.Generics.:+: ConditionalExpression GHC.Generics.:+: Lambda GHC.Generics.:+: NamedExpression GHC.Generics.:+: NotOperator) a)}

deriving newtype (AST.Unmarshal.SymbolMatching)

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_6.

AST.Traversable1.Class.Traversable1 a_6

)

instance GHC.Records.HasField "ann" (Expression a_7) a_7 where

getField = AST.Unmarshal.gann GHC.Base.. getExpression

deriving instance GHC.Classes.Eq a_8 => GHC.Classes.Eq (Expression a_8)

deriving instance GHC.Classes.Ord a_9 => GHC.Classes.Ord (Expression a_9)

deriving instance GHC.Show.Show a_10 => GHC.Show.Show (Expression a_10)

instance AST.Unmarshal.Unmarshal Expression

instance Data.Foldable.Foldable Expression where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Expression where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Expression where

traverse = AST.Traversable1.Class.traverseDefault1

newtype Parameter a = Parameter {getParameter :: ((DefaultParameter GHC.Generics.:+: DictionarySplat GHC.Generics.:+: Identifier GHC.Generics.:+: ListSplat GHC.Generics.:+: Tuple GHC.Generics.:+: TypedDefaultParameter GHC.Generics.:+: TypedParameter) a)}

deriving newtype (AST.Unmarshal.SymbolMatching)

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_11.

AST.Traversable1.Class.Traversable1 a_11

)

instance GHC.Records.HasField "ann" (Parameter a_12) a_12 where

getField = AST.Unmarshal.gann GHC.Base.. getParameter

deriving instance GHC.Classes.Eq a_13 => GHC.Classes.Eq (Parameter a_13)

deriving instance GHC.Classes.Ord a_14 => GHC.Classes.Ord (Parameter a_14)

deriving instance GHC.Show.Show a_15 => GHC.Show.Show (Parameter a_15)

instance AST.Unmarshal.Unmarshal Parameter

instance Data.Foldable.Foldable Parameter where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Parameter where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Parameter where

traverse = AST.Traversable1.Class.traverseDefault1

newtype PrimaryExpression a = PrimaryExpression {getPrimaryExpression :: ((Attribute GHC.Generics.:+: BinaryOperator GHC.Generics.:+: Call GHC.Generics.:+: ConcatenatedString GHC.Generics.:+: Dictionary GHC.Generics.:+: DictionaryComprehension GHC.Generics.:+: Ellipsis GHC.Generics.:+: False GHC.Generics.:+: Float GHC.Generics.:+: GeneratorExpression GHC.Generics.:+: Identifier GHC.Generics.:+: Integer GHC.Generics.:+: List GHC.Generics.:+: ListComprehension GHC.Generics.:+: None GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: Set GHC.Generics.:+: SetComprehension GHC.Generics.:+: String GHC.Generics.:+: Subscript GHC.Generics.:+: True GHC.Generics.:+: Tuple GHC.Generics.:+: UnaryOperator) a)}

deriving newtype (AST.Unmarshal.SymbolMatching)

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_16.

AST.Traversable1.Class.Traversable1 a_16

)

instance GHC.Records.HasField "ann" (PrimaryExpression a_17) a_17 where

getField = AST.Unmarshal.gann GHC.Base.. getPrimaryExpression

deriving instance GHC.Classes.Eq a_18 => GHC.Classes.Eq (PrimaryExpression a_18)

deriving instance GHC.Classes.Ord a_19 => GHC.Classes.Ord (PrimaryExpression a_19)

deriving instance GHC.Show.Show a_20 => GHC.Show.Show (PrimaryExpression a_20)

instance AST.Unmarshal.Unmarshal PrimaryExpression

instance Data.Foldable.Foldable PrimaryExpression where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor PrimaryExpression where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable PrimaryExpression where

traverse = AST.Traversable1.Class.traverseDefault1

newtype SimpleStatement a = SimpleStatement {getSimpleStatement :: ((AssertStatement GHC.Generics.:+: BreakStatement GHC.Generics.:+: ContinueStatement GHC.Generics.:+: DeleteStatement GHC.Generics.:+: ExecStatement GHC.Generics.:+: ExpressionStatement GHC.Generics.:+: FutureImportStatement GHC.Generics.:+: GlobalStatement GHC.Generics.:+: ImportFromStatement GHC.Generics.:+: ImportStatement GHC.Generics.:+: NonlocalStatement GHC.Generics.:+: PassStatement GHC.Generics.:+: PrintStatement GHC.Generics.:+: RaiseStatement GHC.Generics.:+: ReturnStatement) a)}

deriving newtype (AST.Unmarshal.SymbolMatching)

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_21.

AST.Traversable1.Class.Traversable1 a_21

)

instance GHC.Records.HasField "ann" (SimpleStatement a_22) a_22 where

getField = AST.Unmarshal.gann GHC.Base.. getSimpleStatement

deriving instance GHC.Classes.Eq a_23 => GHC.Classes.Eq (SimpleStatement a_23)

deriving instance GHC.Classes.Ord a_24 => GHC.Classes.Ord (SimpleStatement a_24)

deriving instance GHC.Show.Show a_25 => GHC.Show.Show (SimpleStatement a_25)

instance AST.Unmarshal.Unmarshal SimpleStatement

instance Data.Foldable.Foldable SimpleStatement where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor SimpleStatement where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable SimpleStatement where

traverse = AST.Traversable1.Class.traverseDefault1

data AliasedImport a = AliasedImport

{ ann :: a,

alias :: (AST.Parse.Err (Identifier a)),

name :: (AST.Parse.Err (DottedName a))

}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_26.

AST.Traversable1.Class.Traversable1 a_26

)

instance AST.Unmarshal.SymbolMatching AliasedImport where

matchedSymbols _ = [110]

showFailure _ node_27 =

"expected "

GHC.Base.<> ( "aliased_import"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_27 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_27) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_28 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_29 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_30 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_31 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_28

c1_29 = TreeSitter.Node.nodeStartPoint node_27

TreeSitter.Node.TSPoint

r2_30

c2_31 = TreeSitter.Node.nodeEndPoint node_27

deriving instance GHC.Classes.Eq a_32 => GHC.Classes.Eq (AliasedImport a_32)

deriving instance GHC.Classes.Ord a_33 => GHC.Classes.Ord (AliasedImport a_33)

deriving instance GHC.Show.Show a_34 => GHC.Show.Show (AliasedImport a_34)

instance AST.Unmarshal.Unmarshal AliasedImport

instance Data.Foldable.Foldable AliasedImport where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AliasedImport where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AliasedImport where

traverse = AST.Traversable1.Class.traverseDefault1

data ArgumentList a = ArgumentList

{ ann :: a,

extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: DictionarySplat GHC.Generics.:+: KeywordArgument GHC.Generics.:+: ListSplat GHC.Generics.:+: ParenthesizedExpression) a)])

}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_35.

AST.Traversable1.Class.Traversable1 a_35

)

instance AST.Unmarshal.SymbolMatching ArgumentList where

matchedSymbols _ = [146]

showFailure _ node_36 =

"expected "

GHC.Base.<> ( "argument_list"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_36 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_36) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_37 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_38 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_39 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_40 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_37

c1_38 = TreeSitter.Node.nodeStartPoint node_36

TreeSitter.Node.TSPoint

r2_39

c2_40 = TreeSitter.Node.nodeEndPoint node_36

deriving instance GHC.Classes.Eq a_41 => GHC.Classes.Eq (ArgumentList a_41)

deriving instance GHC.Classes.Ord a_42 => GHC.Classes.Ord (ArgumentList a_42)

deriving instance GHC.Show.Show a_43 => GHC.Show.Show (ArgumentList a_43)

instance AST.Unmarshal.Unmarshal ArgumentList

instance Data.Foldable.Foldable ArgumentList where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ArgumentList where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ArgumentList where

traverse = AST.Traversable1.Class.traverseDefault1

data AssertStatement a = AssertStatement

{ ann :: a,

extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Expression a)))

}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_44.

AST.Traversable1.Class.Traversable1 a_44

)

instance AST.Unmarshal.SymbolMatching AssertStatement where

matchedSymbols _ = [114]

showFailure _ node_45 =

"expected "

GHC.Base.<> ( "assert_statement"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_45 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_45) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_46 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_47 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_48 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_49 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_46

c1_47 = TreeSitter.Node.nodeStartPoint node_45

TreeSitter.Node.TSPoint

r2_48

c2_49 = TreeSitter.Node.nodeEndPoint node_45

deriving instance GHC.Classes.Eq a_50 => GHC.Classes.Eq (AssertStatement a_50)

deriving instance GHC.Classes.Ord a_51 => GHC.Classes.Ord (AssertStatement a_51)

deriving instance GHC.Show.Show a_52 => GHC.Show.Show (AssertStatement a_52)

instance AST.Unmarshal.Unmarshal AssertStatement

instance Data.Foldable.Foldable AssertStatement where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AssertStatement where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AssertStatement where

traverse = AST.Traversable1.Class.traverseDefault1

data Assignment a = Assignment

{ ann :: a,

left :: (AST.Parse.Err (ExpressionList a)),

right :: (GHC.Maybe.Maybe (AST.Parse.Err ((Assignment GHC.Generics.:+: AugmentedAssignment GHC.Generics.:+: ExpressionList GHC.Generics.:+: Yield) a))),

type' :: (GHC.Maybe.Maybe (AST.Parse.Err (Type a)))

}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_53.

AST.Traversable1.Class.Traversable1 a_53

)

instance AST.Unmarshal.SymbolMatching Assignment where

matchedSymbols _ = [163]

showFailure _ node_54 =

"expected "

GHC.Base.<> ( "assignment"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_54 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_54) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_55 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_56 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_57 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_58 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_55

c1_56 = TreeSitter.Node.nodeStartPoint node_54

TreeSitter.Node.TSPoint

r2_57

c2_58 = TreeSitter.Node.nodeEndPoint node_54

deriving instance GHC.Classes.Eq a_59 => GHC.Classes.Eq (Assignment a_59)

deriving instance GHC.Classes.Ord a_60 => GHC.Classes.Ord (Assignment a_60)

deriving instance GHC.Show.Show a_61 => GHC.Show.Show (Assignment a_61)

instance AST.Unmarshal.Unmarshal Assignment

instance Data.Foldable.Foldable Assignment where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Assignment where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Assignment where

traverse = AST.Traversable1.Class.traverseDefault1

data Attribute a = Attribute

{ ann :: a,

attribute :: (AST.Parse.Err (Identifier a)),

object :: (AST.Parse.Err (PrimaryExpression a))

}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_62.

AST.Traversable1.Class.Traversable1 a_62

)

instance AST.Unmarshal.SymbolMatching Attribute where

matchedSymbols _ = [167]

showFailure _ node_63 =

"expected "

GHC.Base.<> ( "attribute"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_63 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_63) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_64 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_65 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_66 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_67 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_64

c1_65 = TreeSitter.Node.nodeStartPoint node_63

TreeSitter.Node.TSPoint

r2_66

c2_67 = TreeSitter.Node.nodeEndPoint node_63

deriving instance GHC.Classes.Eq a_68 => GHC.Classes.Eq (Attribute a_68)

deriving instance GHC.Classes.Ord a_69 => GHC.Classes.Ord (Attribute a_69)

deriving instance GHC.Show.Show a_70 => GHC.Show.Show (Attribute a_70)

instance AST.Unmarshal.Unmarshal Attribute

instance Data.Foldable.Foldable Attribute where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Attribute where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Attribute where

traverse = AST.Traversable1.Class.traverseDefault1

data AugmentedAssignment a = AugmentedAssignment

{ ann :: a,

operator :: (AST.Parse.Err ((AnonymousPercentEqual GHC.Generics.:+: AnonymousAmpersandEqual GHC.Generics.:+: AnonymousStarStarEqual GHC.Generics.:+: AnonymousStarEqual GHC.Generics.:+: AnonymousPlusEqual GHC.Generics.:+: AnonymousMinusEqual GHC.Generics.:+: AnonymousSlashSlashEqual GHC.Generics.:+: AnonymousSlashEqual GHC.Generics.:+: AnonymousLAngleLAngleEqual GHC.Generics.:+: AnonymousRAngleRAngleEqual GHC.Generics.:+: AnonymousAtEqual GHC.Generics.:+: AnonymousCaretEqual GHC.Generics.:+: AnonymousPipeEqual) a)),

left :: (AST.Parse.Err (ExpressionList a)),

right :: (AST.Parse.Err ((Assignment GHC.Generics.:+: AugmentedAssignment GHC.Generics.:+: ExpressionList GHC.Generics.:+: Yield) a))

}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_71.

AST.Traversable1.Class.Traversable1 a_71

)

instance AST.Unmarshal.SymbolMatching AugmentedAssignment where

matchedSymbols _ = [164]

showFailure _ node_72 =

"expected "

GHC.Base.<> ( "augmented_assignment"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_72 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_72) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_73 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_74 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_75 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_76 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_73

c1_74 = TreeSitter.Node.nodeStartPoint node_72

TreeSitter.Node.TSPoint

r2_75

c2_76 = TreeSitter.Node.nodeEndPoint node_72

deriving instance GHC.Classes.Eq a_77 => GHC.Classes.Eq (AugmentedAssignment a_77)

deriving instance GHC.Classes.Ord a_78 => GHC.Classes.Ord (AugmentedAssignment a_78)

deriving instance GHC.Show.Show a_79 => GHC.Show.Show (AugmentedAssignment a_79)

instance AST.Unmarshal.Unmarshal AugmentedAssignment

instance Data.Foldable.Foldable AugmentedAssignment where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AugmentedAssignment where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AugmentedAssignment where

traverse = AST.Traversable1.Class.traverseDefault1

data Await a = Await {ann :: a, extraChildren :: (AST.Parse.Err (Expression a))}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_80.

AST.Traversable1.Class.Traversable1 a_80

)

instance AST.Unmarshal.SymbolMatching Await where

matchedSymbols _ = [193]

showFailure _ node_81 =

"expected "

GHC.Base.<> ( "await"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_81 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_81) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_82 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_83 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_84 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_85 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_82

c1_83 = TreeSitter.Node.nodeStartPoint node_81

TreeSitter.Node.TSPoint

r2_84

c2_85 = TreeSitter.Node.nodeEndPoint node_81

deriving instance GHC.Classes.Eq a_86 => GHC.Classes.Eq (Await a_86)

deriving instance GHC.Classes.Ord a_87 => GHC.Classes.Ord (Await a_87)

deriving instance GHC.Show.Show a_88 => GHC.Show.Show (Await a_88)

instance AST.Unmarshal.Unmarshal Await

instance Data.Foldable.Foldable Await where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Await where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Await where

traverse = AST.Traversable1.Class.traverseDefault1

data BinaryOperator a = BinaryOperator

{ ann :: a,

operator :: (AST.Parse.Err ((AnonymousPercent GHC.Generics.:+: AnonymousAmpersand GHC.Generics.:+: AnonymousStar GHC.Generics.:+: AnonymousStarStar GHC.Generics.:+: AnonymousPlus GHC.Generics.:+: AnonymousMinus GHC.Generics.:+: AnonymousSlash GHC.Generics.:+: AnonymousSlashSlash GHC.Generics.:+: AnonymousLAngleLAngle GHC.Generics.:+: AnonymousRAngleRAngle GHC.Generics.:+: AnonymousAt GHC.Generics.:+: AnonymousCaret GHC.Generics.:+: AnonymousPipe) a)),

left :: (AST.Parse.Err (PrimaryExpression a)),

right :: (AST.Parse.Err (PrimaryExpression a))

}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_89.

AST.Traversable1.Class.Traversable1 a_89

)

instance AST.Unmarshal.SymbolMatching BinaryOperator where

matchedSymbols _ = [158]

showFailure _ node_90 =

"expected "

GHC.Base.<> ( "binary_operator"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_90 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_90) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_91 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_92 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_93 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_94 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_91

c1_92 = TreeSitter.Node.nodeStartPoint node_90

TreeSitter.Node.TSPoint

r2_93

c2_94 = TreeSitter.Node.nodeEndPoint node_90

deriving instance GHC.Classes.Eq a_95 => GHC.Classes.Eq (BinaryOperator a_95)

deriving instance GHC.Classes.Ord a_96 => GHC.Classes.Ord (BinaryOperator a_96)

deriving instance GHC.Show.Show a_97 => GHC.Show.Show (BinaryOperator a_97)

instance AST.Unmarshal.Unmarshal BinaryOperator

instance Data.Foldable.Foldable BinaryOperator where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor BinaryOperator where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable BinaryOperator where

traverse = AST.Traversable1.Class.traverseDefault1

data Block a = Block

{ ann :: a,

extraChildren :: ([AST.Parse.Err ((CompoundStatement GHC.Generics.:+: SimpleStatement) a)])

}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_98.

AST.Traversable1.Class.Traversable1 a_98

)

instance AST.Unmarshal.SymbolMatching Block where

matchedSymbols _ = [149]

showFailure _ node_99 =

"expected "

GHC.Base.<> ( "block"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_99 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_99) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_100 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_101 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_102 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_103 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_100

c1_101 = TreeSitter.Node.nodeStartPoint node_99

TreeSitter.Node.TSPoint

r2_102

c2_103 = TreeSitter.Node.nodeEndPoint node_99

deriving instance GHC.Classes.Eq a_104 => GHC.Classes.Eq (Block a_104)

deriving instance GHC.Classes.Ord a_105 => GHC.Classes.Ord (Block a_105)

deriving instance GHC.Show.Show a_106 => GHC.Show.Show (Block a_106)

instance AST.Unmarshal.Unmarshal Block

instance Data.Foldable.Foldable Block where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Block where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Block where

traverse = AST.Traversable1.Class.traverseDefault1

data BooleanOperator a = BooleanOperator

{ ann :: a,

operator :: (AST.Parse.Err ((AnonymousAnd GHC.Generics.:+: AnonymousOr) a)),

left :: (AST.Parse.Err (Expression a)),

right :: (AST.Parse.Err (Expression a))

}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_107.

AST.Traversable1.Class.Traversable1 a_107

)

instance AST.Unmarshal.SymbolMatching BooleanOperator where

matchedSymbols _ = [157]

showFailure _ node_108 =

"expected "

GHC.Base.<> ( "boolean_operator"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_108 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_108) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_109 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_110 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_111 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_112 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_109

c1_110 = TreeSitter.Node.nodeStartPoint node_108

TreeSitter.Node.TSPoint

r2_111

c2_112 = TreeSitter.Node.nodeEndPoint node_108

deriving instance GHC.Classes.Eq a_113 => GHC.Classes.Eq (BooleanOperator a_113)

deriving instance GHC.Classes.Ord a_114 => GHC.Classes.Ord (BooleanOperator a_114)

deriving instance GHC.Show.Show a_115 => GHC.Show.Show (BooleanOperator a_115)

instance AST.Unmarshal.Unmarshal BooleanOperator

instance Data.Foldable.Foldable BooleanOperator where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor BooleanOperator where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable BooleanOperator where

traverse = AST.Traversable1.Class.traverseDefault1

data BreakStatement a = BreakStatement {ann :: a, text :: Data.Text.Internal.Text}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_116.

AST.Traversable1.Class.Traversable1 a_116

)

instance AST.Unmarshal.SymbolMatching BreakStatement where

matchedSymbols _ = [121]

showFailure _ node_117 =

"expected "

GHC.Base.<> ( "break_statement"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_117 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_117) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_118 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_119 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_120 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_121 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_118

c1_119 = TreeSitter.Node.nodeStartPoint node_117

TreeSitter.Node.TSPoint

r2_120

c2_121 = TreeSitter.Node.nodeEndPoint node_117

deriving instance GHC.Classes.Eq a_122 => GHC.Classes.Eq (BreakStatement a_122)

deriving instance GHC.Classes.Ord a_123 => GHC.Classes.Ord (BreakStatement a_123)

deriving instance GHC.Show.Show a_124 => GHC.Show.Show (BreakStatement a_124)

instance AST.Unmarshal.Unmarshal BreakStatement

instance Data.Foldable.Foldable BreakStatement where

foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor BreakStatement where

fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable BreakStatement where

traverse = AST.Traversable1.Class.traverseDefault1

data Call a = Call

{ ann :: a,

function :: (AST.Parse.Err (PrimaryExpression a)),

arguments :: (AST.Parse.Err ((ArgumentList GHC.Generics.:+: GeneratorExpression) a))

}

deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)

deriving anyclass

( forall a_125.

AST.Traversable1.Class.Traversable1 a_125

)

instance AST.Unmarshal.SymbolMatching Call where

matchedSymbols _ = [170]

showFailure _ node_126 =

"expected "

GHC.Base.<> ( "call"

GHC.Base.<> ( " but got "

GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_126 GHC.Classes.== 65535

then "ERROR"

else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_126) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_127 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_128 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_129 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_130 GHC.Base.<> "]")))))))))

)

)

)

where

TreeSitter.Node.TSPoint

r1_127

c1_128 = TreeSitter.Node.nodeStartPoint node_126

TreeSitter.Node.TSPoint

r2_129

c2_130 = TreeSitter.Node.nodeEndPoint node_126

deriving instance GHC.Classes.Eq a_131 => GHC.Classes.Eq (Call a_131)

deriving instance GHC.Classes.Ord a_132 => GHC.Classes.Ord (Call a_132)

deriving instance GHC.Show.Show a_133 => GHC.Show.Show (Call a_133)

instance AST.Unmarshal.Unmarshal Call

instance Data.Foldable.Foldable Call where