postgresql-syntax 0.4.5.0 → 0.5.0.0

raw patch · 351 files changed

+12389/−7243 lines, 351 filesdep +QuickCheckdep +hspecdep −deepseqdep −hedgehogdep −tastydep ~rerebasePVP ok

version bump matches the API change (PVP)

Dependencies added: QuickCheck, hspec

Dependencies removed: deepseq, hedgehog, tasty, tasty-hunit

Dependency ranges changed: rerebase

API changes (from Hackage documentation)

Files

• bench/Main.hs +25/−17
• hedgehog-test/Main.hs +0/−36
• hedgehog-test/Main/Gen.hs +0/−971
• hspec-test/Ast/AExprReversableOpSpec.hs +10/−0
• hspec-test/Ast/AExprSpec.hs +75/−0
• hspec-test/Ast/AexprConstSpec.hs +10/−0
• hspec-test/Ast/AliasClauseSpec.hs +10/−0
• hspec-test/Ast/AllOpSpec.hs +10/−0
• hspec-test/Ast/AnyNameSpec.hs +10/−0
• hspec-test/Ast/AnyOperatorSpec.hs +10/−0
• hspec-test/Ast/ArrayBoundsSpec.hs +10/−0
• hspec-test/Ast/ArrayExprListSpec.hs +10/−0
• hspec-test/Ast/ArrayExprSpec.hs +10/−0
• hspec-test/Ast/AscDescSpec.hs +10/−0
• hspec-test/Ast/AttrsSpec.hs +10/−0
• hspec-test/Ast/BExprIsOpSpec.hs +10/−0
• hspec-test/Ast/BExprSpec.hs +10/−0
• hspec-test/Ast/BconstSpec.hs +10/−0
• hspec-test/Ast/BitSpec.hs +10/−0
• hspec-test/Ast/CExprSpec.hs +10/−0
• hspec-test/Ast/CallStmtSpec.hs +10/−0
• hspec-test/Ast/CaseExprSpec.hs +10/−0
• hspec-test/Ast/CharacterSpec.hs +10/−0
• hspec-test/Ast/ColumnrefSpec.hs +10/−0
• hspec-test/Ast/CommonTableExprSpec.hs +10/−0
• hspec-test/Ast/ConfExprSpec.hs +10/−0
• hspec-test/Ast/ConstCharacterSpec.hs +10/−0
• hspec-test/Ast/ConstDatetimeSpec.hs +10/−0
• hspec-test/Ast/ConstTypenameSpec.hs +10/−0
• hspec-test/Ast/DeleteStmtSpec.hs +10/−0
• hspec-test/Ast/ExplicitRowSpec.hs +10/−0
• hspec-test/Ast/ExprListSpec.hs +10/−0
• hspec-test/Ast/ExtractArgSpec.hs +10/−0
• hspec-test/Ast/ExtractListSpec.hs +10/−0
• hspec-test/Ast/FconstSpec.hs +10/−0
• hspec-test/Ast/ForLockingClauseSpec.hs +10/−0
• hspec-test/Ast/ForLockingItemSpec.hs +10/−0
• hspec-test/Ast/ForLockingStrengthSpec.hs +10/−0
• hspec-test/Ast/FrameBoundSpec.hs +27/−0
• hspec-test/Ast/FrameClauseModeSpec.hs +10/−0
• hspec-test/Ast/FrameClauseSpec.hs +10/−0
• hspec-test/Ast/FrameExtentSpec.hs +10/−0
• hspec-test/Ast/FromClauseSpec.hs +10/−0
• hspec-test/Ast/FromListSpec.hs +10/−0
• hspec-test/Ast/FuncAliasClauseSpec.hs +10/−0
• hspec-test/Ast/FuncApplicationParamsSpec.hs +10/−0
• hspec-test/Ast/FuncApplicationSpec.hs +10/−0
• hspec-test/Ast/FuncArgExprSpec.hs +10/−0
• hspec-test/Ast/FuncConstArgsSpec.hs +10/−0
• hspec-test/Ast/FuncExprCommonSubexprSpec.hs +10/−0
• hspec-test/Ast/FuncExprSpec.hs +10/−0
• hspec-test/Ast/FuncExprWindowlessSpec.hs +10/−0
• hspec-test/Ast/FuncNameSpec.hs +10/−0
• hspec-test/Ast/FuncTableSpec.hs +10/−0
• hspec-test/Ast/GenericTypeSpec.hs +10/−0
• hspec-test/Ast/GroupByItemSpec.hs +10/−0
• hspec-test/Ast/GroupClauseSpec.hs +10/−0
• hspec-test/Ast/HavingClauseSpec.hs +10/−0
• hspec-test/Ast/IconstSpec.hs +10/−0
• hspec-test/Ast/IdentSpec.hs +10/−0
• hspec-test/Ast/ImplicitRowSpec.hs +10/−0
• hspec-test/Ast/InExprSpec.hs +10/−0
• hspec-test/Ast/IndexElemDefSpec.hs +10/−0
• hspec-test/Ast/IndexElemSpec.hs +24/−0
• hspec-test/Ast/IndexParamsSpec.hs +10/−0
• hspec-test/Ast/IndirectionElSpec.hs +10/−0
• hspec-test/Ast/IndirectionSpec.hs +10/−0
• hspec-test/Ast/InsertColumnItemSpec.hs +10/−0
• hspec-test/Ast/InsertColumnListSpec.hs +10/−0
• hspec-test/Ast/InsertRestSpec.hs +10/−0
• hspec-test/Ast/InsertStmtSpec.hs +10/−0
• hspec-test/Ast/InsertTargetSpec.hs +10/−0
• hspec-test/Ast/IntervalSecondSpec.hs +10/−0
• hspec-test/Ast/IntervalSpec.hs +10/−0
• hspec-test/Ast/IntoClauseSpec.hs +10/−0
• hspec-test/Ast/JoinMethSpec.hs +10/−0
• hspec-test/Ast/JoinQualSpec.hs +10/−0
• hspec-test/Ast/JoinTypeSpec.hs +10/−0
• hspec-test/Ast/JoinedTableSpec.hs +10/−0
• hspec-test/Ast/LimitClauseSpec.hs +10/−0
• hspec-test/Ast/MathOpSpec.hs +10/−0
• hspec-test/Ast/NameListSpec.hs +10/−0
• hspec-test/Ast/NullsOrderSpec.hs +10/−0
• hspec-test/Ast/NumericSpec.hs +10/−0
• hspec-test/Ast/OffsetClauseSpec.hs +10/−0
• hspec-test/Ast/OnConflictDoSpec.hs +10/−0
• hspec-test/Ast/OnConflictSpec.hs +10/−0
• hspec-test/Ast/OpSpec.hs +11/−0
• hspec-test/Ast/OptOrdinalitySpec.hs +10/−0
• hspec-test/Ast/OptTempTableNameSpec.hs +10/−0
• hspec-test/Ast/OptVaryingSpec.hs +8/−0
• hspec-test/Ast/OverClauseSpec.hs +10/−0
• hspec-test/Ast/OverlayListSpec.hs +10/−0
• hspec-test/Ast/OverrideKindSpec.hs +10/−0
• hspec-test/Ast/PositionListSpec.hs +10/−0
• hspec-test/Ast/PreparableStmtSpec.hs +60/−0
• hspec-test/Ast/QualAllOpSpec.hs +10/−0
• hspec-test/Ast/QualOpSpec.hs +10/−0
• hspec-test/Ast/QualifiedNameSpec.hs +10/−0
• hspec-test/Ast/RelationExprOptAliasSpec.hs +10/−0
• hspec-test/Ast/RelationExprSpec.hs +10/−0
• hspec-test/Ast/ReturningClauseSpec.hs +10/−0
• hspec-test/Ast/RowSpec.hs +10/−0
• hspec-test/Ast/RowsfromItemSpec.hs +10/−0
• hspec-test/Ast/RowsfromListSpec.hs +10/−0
• hspec-test/Ast/SconstSpec.hs +15/−0
• hspec-test/Ast/SelectBinOpSpec.hs +10/−0
• hspec-test/Ast/SelectClauseSpec.hs +10/−0
• hspec-test/Ast/SelectFetchFirstValueSpec.hs +10/−0
• hspec-test/Ast/SelectLimitSpec.hs +10/−0
• hspec-test/Ast/SelectLimitValueSpec.hs +10/−0
• hspec-test/Ast/SelectNoParensSpec.hs +10/−0
• hspec-test/Ast/SelectStmtSpec.hs +10/−0
• hspec-test/Ast/SelectWithParensSpec.hs +18/−0
• hspec-test/Ast/SetClauseListSpec.hs +10/−0
• hspec-test/Ast/SetClauseSpec.hs +10/−0
• hspec-test/Ast/SetTargetListSpec.hs +10/−0
• hspec-test/Ast/SetTargetSpec.hs +10/−0
• hspec-test/Ast/SimpleSelectSpec.hs +10/−0
• hspec-test/Ast/SimpleTypenameSpec.hs +10/−0
• hspec-test/Ast/SortBySpec.hs +24/−0
• hspec-test/Ast/SortClauseSpec.hs +10/−0
• hspec-test/Ast/SubTypeSpec.hs +10/−0
• hspec-test/Ast/SubqueryOpSpec.hs +10/−0
• hspec-test/Ast/SubstrListFromForSpec.hs +10/−0
• hspec-test/Ast/SubstrListSpec.hs +10/−0
• hspec-test/Ast/SymbolicExprBinOpSpec.hs +10/−0
• hspec-test/Ast/TableFuncElementListSpec.hs +10/−0
• hspec-test/Ast/TableFuncElementSpec.hs +10/−0
• hspec-test/Ast/TableRefSpec.hs +10/−0
• hspec-test/Ast/TablesampleClauseSpec.hs +10/−0
• hspec-test/Ast/TargetElSpec.hs +10/−0
• hspec-test/Ast/TargetListSpec.hs +10/−0
• hspec-test/Ast/TargetingSpec.hs +10/−0
• hspec-test/Ast/TimezoneSpec.hs +10/−0
• hspec-test/Ast/TrimListSpec.hs +10/−0
• hspec-test/Ast/TrimModifierSpec.hs +10/−0
• hspec-test/Ast/TypeListSpec.hs +10/−0
• hspec-test/Ast/TypenameArrayDimensionsSpec.hs +8/−0
• hspec-test/Ast/TypenameSpec.hs +46/−0
• hspec-test/Ast/UpdateStmtSpec.hs +10/−0
• hspec-test/Ast/UsingClauseSpec.hs +10/−0
• hspec-test/Ast/ValuesClauseSpec.hs +10/−0
• hspec-test/Ast/VerbalExprBinOpSpec.hs +10/−0
• hspec-test/Ast/WhenClauseListSpec.hs +10/−0
• hspec-test/Ast/WhenClauseSpec.hs +10/−0
• hspec-test/Ast/WhereClauseSpec.hs +10/−0
• hspec-test/Ast/WhereOrCurrentClauseSpec.hs +10/−0
• hspec-test/Ast/WindowClauseSpec.hs +10/−0
• hspec-test/Ast/WindowDefinitionSpec.hs +10/−0
• hspec-test/Ast/WindowExclusionClauseSpec.hs +10/−0
• hspec-test/Ast/WindowSpecificationSpec.hs +20/−0
• hspec-test/Ast/WithClauseSpec.hs +10/−0
• hspec-test/Ast/XconstSpec.hs +10/−0
• hspec-test/Helpers/Expectations.hs +77/−0
• hspec-test/Helpers/Specs.hs +105/−0
• hspec-test/Main.hs +8/−0
• hspec-test/Spec.hs +1/−0
• library-internal/PostgresqlSyntax/Ast.hs +382/−0
• library-internal/PostgresqlSyntax/Ast/AExpr.hs +462/−0
• library-internal/PostgresqlSyntax/Ast/AExpr.hs-boot +39/−0
• library-internal/PostgresqlSyntax/Ast/AExprReversableOp.hs +113/−0
• library-internal/PostgresqlSyntax/Ast/AexprConst.hs +126/−0
• library-internal/PostgresqlSyntax/Ast/AliasClause.hs +51/−0
• library-internal/PostgresqlSyntax/Ast/AllOp.hs +37/−0
• library-internal/PostgresqlSyntax/Ast/AnyName.hs +51/−0
• library-internal/PostgresqlSyntax/Ast/AnyOperator.hs +56/−0
• library-internal/PostgresqlSyntax/Ast/ArrayBounds.hs +28/−0
• library-internal/PostgresqlSyntax/Ast/ArrayExpr.hs +50/−0
• library-internal/PostgresqlSyntax/Ast/ArrayExpr.hs-boot +19/−0
• library-internal/PostgresqlSyntax/Ast/ArrayExprList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/AscDesc.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/Attrs.hs +45/−0
• library-internal/PostgresqlSyntax/Ast/BExpr.hs +161/−0
• library-internal/PostgresqlSyntax/Ast/BExpr.hs-boot +19/−0
• library-internal/PostgresqlSyntax/Ast/BExprIsOp.hs +55/−0
• library-internal/PostgresqlSyntax/Ast/Bconst.hs +33/−0
• library-internal/PostgresqlSyntax/Ast/Bit.hs +43/−0
• library-internal/PostgresqlSyntax/Ast/CExpr.hs +190/−0
• library-internal/PostgresqlSyntax/Ast/CallStmt.hs +22/−0
• library-internal/PostgresqlSyntax/Ast/CaseExpr.hs +54/−0
• library-internal/PostgresqlSyntax/Ast/Character.hs +57/−0
• library-internal/PostgresqlSyntax/Ast/Columnref.hs +32/−0
• library-internal/PostgresqlSyntax/Ast/CommonTableExpr.hs +59/−0
• library-internal/PostgresqlSyntax/Ast/ConfExpr.hs +51/−0
• library-internal/PostgresqlSyntax/Ast/ConstCharacter.hs +41/−0
• library-internal/PostgresqlSyntax/Ast/ConstDatetime.hs +69/−0
• library-internal/PostgresqlSyntax/Ast/ConstTypename.hs +49/−0
• library-internal/PostgresqlSyntax/Ast/DeleteStmt.hs +56/−0
• library-internal/PostgresqlSyntax/Ast/ExplicitRow.hs +41/−0
• library-internal/PostgresqlSyntax/Ast/ExprList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/ExtractArg.hs +68/−0
• library-internal/PostgresqlSyntax/Ast/ExtractList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/Fconst.hs +30/−0
• library-internal/PostgresqlSyntax/Ast/ForLockingClause.hs +41/−0
• library-internal/PostgresqlSyntax/Ast/ForLockingItem.hs +49/−0
• library-internal/PostgresqlSyntax/Ast/ForLockingStrength.hs +48/−0
• library-internal/PostgresqlSyntax/Ast/FrameBound.hs +56/−0
• library-internal/PostgresqlSyntax/Ast/FrameClause.hs +40/−0
• library-internal/PostgresqlSyntax/Ast/FrameClauseMode.hs +34/−0
• library-internal/PostgresqlSyntax/Ast/FrameExtent.hs +37/−0
• library-internal/PostgresqlSyntax/Ast/FromClause.hs +30/−0
• library-internal/PostgresqlSyntax/Ast/FromList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/FuncAliasClause.hs +83/−0
• library-internal/PostgresqlSyntax/Ast/FuncApplication.hs +39/−0
• library-internal/PostgresqlSyntax/Ast/FuncApplicationParams.hs +111/−0
• library-internal/PostgresqlSyntax/Ast/FuncArgExpr.hs +70/−0
• library-internal/PostgresqlSyntax/Ast/FuncConstArgs.hs +30/−0
• library-internal/PostgresqlSyntax/Ast/FuncExpr.hs +78/−0
• library-internal/PostgresqlSyntax/Ast/FuncExprCommonSubexpr.hs +199/−0
• library-internal/PostgresqlSyntax/Ast/FuncExprCommonSubexpr.hs-boot +19/−0
• library-internal/PostgresqlSyntax/Ast/FuncExprWindowless.hs +37/−0
• library-internal/PostgresqlSyntax/Ast/FuncName.hs +60/−0
• library-internal/PostgresqlSyntax/Ast/FuncTable.hs +50/−0
• library-internal/PostgresqlSyntax/Ast/GenericType.hs +45/−0
• library-internal/PostgresqlSyntax/Ast/GroupByItem.hs +68/−0
• library-internal/PostgresqlSyntax/Ast/GroupClause.hs +35/−0
• library-internal/PostgresqlSyntax/Ast/HavingClause.hs +31/−0
• library-internal/PostgresqlSyntax/Ast/Iconst.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/Ident.hs +103/−0
• library-internal/PostgresqlSyntax/Ast/ImplicitRow.hs +38/−0
• library-internal/PostgresqlSyntax/Ast/InExpr.hs +70/−0
• library-internal/PostgresqlSyntax/Ast/IndexElem.hs +64/−0
• library-internal/PostgresqlSyntax/Ast/IndexElemDef.hs +46/−0
• library-internal/PostgresqlSyntax/Ast/IndexParams.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/Indirection.hs +26/−0
• library-internal/PostgresqlSyntax/Ast/IndirectionEl.hs +104/−0
• library-internal/PostgresqlSyntax/Ast/InsertColumnItem.hs +32/−0
• library-internal/PostgresqlSyntax/Ast/InsertColumnList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/InsertRest.hs +64/−0
• library-internal/PostgresqlSyntax/Ast/InsertStmt.hs +57/−0
• library-internal/PostgresqlSyntax/Ast/InsertTarget.hs +31/−0
• library-internal/PostgresqlSyntax/Ast/Interval.hs +94/−0
• library-internal/PostgresqlSyntax/Ast/IntervalSecond.hs +36/−0
• library-internal/PostgresqlSyntax/Ast/IntoClause.hs +30/−0
• library-internal/PostgresqlSyntax/Ast/JoinMeth.hs +64/−0
• library-internal/PostgresqlSyntax/Ast/JoinQual.hs +40/−0
• library-internal/PostgresqlSyntax/Ast/JoinType.hs +60/−0
• library-internal/PostgresqlSyntax/Ast/JoinedTable.hs +58/−0
• library-internal/PostgresqlSyntax/Ast/JoinedTable.hs-boot +19/−0
• library-internal/PostgresqlSyntax/Ast/LimitClause.hs +100/−0
• library-internal/PostgresqlSyntax/Ast/MathOp.hs +76/−0
• library-internal/PostgresqlSyntax/Ast/NameList.hs +43/−0
• library-internal/PostgresqlSyntax/Ast/NullsOrder.hs +28/−0
• library-internal/PostgresqlSyntax/Ast/Numeric.hs +99/−0
• library-internal/PostgresqlSyntax/Ast/OffsetClause.hs +56/−0
• library-internal/PostgresqlSyntax/Ast/OnConflict.hs +40/−0
• library-internal/PostgresqlSyntax/Ast/OnConflictDo.hs +57/−0
• library-internal/PostgresqlSyntax/Ast/Op.hs +36/−0
• library-internal/PostgresqlSyntax/Ast/OptOrdinality.hs +24/−0
• library-internal/PostgresqlSyntax/Ast/OptTempTableName.hs +85/−0
• library-internal/PostgresqlSyntax/Ast/OptVarying.hs +24/−0
• library-internal/PostgresqlSyntax/Ast/OverClause.hs +43/−0
• library-internal/PostgresqlSyntax/Ast/OverlayList.hs +58/−0
• library-internal/PostgresqlSyntax/Ast/OverrideKind.hs +30/−0
• library-internal/PostgresqlSyntax/Ast/PositionList.hs +26/−0
• library-internal/PostgresqlSyntax/Ast/PreparableStmt.hs +55/−0
• library-internal/PostgresqlSyntax/Ast/QualAllOp.hs +39/−0
• library-internal/PostgresqlSyntax/Ast/QualOp.hs +38/−0
• library-internal/PostgresqlSyntax/Ast/QualifiedName.hs +43/−0
• library-internal/PostgresqlSyntax/Ast/RelationExpr.hs +55/−0
• library-internal/PostgresqlSyntax/Ast/RelationExprOptAlias.hs +51/−0
• library-internal/PostgresqlSyntax/Ast/ReturningClause.hs +33/−0
• library-internal/PostgresqlSyntax/Ast/Row.hs +34/−0
• library-internal/PostgresqlSyntax/Ast/RowsfromItem.hs +39/−0
• library-internal/PostgresqlSyntax/Ast/RowsfromList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/Sconst.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/SelectBinOp.hs +32/−0
• library-internal/PostgresqlSyntax/Ast/SelectClause.hs +46/−0
• library-internal/PostgresqlSyntax/Ast/SelectClause.hs-boot +19/−0
• library-internal/PostgresqlSyntax/Ast/SelectFetchFirstValue.hs +61/−0
• library-internal/PostgresqlSyntax/Ast/SelectLimit.hs +51/−0
• library-internal/PostgresqlSyntax/Ast/SelectLimitValue.hs +38/−0
• library-internal/PostgresqlSyntax/Ast/SelectNoParens.hs +133/−0
• library-internal/PostgresqlSyntax/Ast/SelectNoParens.hs-boot +27/−0
• library-internal/PostgresqlSyntax/Ast/SelectStmt.hs +39/−0
• library-internal/PostgresqlSyntax/Ast/SelectWithParens.hs +103/−0
• library-internal/PostgresqlSyntax/Ast/SelectWithParens.hs-boot +25/−0
• library-internal/PostgresqlSyntax/Ast/SetClause.hs +53/−0
• library-internal/PostgresqlSyntax/Ast/SetClauseList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/SetTarget.hs +32/−0
• library-internal/PostgresqlSyntax/Ast/SetTargetList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/SimpleSelect.hs +184/−0
• library-internal/PostgresqlSyntax/Ast/SimpleSelect.hs-boot +27/−0
• library-internal/PostgresqlSyntax/Ast/SimpleTypename.hs +74/−0
• library-internal/PostgresqlSyntax/Ast/SortBy.hs +60/−0
• library-internal/PostgresqlSyntax/Ast/SortClause.hs +35/−0
• library-internal/PostgresqlSyntax/Ast/SubType.hs +33/−0
• library-internal/PostgresqlSyntax/Ast/SubqueryOp.hs +53/−0
• library-internal/PostgresqlSyntax/Ast/SubstrList.hs +45/−0
• library-internal/PostgresqlSyntax/Ast/SubstrListFromFor.hs +63/−0
• library-internal/PostgresqlSyntax/Ast/SymbolicExprBinOp.hs +30/−0
• library-internal/PostgresqlSyntax/Ast/TableFuncElement.hs +40/−0
• library-internal/PostgresqlSyntax/Ast/TableFuncElementList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/TableRef.hs +265/−0
• library-internal/PostgresqlSyntax/Ast/TableRef.hs-boot +32/−0
• library-internal/PostgresqlSyntax/Ast/TablesampleClause.hs +47/−0
• library-internal/PostgresqlSyntax/Ast/TargetEl.hs +79/−0
• library-internal/PostgresqlSyntax/Ast/TargetList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/Targeting.hs +65/−0
• library-internal/PostgresqlSyntax/Ast/Timezone.hs +30/−0
• library-internal/PostgresqlSyntax/Ast/TrimList.hs +45/−0
• library-internal/PostgresqlSyntax/Ast/TrimModifier.hs +33/−0
• library-internal/PostgresqlSyntax/Ast/TypeList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/Typename.hs +46/−0
• library-internal/PostgresqlSyntax/Ast/TypenameArrayDimensions.hs +45/−0
• library-internal/PostgresqlSyntax/Ast/UpdateStmt.hs +66/−0
• library-internal/PostgresqlSyntax/Ast/UsingClause.hs +28/−0
• library-internal/PostgresqlSyntax/Ast/ValuesClause.hs +40/−0
• library-internal/PostgresqlSyntax/Ast/VerbalExprBinOp.hs +38/−0
• library-internal/PostgresqlSyntax/Ast/WhenClause.hs +35/−0
• library-internal/PostgresqlSyntax/Ast/WhenClauseList.hs +27/−0
• library-internal/PostgresqlSyntax/Ast/WhereClause.hs +31/−0
• library-internal/PostgresqlSyntax/Ast/WhereOrCurrentClause.hs +52/−0
• library-internal/PostgresqlSyntax/Ast/WindowClause.hs +32/−0
• library-internal/PostgresqlSyntax/Ast/WindowDefinition.hs +26/−0
• library-internal/PostgresqlSyntax/Ast/WindowExclusionClause.hs +49/−0
• library-internal/PostgresqlSyntax/Ast/WindowSpecification.hs +79/−0
• library-internal/PostgresqlSyntax/Ast/WithClause.hs +36/−0
• library-internal/PostgresqlSyntax/Ast/WithClause.hs-boot +19/−0
• library-internal/PostgresqlSyntax/Ast/Xconst.hs +34/−0
• library-internal/PostgresqlSyntax/CharSet.hs +21/−0
• library-internal/PostgresqlSyntax/Extras/Error.hs +40/−0
• library-internal/PostgresqlSyntax/Extras/HeadedMegaparsec.hs +133/−0
• library-internal/PostgresqlSyntax/Extras/NonEmpty.hs +33/−0
• library-internal/PostgresqlSyntax/Extras/TextBuilder.hs +16/−0
• library-internal/PostgresqlSyntax/Helpers/Gens.hs +51/−0
• library-internal/PostgresqlSyntax/Helpers/Parsers.hs +221/−0
• library-internal/PostgresqlSyntax/Helpers/Shrinks.hs +30/−0
• library-internal/PostgresqlSyntax/Helpers/TextBuilders.hs +35/−0
• library-internal/PostgresqlSyntax/IsAst.hs +44/−0
• library-internal/PostgresqlSyntax/KeywordSet.hs +66/−0
• library-internal/PostgresqlSyntax/Predicate.hs +71/−0
• library-internal/PostgresqlSyntax/Prelude.hs +99/−0
• library-internal/PostgresqlSyntax/Settings.hs +44/−0
• library-internal/PostgresqlSyntax/Validation.hs +54/−0
• library/PostgresqlSyntax.hs +32/−0
• library/PostgresqlSyntax/Ast.hs +0/−2340
• library/PostgresqlSyntax/CharSet.hs +0/−21
• library/PostgresqlSyntax/Extras/HeadedMegaparsec.hs +0/−118
• library/PostgresqlSyntax/Extras/NonEmpty.hs +0/−33
• library/PostgresqlSyntax/Extras/TextBuilder.hs +0/−16
• library/PostgresqlSyntax/KeywordSet.hs +0/−66
• library/PostgresqlSyntax/Parsing.hs +0/−2290
• library/PostgresqlSyntax/Predicate.hs +0/−71
• library/PostgresqlSyntax/Prelude.hs +0/−96
• library/PostgresqlSyntax/Rendering.hs +0/−921
• library/PostgresqlSyntax/Validation.hs +0/−51
• nesting-bench/Main.hs +2/−6
• postgresql-syntax.cabal +341/−33
• tasty-test/Main.hs +0/−157

@@ -4,7 +4,7 @@ -- Benchmark for the "keyword allocation cost in wide alternations" concern -- raised in <https://github.com/nikita-volkov/postgresql-syntax/issues/21>. ----- Compares the shipped, cheap 'PostgresqlSyntax.Parsing.keyword'+-- Compares the shipped, cheap 'PostgresqlSyntax.Helpers.Parsers.keyword' -- (a bare 'empty' on mismatch, no allocation beyond the consumed text) -- against a richer alternative that reports a proper \"expected one of ...\" -- error via 'Text.Megaparsec.failure' (as PR #20 proposed), the way it would@@ -12,27 +12,23 @@ -- -- Both implementations here pin the reported error offset via -- 'Megaparsec.setOffset', matching the fix applied to the shipped--- 'PostgresqlSyntax.Parsing.keyword' to stay correct under megaparsec+-- 'PostgresqlSyntax.Helpers.Parsers.keyword' to stay correct under megaparsec -- >=9.8's stricter '(<|>)' error-merging. That fix is what makes the rich -- variant produce complete "expecting ..." lists at all under current--- megaparsec; see 'PostgresqlSyntax.Parsing.keyword''s haddock.+-- megaparsec; see 'PostgresqlSyntax.Helpers.Parsers.keyword''s haddock. module Main where  import Criterion.Main import qualified Data.Char as Char-import qualified Data.HashSet as HashSet import qualified Data.Set as Set import qualified Data.Text as Text import HeadedMegaparsec (HeadedParsec, parse, toParsec)-import qualified Hedgehog.Gen as Gen-import qualified Main.Gen as SynGen-import qualified PostgresqlSyntax.KeywordSet as KeywordSet-import qualified PostgresqlSyntax.Parsing as Parsing-import qualified PostgresqlSyntax.Rendering as Rendering+import qualified PostgresqlSyntax+import qualified Test.QuickCheck as Qc import qualified Text.Megaparsec as Megaparsec import Prelude --- * Shared token scanner (mirrors 'PostgresqlSyntax.Parsing.anyKeyword')+-- * Shared token scanner (mirrors 'PostgresqlSyntax.Helpers.Parsers.anyKeyword')  firstIdentifierChar :: Char -> Bool firstIdentifierChar x = Char.isAlpha x || x == '_' || x >= '\200' && x <= '\377'@@ -76,6 +72,18 @@ runHeaded :: HeadedParsec Void Text.Text a -> Text.Text -> Either (Megaparsec.ParseErrorBundle Text.Text Void) a runHeaded p = Megaparsec.runParser (toParsec p <* Megaparsec.eof) "" +-- * Keyword word lists (sized to mirror the shipped keyword sets)++-- | ~90 words: the size of a typical mid-size dispatch, mirroring+-- @PostgresqlSyntax.KeywordSet.reservedKeyword@.+reservedWords :: [Text.Text]+reservedWords = ["all", "analyse", "analyze", "and", "any", "array", "as", "asc", "asymmetric", "both", "case", "cast", "check", "collate", "column", "constraint", "create", "current_catalog", "current_date", "current_role", "current_time", "current_timestamp", "current_user", "default", "deferrable", "desc", "distinct", "do", "else", "end", "except", "false", "fetch", "for", "foreign", "from", "grant", "group", "having", "in", "initially", "intersect", "into", "lateral", "leading", "limit", "localtime", "localtimestamp", "not", "null", "offset", "on", "only", "or", "order", "placing", "primary", "references", "returning", "select", "session_user", "some", "symmetric", "table", "then", "to", "trailing", "true", "union", "unique", "user", "using", "variadic", "when", "where", "window", "with"]++-- | ~440 words: the full reserved-word set, worst case, mirroring+-- @PostgresqlSyntax.KeywordSet.keyword@.+allWords :: [Text.Text]+allWords = ["abort", "absolute", "access", "action", "add", "admin", "after", "aggregate", "all", "also", "alter", "always", "analyse", "analyze", "and", "any", "array", "as", "asc", "assertion", "assignment", "asymmetric", "at", "attach", "attribute", "authorization", "backward", "before", "begin", "between", "bigint", "binary", "bit", "boolean", "both", "by", "cache", "call", "called", "cascade", "cascaded", "case", "cast", "catalog", "chain", "char", "character", "characteristics", "check", "checkpoint", "class", "close", "cluster", "coalesce", "collate", "collation", "column", "columns", "comment", "comments", "commit", "committed", "concurrently", "configuration", "conflict", "connection", "constraint", "constraints", "content", "continue", "conversion", "copy", "cost", "create", "cross", "csv", "cube", "current", "current_catalog", "current_date", "current_role", "current_schema", "current_time", "current_timestamp", "current_user", "cursor", "cycle", "data", "database", "day", "deallocate", "dec", "decimal", "declare", "default", "defaults", "deferrable", "deferred", "definer", "delete", "delimiter", "delimiters", "depends", "desc", "detach", "dictionary", "disable", "discard", "distinct", "do", "document", "domain", "double", "drop", "each", "else", "enable", "encoding", "encrypted", "end", "enum", "escape", "event", "except", "exclude", "excluding", "exclusive", "execute", "exists", "explain", "expression", "extension", "external", "extract", "false", "family", "fetch", "filter", "first", "float", "following", "for", "force", "foreign", "forward", "freeze", "from", "full", "function", "functions", "generated", "global", "grant", "granted", "greatest", "group", "grouping", "groups", "handler", "having", "header", "hold", "hour", "identity", "if", "ilike", "immediate", "immutable", "implicit", "import", "in", "include", "including", "increment", "index", "indexes", "inherit", "inherits", "initially", "inline", "inner", "inout", "input", "insensitive", "insert", "instead", "int", "integer", "intersect", "interval", "into", "invoker", "is", "isnull", "isolation", "join", "key", "label", "language", "large", "last", "lateral", "leading", "leakproof", "least", "left", "level", "like", "limit", "listen", "load", "local", "localtime", "localtimestamp", "location", "lock", "locked", "logged", "mapping", "match", "materialized", "maxvalue", "method", "minute", "minvalue", "mode", "month", "move", "name", "names", "national", "natural", "nchar", "new", "next", "nfc", "nfd", "nfkc", "nfkd", "no", "none", "normalize", "normalized", "not", "nothing", "notify", "notnull", "nowait", "null", "nullif", "nulls", "numeric", "object", "of", "off", "offset", "oids", "old", "on", "only", "operator", "option", "options", "or", "order", "ordinality", "others", "out", "outer", "over", "overlaps", "overlay", "overriding", "owned", "owner", "parallel", "parser", "partial", "partition", "passing", "password", "placing", "plans", "policy", "position", "preceding", "precision", "prepare", "prepared", "preserve", "primary", "prior", "privileges", "procedural", "procedure", "procedures", "program", "publication", "quote", "range", "read", "real", "reassign", "recheck", "recursive", "ref", "references", "referencing", "refresh", "reindex", "relative", "release", "rename", "repeatable", "replace", "replica", "reset", "restart", "restrict", "returning", "returns", "revoke", "right", "role", "rollback", "rollup", "routine", "routines", "row", "rows", "rule", "savepoint", "schema", "schemas", "scroll", "search", "second", "security", "select", "sequence", "sequences", "serializable", "server", "session", "session_user", "set", "setof", "sets", "share", "show", "similar", "simple", "skip", "smallint", "snapshot", "some", "sql", "stable", "standalone", "start", "statement", "statistics", "stdin", "stdout", "storage", "stored", "strict", "strip", "subscription", "substring", "support", "symmetric", "sysid", "system", "table", "tables", "tablesample", "tablespace", "temp", "template", "temporary", "text", "then", "ties", "time", "timestamp", "to", "trailing", "transaction", "transform", "treat", "trigger", "trim", "true", "truncate", "trusted", "type", "types", "uescape", "unbounded", "uncommitted", "unencrypted", "union", "unique", "unknown", "unlisten", "unlogged", "until", "update", "user", "using", "vacuum", "valid", "validate", "validator", "value", "values", "varchar", "variadic", "varying", "verbose", "version", "view", "views", "volatile", "when", "where", "whitespace", "window", "with", "within", "without", "work", "wrapper", "write", "xml", "xmlattributes", "xmlconcat", "xmlelement", "xmlexists", "xmlforest", "xmlnamespaces", "xmlparse", "xmlpi", "xmlroot", "xmlserialize", "xmltable", "year", "yes", "zone"]+ -- * Wide-alternation scenarios  -- | An alternation over every element of the given keyword list, dispatched@@ -87,13 +95,13 @@  main :: IO () main = do-  let reservedWords = HashSet.toList KeywordSet.reservedKeyword -- ~90 words: the size of a typical mid-size dispatch-      allWords = HashSet.toList KeywordSet.keyword -- ~440 words: the full reserved-word set, worst case-      lastOf xs = last xs+  let lastOf xs = last xs+      firstOf (x : _) = x+      firstOf [] = error "empty keyword list"       noMatchToken = "zzzznotakeyword" :: Text.Text -  corpus <- replicateM 500 (Gen.sample (Gen.resize 15 SynGen.preparableStmt))-  let corpusTexts = map (Rendering.toText . Rendering.preparableStmt) corpus+  corpus <- replicateM 500 (Qc.generate (Qc.resize 15 (Qc.arbitrary @PostgresqlSyntax.PreparableStmt)))+  let corpusTexts = map (PostgresqlSyntax.toText mempty) corpus    defaultMain     [ bgroup@@ -105,12 +113,12 @@             ]         | (label, kws) <- [("~90 words", reservedWords), ("~440 words", allWords)],           (scenario, token) <--            [ ("first match", head kws),+            [ ("first match", firstOf kws),               ("last match", lastOf kws),               ("no match", noMatchToken)             ]         ],       bgroup         "full grammar on generated corpus (reference, shipped keyword only)"-        [bench "500 generated preparableStmt" $ nf (map (either (const False) (const True) . Parsing.run Parsing.preparableStmt)) corpusTexts]+        [bench "500 generated preparableStmt" $ nf (map (either (const False) (const True) . PostgresqlSyntax.parse @PostgresqlSyntax.PreparableStmt mempty)) corpusTexts]     ]

@@ -1,36 +0,0 @@-module Main where--import qualified Data.Text as Text-import Hedgehog-import Hedgehog.Main-import qualified Main.Gen as Gen-import qualified PostgresqlSyntax.Parsing as Parsing-import qualified PostgresqlSyntax.Rendering as Rendering-import Prelude--main :: IO ()-main =-  defaultMain-    [ checkParallel-        $ Group "Parsing a rendered AST produces the same AST"-        $ let p name amount gen parser renderer =-                (,) name-                  $ withDiscards (fromIntegral amount * 200)-                  $ withTests amount-                  $ property-                  $ do-                    ast <- forAll gen-                    let sql = Rendering.toText (renderer ast)-                     in do-                          footnote ("SQL: " <> Text.unpack sql)-                          case Parsing.run parser sql of-                            Left err -> do-                              footnote err-                              failure-                            Right ast' -> ast === ast'-           in [ p "typename" 10000 Gen.typename Parsing.typename Rendering.typename,-                p "tableRef" 10000 Gen.tableRef Parsing.tableRef Rendering.tableRef,-                p "aExpr" 60000 Gen.aExpr Parsing.aExpr Rendering.aExpr,-                p "preparableStmt" 30000 Gen.preparableStmt Parsing.preparableStmt Rendering.preparableStmt-              ]-    ]

@@ -1,971 +0,0 @@-{-# OPTIONS_GHC -Wno-missing-signatures #-}--module Main.Gen where--import qualified Data.HashSet as HashSet-import qualified Data.List as List-import qualified Data.Text as Text-import Hedgehog (Gen)-import Hedgehog.Gen-import qualified Hedgehog.Range as Range-import PostgresqlSyntax.Ast-import qualified PostgresqlSyntax.KeywordSet as KeywordSet-import qualified PostgresqlSyntax.Validation as Validation-import Prelude hiding (bit, bool, filter, fromList, maybe, sortBy)---- * Generic--inSet set = filter (flip HashSet.member set)--notInSet set = filter (not . flip HashSet.member set)---- * Statements--preparableStmt =-  choice-    [ SelectPreparableStmt <$> selectStmt,-      InsertPreparableStmt <$> insertStmt,-      UpdatePreparableStmt <$> updateStmt,-      DeletePreparableStmt <$> deleteStmt,-      CallPreparableStmt <$> callStmt-    ]---- * Call--callStmt = CallStmt <$> funcApplication---- * Insert--insertStmt = InsertStmt <$> maybe withClause <*> insertTarget <*> insertRest <*> maybe onConflict <*> maybe returningClause--insertTarget = InsertTarget <$> qualifiedName <*> maybe colId--insertRest =-  choice-    [ SelectInsertRest <$> maybe insertColumnList <*> maybe overrideKind <*> selectStmt,-      pure DefaultValuesInsertRest-    ]--overrideKind = enumBounded--insertColumnList = nonEmpty (Range.exponential 1 7) insertColumnItem--insertColumnItem = InsertColumnItem <$> colId <*> maybe indirection--onConflict = OnConflict <$> maybe confExpr <*> onConflictDo--onConflictDo =-  choice-    [ UpdateOnConflictDo <$> setClauseList <*> maybe whereClause,-      pure NothingOnConflictDo-    ]--confExpr =-  choice-    [ WhereConfExpr <$> indexParams <*> maybe whereClause,-      ConstraintConfExpr <$> name-    ]--returningClause = targetList---- * Update--updateStmt = UpdateStmt <$> maybe withClause <*> relationExprOptAlias <*> setClauseList <*> maybe fromClause <*> maybe whereOrCurrentClause <*> maybe returningClause--setClauseList = nonEmpty (Range.exponential 1 10) setClause--setClause =-  choice-    [ TargetSetClause <$> setTarget <*> aExpr,-      TargetListSetClause <$> setTargetList <*> aExpr-    ]--setTarget = SetTarget <$> colId <*> maybe indirection--setTargetList = nonEmpty (Range.exponential 1 10) setTarget---- * Delete--deleteStmt = DeleteStmt <$> maybe withClause <*> relationExprOptAlias <*> maybe usingClause <*> maybe whereOrCurrentClause <*> maybe returningClause--usingClause = fromList---- * Select--selectStmt = Left <$> selectNoParens---- ** selectNoParens--selectNoParens =-  frequency-    [ (90, SelectNoParens <$> maybe withClause <*> (Left <$> simpleSelect) <*> maybe sortClause <*> maybe selectLimit <*> maybe forLockingClause),-      (10, clausePlusSurroundingsSelectNoParens)-    ]---- |--- A 'SelectNoParens' with at least one of its surrounding clauses present.------ The restriction matters for the @Right@ (parenthesised select) shape of the--- inner clause: @SelectNoParens Nothing (Right x) Nothing Nothing Nothing@--- renders to exactly the same text as @WithParensSelectWithParens x@, and the--- parser canonicalises that text to the latter — see the \"Canonical shape\"--- note on @PostgresqlSyntax.Parsing.selectWithParensBody@. So the degenerate--- combination is excluded here deliberately, rather than by accident of the--- generator's shape: it is the one tree in this family that the round-trip--- property cannot hold for.-clausePlusSurroundingsSelectNoParens = do-  clause <- selectClause-  -- At least one surrounding clause, so the SelectNoParens wrapper is-  -- load-bearing.-  (with, sort, limit, forLocking) <--    filter-      (\(a, b, c, d) -> any not [null a, null b, null c, null d])-      ((,,,) <$> maybe withClause <*> maybe sortClause <*> maybe selectLimit <*> maybe forLockingClause)-  return (SelectNoParens with clause sort limit forLocking)--terminalSelectNoParens =-  SelectNoParens <$> pure Nothing <*> (Left <$> terminalSimpleSelect) <*> pure Nothing <*> pure Nothing <*> pure Nothing---- ** selectWithParens--selectWithParens = sized $ \size ->-  if size <= 1-    then discard-    else-      frequency-        [ (95, NoParensSelectWithParens <$> selectNoParens),-          (5, WithParensSelectWithParens <$> selectWithParens)-        ]--terminalSelectWithParens = NoParensSelectWithParens <$> terminalSelectNoParens---- ** selectClause--selectClause =-  choice-    [ Left <$> simpleSelect,-      Right <$> small selectWithParens-    ]--nonTrailingSelectClause = Left <$> nonTrailingSimpleSelect---- ** simpleSelect--simpleSelect =-  choice-    [ normalSimpleSelect,-      tableSimpleSelect,-      valuesSimpleSelect,-      small nonTrailingSelectClause >>= binSimpleSelect-    ]--nonTrailingSimpleSelect = choice [normalSimpleSelect, valuesSimpleSelect, tableSimpleSelect]--normalSimpleSelect = NormalSimpleSelect <$> maybe targeting <*> maybe intoClause <*> maybe fromClause <*> maybe whereClause <*> maybe groupClause <*> maybe havingClause <*> maybe windowClause--tableSimpleSelect = TableSimpleSelect <$> relationExpr--valuesSimpleSelect = ValuesSimpleSelect <$> valuesClause--binSimpleSelect leftSelect =-  BinSimpleSelect <$> selectBinOp <*> pure leftSelect <*> maybe allOrDistinct <*> small selectClause--terminalSimpleSelect = pure (NormalSimpleSelect Nothing Nothing Nothing Nothing Nothing Nothing Nothing)---- * Targeting--targeting =-  choice-    [ NormalTargeting <$> targetList,-      AllTargeting <$> maybe targetList,-      DistinctTargeting <$> maybe (nonEmpty (Range.exponential 1 8) aExpr) <*> targetList-    ]--targetList = nonEmpty (Range.exponential 1 8) targetEl--targetEl =-  choice-    [ pure AsteriskTargetEl,-      AliasedExprTargetEl <$> aExpr <*> colLabel,-      ImplicitlyAliasedExprTargetEl <$> prefixAExpr <*> ident,-      ExprTargetEl <$> aExpr-    ]---- * BinSimpleSelect--selectBinOp = element [UnionSelectBinOp, IntersectSelectBinOp, ExceptSelectBinOp]---- * With Clause--withClause = WithClause <$> bool <*> nonEmpty (Range.exponential 1 7) commonTableExpr--commonTableExpr = CommonTableExpr <$> name <*> maybe (nonEmpty (Range.exponential 1 8) name) <*> maybe bool <*> small preparableStmt---- * Into Clause--intoClause = optTempTableName--optTempTableName =-  choice-    [ TemporaryOptTempTableName <$> bool <*> qualifiedName,-      TempOptTempTableName <$> bool <*> qualifiedName,-      LocalTemporaryOptTempTableName <$> bool <*> qualifiedName,-      LocalTempOptTempTableName <$> bool <*> qualifiedName,-      GlobalTemporaryOptTempTableName <$> bool <*> qualifiedName,-      GlobalTempOptTempTableName <$> bool <*> qualifiedName,-      UnloggedOptTempTableName <$> bool <*> qualifiedName,-      TableOptTempTableName <$> qualifiedName,-      QualifedOptTempTableName <$> qualifiedName-    ]---- * From Clause--fromList = nonEmpty (Range.exponential 1 8) tableRef--fromClause = fromList--tableRef = choice [relationExprTableRef, selectTableRef, joinTableRef]--relationExprTableRef = RelationExprTableRef <$> relationExpr <*> maybe aliasClause <*> maybe tablesampleClause--funcTableRef = FuncTableRef <$> bool <*> funcTable <*> maybe funcAliasClause--selectTableRef = SelectTableRef <$> bool <*> small selectWithParens <*> maybe aliasClause--joinTableRef = JoinTableRef <$> joinedTable <*> maybe aliasClause--relationExpr =-  choice-    [ SimpleRelationExpr <$> qualifiedName <*> bool,-      OnlyRelationExpr <$> qualifiedName <*> bool-    ]--relationExprOptAlias = RelationExprOptAlias <$> relationExpr <*> maybe ((,) <$> bool <*> colId)--tablesampleClause = TablesampleClause <$> funcName <*> exprList <*> maybe repeatableClause--repeatableClause = aExpr--funcTable =-  choice-    [ FuncExprFuncTable <$> funcExprWindowless <*> optOrdinality,-      RowsFromFuncTable <$> rowsfromList <*> optOrdinality-    ]--rowsfromItem = RowsfromItem <$> funcExprWindowless <*> maybe colDefList--rowsfromList = nonEmpty (Range.exponential 1 8) rowsfromItem--colDefList = tableFuncElementList--optOrdinality = bool--tableFuncElementList = nonEmpty (Range.exponential 1 7) tableFuncElement--tableFuncElement = TableFuncElement <$> colId <*> typename <*> maybe collateClause--collateClause = anyName--aliasClause = AliasClause <$> bool <*> name <*> maybe (nonEmpty (Range.exponential 1 8) name)--funcAliasClause =-  choice-    [ AliasFuncAliasClause <$> aliasClause,-      AsFuncAliasClause <$> tableFuncElementList,-      AsColIdFuncAliasClause <$> colId <*> tableFuncElementList,-      ColIdFuncAliasClause <$> colId <*> tableFuncElementList-    ]--joinedTable =-  frequency-    [ (5,) $ InParensJoinedTable <$> joinedTable,-      (95,) $ MethJoinedTable <$> joinMeth <*> tableRef <*> choice [relationExprTableRef, selectTableRef, funcTableRef]-    ]--joinMeth =-  choice-    [ pure CrossJoinMeth,-      QualJoinMeth <$> maybe joinType <*> joinQual,-      NaturalJoinMeth <$> maybe joinType-    ]--joinType =-  choice-    [ FullJoinType <$> bool,-      LeftJoinType <$> bool,-      RightJoinType <$> bool,-      pure InnerJoinType-    ]--joinQual =-  choice-    [ UsingJoinQual <$> nonEmpty (Range.exponential 1 8) name,-      OnJoinQual <$> aExpr-    ]---- * Group Clause--groupClause = nonEmpty (Range.exponential 1 8) groupByItem--groupByItem =-  choice-    [ ExprGroupByItem <$> aExpr,-      pure EmptyGroupingSetGroupByItem,-      RollupGroupByItem <$> nonEmpty (Range.exponential 1 8) aExpr,-      CubeGroupByItem <$> nonEmpty (Range.exponential 1 8) aExpr,-      GroupingSetsGroupByItem <$> nonEmpty (Range.exponential 1 3) groupByItem-    ]---- * Having Clause--havingClause = aExpr---- * Where Clause--whereClause = aExpr--whereOrCurrentClause =-  choice-    [ ExprWhereOrCurrentClause <$> aExpr,-      CursorWhereOrCurrentClause <$> cursorName-    ]---- * Window Clause--windowClause = nonEmpty (Range.exponential 1 8) windowDefinition--windowDefinition = WindowDefinition <$> name <*> windowSpecification--windowSpecification = WindowSpecification <$> maybe name <*> maybe (nonEmpty (Range.exponential 1 8) nonSuffixOpAExpr) <*> maybe sortClause <*> maybe frameClause--frameClause = FrameClause <$> frameClauseMode <*> frameExtent <*> maybe windowExclusionClause--frameClauseMode = element [RangeFrameClauseMode, RowsFrameClauseMode, GroupsFrameClauseMode]--frameExtent =-  choice-    [ SingularFrameExtent <$> frameBound,-      BetweenFrameExtent <$> frameBound <*> frameBound-    ]--frameBound =-  choice-    [ pure UnboundedPrecedingFrameBound,-      pure UnboundedFollowingFrameBound,-      pure CurrentRowFrameBound,-      PrecedingFrameBound <$> prefixAExpr,-      FollowingFrameBound <$> prefixAExpr-    ]--windowExclusionClause = element [CurrentRowWindowExclusionClause, GroupWindowExclusionClause, TiesWindowExclusionClause, NoOthersWindowExclusionClause]---- * Values Clause--valuesClause = nonEmpty (Range.exponential 1 8) (nonEmpty (Range.exponential 1 8) aExpr)---- * Sort Clause--sortClause = nonEmpty (Range.exponential 1 8) sortBy--sortBy =-  choice-    [ UsingSortBy <$> nonSuffixOpAExpr <*> qualAllOp <*> maybe nullsOrder,-      AscDescSortBy <$> nonSuffixOpAExpr <*> maybe ascDesc <*> maybe nullsOrder-    ]---- * All or distinct--allOrDistinct = bool---- * Limit--selectLimit =-  choice-    [ LimitOffsetSelectLimit <$> limitClause <*> offsetClause,-      OffsetLimitSelectLimit <$> offsetClause <*> limitClause,-      LimitSelectLimit <$> limitClause,-      OffsetSelectLimit <$> offsetClause-    ]--limitClause =-  choice-    [ LimitLimitClause <$> selectLimitValue <*> maybe aExpr,-      FetchOnlyLimitClause <$> bool <*> maybe selectFetchFirstValue <*> bool-    ]--selectFetchFirstValue =-  choice-    [ ExprSelectFetchFirstValue <$> cExpr,-      NumSelectFetchFirstValue <$> bool <*> iconstOrFconst-    ]--selectLimitValue =-  choice-    [ ExprSelectLimitValue <$> aExpr,-      pure AllSelectLimitValue-    ]--offsetClause =-  choice-    [ ExprOffsetClause <$> aExpr,-      FetchFirstOffsetClause <$> selectFetchFirstValue <*> bool-    ]---- * For Locking--forLockingClause =-  choice-    [ ItemsForLockingClause <$> nonEmpty (Range.exponential 1 8) forLockingItem,-      pure ReadOnlyForLockingClause-    ]--forLockingItem = ForLockingItem <$> forLockingStrength <*> maybe (nonEmpty (Range.exponential 1 8) qualifiedName) <*> maybe bool--forLockingStrength =-  element-    [ UpdateForLockingStrength,-      NoKeyUpdateForLockingStrength,-      ShareForLockingStrength,-      KeyForLockingStrength-    ]---- * Expressions--exprList = nonEmpty (Range.exponential 1 7) aExpr--aExpr =-  recursive-    choice-    [ CExprAExpr <$> cExpr,-      pure DefaultAExpr-    ]-    [ TypecastAExpr <$> prefixAExpr <*> typename,-      CollateAExpr <$> prefixAExpr <*> anyName,-      AtTimeZoneAExpr <$> prefixAExpr <*> aExpr,-      PlusAExpr <$> aExpr,-      MinusAExpr <$> aExpr,-      SymbolicBinOpAExpr <$> prefixAExpr <*> symbolicExprBinOp <*> aExpr,-      PrefixQualOpAExpr <$> qualOp <*> aExpr,-      SuffixQualOpAExpr <$> prefixAExpr <*> qualOp,-      AndAExpr <$> prefixAExpr <*> aExpr,-      OrAExpr <$> prefixAExpr <*> aExpr,-      NotAExpr <$> aExpr,-      VerbalExprBinOpAExpr <$> prefixAExpr <*> bool <*> verbalExprBinOp <*> prefixAExpr <*> maybe aExpr,-      ReversableOpAExpr <$> prefixAExpr <*> bool <*> aExprReversableOp,-      IsnullAExpr <$> prefixAExpr,-      NotnullAExpr <$> prefixAExpr,-      OverlapsAExpr <$> row <*> row,-      SubqueryAExpr <$> prefixAExpr <*> subqueryOp <*> subType <*> choice [Left <$> selectWithParens, Right <$> nonSelectAExpr],-      UniqueAExpr <$> selectWithParens-    ]--prefixAExpr =-  choice-    [ CExprAExpr <$> cExpr,-      pure DefaultAExpr,-      UniqueAExpr <$> selectWithParens-    ]--nonSuffixOpAExpr =-  recursive-    choice-    [ CExprAExpr <$> cExpr,-      pure DefaultAExpr-    ]-    [ TypecastAExpr <$> prefixAExpr <*> typename,-      CollateAExpr <$> prefixAExpr <*> anyName,-      AtTimeZoneAExpr <$> prefixAExpr <*> nonSuffixOpAExpr,-      PlusAExpr <$> nonSuffixOpAExpr,-      MinusAExpr <$> nonSuffixOpAExpr,-      SymbolicBinOpAExpr <$> prefixAExpr <*> symbolicExprBinOp <*> nonSuffixOpAExpr,-      PrefixQualOpAExpr <$> qualOp <*> nonSuffixOpAExpr,-      AndAExpr <$> prefixAExpr <*> nonSuffixOpAExpr,-      OrAExpr <$> prefixAExpr <*> nonSuffixOpAExpr,-      NotAExpr <$> nonSuffixOpAExpr,-      VerbalExprBinOpAExpr <$> prefixAExpr <*> bool <*> verbalExprBinOp <*> prefixAExpr <*> maybe nonSuffixOpAExpr,-      IsnullAExpr <$> prefixAExpr,-      NotnullAExpr <$> prefixAExpr,-      UniqueAExpr <$> selectWithParens-    ]--nonSelectAExpr =-  choice-    [ TypecastAExpr <$> prefixAExpr <*> typename,-      CollateAExpr <$> prefixAExpr <*> anyName,-      AtTimeZoneAExpr <$> prefixAExpr <*> aExpr,-      PlusAExpr <$> aExpr,-      MinusAExpr <$> aExpr,-      SymbolicBinOpAExpr <$> prefixAExpr <*> symbolicExprBinOp <*> aExpr,-      PrefixQualOpAExpr <$> qualOp <*> aExpr,-      SuffixQualOpAExpr <$> prefixAExpr <*> qualOp,-      AndAExpr <$> prefixAExpr <*> aExpr,-      OrAExpr <$> prefixAExpr <*> aExpr,-      NotAExpr <$> aExpr,-      VerbalExprBinOpAExpr <$> prefixAExpr <*> bool <*> verbalExprBinOp <*> prefixAExpr <*> maybe aExpr,-      ReversableOpAExpr <$> prefixAExpr <*> bool <*> aExprReversableOp,-      IsnullAExpr <$> prefixAExpr,-      NotnullAExpr <$> prefixAExpr,-      OverlapsAExpr <$> row <*> row,-      SubqueryAExpr <$> prefixAExpr <*> subqueryOp <*> subType <*> choice [Left <$> selectWithParens, Right <$> nonSelectAExpr],-      UniqueAExpr <$> selectWithParens-    ]--bExpr =-  recursive-    choice-    [ CExprBExpr <$> cExpr-    ]-    [ TypecastBExpr <$> prefixBExpr <*> typename,-      PlusBExpr <$> bExpr,-      MinusBExpr <$> bExpr,-      SymbolicBinOpBExpr <$> prefixBExpr <*> symbolicExprBinOp <*> bExpr,-      QualOpBExpr <$> qualOp <*> bExpr,-      IsOpBExpr <$> prefixBExpr <*> bool <*> bExprIsOp-    ]--prefixBExpr =-  choice-    [ CExprBExpr <$> cExpr-    ]--cExpr =-  recursive-    choice-    [ ColumnrefCExpr <$> columnref-    ]-    [ AexprConstCExpr <$> aexprConst,-      ParamCExpr <$> integral (Range.linear 1 19) <*> maybe indirection,-      InParensCExpr <$> nonSelectAExpr <*> maybe indirection,-      CaseCExpr <$> caseExpr,-      FuncCExpr <$> funcExpr,-      SelectWithParensCExpr <$> selectWithParens <*> maybe indirection,-      ExistsCExpr <$> selectWithParens,-      ArrayCExpr <$> choice [Left <$> selectWithParens, Right <$> arrayExpr],-      ExplicitRowCExpr <$> explicitRow,-      ImplicitRowCExpr <$> implicitRow,-      GroupingCExpr <$> exprList-    ]--caseExpr = CaseExpr <$> maybe aExpr <*> whenClauseList <*> maybe aExpr--whenClauseList = nonEmpty (Range.exponential 1 7) whenClause--whenClause = WhenClause <$> small aExpr <*> small aExpr--inExpr =-  choice-    [ SelectInExpr <$> NoParensSelectWithParens <$> selectNoParens,-      ExprListInExpr <$> exprList-    ]--arrayExpr =-  small-    $ choice-      [ ExprListArrayExpr <$> exprList,-        ArrayExprListArrayExpr <$> arrayExprList,-        pure EmptyArrayExpr-      ]--arrayExprList = nonEmpty (Range.exponential 1 4) arrayExpr--row =-  choice-    [ ExplicitRowRow <$> explicitRow,-      ImplicitRowRow <$> implicitRow-    ]--explicitRow = maybe exprList--implicitRow = ImplicitRow <$> exprList <*> aExpr---- ** FuncExpr--funcExpr =-  choice-    [ ApplicationFuncExpr <$> funcApplication <*> maybe withinGroupClause <*> maybe filterClause <*> maybe overClause,-      SubexprFuncExpr <$> funcExprCommonSubexpr-    ]--funcExprWindowless =-  choice-    [ ApplicationFuncExprWindowless <$> funcApplication,-      CommonSubexprFuncExprWindowless <$> funcExprCommonSubexpr-    ]--funcApplication = FuncApplication <$> funcName <*> maybe funcApplicationParams--funcApplicationParams =-  choice-    [ NormalFuncApplicationParams <$> maybe allOrDistinct <*> nonEmpty (Range.exponential 1 8) funcArgExpr <*> maybe sortClause,-      VariadicFuncApplicationParams <$> maybe (nonEmpty (Range.exponential 1 8) funcArgExpr) <*> funcArgExpr <*> maybe sortClause,-      pure StarFuncApplicationParams-    ]--funcArgExpr =-  choice-    [ ExprFuncArgExpr <$> small aExpr,-      ColonEqualsFuncArgExpr <$> name <*> small aExpr,-      EqualsGreaterFuncArgExpr <$> name <*> small aExpr-    ]--withinGroupClause = sortClause--filterClause = aExpr--overClause = choice [WindowOverClause <$> windowSpecification, ColIdOverClause <$> colId]--funcExprCommonSubexpr =-  choice-    [ CollationForFuncExprCommonSubexpr <$> aExpr,-      pure CurrentDateFuncExprCommonSubexpr,-      CurrentTimeFuncExprCommonSubexpr <$> maybe iconst,-      CurrentTimestampFuncExprCommonSubexpr <$> maybe iconst,-      LocalTimeFuncExprCommonSubexpr <$> maybe iconst,-      LocalTimestampFuncExprCommonSubexpr <$> maybe iconst,-      pure CurrentRoleFuncExprCommonSubexpr,-      pure CurrentUserFuncExprCommonSubexpr,-      pure SessionUserFuncExprCommonSubexpr,-      pure UserFuncExprCommonSubexpr,-      pure CurrentCatalogFuncExprCommonSubexpr,-      pure CurrentSchemaFuncExprCommonSubexpr,-      CastFuncExprCommonSubexpr <$> aExpr <*> typename,-      ExtractFuncExprCommonSubexpr <$> maybe extractList,-      OverlayFuncExprCommonSubexpr <$> overlayList,-      PositionFuncExprCommonSubexpr <$> maybe positionList,-      SubstringFuncExprCommonSubexpr <$> maybe substrList,-      TreatFuncExprCommonSubexpr <$> aExpr <*> typename,-      TrimFuncExprCommonSubexpr <$> maybe trimModifier <*> trimList,-      NullIfFuncExprCommonSubexpr <$> aExpr <*> aExpr,-      CoalesceFuncExprCommonSubexpr <$> exprList,-      GreatestFuncExprCommonSubexpr <$> exprList,-      LeastFuncExprCommonSubexpr <$> exprList-    ]--extractList = ExtractList <$> extractArg <*> aExpr--extractArg =-  choice-    [ IdentExtractArg <$> ident,-      pure YearExtractArg,-      pure MonthExtractArg,-      pure DayExtractArg,-      pure HourExtractArg,-      pure MinuteExtractArg,-      pure SecondExtractArg,-      SconstExtractArg <$> sconst-    ]--overlayList = OverlayList <$> aExpr <*> overlayPlacing <*> substrFrom <*> maybe substrFor--overlayPlacing = aExpr--positionList = PositionList <$> bExpr <*> bExpr--substrList =-  choice-    [ ExprSubstrList <$> aExpr <*> substrListFromFor,-      ExprListSubstrList <$> exprList-    ]--substrListFromFor =-  choice-    [ FromForSubstrListFromFor <$> substrFrom <*> substrFor,-      ForFromSubstrListFromFor <$> substrFor <*> substrFrom,-      FromSubstrListFromFor <$> substrFrom,-      ForSubstrListFromFor <$> substrFor-    ]--substrFrom = aExpr--substrFor = aExpr--trimModifier = enumBounded--trimList =-  choice-    [ ExprFromExprListTrimList <$> aExpr <*> exprList,-      FromExprListTrimList <$> exprList,-      ExprListTrimList <$> exprList-    ]---- * Operators--qualOp = choice [OpQualOp <$> op, OperatorQualOp <$> anyOperator]--qualAllOp =-  choice-    [ AllQualAllOp <$> allOp,-      AnyQualAllOp <$> anyOperator-    ]--op = do-  a <- text (Range.exponential 1 7) (listElement "+-*/<>=~!@#%^&|`?")-  case Validation.op a of-    Nothing -> return a-    _ -> discard--anyOperator =-  recursive-    choice-    [ AllOpAnyOperator <$> allOp-    ]-    [ QualifiedAnyOperator <$> colId <*> anyOperator-    ]--allOp = choice [OpAllOp <$> op, MathAllOp <$> mathOp]--mathOp = enumBounded--symbolicExprBinOp =-  choice-    [ MathSymbolicExprBinOp <$> mathOp,-      QualSymbolicExprBinOp <$> qualOp-    ]--binOp = element (toList KeywordSet.symbolicBinOp <> ["AND", "OR", "IS DISTINCT FROM", "IS NOT DISTINCT FROM"])--verbalExprBinOp = enumBounded--aExprReversableOp =-  choice-    [ pure NullAExprReversableOp,-      pure TrueAExprReversableOp,-      pure FalseAExprReversableOp,-      pure UnknownAExprReversableOp,-      DistinctFromAExprReversableOp <$> aExpr,-      OfAExprReversableOp <$> typeList,-      BetweenAExprReversableOp <$> bool <*> bExpr <*> aExpr,-      BetweenSymmetricAExprReversableOp <$> bExpr <*> aExpr,-      InAExprReversableOp <$> inExpr,-      pure DocumentAExprReversableOp-    ]--bExprIsOp =-  choice-    [ DistinctFromBExprIsOp <$> bExpr,-      OfBExprIsOp <$> typeList,-      pure DocumentBExprIsOp-    ]--subqueryOp =-  choice-    [ AllSubqueryOp <$> allOp,-      AnySubqueryOp <$> anyOperator,-      LikeSubqueryOp <$> bool,-      IlikeSubqueryOp <$> bool-    ]---- * Constants--aexprConst =-  choice-    [ IAexprConst <$> iconst,-      FAexprConst <$> fconst,-      SAexprConst <$> sconst,-      BAexprConst <$> text (Range.exponential 1 100) (listElement "01"),-      XAexprConst <$> text (Range.exponential 1 100) (listElement "0123456789abcdefABCDEF"),-      FuncAexprConst <$> funcName <*> maybe funcConstArgs <*> sconst,-      ConstTypenameAexprConst <$> constTypename <*> sconst,-      StringIntervalAexprConst <$> sconst <*> maybe interval,-      IntIntervalAexprConst <$> integral (Range.exponential 0 2309482309483029) <*> sconst,-      BoolAexprConst <$> bool,-      pure NullAexprConst-    ]--funcConstArgs = FuncConstArgs <$> nonEmpty (Range.exponential 1 7) funcArgExpr <*> maybe sortClause--constTypename =-  choice-    [ NumericConstTypename <$> numeric,-      ConstBitConstTypename <$> constBit,-      ConstCharacterConstTypename <$> constCharacter,-      ConstDatetimeConstTypename <$> constDatetime-    ]--numeric =-  choice-    [ pure IntNumeric,-      pure IntegerNumeric,-      pure SmallintNumeric,-      pure BigintNumeric,-      pure RealNumeric,-      FloatNumeric <$> maybe iconst,-      pure DoublePrecisionNumeric,-      DecimalNumeric <$> maybe (nonEmpty (Range.exponential 1 7) (small aExpr)),-      DecNumeric <$> maybe (nonEmpty (Range.exponential 1 7) (small aExpr)),-      NumericNumeric <$> maybe (nonEmpty (Range.exponential 1 7) (small aExpr)),-      pure BooleanNumeric-    ]--bit = Bit <$> bool <*> maybe (nonEmpty (Range.exponential 1 7) (small aExpr))--constBit = bit--constCharacter = ConstCharacter <$> character <*> maybe iconst--character =-  choice-    [ CharacterCharacter <$> bool,-      CharCharacter <$> bool,-      pure VarcharCharacter,-      NationalCharacterCharacter <$> bool,-      NationalCharCharacter <$> bool,-      NcharCharacter <$> bool-    ]--constDatetime =-  choice-    [ TimestampConstDatetime <$> maybe iconst <*> maybe bool,-      TimeConstDatetime <$> maybe iconst <*> maybe bool-    ]--interval =-  choice-    [ pure YearInterval,-      pure MonthInterval,-      pure DayInterval,-      pure HourInterval,-      pure MinuteInterval,-      SecondInterval <$> intervalSecond,-      pure YearToMonthInterval,-      pure DayToHourInterval,-      pure DayToMinuteInterval,-      DayToSecondInterval <$> intervalSecond,-      pure HourToMinuteInterval,-      HourToSecondInterval <$> intervalSecond,-      MinuteToSecondInterval <$> intervalSecond-    ]--intervalSecond = maybe iconst--sconst = text (Range.exponential 0 1000) unicode--iconstOrFconst = choice [Left <$> iconst <|> Right <$> fconst]--fconst =-  filter (\a -> fromIntegral (round a :: Int) /= a)-    $ realFrac_ (Range.exponentialFloat 0 309457394857984375983475943)--iconst = integral (Range.exponential 0 maxBound)---- * Types--nullable = pure False--arrayDimensionsAmount = int (Range.exponential 0 4)---- ** Typename--typename = Typename <$> bool <*> simpleTypename <*> pure False <*> maybe ((,) <$> typenameArrayDimensions <*> pure False)--typenameArrayDimensions =-  choice-    [ BoundsTypenameArrayDimensions <$> arrayBounds,-      ExplicitTypenameArrayDimensions <$> maybe iconst-    ]--arrayBounds = nonEmpty (Range.exponential 1 4) (maybe iconst)--simpleTypename =-  choice-    [ GenericTypeSimpleTypename <$> genericType,-      NumericSimpleTypename <$> numeric,-      BitSimpleTypename <$> bit,-      CharacterSimpleTypename <$> character,-      ConstDatetimeSimpleTypename <$> constDatetime,-      ConstIntervalSimpleTypename <$> choice [Left <$> maybe interval, Right <$> iconst]-    ]--genericType = GenericType <$> typeFunctionName <*> maybe attrs <*> maybe typeModifiers--attrs = nonEmpty (Range.exponential 1 10) attrName--typeModifiers = exprList--typeList = nonEmpty (Range.exponential 1 7) typename--subType = enumBounded---- * Names--columnref = Columnref <$> colId <*> maybe indirection--keywordNotInSet = \set -> notInSet set $ do-  a <- element startList-  b <- text (Range.linear 1 29) (element contList)-  return (Text.cons a b)-  where-    startList = "abcdefghijklmnopqrstuvwxyz_" <> List.filter isLower (enumFromTo '\200' '\377')-    contList = startList <> "0123456789$"--ident = identWithSet mempty--name = identWithSet KeywordSet.colId--cursorName = name--identWithSet set =-  frequency-    [ (95,) $ UnquotedIdent <$> (keywordNotInSet . HashSet.difference KeywordSet.keyword) set,-      (5,) $ QuotedIdent <$> text (Range.linear 1 30) quotedChar-    ]--qualifiedName =-  choice-    [ SimpleQualifiedName <$> name,-      IndirectedQualifiedName <$> name <*> indirection-    ]--indirection = nonEmpty (Range.linear 1 3) indirectionEl--indirectionEl =-  choice-    [ AttrNameIndirectionEl <$> name,-      pure AllIndirectionEl,-      ExprIndirectionEl <$> (small aExpr),-      SliceIndirectionEl <$> maybe (small aExpr) <*> maybe (small aExpr)-    ]--quotedChar = filter (not . isControl) unicode--colId = name--colLabel = name--attrName = colLabel--typeFunctionName = identWithSet KeywordSet.typeFunctionName--funcName =-  choice-    [ TypeFuncName <$> typeFunctionName,-      IndirectedFuncName <$> colId <*> indirection-    ]--anyName = AnyName <$> colId <*> maybe attrs---- * Indexes--indexParams = nonEmpty (Range.exponential 1 5) indexElem--indexElem = IndexElem <$> indexElemDef <*> maybe collate <*> maybe class_ <*> maybe ascDesc <*> maybe nullsOrder--indexElemDef =-  choice-    [ IdIndexElemDef <$> colId,-      FuncIndexElemDef <$> funcExprWindowless,-      ExprIndexElemDef <$> aExpr-    ]--collate = anyName--class_ = anyName--ascDesc = enumBounded--nullsOrder = enumBounded---- * Helpers--listElement :: [a] -> Gen a-listElement = element

@@ -0,0 +1,10 @@+module Ast.AExprReversableOpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.AExprReversableOp+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @AExprReversableOp+  itSatisfiesArbitrary @AExprReversableOp

@@ -0,0 +1,75 @@+module Ast.AExprSpec (spec) where++import qualified Data.Text as Text+import Helpers.Specs+import PostgresqlSyntax.Ast.AExpr+import PostgresqlSyntax.Ast.CExpr+import PostgresqlSyntax.Ast.Columnref+import PostgresqlSyntax.Ast.Ident+import PostgresqlSyntax.Ast.VerbalExprBinOp+import PostgresqlSyntax.IsAst+import Test.Hspec+import Prelude++spec :: Spec+spec = do+  itSatisfiesIsAst @AExpr+  itSatisfiesArbitrary @AExpr+  describe "Postgres grammar conformance" $ do+    -- gram.y:15985,15987 have only @a_expr qual_Op a_expr@ and+    -- @qual_Op a_expr@ — the postfix @a_expr qual_Op@ form was removed+    -- from Postgres in v14.+    describe "rejects postfix operators" $ do+      itRejects @AExpr "1 +#"+      itRejects @AExpr "1 OPERATOR(pg_catalog.+#)"+      itRejects @AExpr "a +#"+  describe "Nesting depth" $ do+    itParsesWithin @AExpr 5 (Text.replicate 50 "(" <> "a + b" <> Text.replicate 50 ")")+    let terms off = Text.intercalate " + " ["coalesce(c" <> Text.pack (show (off + i)) <> ", 0)" | i <- [1 .. 24 :: Int]]+        coalesceSumInput = Text.replicate 6 "(" <> "(" <> terms 0 <> ") - (" <> terms 24 <> ")" <> Text.replicate 6 ")"+    itParsesWithin @AExpr 5 coalesceSumInput+    it "OVERLAPS still parses" $ do+      let render :: AExpr -> Text+          render = toText mempty+      fmap render (parse @AExpr mempty "(1, 2) overlaps (3, 4)") `shouldBe` Right "(1, 2) OVERLAPS (3, 4)"+      fmap render (parse @AExpr mempty "row(1, 2) overlaps row(3, 4)") `shouldBe` Right "ROW (1, 2) OVERLAPS ROW (3, 4)"+  describe "LIKE/ILIKE/SIMILAR TO ESCAPE rhs" $ do+    -- Regression for a bug introduced in 92a4d96: the ESCAPE-clause guard on+    -- the LIKE/ILIKE/SIMILAR TO pattern operand (`d`) was applied whenever an+    -- ESCAPE clause was present at all, instead of only when `d` is itself an+    -- unbounded shape. That spuriously parenthesized bounded operands (a+    -- plain column reference here), producing an extra 'InParensCExpr' layer+    -- on reparse that the original AST never had.+    let render :: AExpr -> Text+        render = toText mempty+        roundtrip sql = fmap render (parse @AExpr mempty sql)+    it "does not add parens around a bounded column-reference rhs" $ do+      roundtrip "a LIKE b ESCAPE 'x'" `shouldBe` Right "a LIKE b ESCAPE 'x'"+    it "does not add parens around a bounded ILIKE rhs" $ do+      roundtrip "a ILIKE b ESCAPE 'x'" `shouldBe` Right "a ILIKE b ESCAPE 'x'"+    it "does not add parens around a bounded SIMILAR TO rhs" $ do+      roundtrip "a SIMILAR TO b ESCAPE 'x'" `shouldBe` Right "a SIMILAR TO b ESCAPE 'x'"+    it "still parenthesizes an unbounded (nested, escape-less LIKE) rhs" $ do+      -- Constructed directly rather than by parsing a string: parsing+      -- "a LIKE b LIKE c ESCAPE 'x'" greedily binds the ESCAPE to the+      -- innermost LIKE (its own @d@ operand is unrestricted @a_expr@), so it+      -- can't reach the shape below by parsing alone. The shape is real+      -- though: an unbounded, escape-less nested 'VerbalExprBinOpAExpr' as+      -- the rhs of an outer production that itself has an ESCAPE clause. Left+      -- unparenthesized, rendering it bare would let a reparse of the outer+      -- ESCAPE bind to the inner LIKE instead, changing the AST.+      -- Reparsing always wraps a parenthesized operand in an explicit+      -- 'InParensCExpr' (parens are themselves a production), so the+      -- fixpoint of render/parse is the parenthesized form, not the bare+      -- @outer@ below — that's expected and matches how+      -- 'PostgresqlSyntax.Ast.AExpr.Qc.Arbitrary'\'s generator pre-wraps+      -- this same shape. What matters here is that the parens are present at+      -- all, and that the fixpoint is stable.+      let colref name = CExprAExpr (ColumnrefCExpr (Columnref (UnquotedIdent name) Nothing))+          innerD = VerbalExprBinOpAExpr (colref "b") False LikeVerbalExprBinOp (colref "c") Nothing+          outer = VerbalExprBinOpAExpr (colref "a") False LikeVerbalExprBinOp innerD (Just (colref "e"))+          wrappedOuter = VerbalExprBinOpAExpr (colref "a") False LikeVerbalExprBinOp (CExprAExpr (InParensCExpr innerD Nothing)) (Just (colref "e"))+          sql = render outer+      sql `shouldBe` "a LIKE (b LIKE c) ESCAPE e"+      parse @AExpr mempty sql `shouldBe` Right wrappedOuter+      fmap render (parse @AExpr mempty sql) `shouldBe` Right sql

@@ -0,0 +1,10 @@+module Ast.AexprConstSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.AexprConst+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @AexprConst+  itSatisfiesArbitrary @AexprConst

@@ -0,0 +1,10 @@+module Ast.AliasClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.AliasClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @AliasClause+  itSatisfiesArbitrary @AliasClause

@@ -0,0 +1,10 @@+module Ast.AllOpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.AllOp+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @AllOp+  itSatisfiesArbitrary @AllOp

@@ -0,0 +1,10 @@+module Ast.AnyNameSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.AnyName+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @AnyName+  itSatisfiesArbitrary @AnyName

@@ -0,0 +1,10 @@+module Ast.AnyOperatorSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.AnyOperator+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @AnyOperator+  itSatisfiesArbitrary @AnyOperator

@@ -0,0 +1,10 @@+module Ast.ArrayBoundsSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ArrayBounds+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ArrayBounds+  itSatisfiesArbitrary @ArrayBounds

@@ -0,0 +1,10 @@+module Ast.ArrayExprListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ArrayExprList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ArrayExprList+  itSatisfiesArbitrary @ArrayExprList

@@ -0,0 +1,10 @@+module Ast.ArrayExprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ArrayExpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ArrayExpr+  itSatisfiesArbitrary @ArrayExpr

@@ -0,0 +1,10 @@+module Ast.AscDescSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.AscDesc+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @AscDesc+  itSatisfiesArbitrary @AscDesc

@@ -0,0 +1,10 @@+module Ast.AttrsSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Attrs+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Attrs+  itSatisfiesArbitrary @Attrs

@@ -0,0 +1,10 @@+module Ast.BExprIsOpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.BExprIsOp+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @BExprIsOp+  itSatisfiesArbitrary @BExprIsOp

@@ -0,0 +1,10 @@+module Ast.BExprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.BExpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @BExpr+  itSatisfiesArbitrary @BExpr

@@ -0,0 +1,10 @@+module Ast.BconstSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Bconst+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Bconst+  itSatisfiesArbitrary @Bconst

@@ -0,0 +1,10 @@+module Ast.BitSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Bit+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Bit+  itSatisfiesArbitrary @Bit

@@ -0,0 +1,10 @@+module Ast.CExprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.CExpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @CExpr+  itSatisfiesArbitrary @CExpr

@@ -0,0 +1,10 @@+module Ast.CallStmtSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.CallStmt+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @CallStmt+  itSatisfiesArbitrary @CallStmt

@@ -0,0 +1,10 @@+module Ast.CaseExprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.CaseExpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @CaseExpr+  itSatisfiesArbitrary @CaseExpr

@@ -0,0 +1,10 @@+module Ast.CharacterSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Character+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Character+  itSatisfiesArbitrary @Character

@@ -0,0 +1,10 @@+module Ast.ColumnrefSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Columnref+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Columnref+  itSatisfiesArbitrary @Columnref

@@ -0,0 +1,10 @@+module Ast.CommonTableExprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.CommonTableExpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @CommonTableExpr+  itSatisfiesArbitrary @CommonTableExpr

@@ -0,0 +1,10 @@+module Ast.ConfExprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ConfExpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ConfExpr+  itSatisfiesArbitrary @ConfExpr

@@ -0,0 +1,10 @@+module Ast.ConstCharacterSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ConstCharacter+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ConstCharacter+  itSatisfiesArbitrary @ConstCharacter

@@ -0,0 +1,10 @@+module Ast.ConstDatetimeSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ConstDatetime+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ConstDatetime+  itSatisfiesArbitrary @ConstDatetime

@@ -0,0 +1,10 @@+module Ast.ConstTypenameSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ConstTypename+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ConstTypename+  itSatisfiesArbitrary @ConstTypename

@@ -0,0 +1,10 @@+module Ast.DeleteStmtSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.DeleteStmt+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @DeleteStmt+  itSatisfiesArbitrary @DeleteStmt

@@ -0,0 +1,10 @@+module Ast.ExplicitRowSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ExplicitRow+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ExplicitRow+  itSatisfiesArbitrary @ExplicitRow

@@ -0,0 +1,10 @@+module Ast.ExprListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ExprList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ExprList+  itSatisfiesArbitrary @ExprList

@@ -0,0 +1,10 @@+module Ast.ExtractArgSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ExtractArg+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ExtractArg+  itSatisfiesArbitrary @ExtractArg

@@ -0,0 +1,10 @@+module Ast.ExtractListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ExtractList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ExtractList+  itSatisfiesArbitrary @ExtractList

@@ -0,0 +1,10 @@+module Ast.FconstSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Fconst+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Fconst+  itSatisfiesArbitrary @Fconst

@@ -0,0 +1,10 @@+module Ast.ForLockingClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ForLockingClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ForLockingClause+  itSatisfiesArbitrary @ForLockingClause

@@ -0,0 +1,10 @@+module Ast.ForLockingItemSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ForLockingItem+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ForLockingItem+  itSatisfiesArbitrary @ForLockingItem

@@ -0,0 +1,10 @@+module Ast.ForLockingStrengthSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ForLockingStrength+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ForLockingStrength+  itSatisfiesArbitrary @ForLockingStrength

@@ -0,0 +1,27 @@+module Ast.FrameBoundSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FrameBound+import PostgresqlSyntax.IsAst+import Test.Hspec+import Prelude++spec :: Spec+spec = do+  itSatisfiesIsAst @FrameBound+  itSatisfiesArbitrary @FrameBound+  describe "Postgres grammar conformance" $ do+    -- gram.y:17567 frame_bound. UNBOUNDED is an unreserved keyword, so+    -- @UNBOUNDED PRECEDING@ is ambiguous with @a_expr PRECEDING@ where+    -- the a_expr is a column named "unbounded"; gram.y:915 resolves it by+    -- giving UNBOUNDED lower precedence than PRECEDING, i.e. the keyword+    -- reading wins and the column reading needs quoting.+    it "frame_bound" $ do+      let render :: FrameBound -> Text+          render = toText mempty+      fmap render (parse @FrameBound mempty "unbounded preceding") `shouldBe` Right "UNBOUNDED PRECEDING"+      fmap render (parse @FrameBound mempty "unbounded following") `shouldBe` Right "UNBOUNDED FOLLOWING"+      fmap render (parse @FrameBound mempty "current row") `shouldBe` Right "CURRENT ROW"+      fmap render (parse @FrameBound mempty "1 preceding") `shouldBe` Right "1 PRECEDING"+      fmap render (parse @FrameBound mempty "a following") `shouldBe` Right "a FOLLOWING"+      fmap render (parse @FrameBound mempty "\"unbounded\" preceding") `shouldBe` Right "\"unbounded\" PRECEDING"

@@ -0,0 +1,10 @@+module Ast.FrameClauseModeSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FrameClauseMode+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FrameClauseMode+  itSatisfiesArbitrary @FrameClauseMode

@@ -0,0 +1,10 @@+module Ast.FrameClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FrameClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FrameClause+  itSatisfiesArbitrary @FrameClause

@@ -0,0 +1,10 @@+module Ast.FrameExtentSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FrameExtent+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FrameExtent+  itSatisfiesArbitrary @FrameExtent

@@ -0,0 +1,10 @@+module Ast.FromClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FromClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FromClause+  itSatisfiesArbitrary @FromClause

@@ -0,0 +1,10 @@+module Ast.FromListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FromList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FromList+  itSatisfiesArbitrary @FromList

@@ -0,0 +1,10 @@+module Ast.FuncAliasClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FuncAliasClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FuncAliasClause+  itSatisfiesArbitrary @FuncAliasClause

@@ -0,0 +1,10 @@+module Ast.FuncApplicationParamsSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FuncApplicationParams+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FuncApplicationParams+  itSatisfiesArbitrary @FuncApplicationParams

@@ -0,0 +1,10 @@+module Ast.FuncApplicationSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FuncApplication+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FuncApplication+  itSatisfiesArbitrary @FuncApplication

@@ -0,0 +1,10 @@+module Ast.FuncArgExprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FuncArgExpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FuncArgExpr+  itSatisfiesArbitrary @FuncArgExpr

@@ -0,0 +1,10 @@+module Ast.FuncConstArgsSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FuncConstArgs+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FuncConstArgs+  itSatisfiesArbitrary @FuncConstArgs

@@ -0,0 +1,10 @@+module Ast.FuncExprCommonSubexprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FuncExprCommonSubexpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FuncExprCommonSubexpr+  itSatisfiesArbitrary @FuncExprCommonSubexpr

@@ -0,0 +1,10 @@+module Ast.FuncExprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FuncExpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FuncExpr+  itSatisfiesArbitrary @FuncExpr

@@ -0,0 +1,10 @@+module Ast.FuncExprWindowlessSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FuncExprWindowless+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FuncExprWindowless+  itSatisfiesArbitrary @FuncExprWindowless

@@ -0,0 +1,10 @@+module Ast.FuncNameSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FuncName+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FuncName+  itSatisfiesArbitrary @FuncName

@@ -0,0 +1,10 @@+module Ast.FuncTableSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.FuncTable+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @FuncTable+  itSatisfiesArbitrary @FuncTable

@@ -0,0 +1,10 @@+module Ast.GenericTypeSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.GenericType+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @GenericType+  itSatisfiesArbitrary @GenericType

@@ -0,0 +1,10 @@+module Ast.GroupByItemSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.GroupByItem+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @GroupByItem+  itSatisfiesArbitrary @GroupByItem

@@ -0,0 +1,10 @@+module Ast.GroupClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.GroupClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @GroupClause+  itSatisfiesArbitrary @GroupClause

@@ -0,0 +1,10 @@+module Ast.HavingClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.HavingClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @HavingClause+  itSatisfiesArbitrary @HavingClause

@@ -0,0 +1,10 @@+module Ast.IconstSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Iconst+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Iconst+  itSatisfiesArbitrary @Iconst

@@ -0,0 +1,10 @@+module Ast.IdentSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Ident+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Ident+  itSatisfiesArbitrary @Ident

@@ -0,0 +1,10 @@+module Ast.ImplicitRowSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ImplicitRow+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ImplicitRow+  itSatisfiesArbitrary @ImplicitRow

@@ -0,0 +1,10 @@+module Ast.InExprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.InExpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @InExpr+  itSatisfiesArbitrary @InExpr

@@ -0,0 +1,10 @@+module Ast.IndexElemDefSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.IndexElemDef+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @IndexElemDef+  itSatisfiesArbitrary @IndexElemDef

@@ -0,0 +1,24 @@+module Ast.IndexElemSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.IndexElem+import PostgresqlSyntax.IsAst+import Test.Hspec+import Prelude++spec :: Spec+spec = do+  itSatisfiesIsAst @IndexElem+  itSatisfiesArbitrary @IndexElem+  describe "Postgres grammar conformance" $ do+    -- gram.y:8558 index_elem: ColId index_elem_options, and gram.y:8596+    -- opt_nulls_order. index_elem_options' operator-class name+    -- (opt_qualified_name, gram.y:8525) is a bare ColId, so it is+    -- directly ambiguous with the unreserved NULLS that follows it.+    it "index_elem" $ do+      let render :: IndexElem -> Text+          render = toText mempty+      fmap render (parse @IndexElem mempty "a") `shouldBe` Right "a"+      fmap render (parse @IndexElem mempty "a nulls first") `shouldBe` Right "a NULLS FIRST"+      fmap render (parse @IndexElem mempty "a text_ops nulls first") `shouldBe` Right "a text_ops NULLS FIRST"+      fmap render (parse @IndexElem mempty "a collate \"C\" text_ops desc") `shouldBe` Right "a COLLATE \"C\" text_ops DESC"

@@ -0,0 +1,10 @@+module Ast.IndexParamsSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.IndexParams+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @IndexParams+  itSatisfiesArbitrary @IndexParams

@@ -0,0 +1,10 @@+module Ast.IndirectionElSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.IndirectionEl+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @IndirectionEl+  itSatisfiesArbitrary @IndirectionEl

@@ -0,0 +1,10 @@+module Ast.IndirectionSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Indirection+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Indirection+  itSatisfiesArbitrary @Indirection

@@ -0,0 +1,10 @@+module Ast.InsertColumnItemSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.InsertColumnItem+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @InsertColumnItem+  itSatisfiesArbitrary @InsertColumnItem

@@ -0,0 +1,10 @@+module Ast.InsertColumnListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.InsertColumnList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @InsertColumnList+  itSatisfiesArbitrary @InsertColumnList

@@ -0,0 +1,10 @@+module Ast.InsertRestSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.InsertRest+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @InsertRest+  itSatisfiesArbitrary @InsertRest

@@ -0,0 +1,10 @@+module Ast.InsertStmtSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.InsertStmt+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @InsertStmt+  itSatisfiesArbitrary @InsertStmt

@@ -0,0 +1,10 @@+module Ast.InsertTargetSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.InsertTarget+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @InsertTarget+  itSatisfiesArbitrary @InsertTarget

@@ -0,0 +1,10 @@+module Ast.IntervalSecondSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.IntervalSecond+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @IntervalSecond+  itSatisfiesArbitrary @IntervalSecond

@@ -0,0 +1,10 @@+module Ast.IntervalSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Interval+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Interval+  itSatisfiesArbitrary @Interval

@@ -0,0 +1,10 @@+module Ast.IntoClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.IntoClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @IntoClause+  itSatisfiesArbitrary @IntoClause

@@ -0,0 +1,10 @@+module Ast.JoinMethSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.JoinMeth+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @JoinMeth+  itSatisfiesArbitrary @JoinMeth

@@ -0,0 +1,10 @@+module Ast.JoinQualSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.JoinQual+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @JoinQual+  itSatisfiesArbitrary @JoinQual

@@ -0,0 +1,10 @@+module Ast.JoinTypeSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.JoinType+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @JoinType+  itSatisfiesArbitrary @JoinType

@@ -0,0 +1,10 @@+module Ast.JoinedTableSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.JoinedTable+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @JoinedTable+  itSatisfiesArbitrary @JoinedTable

@@ -0,0 +1,10 @@+module Ast.LimitClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.LimitClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @LimitClause+  itSatisfiesArbitrary @LimitClause

@@ -0,0 +1,10 @@+module Ast.MathOpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.MathOp+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @MathOp+  itSatisfiesArbitrary @MathOp

@@ -0,0 +1,10 @@+module Ast.NameListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.NameList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @NameList+  itSatisfiesArbitrary @NameList

@@ -0,0 +1,10 @@+module Ast.NullsOrderSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.NullsOrder+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @NullsOrder+  itSatisfiesArbitrary @NullsOrder

@@ -0,0 +1,10 @@+module Ast.NumericSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Numeric+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Numeric+  itSatisfiesArbitrary @Numeric

@@ -0,0 +1,10 @@+module Ast.OffsetClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.OffsetClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @OffsetClause+  itSatisfiesArbitrary @OffsetClause

@@ -0,0 +1,10 @@+module Ast.OnConflictDoSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.OnConflictDo+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @OnConflictDo+  itSatisfiesArbitrary @OnConflictDo

@@ -0,0 +1,10 @@+module Ast.OnConflictSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.OnConflict+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @OnConflict+  itSatisfiesArbitrary @OnConflict

@@ -0,0 +1,11 @@+module Ast.OpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Op+import Test.Hspec+import Prelude hiding (Op)++spec :: Spec+spec = do+  itSatisfiesIsAst @Op+  itSatisfiesArbitrary @Op

@@ -0,0 +1,10 @@+module Ast.OptOrdinalitySpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.OptOrdinality+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @OptOrdinality+  itSatisfiesArbitrary @OptOrdinality

@@ -0,0 +1,10 @@+module Ast.OptTempTableNameSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.OptTempTableName+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @OptTempTableName+  itSatisfiesArbitrary @OptTempTableName

@@ -0,0 +1,8 @@+module Ast.OptVaryingSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.OptVarying+import Test.Hspec++spec :: Spec+spec = itSatisfiesArbitrary @OptVarying

@@ -0,0 +1,10 @@+module Ast.OverClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.OverClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @OverClause+  itSatisfiesArbitrary @OverClause

@@ -0,0 +1,10 @@+module Ast.OverlayListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.OverlayList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @OverlayList+  itSatisfiesArbitrary @OverlayList

@@ -0,0 +1,10 @@+module Ast.OverrideKindSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.OverrideKind+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @OverrideKind+  itSatisfiesArbitrary @OverrideKind

@@ -0,0 +1,10 @@+module Ast.PositionListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.PositionList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @PositionList+  itSatisfiesArbitrary @PositionList

@@ -0,0 +1,60 @@+module Ast.PreparableStmtSpec (spec) where++import qualified Data.Text as Text+import Helpers.Specs+import PostgresqlSyntax.Ast.PreparableStmt+import Test.Hspec+import Prelude++spec :: Spec+spec = do+  itSatisfiesIsAst @PreparableStmt+  itSatisfiesArbitrary @PreparableStmt+  describe "Parsers" $ do+    itParses @PreparableStmt+      "select i :: int8 from auth.user as u\n\+      \inner join edgenode.usere_provider as p\n\+      \on u.id = p.user_id\n\+      \inner join edgenode.provider_branch as b\n\+      \on b.provider_fk = p.provider_id"+    itParses @PreparableStmt "select * from items for update limit 1"+    itParses @PreparableStmt "select * from items limit 1 for update"+    itParses @PreparableStmt "select * from items for share limit 10"+    itParses @PreparableStmt "select * from items for no key update limit 1"+    itParses @PreparableStmt "select * from items for key share limit 1"+    itParses @PreparableStmt "select * from items for update of items nowait limit 1"+    itParses @PreparableStmt "select * from items for update skip locked limit 1"+    itParses @PreparableStmt "select * from items order by id for update limit 1"+    itParses @PreparableStmt "select * from items for update offset 5 limit 10"+  describe "Nesting depth" $ do+    itParsesWithin @PreparableStmt 5 ("select " <> Text.replicate 50 "(" <> "a + b" <> Text.replicate 50 ")")+  describe "Error reporting" $ do+    itReportsError @PreparableStmt+      "select i :: int8 fom auth.user as u\n\+      \inner join edgenode.usere_provider as p\n\+      \on u.id = p.user_id\n\+      \inner join edgenode.provider_branch as b\n\+      \on b.provider_fk = p.provider_id"+      "(21,\"offset=21:\\nunexpected 'a'\\nexpecting end of input or white space\\n\")"+    itReportsError @PreparableStmt+      "select i :: int8 from auth.user as u\n\+      \WHERE u.id IS NO NULL && TRUE"+      "(51,\"offset=51:\\nexpecting white space\\n\")"+  describe "SourcePos error reporting" $ do+    itReportsSourcePosError @PreparableStmt+      "select i :: int8 fom auth.user as u\n\+      \inner join edgenode.usere_provider as p\n\+      \on u.id = p.user_id\n\+      \inner join edgenode.provider_branch as b\n\+      \on b.provider_fk = p.provider_id"+      "1:22 unexpected 'a'\nexpecting end of input or white space\n"+    itReportsSourcePosError @PreparableStmt+      "select i :: int8 from auth.user as u\n\+      \WHERE u.id IS NO NULL && TRUE"+      "2:15 expecting white space\n"+    itReportsSourcePosError @PreparableStmt+      "SLECT id FROM qsdqsd"+      "1:1 unexpected 'S'\nexpecting '(' or white space\n"+    itReportsSourcePosError @PreparableStmt+      "SELECT id FROM as"+      "1:18 Reserved keyword \"as\" used as an identifier. If that's what you intend, you have to wrap it in double quotes.\n"

@@ -0,0 +1,10 @@+module Ast.QualAllOpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.QualAllOp+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @QualAllOp+  itSatisfiesArbitrary @QualAllOp

@@ -0,0 +1,10 @@+module Ast.QualOpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.QualOp+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @QualOp+  itSatisfiesArbitrary @QualOp

@@ -0,0 +1,10 @@+module Ast.QualifiedNameSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.QualifiedName+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @QualifiedName+  itSatisfiesArbitrary @QualifiedName

@@ -0,0 +1,10 @@+module Ast.RelationExprOptAliasSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.RelationExprOptAlias+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @RelationExprOptAlias+  itSatisfiesArbitrary @RelationExprOptAlias

@@ -0,0 +1,10 @@+module Ast.RelationExprSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.RelationExpr+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @RelationExpr+  itSatisfiesArbitrary @RelationExpr

@@ -0,0 +1,10 @@+module Ast.ReturningClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ReturningClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ReturningClause+  itSatisfiesArbitrary @ReturningClause

@@ -0,0 +1,10 @@+module Ast.RowSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Row+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Row+  itSatisfiesArbitrary @Row

@@ -0,0 +1,10 @@+module Ast.RowsfromItemSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.RowsfromItem+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @RowsfromItem+  itSatisfiesArbitrary @RowsfromItem

@@ -0,0 +1,10 @@+module Ast.RowsfromListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.RowsfromList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @RowsfromList+  itSatisfiesArbitrary @RowsfromList

@@ -0,0 +1,15 @@+module Ast.SconstSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Sconst+import Test.Hspec+import Prelude++spec :: Spec+spec = do+  itSatisfiesIsAst @Sconst+  itSatisfiesArbitrary @Sconst+  describe "Parsers" $ do+    itParses @Sconst "'it''s good'"+    itParses @Sconst "$$it's good$$"+    itParses @Sconst "$x$it's good$x$"

@@ -0,0 +1,10 @@+module Ast.SelectBinOpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SelectBinOp+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SelectBinOp+  itSatisfiesArbitrary @SelectBinOp

@@ -0,0 +1,10 @@+module Ast.SelectClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SelectClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SelectClause+  itSatisfiesArbitrary @SelectClause

@@ -0,0 +1,10 @@+module Ast.SelectFetchFirstValueSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SelectFetchFirstValue+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SelectFetchFirstValue+  itSatisfiesArbitrary @SelectFetchFirstValue

@@ -0,0 +1,10 @@+module Ast.SelectLimitSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SelectLimit+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SelectLimit+  itSatisfiesArbitrary @SelectLimit

@@ -0,0 +1,10 @@+module Ast.SelectLimitValueSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SelectLimitValue+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SelectLimitValue+  itSatisfiesArbitrary @SelectLimitValue

@@ -0,0 +1,10 @@+module Ast.SelectNoParensSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SelectNoParens+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SelectNoParens+  itSatisfiesArbitrary @SelectNoParens

@@ -0,0 +1,10 @@+module Ast.SelectStmtSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SelectStmt+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SelectStmt+  itSatisfiesArbitrary @SelectStmt

@@ -0,0 +1,18 @@+module Ast.SelectWithParensSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SelectNoParens+import PostgresqlSyntax.Ast.SelectWithParens+import PostgresqlSyntax.IsAst+import Test.Hspec+import Prelude++spec :: Spec+spec = do+  itSatisfiesIsAst @SelectWithParens+  itSatisfiesArbitrary @SelectWithParens+  describe "Nesting depth" $ do+    -- The parenthesised sub-select has two possible representations.+    it "redundant parens around a sub-select are canonicalised"+      $ parse @SelectWithParens mempty "((select 1))"+      `shouldBe` (WithParensSelectWithParens . NoParensSelectWithParens <$> parse @SelectNoParens mempty "select 1")

@@ -0,0 +1,10 @@+module Ast.SetClauseListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SetClauseList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SetClauseList+  itSatisfiesArbitrary @SetClauseList

@@ -0,0 +1,10 @@+module Ast.SetClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SetClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SetClause+  itSatisfiesArbitrary @SetClause

@@ -0,0 +1,10 @@+module Ast.SetTargetListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SetTargetList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SetTargetList+  itSatisfiesArbitrary @SetTargetList

@@ -0,0 +1,10 @@+module Ast.SetTargetSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SetTarget+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SetTarget+  itSatisfiesArbitrary @SetTarget

@@ -0,0 +1,10 @@+module Ast.SimpleSelectSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SimpleSelect+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SimpleSelect+  itSatisfiesArbitrary @SimpleSelect

@@ -0,0 +1,10 @@+module Ast.SimpleTypenameSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SimpleTypename+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SimpleTypename+  itSatisfiesArbitrary @SimpleTypename

@@ -0,0 +1,24 @@+module Ast.SortBySpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SortBy+import PostgresqlSyntax.IsAst+import Test.Hspec+import Prelude++spec :: Spec+spec = do+  itSatisfiesIsAst @SortBy+  itSatisfiesArbitrary @SortBy+  describe "Postgres grammar conformance" $ do+    it "sortby" $ do+      let render :: SortBy -> Text+          render = toText mempty+      fmap render (parse @SortBy mempty "a") `shouldBe` Right "a"+      fmap render (parse @SortBy mempty "a asc") `shouldBe` Right "a ASC"+      fmap render (parse @SortBy mempty "a desc nulls last") `shouldBe` Right "a DESC NULLS LAST"+      fmap render (parse @SortBy mempty "a nulls first") `shouldBe` Right "a NULLS FIRST"+      fmap render (parse @SortBy mempty "a using > nulls last") `shouldBe` Right "a USING > NULLS LAST"+      case parse @SortBy mempty "nulls" of+        Left _ -> pure ()+        Right _ -> expectationFailure "expected a parse failure for bare \"nulls\""

@@ -0,0 +1,10 @@+module Ast.SortClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SortClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SortClause+  itSatisfiesArbitrary @SortClause

@@ -0,0 +1,10 @@+module Ast.SubTypeSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SubType+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SubType+  itSatisfiesArbitrary @SubType

@@ -0,0 +1,10 @@+module Ast.SubqueryOpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SubqueryOp+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SubqueryOp+  itSatisfiesArbitrary @SubqueryOp

@@ -0,0 +1,10 @@+module Ast.SubstrListFromForSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SubstrListFromFor+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SubstrListFromFor+  itSatisfiesArbitrary @SubstrListFromFor

@@ -0,0 +1,10 @@+module Ast.SubstrListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SubstrList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SubstrList+  itSatisfiesArbitrary @SubstrList

@@ -0,0 +1,10 @@+module Ast.SymbolicExprBinOpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.SymbolicExprBinOp+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @SymbolicExprBinOp+  itSatisfiesArbitrary @SymbolicExprBinOp

@@ -0,0 +1,10 @@+module Ast.TableFuncElementListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.TableFuncElementList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @TableFuncElementList+  itSatisfiesArbitrary @TableFuncElementList

@@ -0,0 +1,10 @@+module Ast.TableFuncElementSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.TableFuncElement+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @TableFuncElement+  itSatisfiesArbitrary @TableFuncElement

@@ -0,0 +1,10 @@+module Ast.TableRefSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.TableRef+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @TableRef+  itSatisfiesArbitrary @TableRef

@@ -0,0 +1,10 @@+module Ast.TablesampleClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.TablesampleClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @TablesampleClause+  itSatisfiesArbitrary @TablesampleClause

@@ -0,0 +1,10 @@+module Ast.TargetElSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.TargetEl+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @TargetEl+  itSatisfiesArbitrary @TargetEl

@@ -0,0 +1,10 @@+module Ast.TargetListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.TargetList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @TargetList+  itSatisfiesArbitrary @TargetList

@@ -0,0 +1,10 @@+module Ast.TargetingSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Targeting+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Targeting+  itSatisfiesArbitrary @Targeting

@@ -0,0 +1,10 @@+module Ast.TimezoneSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Timezone+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Timezone+  itSatisfiesArbitrary @Timezone

@@ -0,0 +1,10 @@+module Ast.TrimListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.TrimList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @TrimList+  itSatisfiesArbitrary @TrimList

@@ -0,0 +1,10 @@+module Ast.TrimModifierSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.TrimModifier+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @TrimModifier+  itSatisfiesArbitrary @TrimModifier

@@ -0,0 +1,10 @@+module Ast.TypeListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.TypeList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @TypeList+  itSatisfiesArbitrary @TypeList

@@ -0,0 +1,8 @@+module Ast.TypenameArrayDimensionsSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.TypenameArrayDimensions+import Test.Hspec++spec :: Spec+spec = itSatisfiesArbitrary @TypenameArrayDimensions

@@ -0,0 +1,46 @@+module Ast.TypenameSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Typename+import PostgresqlSyntax.Settings (nullabilityMarkers)+import Test.Hspec+import Prelude++spec :: Spec+spec = do+  itSatisfiesIsAst @Typename+  itSatisfiesArbitrary @Typename+  describe "Parsers" $ do+    itParses @Typename "int4"+    itParses @Typename "int4[][]"+    itParses @Typename "aa array"+    itParses @Typename "DOUBLE PRECISION"+    itParses @Typename "bool"+    itParses @Typename "int2"+    itParses @Typename "int4"+    itParses @Typename "int8"+    itParses @Typename "float4"+    itParses @Typename "float8"+    itParses @Typename "numeric"+    itParses @Typename "char"+    itParses @Typename "text"+    itParses @Typename "bytea"+    itParses @Typename "date"+    itParses @Typename "timestamp"+    itParses @Typename "timestamptz"+    itParses @Typename "time"+    itParses @Typename "timetz"+    itParses @Typename "interval"+    itParses @Typename "uuid"+    itParses @Typename "inet"+    itParses @Typename "json"+    itParses @Typename "jsonb"+  describe "extended" $ do+    itParsesWith @Typename (nullabilityMarkers True) "text?"+    itParsesWith @Typename (nullabilityMarkers True) "text[]?"+    itParsesWith @Typename (nullabilityMarkers True) "text?[]?"+    itParsesWith @Typename (nullabilityMarkers True) "text?[]"+    itRejectsWith @Typename mempty "text?"+    itRejectsWith @Typename mempty "text[]?"+    itRejectsWith @Typename mempty "text?[]?"+    itRejectsWith @Typename mempty "text?[]"

@@ -0,0 +1,10 @@+module Ast.UpdateStmtSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.UpdateStmt+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @UpdateStmt+  itSatisfiesArbitrary @UpdateStmt

@@ -0,0 +1,10 @@+module Ast.UsingClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.UsingClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @UsingClause+  itSatisfiesArbitrary @UsingClause

@@ -0,0 +1,10 @@+module Ast.ValuesClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.ValuesClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @ValuesClause+  itSatisfiesArbitrary @ValuesClause

@@ -0,0 +1,10 @@+module Ast.VerbalExprBinOpSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.VerbalExprBinOp+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @VerbalExprBinOp+  itSatisfiesArbitrary @VerbalExprBinOp

@@ -0,0 +1,10 @@+module Ast.WhenClauseListSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.WhenClauseList+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @WhenClauseList+  itSatisfiesArbitrary @WhenClauseList

@@ -0,0 +1,10 @@+module Ast.WhenClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.WhenClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @WhenClause+  itSatisfiesArbitrary @WhenClause

@@ -0,0 +1,10 @@+module Ast.WhereClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.WhereClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @WhereClause+  itSatisfiesArbitrary @WhereClause

@@ -0,0 +1,10 @@+module Ast.WhereOrCurrentClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.WhereOrCurrentClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @WhereOrCurrentClause+  itSatisfiesArbitrary @WhereOrCurrentClause

@@ -0,0 +1,10 @@+module Ast.WindowClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.WindowClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @WindowClause+  itSatisfiesArbitrary @WindowClause

@@ -0,0 +1,10 @@+module Ast.WindowDefinitionSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.WindowDefinition+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @WindowDefinition+  itSatisfiesArbitrary @WindowDefinition

@@ -0,0 +1,10 @@+module Ast.WindowExclusionClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.WindowExclusionClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @WindowExclusionClause+  itSatisfiesArbitrary @WindowExclusionClause

@@ -0,0 +1,20 @@+module Ast.WindowSpecificationSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.WindowSpecification+import Test.Hspec+import Prelude++spec :: Spec+spec = do+  itSatisfiesIsAst @WindowSpecification+  itSatisfiesArbitrary @WindowSpecification+  describe "Postgres grammar conformance" $ do+    -- gram.y:17428 window_specification: the sort clause and the+    -- partition clause are both followed by opt_frame_clause, whose+    -- leading keywords (RANGE/ROWS/GROUPS, kwlist.h:375,408,201) are+    -- unreserved and therefore also legal ColIds.+    itParses @WindowSpecification "(order by a rows unbounded preceding)"+    itParses @WindowSpecification "(order by a range unbounded preceding)"+    itParses @WindowSpecification "(partition by a groups unbounded preceding)"+    itParses @WindowSpecification "(partition by a order by b rows 1 preceding)"

@@ -0,0 +1,10 @@+module Ast.WithClauseSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.WithClause+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @WithClause+  itSatisfiesArbitrary @WithClause

@@ -0,0 +1,10 @@+module Ast.XconstSpec (spec) where++import Helpers.Specs+import PostgresqlSyntax.Ast.Xconst+import Test.Hspec++spec :: Spec+spec = do+  itSatisfiesIsAst @Xconst+  itSatisfiesArbitrary @Xconst

@@ -0,0 +1,77 @@+{-# LANGUAGE AllowAmbiguousTypes #-}++module Helpers.Expectations+  ( parsesTo,+    rejects,+    reportsError,+    reportsSourcePosError,+    parsesWithin,+    parsesToWith,+    rejectsWith,+  )+where++import qualified Data.List.NonEmpty as NonEmpty+import qualified Data.Text as Text+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Settings (Settings)+import Test.Hspec+import Text.Megaparsec.Pos (sourcePosPretty)+import Prelude++parsesTo :: forall a. (HasCallStack, IsAst a) => Text -> Expectation+parsesTo input =+  case parse @a mempty input of+    Left err -> expectationFailure (Text.unpack (err <> "\ninput: " <> input))+    Right _ -> pure ()++rejects :: forall a. (HasCallStack, IsAst a, Show a) => Text -> Expectation+rejects input =+  case parse @a mempty input of+    Left _ -> pure ()+    Right a ->+      expectationFailure+        ("expected a parse failure\ninput: " <> Text.unpack input <> "\nparsed: " <> show a)++reportsError :: forall a. (HasCallStack, IsAst a) => Text -> String -> Expectation+reportsError input expected =+  case parseWithPosError @a mempty input of+    Left err -> show (NonEmpty.head err) `shouldBe` expected+    Right _ -> expectationFailure "expected a parse error, but it succeeded"++-- | Like 'reportsError' but checks 'parseWithSourcePosError''s+-- 'Text.Megaparsec.SourcePos'-based errors instead.+reportsSourcePosError :: forall a. (HasCallStack, IsAst a) => Text -> String -> Expectation+reportsSourcePosError input expected =+  case parseWithSourcePosError @a mempty input of+    Left err ->+      let (pos, msg) = NonEmpty.head err+       in (Text.unpack (Text.pack (sourcePosPretty pos) <> " " <> msg)) `shouldBe` expected+    Right _ -> expectationFailure "expected a parse error, but it succeeded"++parsesWithin :: forall a. (HasCallStack, IsAst a) => Int -> Text -> Expectation+parsesWithin seconds input = do+  result <-+    timeout (seconds * 1000000)+      $ case parse @a mempty input of+        Left err -> expectationFailure (Text.unpack (err <> "\ninput: " <> input))+        Right _ -> pure ()+  case result of+    Nothing -> expectationFailure ("Did not finish parsing within " <> show seconds <> "s")+    Just () -> pure ()++-- | Like 'parsesTo' but with a non-default 'Settings'.+parsesToWith :: forall a. (HasCallStack, IsAst a) => Settings -> Text -> Expectation+parsesToWith settings input =+  case parse @a settings input of+    Left err -> expectationFailure (Text.unpack (err <> "\ninput: " <> input))+    Right _ -> pure ()++-- | Like 'rejects' but with a non-default 'Settings'.+rejectsWith :: forall a. (HasCallStack, IsAst a, Show a) => Settings -> Text -> Expectation+rejectsWith settings input =+  case parse @a settings input of+    Left _ -> pure ()+    Right a ->+      expectationFailure+        ("expected a parse failure\ninput: " <> Text.unpack input <> "\nparsed: " <> show a)

@@ -0,0 +1,105 @@+{-# LANGUAGE AllowAmbiguousTypes #-}++module Helpers.Specs+  ( itSatisfiesIsAst,+    itSatisfiesArbitrary,+    itParses,+    itRejects,+    itReportsError,+    itReportsSourcePosError,+    itParsesWithin,++    -- * Settings-aware variants+    itParsesWith,+    itRejectsWith,+  )+where++import qualified Data.Text as Text+import qualified Helpers.Expectations as Expectations+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Settings (Settings)+import Test.Hspec+import Test.Hspec.QuickCheck (prop)+import Test.QuickCheck (counterexample, (===))+import qualified Test.QuickCheck as Qc+import Prelude++itSatisfiesIsAst :: forall a. (IsAst a, Eq a, Show a, Qc.Arbitrary a) => Spec+itSatisfiesIsAst =+  describe "IsAst" $ do+    prop "Roundtrips" $ \(a :: a) ->+      let sql = toText mempty a+       in case parse mempty sql of+            Left err ->+              counterexample ("rendered: " <> Text.unpack sql <> "\nparse failed: " <> Text.unpack err) False+            Right a' ->+              counterexample+                ("rendered: " <> Text.unpack sql <> "\nrestored: " <> Text.unpack (toText mempty a'))+                (a' === a)++itSatisfiesArbitrary :: forall a. (IsAst a, Show a, Qc.Arbitrary a) => Spec+itSatisfiesArbitrary =+  describe "Arbitrary" $ do+    prop "Terminates at size 0" terminatesAtZero+    prop "Grows boundedly" growsBounded+  where+    terminatesAtZero =+      Qc.forAll (Qc.resize 0 (Qc.arbitrary @a)) $ \x ->+        let sql = toText mempty x+            len = Text.length sql+         in Qc.counterexample+              ("rendered " <> show len <> " chars at size 0 (max " <> show zeroSizeMaxLen <> ")" <> "\n" <> Text.unpack sql)+              (len <= zeroSizeMaxLen)+      where+        zeroSizeMaxLen = 500 :: Int++    growsBounded =+      Qc.forAll (Qc.resize maxGenSize (Qc.arbitrary @a)) $ \x ->+        let sql = toText mempty x+            len = Text.length sql+         in Qc.counterexample+              ("rendered " <> show len <> " chars at size " <> show maxGenSize <> " (max " <> show maxGenSizeMaxLen <> ")")+              (len <= maxGenSizeMaxLen)+      where+        maxGenSize = 100 :: Int+        maxGenSizeMaxLen = 1000000 :: Int++itParses :: forall a. (HasCallStack, IsAst a) => Text -> Spec+itParses sql =+  describe (Text.unpack sql) $ do+    it "Parses" (Expectations.parsesTo @a sql)++itRejects :: forall a. (HasCallStack, IsAst a, Show a) => Text -> Spec+itRejects sql =+  describe (Text.unpack sql) $ do+    it "Rejects" (Expectations.rejects @a sql)++itReportsError :: forall a. (HasCallStack, IsAst a) => Text -> String -> Spec+itReportsError sql expected =+  describe (Text.unpack sql) $ do+    it ("Reports error: " <> expected) (Expectations.reportsError @a sql expected)++-- | Like 'itReportsError' but checks 'PostgresqlSyntax.IsAst.parseWithSourcePosError''s+-- 'Text.Megaparsec.SourcePos'-based errors instead.+itReportsSourcePosError :: forall a. (HasCallStack, IsAst a) => Text -> String -> Spec+itReportsSourcePosError sql expected =+  describe (Text.unpack sql) $ do+    it ("Reports error: " <> expected) (Expectations.reportsSourcePosError @a sql expected)++itParsesWithin :: forall a. (HasCallStack, IsAst a) => Int -> Text -> Spec+itParsesWithin seconds sql =+  describe (Text.unpack sql) $ do+    it ("Parses within " <> show seconds <> " seconds") (Expectations.parsesWithin @a seconds sql)++-- | Wraps 'Expectations.parsesToWith' as a standalone 'Spec'.+itParsesWith :: forall a. (HasCallStack, IsAst a) => Settings -> Text -> Spec+itParsesWith settings sql =+  describe (Text.unpack sql) $ do+    it "Parses" (Expectations.parsesToWith @a settings sql)++-- | Wraps 'Expectations.rejectsWith' as a standalone 'Spec'.+itRejectsWith :: forall a. (HasCallStack, IsAst a, Show a) => Settings -> Text -> Spec+itRejectsWith settings sql =+  describe (Text.unpack sql) $ do+    it "Rejects" (Expectations.rejectsWith @a settings sql)

@@ -0,0 +1,8 @@+module Main (main) where++import qualified Spec+import Test.Hspec+import Prelude++main :: IO ()+main = hspec $ parallel Spec.spec

@@ -0,0 +1,1 @@+{-# OPTIONS_GHC -F -pgmF hspec-discover -optF --module-name=Spec #-}

@@ -0,0 +1,382 @@+-- |+-- Names for nodes mostly resemble the according definitions in the @gram.y@+-- original Postgres parser file, except for the cases where we can optimize on that.+--+-- For reasoning see the docs of the parsing module of this project.+module PostgresqlSyntax.Ast+  ( -- * Nodes+    AExpr (..),+    AExprReversableOp (..),+    AexprConst (..),+    AliasClause (..),+    AllOp (..),+    AnyName (..),+    AnyOperator (..),+    ArrayBounds (..),+    ArrayExpr (..),+    ArrayExprList (..),+    AscDesc (..),+    Attrs (..),+    BExpr (..),+    BExprIsOp (..),+    Bconst (..),+    Bit (..),+    CExpr (..),+    CallStmt (..),+    CaseExpr (..),+    Character (..),+    Columnref (..),+    CommonTableExpr (..),+    ConfExpr (..),+    ConstCharacter (..),+    ConstDatetime (..),+    ConstTypename (..),+    DeleteStmt (..),+    ExplicitRow (..),+    ExprList (..),+    ExtractArg (..),+    ExtractList (..),+    Fconst (..),+    ForLockingClause (..),+    ForLockingItem (..),+    ForLockingStrength (..),+    FrameBound (..),+    FrameClause (..),+    FrameClauseMode (..),+    FrameExtent (..),+    FromClause (..),+    FromList (..),+    FuncAliasClause (..),+    FuncApplication (..),+    FuncApplicationParams (..),+    FuncArgExpr (..),+    FuncConstArgs (..),+    FuncExpr (..),+    FuncExprCommonSubexpr (..),+    FuncExprWindowless (..),+    FuncName (..),+    FuncTable (..),+    GenericType (..),+    GroupByItem (..),+    GroupClause (..),+    HavingClause (..),+    Iconst (..),+    Ident (..),+    ImplicitRow (..),+    InExpr (..),+    IndexElem (..),+    IndexElemDef (..),+    IndexParams (..),+    Indirection (..),+    IndirectionEl (..),+    InsertColumnItem (..),+    InsertColumnList (..),+    InsertRest (..),+    InsertStmt (..),+    InsertTarget (..),+    Interval (..),+    IntervalSecond (..),+    IntoClause (..),+    JoinMeth (..),+    JoinQual (..),+    JoinType (..),+    JoinedTable (..),+    LimitClause (..),+    MathOp (..),+    NameList (..),+    NullsOrder (..),+    Numeric (..),+    OffsetClause (..),+    OnConflict (..),+    OnConflictDo (..),+    Op (..),+    OptOrdinality (..),+    OptTempTableName (..),+    OptVarying (..),+    OverClause (..),+    OverlayList (..),+    OverrideKind (..),+    PositionList (..),+    PreparableStmt (..),+    QualAllOp (..),+    QualOp (..),+    QualifiedName (..),+    RelationExpr (..),+    RelationExprOptAlias (..),+    ReturningClause (..),+    Row (..),+    RowsfromItem (..),+    RowsfromList (..),+    Sconst (..),+    SelectBinOp (..),+    SelectClause (..),+    SelectFetchFirstValue (..),+    SelectLimit (..),+    SelectLimitValue (..),+    SelectNoParens (..),+    SelectStmt (..),+    SelectWithParens (..),+    SetClause (..),+    SetClauseList (..),+    SetTarget (..),+    SetTargetList (..),+    SimpleSelect (..),+    SimpleTypename (..),+    SortBy (..),+    SortClause (..),+    SubType (..),+    SubqueryOp (..),+    SubstrList (..),+    SubstrListFromFor (..),+    SymbolicExprBinOp (..),+    TableFuncElement (..),+    TableFuncElementList (..),+    TableRef (..),+    TablesampleClause (..),+    TargetEl (..),+    TargetList (..),+    Targeting (..),+    Timezone (..),+    TrimList (..),+    TrimModifier (..),+    TypeList (..),+    Typename (..),+    TypenameArrayDimensions (..),+    UpdateStmt (..),+    UsingClause (..),+    ValuesClause (..),+    VerbalExprBinOp (..),+    WhenClause (..),+    WhenClauseList (..),+    WhereClause (..),+    WhereOrCurrentClause (..),+    WindowClause (..),+    WindowDefinition (..),+    WindowExclusionClause (..),+    WindowSpecification (..),+    WithClause (..),+    Xconst (..),++    -- * Bare aliases+    ExistingWindowName,+    PartitionClause,+    RepeatableClause,+    ColDefList,+    CollateClause,+    WithinGroupClause,+    FilterClause,+    OverlayPlacing,+    SubstrFrom,+    SubstrFor,+    CaseArg,+    CaseDefault,+    ConstBit,+    ColId,+    ColLabel,+    Name,+    CursorName,+    AttrName,+    TypeModifiers,+    Collate,+    Class,+    TypeFunctionName,+  )+where++import PostgresqlSyntax.Ast.AExpr+import PostgresqlSyntax.Ast.AExprReversableOp+import PostgresqlSyntax.Ast.AexprConst+import PostgresqlSyntax.Ast.AliasClause+import PostgresqlSyntax.Ast.AllOp+import PostgresqlSyntax.Ast.AnyName+import PostgresqlSyntax.Ast.AnyOperator+import PostgresqlSyntax.Ast.ArrayBounds+import PostgresqlSyntax.Ast.ArrayExpr+import PostgresqlSyntax.Ast.ArrayExprList+import PostgresqlSyntax.Ast.AscDesc+import PostgresqlSyntax.Ast.Attrs+import PostgresqlSyntax.Ast.BExpr+import PostgresqlSyntax.Ast.BExprIsOp+import PostgresqlSyntax.Ast.Bconst+import PostgresqlSyntax.Ast.Bit+import PostgresqlSyntax.Ast.CExpr+import PostgresqlSyntax.Ast.CallStmt+import PostgresqlSyntax.Ast.CaseExpr+import PostgresqlSyntax.Ast.Character+import PostgresqlSyntax.Ast.Columnref+import PostgresqlSyntax.Ast.CommonTableExpr+import PostgresqlSyntax.Ast.ConfExpr+import PostgresqlSyntax.Ast.ConstCharacter+import PostgresqlSyntax.Ast.ConstDatetime+import PostgresqlSyntax.Ast.ConstTypename+import PostgresqlSyntax.Ast.DeleteStmt+import PostgresqlSyntax.Ast.ExplicitRow+import PostgresqlSyntax.Ast.ExprList+import PostgresqlSyntax.Ast.ExtractArg+import PostgresqlSyntax.Ast.ExtractList+import PostgresqlSyntax.Ast.Fconst+import PostgresqlSyntax.Ast.ForLockingClause+import PostgresqlSyntax.Ast.ForLockingItem+import PostgresqlSyntax.Ast.ForLockingStrength+import PostgresqlSyntax.Ast.FrameBound+import PostgresqlSyntax.Ast.FrameClause+import PostgresqlSyntax.Ast.FrameClauseMode+import PostgresqlSyntax.Ast.FrameExtent+import PostgresqlSyntax.Ast.FromClause+import PostgresqlSyntax.Ast.FromList+import PostgresqlSyntax.Ast.FuncAliasClause+import PostgresqlSyntax.Ast.FuncApplication+import PostgresqlSyntax.Ast.FuncApplicationParams+import PostgresqlSyntax.Ast.FuncArgExpr+import PostgresqlSyntax.Ast.FuncConstArgs+import PostgresqlSyntax.Ast.FuncExpr+import PostgresqlSyntax.Ast.FuncExprCommonSubexpr+import PostgresqlSyntax.Ast.FuncExprWindowless+import PostgresqlSyntax.Ast.FuncName+import PostgresqlSyntax.Ast.FuncTable+import PostgresqlSyntax.Ast.GenericType+import PostgresqlSyntax.Ast.GroupByItem+import PostgresqlSyntax.Ast.GroupClause+import PostgresqlSyntax.Ast.HavingClause+import PostgresqlSyntax.Ast.Iconst+import PostgresqlSyntax.Ast.Ident+import PostgresqlSyntax.Ast.ImplicitRow+import PostgresqlSyntax.Ast.InExpr+import PostgresqlSyntax.Ast.IndexElem+import PostgresqlSyntax.Ast.IndexElemDef+import PostgresqlSyntax.Ast.IndexParams+import PostgresqlSyntax.Ast.Indirection+import PostgresqlSyntax.Ast.IndirectionEl+import PostgresqlSyntax.Ast.InsertColumnItem+import PostgresqlSyntax.Ast.InsertColumnList+import PostgresqlSyntax.Ast.InsertRest+import PostgresqlSyntax.Ast.InsertStmt+import PostgresqlSyntax.Ast.InsertTarget+import PostgresqlSyntax.Ast.Interval+import PostgresqlSyntax.Ast.IntervalSecond+import PostgresqlSyntax.Ast.IntoClause+import PostgresqlSyntax.Ast.JoinMeth+import PostgresqlSyntax.Ast.JoinQual+import PostgresqlSyntax.Ast.JoinType+import PostgresqlSyntax.Ast.JoinedTable+import PostgresqlSyntax.Ast.LimitClause+import PostgresqlSyntax.Ast.MathOp+import PostgresqlSyntax.Ast.NameList+import PostgresqlSyntax.Ast.NullsOrder+import PostgresqlSyntax.Ast.Numeric+import PostgresqlSyntax.Ast.OffsetClause+import PostgresqlSyntax.Ast.OnConflict+import PostgresqlSyntax.Ast.OnConflictDo+import PostgresqlSyntax.Ast.Op+import PostgresqlSyntax.Ast.OptOrdinality+import PostgresqlSyntax.Ast.OptTempTableName+import PostgresqlSyntax.Ast.OptVarying+import PostgresqlSyntax.Ast.OverClause+import PostgresqlSyntax.Ast.OverlayList+import PostgresqlSyntax.Ast.OverrideKind+import PostgresqlSyntax.Ast.PositionList+import PostgresqlSyntax.Ast.PreparableStmt+import PostgresqlSyntax.Ast.QualAllOp+import PostgresqlSyntax.Ast.QualOp+import PostgresqlSyntax.Ast.QualifiedName+import PostgresqlSyntax.Ast.RelationExpr+import PostgresqlSyntax.Ast.RelationExprOptAlias+import PostgresqlSyntax.Ast.ReturningClause+import PostgresqlSyntax.Ast.Row+import PostgresqlSyntax.Ast.RowsfromItem+import PostgresqlSyntax.Ast.RowsfromList+import PostgresqlSyntax.Ast.Sconst+import PostgresqlSyntax.Ast.SelectBinOp+import PostgresqlSyntax.Ast.SelectClause+import PostgresqlSyntax.Ast.SelectFetchFirstValue+import PostgresqlSyntax.Ast.SelectLimit+import PostgresqlSyntax.Ast.SelectLimitValue+import PostgresqlSyntax.Ast.SelectNoParens+import PostgresqlSyntax.Ast.SelectStmt+import PostgresqlSyntax.Ast.SelectWithParens+import PostgresqlSyntax.Ast.SetClause+import PostgresqlSyntax.Ast.SetClauseList+import PostgresqlSyntax.Ast.SetTarget+import PostgresqlSyntax.Ast.SetTargetList+import PostgresqlSyntax.Ast.SimpleSelect+import PostgresqlSyntax.Ast.SimpleTypename+import PostgresqlSyntax.Ast.SortBy+import PostgresqlSyntax.Ast.SortClause+import PostgresqlSyntax.Ast.SubType+import PostgresqlSyntax.Ast.SubqueryOp+import PostgresqlSyntax.Ast.SubstrList+import PostgresqlSyntax.Ast.SubstrListFromFor+import PostgresqlSyntax.Ast.SymbolicExprBinOp+import PostgresqlSyntax.Ast.TableFuncElement+import PostgresqlSyntax.Ast.TableFuncElementList+import PostgresqlSyntax.Ast.TableRef+import PostgresqlSyntax.Ast.TablesampleClause+import PostgresqlSyntax.Ast.TargetEl+import PostgresqlSyntax.Ast.TargetList+import PostgresqlSyntax.Ast.Targeting+import PostgresqlSyntax.Ast.Timezone+import PostgresqlSyntax.Ast.TrimList+import PostgresqlSyntax.Ast.TrimModifier+import PostgresqlSyntax.Ast.TypeList+import PostgresqlSyntax.Ast.Typename+import PostgresqlSyntax.Ast.TypenameArrayDimensions+import PostgresqlSyntax.Ast.UpdateStmt+import PostgresqlSyntax.Ast.UsingClause+import PostgresqlSyntax.Ast.ValuesClause+import PostgresqlSyntax.Ast.VerbalExprBinOp+import PostgresqlSyntax.Ast.WhenClause+import PostgresqlSyntax.Ast.WhenClauseList+import PostgresqlSyntax.Ast.WhereClause+import PostgresqlSyntax.Ast.WhereOrCurrentClause+import PostgresqlSyntax.Ast.WindowClause+import PostgresqlSyntax.Ast.WindowDefinition+import PostgresqlSyntax.Ast.WindowExclusionClause+import PostgresqlSyntax.Ast.WindowSpecification+import PostgresqlSyntax.Ast.WithClause+import PostgresqlSyntax.Ast.Xconst++-- * Bare aliases++type ExistingWindowName = ColId++type PartitionClause = ExprList++type RepeatableClause = AExpr++type ColDefList = TableFuncElementList++type CollateClause = AnyName++type WithinGroupClause = SortClause++type FilterClause = AExpr++type OverlayPlacing = AExpr++type SubstrFrom = AExpr++type SubstrFor = AExpr++type CaseArg = AExpr++type CaseDefault = AExpr++type ConstBit = Bit++type ColId = Ident++type ColLabel = Ident++type Name = ColId++type CursorName = Name++type AttrName = ColLabel++type TypeModifiers = ExprList++type Collate = AnyName++type Class = AnyName++type TypeFunctionName = Ident

@@ -0,0 +1,462 @@+module PostgresqlSyntax.Ast.AExpr+  ( AExpr (..),+    filteredParser,+    isBoundedAExprOperand,+    safeAExprOperand,+    selectWithParensAExpr,+    refineToSelectWithParens,+    canonicalize,+  )+where++import qualified HeadedMegaparsec as Parser+import PostgresqlSyntax.Ast.AExprReversableOp+import PostgresqlSyntax.Ast.AnyName hiding (filteredParser)+import PostgresqlSyntax.Ast.CExpr (CExpr)+import qualified PostgresqlSyntax.Ast.CExpr as CExpr+import PostgresqlSyntax.Ast.Ident+import PostgresqlSyntax.Ast.QualOp+import PostgresqlSyntax.Ast.Row+import {-# SOURCE #-} PostgresqlSyntax.Ast.SelectWithParens (SelectWithParens)+import PostgresqlSyntax.Ast.SubType+import PostgresqlSyntax.Ast.SubqueryOp+import PostgresqlSyntax.Ast.SymbolicExprBinOp+import PostgresqlSyntax.Ast.Typename+import PostgresqlSyntax.Ast.VerbalExprBinOp+import qualified PostgresqlSyntax.Helpers.Gens as Gens+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import qualified PostgresqlSyntax.Helpers.TextBuilders as TextBuilders+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Prelude+import PostgresqlSyntax.Settings (Settings)+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- a_expr:+--   | c_expr+--   | a_expr TYPECAST Typename+--   | a_expr COLLATE any_name+--   | a_expr AT TIME ZONE a_expr+--   | '+' a_expr+--   | '-' a_expr+--   | a_expr '+' a_expr+--   | a_expr '-' a_expr+--   | a_expr '*' a_expr+--   | a_expr '/' a_expr+--   | a_expr '%' a_expr+--   | a_expr '^' a_expr+--   | a_expr '<' a_expr+--   | a_expr '>' a_expr+--   | a_expr '=' a_expr+--   | a_expr LESS_EQUALS a_expr+--   | a_expr GREATER_EQUALS a_expr+--   | a_expr NOT_EQUALS a_expr+--   | a_expr qual_Op a_expr+--   | qual_Op a_expr+--   | a_expr AND a_expr+--   | a_expr OR a_expr+--   | NOT a_expr+--   | NOT_LA a_expr+--   | a_expr LIKE a_expr+--   | a_expr LIKE a_expr ESCAPE a_expr+--   | a_expr NOT_LA LIKE a_expr+--   | a_expr NOT_LA LIKE a_expr ESCAPE a_expr+--   | a_expr ILIKE a_expr+--   | a_expr ILIKE a_expr ESCAPE a_expr+--   | a_expr NOT_LA ILIKE a_expr+--   | a_expr NOT_LA ILIKE a_expr ESCAPE a_expr+--   | a_expr SIMILAR TO a_expr+--   | a_expr SIMILAR TO a_expr ESCAPE a_expr+--   | a_expr NOT_LA SIMILAR TO a_expr+--   | a_expr NOT_LA SIMILAR TO a_expr ESCAPE a_expr+--   | a_expr IS NULL_P+--   | a_expr ISNULL+--   | a_expr IS NOT NULL_P+--   | a_expr NOTNULL+--   | row OVERLAPS row+--   | a_expr IS TRUE_P+--   | a_expr IS NOT TRUE_P+--   | a_expr IS FALSE_P+--   | a_expr IS NOT FALSE_P+--   | a_expr IS UNKNOWN+--   | a_expr IS NOT UNKNOWN+--   | a_expr IS DISTINCT FROM a_expr+--   | a_expr IS NOT DISTINCT FROM a_expr+--   | a_expr IS OF '(' type_list ')'+--   | a_expr IS NOT OF '(' type_list ')'+--   | a_expr BETWEEN opt_asymmetric b_expr AND a_expr+--   | a_expr NOT_LA BETWEEN opt_asymmetric b_expr AND a_expr+--   | a_expr BETWEEN SYMMETRIC b_expr AND a_expr+--   | a_expr NOT_LA BETWEEN SYMMETRIC b_expr AND a_expr+--   | a_expr IN_P in_expr+--   | a_expr NOT_LA IN_P in_expr+--   | a_expr subquery_Op sub_type select_with_parens+--   | a_expr subquery_Op sub_type '(' a_expr ')'+--   | UNIQUE select_with_parens+--   | a_expr IS DOCUMENT_P+--   | a_expr IS NOT DOCUMENT_P+--   | DEFAULT+-- @+data AExpr+  = CExprAExpr CExpr+  | TypecastAExpr AExpr Typename+  | CollateAExpr AExpr AnyName+  | AtTimeZoneAExpr AExpr AExpr+  | PlusAExpr AExpr+  | MinusAExpr AExpr+  | SymbolicBinOpAExpr AExpr SymbolicExprBinOp AExpr+  | PrefixQualOpAExpr QualOp AExpr+  | AndAExpr AExpr AExpr+  | OrAExpr AExpr AExpr+  | NotAExpr AExpr+  | VerbalExprBinOpAExpr AExpr Bool VerbalExprBinOp AExpr (Maybe AExpr)+  | ReversableOpAExpr AExpr Bool AExprReversableOp+  | IsnullAExpr AExpr+  | NotnullAExpr AExpr+  | OverlapsAExpr Row Row+  | SubqueryAExpr AExpr SubqueryOp SubType (Either SelectWithParens AExpr)+  | UniqueAExpr SelectWithParens+  | DefaultAExpr+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst AExpr where+  toTextBuilder settings = \case+    CExprAExpr a -> toTextBuilder settings a+    TypecastAExpr a b -> renderOperand a <> " :: " <> toTextBuilder settings b+    CollateAExpr a b -> renderOperand a <> " COLLATE " <> toTextBuilder settings b+    AtTimeZoneAExpr a b -> renderOperand a <> " AT TIME ZONE " <> toTextBuilder settings b+    PlusAExpr a -> "+ " <> toTextBuilder settings a+    MinusAExpr a -> "- " <> toTextBuilder settings a+    SymbolicBinOpAExpr a b c -> renderOperand a <> " " <> toTextBuilder settings b <> " " <> toTextBuilder settings c+    PrefixQualOpAExpr a b -> toTextBuilder settings a <> " " <> toTextBuilder settings b+    AndAExpr a b -> renderOperand a <> " AND " <> toTextBuilder settings b+    OrAExpr a b -> renderOperand a <> " OR " <> toTextBuilder settings b+    NotAExpr a -> "NOT " <> toTextBuilder settings a+    VerbalExprBinOpAExpr a b c d e -> renderOperand a <> " " <> bool "" "NOT " b <> toTextBuilder settings c <> " " <> renderVerbalRhs e d <> foldMap (mappend " ESCAPE " . toTextBuilder settings) e+    ReversableOpAExpr a b c -> renderOperand a <> " " <> renderAExprReversableOp b c+    IsnullAExpr a -> renderOperand a <> " ISNULL"+    NotnullAExpr a -> renderOperand a <> " NOTNULL"+    OverlapsAExpr a b -> toTextBuilder settings a <> " OVERLAPS " <> toTextBuilder settings b+    SubqueryAExpr a b c d -> renderOperand a <> " " <> toTextBuilder settings b <> " " <> toTextBuilder settings c <> " " <> either (toTextBuilder settings) (TextBuilders.renderInParens . toTextBuilder settings) d+    UniqueAExpr a -> "UNIQUE " <> toTextBuilder settings a+    DefaultAExpr -> "DEFAULT"+    where+      -- Renders an operand sitting in the left\/accumulator position of a+      -- suffix production (the @a@ that 'customizedParser'\'s @suffixRec@+      -- threads through). Every alternative in @suffix@ parses its+      -- right-hand operand via an unrestricted recursive @a_expr@ call, so+      -- rendering it plainly always reconstructs the same shape on reparse.+      -- The *left* position is different: control only returns to+      -- @suffixRec@'s loop after a __bounded__ production — one that+      -- doesn't itself end in an unrestricted recursive @a_expr@. A value+      -- shaped like 'PlusAExpr'\/'MinusAExpr'\/'NotAExpr'\/+      -- 'PrefixQualOpAExpr'\/'AtTimeZoneAExpr'\/'SymbolicBinOpAExpr'\/+      -- 'AndAExpr'\/'OrAExpr'\/'VerbalExprBinOpAExpr', or a 'ReversableOpAExpr'+      -- whose 'PostgresqlSyntax.Ast.AExprReversableOp' ends in one too, is+      -- unbounded — placed there bare, it would greedily re-absorb whatever+      -- follows on reparse (e.g. rendering @SymbolicBinOpAExpr (NotAExpr x)+      -- op y@ plainly as @NOT x op y@ reparses as @NotAExpr (SymbolicBinOpAExpr+      -- x op y)@). Parenthesizing it, via the existing @'(' a_expr ')'@+      -- 'PostgresqlSyntax.Ast.CExpr' production, keeps rendering correct for+      -- any 'AExpr' value, whether or not the parser itself could have+      -- produced it in that position.+      renderOperand a+        | isBoundedAExprOperand a = toTextBuilder settings a+        | otherwise = TextBuilders.renderInParens (toTextBuilder settings a)+      -- The @d@ operand of a @LIKE@\/@ILIKE@\/@SIMILAR TO@ production, when+      -- it has a trailing @ESCAPE@ clause of its own (@e@). Since @d@ is+      -- parsed via an unrestricted recursive @a_expr@, rendering it bare+      -- when it's unbounded (see 'isBoundedAExprOperand') — e.g. a dangling+      -- operator, or an escape-less 'VerbalExprBinOpAExpr' whose own greedy+      -- @optional escape@ check would otherwise swallow the text meant for+      -- \*this* production's @ESCAPE@ — reparses differently. Bounded shapes+      -- (a column reference, a constant, an already-parenthesized+      -- expression, DEFAULT, …) always terminate cleanly and never need the+      -- extra parens, exactly like @renderOperand@'s left position.+      renderVerbalRhs e d = case e of+        Nothing -> toTextBuilder settings d+        Just _+          | isBoundedAExprOperand d -> toTextBuilder settings d+          | otherwise -> TextBuilders.renderInParens (toTextBuilder settings d)+      -- Distinct from 'PostgresqlSyntax.Ast.AExprReversableOp'\'s own+      -- @toTextBuilder@ (which bakes in the "positive" @IS@\/@BETWEEN@\/@IN@+      -- Parsers.keyword but not the negation) — this one threads the external+      -- @Bool@ (@NOT@) in, mirroring the pre-extraction top-level+      -- @aExprReversableOp@ renderer.+      renderAExprReversableOp a = \case+        NullAExprReversableOp -> bool "IS " "IS NOT " a <> "NULL"+        TrueAExprReversableOp -> bool "IS " "IS NOT " a <> "TRUE"+        FalseAExprReversableOp -> bool "IS " "IS NOT " a <> "FALSE"+        UnknownAExprReversableOp -> bool "IS " "IS NOT " a <> "UNKNOWN"+        DistinctFromAExprReversableOp b -> bool "IS " "IS NOT " a <> "DISTINCT FROM " <> toTextBuilder settings b+        OfAExprReversableOp b -> bool "IS " "IS NOT " a <> "OF " <> TextBuilders.renderInParens (toTextBuilder settings b)+        BetweenAExprReversableOp b c d -> bool "" "NOT " a <> bool "BETWEEN " "BETWEEN ASYMMETRIC " b <> toTextBuilder settings c <> " AND " <> toTextBuilder settings d+        BetweenSymmetricAExprReversableOp b c -> bool "" "NOT " a <> "BETWEEN SYMMETRIC " <> toTextBuilder settings b <> " AND " <> toTextBuilder settings c+        InAExprReversableOp b -> bool "" "NOT " a <> "IN " <> toTextBuilder settings b+        DocumentAExprReversableOp -> bool "IS " "IS NOT " a <> "DOCUMENT"+  parser settings = customizedParser settings (parser settings)++-- |+-- Parameterized over the 'PostgresqlSyntax.Ast.CExpr' parser embedded at the+-- base case — the only axis 'filteredParser' needs to customize (via+-- 'PostgresqlSyntax.Ast.CExpr.customizedParser'). Every other occurrence of+-- @a_expr@\/@b_expr@\/@select_with_parens@ in the grammar below uses the+-- ordinary, unfiltered parsers, exactly as the pre-extraction+-- @customizedAExpr@ did (its @bExpr@\/@selectWithParens@ references were+-- never threaded through the @cExpr@ parameter either).+customizedParser :: Settings -> Parser CExpr -> Parser AExpr+customizedParser settings cExpr = suffixRec base suffix+  where+    aExpr = customizedParser settings cExpr+    base =+      asum+        [ DefaultAExpr <$ Parsers.keyword "default",+          UniqueAExpr <$> (Parsers.keyword "unique" *> Parsers.space1 *> parser settings),+          Parsers.qualOpExpr settings aExpr PrefixQualOpAExpr,+          PlusAExpr <$> Parsers.plusedExpr aExpr,+          MinusAExpr <$> Parsers.minusedExpr aExpr,+          NotAExpr <$> (Parsers.keyword "not" *> Parsers.space1 *> aExpr),+          CExprAExpr <$> cExpr+        ]+    suffix a =+      asum+        [ overlapsSuffix settings a,+          do+            Parsers.space1+            b <- Parser.wrapToHead (parser settings)+            Parsers.space1+            c <- Parser.wrapToHead (parser settings)+            Parsers.space+            d <- Left <$> Parser.wrapToHead (parser settings) <|> Right <$> Parsers.inParens aExpr+            return (SubqueryAExpr a b c d),+          Parsers.typecastExpr settings a TypecastAExpr,+          CollateAExpr a <$> (Parsers.space1 *> Parsers.keyword "collate" *> Parsers.space1 *> Parser.endHead *> parser settings),+          AtTimeZoneAExpr a <$> (Parsers.space1 *> Parsers.keyphrase "at time zone" *> Parsers.space1 *> Parser.endHead *> aExpr),+          Parsers.symbolicBinOpExpr settings a aExpr SymbolicBinOpAExpr,+          AndAExpr a <$> (Parsers.space1 *> Parsers.keyword "and" *> Parsers.space1 *> Parser.endHead *> aExpr),+          OrAExpr a <$> (Parsers.space1 *> Parsers.keyword "or" *> Parsers.space1 *> Parser.endHead *> aExpr),+          do+            Parsers.space1+            b <- Parsers.trueIfPresent (Parsers.keyword "not" *> Parsers.space1)+            c <- parser settings+            Parsers.space1+            Parser.endHead+            d <- aExpr+            e <- optional (Parsers.space1 *> Parsers.keyword "escape" *> Parsers.space1 *> Parser.endHead *> aExpr)+            return (VerbalExprBinOpAExpr a b c d e),+          do+            Parsers.space1+            Parsers.keyword "is"+            Parsers.space1+            Parser.endHead+            b <- Parsers.trueIfPresent (Parsers.keyword "not" *> Parsers.space1)+            c <-+              asum+                [ NullAExprReversableOp <$ Parsers.keyword "null",+                  TrueAExprReversableOp <$ Parsers.keyword "true",+                  FalseAExprReversableOp <$ Parsers.keyword "false",+                  UnknownAExprReversableOp <$ Parsers.keyword "unknown",+                  DistinctFromAExprReversableOp <$> (Parsers.keyword "distinct" *> Parsers.space1 *> Parsers.keyword "from" *> Parsers.space1 *> Parser.endHead *> aExpr),+                  OfAExprReversableOp <$> (Parsers.keyword "of" *> Parsers.space1 *> Parser.endHead *> Parsers.inParens (parser settings)),+                  DocumentAExprReversableOp <$ Parsers.keyword "document"+                ]+            return (ReversableOpAExpr a b c),+          do+            Parsers.space1+            b <- Parsers.trueIfPresent (Parsers.keyword "not" *> Parsers.space1)+            Parsers.keyword "between"+            Parsers.space1+            Parser.endHead+            c <-+              asum+                [ BetweenSymmetricAExprReversableOp <$ (Parsers.keyword "symmetric" *> Parsers.space1),+                  BetweenAExprReversableOp True <$ (Parsers.keyword "asymmetric" *> Parsers.space1),+                  pure (BetweenAExprReversableOp False)+                ]+            d <- parser settings+            Parsers.space1+            Parsers.keyword "and"+            Parsers.space1+            e <- aExpr+            return (ReversableOpAExpr a b (c d e)),+          do+            Parsers.space1+            b <- Parsers.trueIfPresent (Parsers.keyword "not" *> Parsers.space1)+            Parsers.keyword "in"+            Parsers.space+            c <- InAExprReversableOp <$> parser settings+            return (ReversableOpAExpr a b c),+          IsnullAExpr a <$ (Parsers.space1 *> Parsers.keyword "isnull"),+          NotnullAExpr a <$ (Parsers.space1 *> Parsers.keyword "notnull")+        ]++-- |+-- The @OVERLAPS@ operator, as a suffix of an already parsed left operand.+-- Reinterprets the already-parsed base 'AExpr' as a 'Row' rather than+-- speculatively parsing a @row@ on top of it — see the original+-- @overlapsSuffix@ in the pre-extraction @PostgresqlSyntax.Parsing@ for the+-- exponential-blowup rationale this avoids.+overlapsSuffix :: Settings -> AExpr -> Parser AExpr+overlapsSuffix settings a = do+  b <- maybe empty pure (aExprRow a)+  Parsers.space1+  Parsers.keyword "overlaps"+  Parser.endHead+  Parsers.space1+  c <- parser settings+  return (OverlapsAExpr b c)+  where+    aExprRow = \case+      CExprAExpr (CExpr.ExplicitRowCExpr x) -> Just (ExplicitRowRow x)+      CExprAExpr (CExpr.ImplicitRowCExpr x) -> Just (ImplicitRowRow x)+      _ -> Nothing++-- | 'parser', but rejecting the given words when they'd otherwise be+-- accepted as a trailing bare column-reference identifier. Needed by+-- "PostgresqlSyntax.Ast.SortBy", which must not let @a_expr@ swallow a+-- Parsers.keyword (@USING@\/@ASC@\/@DESC@\/@NULLS@) that is meant to terminate it.+filteredParser :: Settings -> [Text] -> Parser AExpr+filteredParser settings excluded = customizedParser settings (CExpr.customizedParser settings (Parsers.filteredColIdLike UnquotedIdent (parser settings) excluded))++-- |+-- Whether the given 'AExpr' is safe to place in the left\/accumulator+-- position of a suffix production without parenthesizing it — see+-- @renderOperand@ in the 'IsAst' instance above for why that position is+-- special. A shape is bounded when parsing it can never end in an+-- unrestricted recursive @a_expr@ call, i.e. control is guaranteed to+-- return to @suffixRec@'s loop once it's done.+--+-- Note this predicate is purely about operator precedence and+-- associativity: an unbounded shape is one whose own rendering ends in an+-- unrestricted recursive @a_expr@, so placed bare in the left position it+-- would re-absorb the suffix that follows (e.g. rendering+-- @SymbolicBinOpAExpr (NotAExpr x) op y@ plainly as @NOT x op y@ reparses+-- as @NotAExpr (SymbolicBinOpAExpr x op y)@). It is /not/ a general+-- terminator-keyword guard — it isn't a general-purpose mechanism against+-- an expression swallowing a keyword that terminates an enclosing+-- production; the only shape that ever created that hazard by construction+-- was the postfix @a_expr qual_Op@ production, which no longer exists here+-- or in @references/gram.y@ (see gram.y:15985,15987; Postgres removed+-- postfix operators in v14). It does incidentally get reused for that+-- purpose in "PostgresqlSyntax.Ast.TargetEl" (to stop an @OrAExpr@'s right+-- operand from absorbing a following implicit alias) — that's just one+-- call site's use of it, not evidence of general applicability.+isBoundedAExprOperand :: AExpr -> Bool+isBoundedAExprOperand = \case+  PlusAExpr {} -> False+  MinusAExpr {} -> False+  NotAExpr {} -> False+  PrefixQualOpAExpr {} -> False+  AtTimeZoneAExpr {} -> False+  SymbolicBinOpAExpr {} -> False+  AndAExpr {} -> False+  OrAExpr {} -> False+  VerbalExprBinOpAExpr {} -> False+  ReversableOpAExpr _ _ c -> case c of+    DistinctFromAExprReversableOp {} -> False+    BetweenAExprReversableOp {} -> False+    BetweenSymmetricAExprReversableOp {} -> False+    _ -> True+  _ -> True++-- |+-- A generator for the left\/accumulator position of a suffix production+-- (see 'isBoundedAExprOperand'): whatever the given generator produces gets+-- wrapped in an explicit @'(' a_expr ')'@ (via 'CExpr.InParensCExpr') when+-- it wouldn't otherwise be reachable there, so the result always round-trips+-- through 'parser'.+safeAExprOperand :: Qc.Gen AExpr -> Qc.Gen AExpr+safeAExprOperand gen = do+  a <- gen+  pure $+    if isBoundedAExprOperand a+      then a+      else CExprAExpr (CExpr.InParensCExpr a Nothing)++-- |+-- Smart constructor wrapping a bare 'SelectWithParens' as an 'AExpr', for+-- modules that can only see 'AExpr' via its @hs-boot@ (which keeps it+-- abstract to break an import cycle) — see "PostgresqlSyntax.Ast.InExpr",+-- which needs it to canonicalize a @select_with_parens@\/@expr_list@+-- ambiguity.+selectWithParensAExpr :: SelectWithParens -> AExpr+selectWithParensAExpr a = CExprAExpr (CExpr.SelectWithParensCExpr a Nothing)++-- |+-- If an 'AExpr' is a bare, indirection-less 'PostgresqlSyntax.Ast.CExpr.SelectWithParensCExpr'+-- wrapping, returns the wrapped 'SelectWithParens'. The inverse of+-- 'selectWithParensAExpr', exposed for the same @hs-boot@-abstraction reason+-- — see "PostgresqlSyntax.Ast.CExpr", which needs it to canonicalize an+-- @'(' a_expr ')'@\/@select_with_parens@ ambiguity analogous to the one+-- described there.+refineToSelectWithParens :: AExpr -> Maybe SelectWithParens+refineToSelectWithParens = \case+  CExprAExpr (CExpr.SelectWithParensCExpr a Nothing) -> Just a+  _ -> Nothing++-- |+-- Collapses the non-canonical @Right@-wrapping-a-bare-@select_with_parens@+-- shape of 'SubqueryAExpr'\'s final field to the @Left@ shape the parser+-- actually produces for it.+--+-- @a_expr subquery_Op sub_type select_with_parens@ (i.e. @Left@) and+-- @a_expr subquery_Op sub_type '(' a_expr ')'@ (i.e. @Right@) overlap+-- whenever the parenthesized @a_expr@ is itself nothing but a bare,+-- indirection-less @select_with_parens@: both parse @x = ANY ((select 1))@.+-- @suffix@ tries the @select_with_parens@ alternative before the+-- parenthesized @a_expr@ one (see the @d <- Left <$> ... <|> Right <$> ...@+-- line above), so that's always what the parser returns — never @Right@ —+-- making the latter non-canonical for this shape. Both 'arbitrary' and+-- 'shrink' can otherwise construct it, which renders fine but parses back to+-- a different, canonical value and so breaks the roundtrip property.+canonicalize :: AExpr -> AExpr+canonicalize = \case+  SubqueryAExpr a b c (Right d)+    | Just inner <- refineToSelectWithParens d -> SubqueryAExpr a b c (Left inner)+  other -> other++instance Qc.Arbitrary AExpr where+  shrink = fmap canonicalize . Qc.genericShrink+  arbitrary =+    fmap canonicalize $ Qc.sized $ \n ->+      if n <= 1+        then pure DefaultAExpr+        else+          Qc.oneof+            [ CExprAExpr <$> Qc.arbitrary,+              pure DefaultAExpr,+              TypecastAExpr <$> safeAExprOperand (Gens.downscale Qc.arbitrary) <*> Qc.arbitrary,+              CollateAExpr <$> safeAExprOperand (Gens.downscale Qc.arbitrary) <*> Qc.arbitrary,+              AtTimeZoneAExpr <$> safeAExprOperand (Gens.downscale Qc.arbitrary) <*> Gens.downscale Qc.arbitrary,+              PlusAExpr <$> Gens.downscale Qc.arbitrary,+              MinusAExpr <$> Gens.downscale Qc.arbitrary,+              SymbolicBinOpAExpr <$> safeAExprOperand (Gens.downscale Qc.arbitrary) <*> Qc.arbitrary <*> Gens.downscale Qc.arbitrary,+              PrefixQualOpAExpr <$> Qc.arbitrary <*> Gens.downscale Qc.arbitrary,+              AndAExpr <$> safeAExprOperand (Gens.downscale Qc.arbitrary) <*> Gens.downscale Qc.arbitrary,+              OrAExpr <$> safeAExprOperand (Gens.downscale Qc.arbitrary) <*> Gens.downscale Qc.arbitrary,+              NotAExpr <$> Gens.downscale Qc.arbitrary,+              ( do+                  a <- safeAExprOperand (Gens.downscale Qc.arbitrary)+                  b <- Qc.arbitrary+                  c <- Qc.arbitrary+                  e <- Gens.terminatingMaybe (Gens.downscale Qc.arbitrary)+                  -- See @renderVerbalRhs@ in the 'IsAst' instance above:+                  -- whenever there's an escape clause, an unbounded @d@ must+                  -- be pre-wrapped in parens so the generated value already+                  -- matches what parsing the (necessarily parenthesized)+                  -- rendering reconstructs — the same rule 'safeAExprOperand'+                  -- applies for the left/accumulator position.+                  d <- case e of+                    Nothing -> Gens.downscale Qc.arbitrary+                    Just _ -> safeAExprOperand (Gens.downscale Qc.arbitrary)+                  pure (VerbalExprBinOpAExpr a b c d e)+              ),+              ReversableOpAExpr <$> safeAExprOperand (Gens.downscale Qc.arbitrary) <*> Qc.arbitrary <*> Qc.arbitrary,+              IsnullAExpr <$> safeAExprOperand (Gens.downscale Qc.arbitrary),+              NotnullAExpr <$> safeAExprOperand (Gens.downscale Qc.arbitrary),+              OverlapsAExpr <$> Qc.arbitrary <*> Qc.arbitrary,+              SubqueryAExpr <$> safeAExprOperand (Gens.downscale Qc.arbitrary) <*> Qc.arbitrary <*> Qc.arbitrary <*> Gens.downscale Qc.arbitrary,+              UniqueAExpr <$> Gens.downscale Qc.arbitrary+            ]

@@ -0,0 +1,39 @@+module PostgresqlSyntax.Ast.AExpr where++import {-# SOURCE #-} PostgresqlSyntax.Ast.SelectWithParens (SelectWithParens)+import PostgresqlSyntax.IsAst (IsAst)+import PostgresqlSyntax.Prelude (Bool, Data, Eq, Maybe, Ord, Parser, Show, Text)+import PostgresqlSyntax.Settings (Settings)+import Test.QuickCheck (Arbitrary, Gen)++data AExpr++instance Show AExpr++instance Eq AExpr++instance Ord AExpr++instance Data AExpr++instance IsAst AExpr++instance Arbitrary AExpr++-- | 'parser', but rejecting the given words when they'd otherwise be+-- accepted as a trailing bare column-reference identifier. Needed by+-- "PostgresqlSyntax.Ast.SortBy", which must not let @a_expr@ swallow a+-- keyword (@USING@\/@ASC@\/@DESC@\/@NULLS@) that is meant to terminate it.+filteredParser :: Settings -> [Text] -> Parser AExpr++-- | See "PostgresqlSyntax.Ast.AExpr" for the full documentation.+isBoundedAExprOperand :: AExpr -> Bool++-- | See "PostgresqlSyntax.Ast.AExpr" for the full documentation.+safeAExprOperand :: Gen AExpr -> Gen AExpr++-- | See "PostgresqlSyntax.Ast.AExpr" for the full documentation.+selectWithParensAExpr :: SelectWithParens -> AExpr++-- | See "PostgresqlSyntax.Ast.AExpr" for the full documentation.+refineToSelectWithParens :: AExpr -> Maybe SelectWithParens

@@ -0,0 +1,113 @@+module PostgresqlSyntax.Ast.AExprReversableOp where++import qualified HeadedMegaparsec as Parser+import {-# SOURCE #-} PostgresqlSyntax.Ast.AExpr (AExpr)+import {-# SOURCE #-} PostgresqlSyntax.Ast.BExpr (BExpr)+import PostgresqlSyntax.Ast.InExpr+import PostgresqlSyntax.Ast.TypeList+import qualified PostgresqlSyntax.Helpers.Gens as Gens+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import qualified PostgresqlSyntax.Helpers.TextBuilders as TextBuilders+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc++-- |+-- The part of the following productions that follows @a_expr [NOT]@ /+-- @b_expr [NOT]@ — the leading @IS@\/@NOT@ toggle itself is external to this+-- type (it lives alongside it, e.g. in @ReversableOpAExpr AExpr Bool+-- AExprReversableOp@), mirroring how 'PostgresqlSyntax.Ast.VerbalExprBinOp'+-- keeps @NOT_LA@ external. Only the @IS@\/@BETWEEN@\/@IN@ Parsers.keyword that's+-- intrinsic to each specific alternative (as opposed to the shared negation)+-- is captured here.+--+-- ==== References+-- @+--   | a_expr IS NULL_P+--   | a_expr IS TRUE_P+--   | a_expr IS FALSE_P+--   | a_expr IS UNKNOWN+--   | a_expr IS DISTINCT FROM a_expr+--   | a_expr IS OF '(' type_list ')'+--   | a_expr BETWEEN opt_asymmetric b_expr AND a_expr+--   | a_expr BETWEEN SYMMETRIC b_expr AND a_expr+--   | a_expr IN_P in_expr+--   | a_expr IS DOCUMENT_P+-- @+data AExprReversableOp+  = NullAExprReversableOp+  | TrueAExprReversableOp+  | FalseAExprReversableOp+  | UnknownAExprReversableOp+  | DistinctFromAExprReversableOp AExpr+  | OfAExprReversableOp TypeList+  | BetweenAExprReversableOp Bool BExpr AExpr+  | BetweenSymmetricAExprReversableOp BExpr AExpr+  | InAExprReversableOp InExpr+  | DocumentAExprReversableOp+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst AExprReversableOp where+  toTextBuilder settings = \case+    NullAExprReversableOp -> "IS NULL"+    TrueAExprReversableOp -> "IS TRUE"+    FalseAExprReversableOp -> "IS FALSE"+    UnknownAExprReversableOp -> "IS UNKNOWN"+    DistinctFromAExprReversableOp b -> "IS DISTINCT FROM " <> toTextBuilder settings b+    OfAExprReversableOp b -> "IS OF " <> TextBuilders.renderInParens (toTextBuilder settings b)+    BetweenAExprReversableOp b c d -> bool "BETWEEN " "BETWEEN ASYMMETRIC " b <> toTextBuilder settings c <> " AND " <> toTextBuilder settings d+    BetweenSymmetricAExprReversableOp b c -> "BETWEEN SYMMETRIC " <> toTextBuilder settings b <> " AND " <> toTextBuilder settings c+    InAExprReversableOp b -> "IN " <> toTextBuilder settings b+    DocumentAExprReversableOp -> "IS DOCUMENT"+  parser settings =+    asum+      [ Parsers.keyword "is"+          *> Parsers.space1+          *> Parser.endHead+          *> asum+            [ NullAExprReversableOp <$ Parsers.keyword "null",+              TrueAExprReversableOp <$ Parsers.keyword "true",+              FalseAExprReversableOp <$ Parsers.keyword "false",+              UnknownAExprReversableOp <$ Parsers.keyword "unknown",+              DistinctFromAExprReversableOp <$> (Parsers.keyword "distinct" *> Parsers.space1 *> Parsers.keyword "from" *> Parsers.space1 *> Parser.endHead *> parser settings),+              OfAExprReversableOp <$> (Parsers.keyword "of" *> Parsers.space1 *> Parser.endHead *> Parsers.inParens (parser settings)),+              DocumentAExprReversableOp <$ Parsers.keyword "document"+            ],+        do+          Parsers.keyword "between"+          Parsers.space1+          Parser.endHead+          c <-+            asum+              [ BetweenSymmetricAExprReversableOp <$ (Parsers.keyword "symmetric" *> Parsers.space1),+                BetweenAExprReversableOp True <$ (Parsers.keyword "asymmetric" *> Parsers.space1),+                pure (BetweenAExprReversableOp False)+              ]+          d <- parser settings+          Parsers.space1+          Parsers.keyword "and"+          Parsers.space1+          e <- parser settings+          return (c d e),+        InAExprReversableOp <$> (Parsers.keyword "in" *> Parsers.space *> parser settings)+      ]++instance Qc.Arbitrary AExprReversableOp where+  shrink = Qc.genericShrink+  arbitrary =+    Qc.sized $ \n ->+      if n <= 1+        then Qc.oneof [pure NullAExprReversableOp, pure TrueAExprReversableOp, pure FalseAExprReversableOp, pure UnknownAExprReversableOp, pure DocumentAExprReversableOp]+        else+          Qc.oneof+            [ pure NullAExprReversableOp,+              pure TrueAExprReversableOp,+              pure FalseAExprReversableOp,+              pure UnknownAExprReversableOp,+              DistinctFromAExprReversableOp <$> Gens.downscale Qc.arbitrary,+              OfAExprReversableOp <$> Gens.downscale Qc.arbitrary,+              BetweenAExprReversableOp <$> Qc.arbitrary <*> Gens.downscale Qc.arbitrary <*> Gens.downscale Qc.arbitrary,+              BetweenSymmetricAExprReversableOp <$> Gens.downscale Qc.arbitrary <*> Gens.downscale Qc.arbitrary,+              InAExprReversableOp <$> Gens.downscale Qc.arbitrary,+              pure DocumentAExprReversableOp+            ]

@@ -0,0 +1,126 @@+module PostgresqlSyntax.Ast.AexprConst where++import qualified HeadedMegaparsec as Parser+import PostgresqlSyntax.Ast.Bconst+import PostgresqlSyntax.Ast.ConstTypename+import PostgresqlSyntax.Ast.Fconst+import PostgresqlSyntax.Ast.FuncConstArgs+import PostgresqlSyntax.Ast.FuncName+import PostgresqlSyntax.Ast.Iconst+import PostgresqlSyntax.Ast.Interval+import PostgresqlSyntax.Ast.Sconst+import PostgresqlSyntax.Ast.Xconst+import qualified PostgresqlSyntax.Helpers.Gens as Gens+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import qualified PostgresqlSyntax.Helpers.TextBuilders as TextBuilders+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc+import qualified Text.Megaparsec as Megaparsec+import qualified Text.Megaparsec.Char as MegaparsecChar++-- |+-- ==== References+-- @+-- AexprConst:+--   |  Iconst+--   |  FCONST+--   |  Sconst+--   |  BCONST+--   |  XCONST+--   |  func_name Sconst+--   |  func_name '(' func_arg_list opt_sort_clause ')' Sconst+--   |  ConstTypename Sconst+--   |  ConstInterval Sconst opt_interval+--   |  ConstInterval '(' Iconst ')' Sconst+--   |  TRUE_P+--   |  FALSE_P+--   |  NULL_P+-- @+data AexprConst+  = IAexprConst Iconst+  | FAexprConst Fconst+  | SAexprConst Sconst+  | BAexprConst Bconst+  | XAexprConst Xconst+  | FuncAexprConst FuncName (Maybe FuncConstArgs) Sconst+  | ConstTypenameAexprConst ConstTypename Sconst+  | StringIntervalAexprConst Sconst (Maybe Interval)+  | IntIntervalAexprConst Iconst Sconst+  | BoolAexprConst Bool+  | NullAexprConst+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst AexprConst where+  toTextBuilder settings = \case+    IAexprConst a -> toTextBuilder settings a+    FAexprConst a -> toTextBuilder settings a+    SAexprConst a -> toTextBuilder settings a+    BAexprConst a -> toTextBuilder settings a+    XAexprConst a -> toTextBuilder settings a+    FuncAexprConst a b c -> toTextBuilder settings a <> foldMap (TextBuilders.renderInParens . toTextBuilder settings) b <> " " <> toTextBuilder settings c+    ConstTypenameAexprConst a b -> toTextBuilder settings a <> " " <> toTextBuilder settings b+    StringIntervalAexprConst a b -> "INTERVAL " <> toTextBuilder settings a <> TextBuilders.suffixMaybe (toTextBuilder settings) b+    IntIntervalAexprConst a b -> "INTERVAL " <> TextBuilders.renderInParens (toTextBuilder settings a) <> " " <> toTextBuilder settings b+    BoolAexprConst a -> if a then "TRUE" else "FALSE"+    NullAexprConst -> "NULL"+  parser settings =+    asum+      [ do+          Parsers.keyword "interval"+          Parsers.space1+          Parser.endHead+          a <-+            asum+              [ do+                  a <- parser settings+                  Parser.endHead+                  b <- optional (Parsers.space1 *> parser settings)+                  return (StringIntervalAexprConst a b),+                do+                  a <- Parsers.inParens (parser settings)+                  Parsers.space1+                  Parser.endHead+                  b <- parser settings+                  return (IntIntervalAexprConst a b)+              ]+          return a,+        do+          a <- parser settings+          Parsers.space1+          Parser.endHead+          b <- parser settings+          return (ConstTypenameAexprConst a b),+        BoolAexprConst True <$ Parsers.keyword "true",+        BoolAexprConst False <$ Parsers.keyword "false",+        NullAexprConst <$ Parsers.keyword "null" <* Parser.parse (Megaparsec.notFollowedBy MegaparsecChar.alphaNumChar),+        either IAexprConst FAexprConst <$> (Right <$> parser settings <|> Left <$> parser settings),+        SAexprConst <$> parser settings,+        BAexprConst <$> parser settings,+        XAexprConst <$> parser settings,+        Parser.wrapToHead $ do+          a <- parser settings+          Parsers.space+          b <- Parsers.inParens (parser settings)+          Parsers.space1+          d <- parser settings+          return (FuncAexprConst a (Just b) d),+        FuncAexprConst <$> (Parser.wrapToHead (parser settings) <* Parsers.space1) <*> pure Nothing <*> parser settings+      ]++instance Qc.Arbitrary AexprConst where+  shrink = Qc.genericShrink+  arbitrary =+    Qc.oneof+      [ IAexprConst <$> Qc.arbitrary,+        FAexprConst <$> Qc.arbitrary,+        SAexprConst <$> Qc.arbitrary,+        BAexprConst <$> Qc.arbitrary,+        XAexprConst <$> Qc.arbitrary,+        FuncAexprConst <$> Qc.arbitrary <*> Gens.terminatingMaybe Qc.arbitrary <*> Qc.arbitrary,+        ConstTypenameAexprConst <$> Qc.arbitrary <*> Qc.arbitrary,+        StringIntervalAexprConst <$> Qc.arbitrary <*> Qc.arbitrary,+        IntIntervalAexprConst <$> Qc.arbitrary <*> Qc.arbitrary,+        BoolAexprConst <$> Qc.arbitrary,+        pure NullAexprConst+      ]

@@ -0,0 +1,51 @@+module PostgresqlSyntax.Ast.AliasClause where++import qualified HeadedMegaparsec as Parser+import PostgresqlSyntax.Ast.Ident+import PostgresqlSyntax.Ast.NameList+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import qualified PostgresqlSyntax.Helpers.TextBuilders as TextBuilders+import PostgresqlSyntax.IsAst+import qualified PostgresqlSyntax.KeywordSet as KeywordSet+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- alias_clause:+--   |  AS ColId '(' name_list ')'+--   |  AS ColId+--   |  ColId '(' name_list ')'+--   |  ColId+-- @+--+-- 'PostgresqlSyntax.Ast.ColId' is a bare alias to 'Ident', but its /parser/+-- (kept in "PostgresqlSyntax.Parsing" since @ColId@ itself isn't extracted+-- in this batch) is more permissive than plain 'Ident'. Since this module+-- sits below "PostgresqlSyntax.Parsing" (no import cycle allowed), that+-- ColId-flavored element parser is duplicated here (mirroring @colId@'s+-- definition), same as 'PostgresqlSyntax.Ast.NameList'.+data AliasClause = AliasClause Bool Ident (Maybe NameList)+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst AliasClause where+  toTextBuilder settings (AliasClause a b c) =+    TextBuilders.optLexemes+      [ if a then Just "AS" else Nothing,+        Just (toTextBuilder settings b),+        fmap (TextBuilders.renderInParens . toTextBuilder settings) c+      ]+  parser settings = do+    (as, alias) <- (True,) <$> (Parsers.keyword "as" *> Parsers.space1 *> Parser.endHead *> colIdLikeName) <|> (False,) <$> colIdLikeName+    columnAliases <- optional (Parsers.space1 *> Parsers.inParens (parser settings))+    return (AliasClause as alias columnAliases)+    where+      colIdLikeName =+        Parser.label "identifier" $+          parser settings+            <|> Parsers.keywordNameFromSet UnquotedIdent (KeywordSet.unreservedKeyword <> KeywordSet.colNameKeyword)++instance Qc.Arbitrary AliasClause where+  shrink = Qc.genericShrink+  arbitrary = AliasClause <$> arbitrary <*> arbitrary <*> arbitrary

@@ -0,0 +1,37 @@+module PostgresqlSyntax.Ast.AllOp where++import PostgresqlSyntax.Ast.MathOp+import PostgresqlSyntax.Ast.Op+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- all_Op:+--   | Op+--   | MathOp+-- @+data AllOp+  = OpAllOp Op+  | MathAllOp MathOp+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst AllOp where+  toTextBuilder settings = \case+    OpAllOp a -> toTextBuilder settings a+    MathAllOp a -> toTextBuilder settings a+  parser settings =+    asum+      [ OpAllOp <$> parser settings,+        MathAllOp <$> parser settings+      ]++instance Qc.Arbitrary AllOp where+  shrink = Qc.genericShrink+  arbitrary =+    Qc.oneof+      [ OpAllOp <$> Qc.arbitrary,+        MathAllOp <$> Qc.arbitrary+      ]

@@ -0,0 +1,51 @@+module PostgresqlSyntax.Ast.AnyName where++import qualified HeadedMegaparsec as Parser+import PostgresqlSyntax.Ast.Attrs+import PostgresqlSyntax.Ast.Ident+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import PostgresqlSyntax.IsAst+import qualified PostgresqlSyntax.KeywordSet as KeywordSet+import PostgresqlSyntax.Prelude+import PostgresqlSyntax.Settings (Settings)+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- any_name:+--   | ColId+--   | ColId attrs+-- @+--+-- 'PostgresqlSyntax.Ast.ColId' is a bare alias to 'Ident', but its /parser/+-- (kept in "PostgresqlSyntax.Parsing" since @ColId@ itself isn't extracted+-- in this batch) is more permissive than plain 'Ident'. Since this module+-- sits below "PostgresqlSyntax.Parsing" (no import cycle allowed), that+-- ColId-flavored element parser is duplicated here (mirroring @colId@'s+-- definition), same as 'PostgresqlSyntax.Ast.NameList'. (This is also+-- exactly what "PostgresqlSyntax.Parsing"'s @customizedAnyName@ does with+-- its @colId@ argument; that generic helper stays in "PostgresqlSyntax.Parsing"+-- since its other caller, @filteredAnyName@, passes a filtered variant.)+data AnyName = AnyName Ident (Maybe Attrs)+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst AnyName where+  toTextBuilder settings (AnyName a b) = toTextBuilder settings a <> foldMap (toTextBuilder settings) b+  parser settings = AnyName <$> (Parser.wrapToHead colIdLikeName <* Parser.endHead) <*> optional (Parsers.space *> parser settings)+    where+      colIdLikeName =+        Parser.label "identifier" $+          parser settings+            <|> Parsers.keywordNameFromSet UnquotedIdent (KeywordSet.unreservedKeyword <> KeywordSet.colNameKeyword)++instance Qc.Arbitrary AnyName where+  shrink = Qc.genericShrink+  arbitrary = AnyName <$> arbitrary <*> arbitrary++-- | 'parser', but rejecting the given words when they'd otherwise be+-- accepted as the leading identifier — needed by+-- "PostgresqlSyntax.Ast.IndexElem"'s @opt_class@ position, mirroring the+-- pre-extraction @filteredAnyName@.+filteredParser :: Settings -> [Text] -> Parser AnyName+filteredParser settings excluded = AnyName <$> (Parser.wrapToHead (Parsers.filteredColIdLike UnquotedIdent (parser settings) excluded) <* Parser.endHead) <*> optional (Parsers.space *> parser settings)

@@ -0,0 +1,56 @@+module PostgresqlSyntax.Ast.AnyOperator where++import qualified HeadedMegaparsec as Parser+import PostgresqlSyntax.Ast.AllOp+import PostgresqlSyntax.Ast.Ident+import qualified PostgresqlSyntax.Helpers.Gens as Gens+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import PostgresqlSyntax.IsAst+import qualified PostgresqlSyntax.KeywordSet as KeywordSet+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- any_operator:+--   | all_Op+--   | ColId '.' any_operator+-- @+--+-- 'PostgresqlSyntax.Ast.ColId' is a bare alias to 'Ident', but its /parser/+-- (kept in "PostgresqlSyntax.Parsing" since @ColId@ itself isn't extracted+-- in this batch) is more permissive than plain 'Ident'. Since this module+-- sits below "PostgresqlSyntax.Parsing" (no import cycle allowed), that+-- ColId-flavored element parser is duplicated here (mirroring @colId@'s+-- definition), same as 'PostgresqlSyntax.Ast.NameList'.+data AnyOperator+  = AllOpAnyOperator AllOp+  | QualifiedAnyOperator Ident AnyOperator+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst AnyOperator where+  toTextBuilder settings = \case+    AllOpAnyOperator a -> toTextBuilder settings a+    QualifiedAnyOperator a b -> toTextBuilder settings a <> "." <> toTextBuilder settings b+  parser settings =+    asum+      [ AllOpAnyOperator <$> parser settings,+        QualifiedAnyOperator <$> colIdLikeName <*> (Parsers.space *> Parsers.char '.' *> Parsers.space *> parser settings)+      ]+    where+      colIdLikeName =+        Parser.label "identifier" $+          parser settings+            <|> Parsers.keywordNameFromSet UnquotedIdent (KeywordSet.unreservedKeyword <> KeywordSet.colNameKeyword)++instance Qc.Arbitrary AnyOperator where+  shrink = Qc.genericShrink+  arbitrary = Qc.sized $ \n ->+    if n <= 1+      then AllOpAnyOperator <$> Qc.arbitrary+      else+        Qc.oneof+          [ AllOpAnyOperator <$> Qc.arbitrary,+            QualifiedAnyOperator <$> Qc.arbitrary <*> Gens.downscale Qc.arbitrary+          ]

@@ -0,0 +1,28 @@+module PostgresqlSyntax.Ast.ArrayBounds where++import PostgresqlSyntax.Ast.Iconst+import qualified PostgresqlSyntax.Helpers.Gens as Gens+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import qualified PostgresqlSyntax.Helpers.TextBuilders as TextBuilders+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- opt_array_bounds:+--   | opt_array_bounds '[' Iconst ']'+--   | opt_array_bounds '[' ']'+--   | EMPTY+-- @+newtype ArrayBounds = ArrayBounds (NonEmpty (Maybe Iconst))+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst ArrayBounds where+  toTextBuilder settings (ArrayBounds a) = TextBuilders.spaceNonEmpty (TextBuilders.renderInBrackets . foldMap (toTextBuilder settings)) a+  parser settings = ArrayBounds <$> Parsers.sep1 Parsers.space (Parsers.inBrackets (optional (parser settings)))++instance Qc.Arbitrary ArrayBounds where+  shrink = Qc.genericShrink+  arbitrary = ArrayBounds <$> Gens.nonEmptyUpTo 3 (Qc.oneof [pure Nothing, Just <$> Qc.arbitrary])

@@ -0,0 +1,50 @@+module PostgresqlSyntax.Ast.ArrayExpr where++import PostgresqlSyntax.Ast.ArrayExprList+import PostgresqlSyntax.Ast.ExprList+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import qualified PostgresqlSyntax.Helpers.TextBuilders as TextBuilders+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- array_expr:+--   | '[' expr_list ']'+--   | '[' array_expr_list ']'+--   | '[' ']'+-- @+data ArrayExpr+  = ExprListArrayExpr ExprList+  | ArrayExprListArrayExpr ArrayExprList+  | EmptyArrayExpr+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst ArrayExpr where+  toTextBuilder settings =+    TextBuilders.renderInBrackets . \case+      ExprListArrayExpr a -> toTextBuilder settings a+      ArrayExprListArrayExpr a -> toTextBuilder settings a+      EmptyArrayExpr -> mempty+  parser settings =+    Parsers.inBrackets $+      asum+        [ ArrayExprListArrayExpr <$> parser settings,+          ExprListArrayExpr <$> parser settings,+          pure EmptyArrayExpr+        ]++instance Qc.Arbitrary ArrayExpr where+  shrink = Qc.genericShrink+  arbitrary =+    Qc.sized $ \n ->+      if n <= 1+        then pure EmptyArrayExpr+        else+          Qc.oneof+            [ ExprListArrayExpr <$> Qc.arbitrary,+              ArrayExprListArrayExpr <$> Qc.arbitrary,+              pure EmptyArrayExpr+            ]

@@ -0,0 +1,19 @@+module PostgresqlSyntax.Ast.ArrayExpr where++import PostgresqlSyntax.IsAst (IsAst)+import PostgresqlSyntax.Prelude (Data, Eq, Ord, Show)+import Test.QuickCheck (Arbitrary)++data ArrayExpr++instance Show ArrayExpr++instance Eq ArrayExpr++instance Ord ArrayExpr++instance Data ArrayExpr++instance IsAst ArrayExpr++instance Arbitrary ArrayExpr

@@ -0,0 +1,27 @@+module PostgresqlSyntax.Ast.ArrayExprList where++import {-# SOURCE #-} PostgresqlSyntax.Ast.ArrayExpr (ArrayExpr)+import qualified PostgresqlSyntax.Helpers.Gens as Gens+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import qualified PostgresqlSyntax.Helpers.TextBuilders as TextBuilders+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- array_expr_list:+--   | array_expr+--   | array_expr_list ',' array_expr+-- @+newtype ArrayExprList = ArrayExprList (NonEmpty ArrayExpr)+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst ArrayExprList where+  toTextBuilder settings (ArrayExprList a) = TextBuilders.commaNonEmpty (toTextBuilder settings) a+  parser settings = ArrayExprList <$> Parsers.sep1 Parsers.commaSeparator (parser settings)++instance Qc.Arbitrary ArrayExprList where+  shrink = Qc.genericShrink+  arbitrary = ArrayExprList <$> Gens.nonEmptyUpTo 100 (Gens.downscale Qc.arbitrary)

@@ -0,0 +1,27 @@+module PostgresqlSyntax.Ast.AscDesc where++import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- opt_asc_desc:+--   | ASC+--   | DESC+--   | EMPTY+-- @+data AscDesc = AscAscDesc | DescAscDesc+  deriving (Show, Generic, Eq, Ord, Data, Enum, Bounded)++instance IsAst AscDesc where+  toTextBuilder _settings = \case+    AscAscDesc -> "ASC"+    DescAscDesc -> "DESC"+  parser _settings = Parsers.keyword "asc" $> AscAscDesc <|> Parsers.keyword "desc" $> DescAscDesc++instance Qc.Arbitrary AscDesc where+  shrink = Qc.genericShrink+  arbitrary = Qc.elements [minBound .. maxBound]

@@ -0,0 +1,45 @@+module PostgresqlSyntax.Ast.Attrs where++import qualified Control.Applicative.Combinators.NonEmpty as NonEmpty+import qualified HeadedMegaparsec as Parser+import PostgresqlSyntax.Ast.Ident+import qualified PostgresqlSyntax.Helpers.Gens as Gens+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import PostgresqlSyntax.IsAst+import qualified PostgresqlSyntax.KeywordSet as KeywordSet+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- attrs:+--   | '.' attr_name+--   | attrs '.' attr_name+-- @+--+-- 'PostgresqlSyntax.Ast.AttrName' is a bare alias to+-- 'PostgresqlSyntax.Ast.ColLabel' which is a bare alias to 'Ident', but the+-- @ColLabel@ /parser/ (kept in "PostgresqlSyntax.Parsing" since @ColLabel@+-- itself isn't extracted in this batch) is more permissive than plain+-- 'Ident': it additionally accepts the full @keyword@ lexical class as an+-- identifier. Since this module sits below "PostgresqlSyntax.Parsing" (no+-- import cycle allowed), that ColLabel-flavored element parser is+-- duplicated here (mirroring @colLabel@'s definition) rather than reused,+-- to preserve exact parsing behavior. (See 'PostgresqlSyntax.Ast.NameList'+-- for the same pattern applied to @ColId@.)+newtype Attrs = Attrs (NonEmpty Ident)+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst Attrs where+  toTextBuilder settings (Attrs a) = foldMap (mappend "." . toTextBuilder settings) a+  parser settings = Attrs <$> NonEmpty.some (Parsers.char '.' *> Parser.endHead *> Parsers.space *> colLabelLikeName)+    where+      colLabelLikeName =+        Parser.label "column label" $+          Parsers.keywordNameFromSet UnquotedIdent KeywordSet.keyword+            <|> parser settings++instance Qc.Arbitrary Attrs where+  shrink = Qc.genericShrink+  arbitrary = Attrs <$> Gens.nonEmptyUpTo 9 Qc.arbitrary

@@ -0,0 +1,161 @@+module PostgresqlSyntax.Ast.BExpr where++import qualified HeadedMegaparsec as Parser+import PostgresqlSyntax.Ast.BExprIsOp+import PostgresqlSyntax.Ast.CExpr (CExpr)+import PostgresqlSyntax.Ast.QualOp+import PostgresqlSyntax.Ast.SymbolicExprBinOp+import PostgresqlSyntax.Ast.Typename+import qualified PostgresqlSyntax.Helpers.Gens as Gens+import qualified PostgresqlSyntax.Helpers.Parsers as Parsers+import qualified PostgresqlSyntax.Helpers.TextBuilders as TextBuilders+import PostgresqlSyntax.IsAst+import PostgresqlSyntax.Prelude+import qualified Test.QuickCheck as Qc++-- |+-- ==== References+-- @+-- b_expr:+--   | c_expr+--   | b_expr TYPECAST Typename+--   | '+' b_expr+--   | '-' b_expr+--   | b_expr '+' b_expr+--   | b_expr '-' b_expr+--   | b_expr '*' b_expr+--   | b_expr '/' b_expr+--   | b_expr '%' b_expr+--   | b_expr '^' b_expr+--   | b_expr '<' b_expr+--   | b_expr '>' b_expr+--   | b_expr '=' b_expr+--   | b_expr LESS_EQUALS b_expr+--   | b_expr GREATER_EQUALS b_expr+--   | b_expr NOT_EQUALS b_expr+--   | b_expr qual_Op b_expr+--   | qual_Op b_expr+--   | b_expr IS DISTINCT FROM b_expr+--   | b_expr IS NOT DISTINCT FROM b_expr+--   | b_expr IS OF '(' type_list ')'+--   | b_expr IS NOT OF '(' type_list ')'+--   | b_expr IS DOCUMENT_P+--   | b_expr IS NOT DOCUMENT_P+-- @+--+-- Unlike 'PostgresqlSyntax.Ast.AExpr', nothing customizes this parser's+-- @c_expr@\/identifier axis externally, so — despite also being a+-- recursion hub — it needs no @customizedParser@\/@filteredParser@ export.+data BExpr+  = CExprBExpr CExpr+  | TypecastBExpr BExpr Typename+  | PlusBExpr BExpr+  | MinusBExpr BExpr+  | SymbolicBinOpBExpr BExpr SymbolicExprBinOp BExpr+  | QualOpBExpr QualOp BExpr+  | IsOpBExpr BExpr Bool BExprIsOp+  deriving (Show, Generic, Eq, Ord, Data)++instance IsAst BExpr where+  toTextBuilder settings = \case+    CExprBExpr a -> toTextBuilder settings a+    TypecastBExpr a b -> renderOperand a <> " :: " <> toTextBuilder settings b+    PlusBExpr a -> "+ " <> toTextBuilder settings a+    MinusBExpr a -> "- " <> toTextBuilder settings a+    SymbolicBinOpBExpr a b c -> renderOperand a <> " " <> toTextBuilder settings b <> " " <> toTextBuilder settings c+    QualOpBExpr a b -> toTextBuilder settings a <> " " <> toTextBuilder settings b+    IsOpBExpr a b c -> renderOperand a <> " " <> renderBExprIsOp b c+    where+      -- See 'PostgresqlSyntax.Ast.AExpr'\'s @renderOperand@ for the+      -- rationale — same left\/accumulator-position hazard, mirrored here+      -- for 'BExpr'\'s own (smaller) suffix grammar. Unlike 'AExpr', there's+      -- no @'(' b_expr ')'@ production to fall back on, so parenthesizing+      -- reinterprets the operand as an @a_expr@ via+      -- 'PostgresqlSyntax.Ast.CExpr'\'s @'(' a_expr ')'@ instead — still+      -- valid, semantically-equivalent SQL, just not the same 'BExpr' shape+      -- on reparse (only relevant to hand-constructed values; the+      -- 'Qc.Arbitrary' instance below never generates an operand needing+      -- this fallback).+      renderOperand a+        | isBoundedBExprOperand a = toTextBuilder settings a+        | otherwise = TextBuilders.renderInParens (toTextBuilder settings a)+      renderBExprIsOp a =+        mappend (bool "IS " "IS NOT " a) . \case+          DistinctFromBExprIsOp b -> "DISTINCT FROM " <> toTextBuilder settings b+          OfBExprIsOp b -> "OF " <> TextBuilders.renderInParens (toTextBuilder settings b)+          DocumentBExprIsOp -> "DOCUMENT"+  parser settings = suffixRec base suffix+    where+      bExpr = suffixRec base suffix+      base =+        asum+          [ Parsers.qualOpExpr settings bExpr QualOpBExpr,+            PlusBExpr <$> Parsers.plusedExpr bExpr,+            MinusBExpr <$> Parsers.minusedExpr bExpr,+            CExprBExpr <$> parser settings+          ]+      suffix a =+        asum+          [ Parsers.typecastExpr settings a TypecastBExpr,+            Parsers.symbolicBinOpExpr settings a bExpr SymbolicBinOpBExpr,+            do+              Parsers.space1+              Parsers.keyword "is"+              Parsers.space1+              Parser.endHead+              b <- Parsers.trueIfPresent (Parsers.keyword "not" *> Parsers.space1)+              c <-+                asum+                  [ DistinctFromBExprIsOp <$> (Parsers.keyphrase "distinct from" *> Parsers.space1 *> Parser.endHead *> bExpr),+                    OfBExprIsOp <$> (Parsers.keyword "of" *> Parsers.space1 *> Parser.endHead *> Parsers.inParens (parser settings)),+                    DocumentBExprIsOp <$ Parsers.keyword "document"+                  ]+              return (IsOpBExpr a b c)+          ]++-- |+-- Whether the given 'BExpr' is safe to place in the left\/accumulator+-- position of a suffix production without parenthesizing it — see+-- 'IsAst' 'BExpr'\'s @renderOperand@. Mirrors+-- 'PostgresqlSyntax.Ast.AExpr.isBoundedAExprOperand'.+isBoundedBExprOperand :: BExpr -> Bool+isBoundedBExprOperand = \case+  PlusBExpr {} -> False+  MinusBExpr {} -> False+  QualOpBExpr {} -> False+  SymbolicBinOpBExpr {} -> False+  IsOpBExpr _ _ c -> case c of+    DistinctFromBExprIsOp {} -> False+    _ -> True+  _ -> True++-- |+-- A generator for the left\/accumulator position of a suffix production+-- (see 'isBoundedBExprOperand'). Unlike+-- 'PostgresqlSyntax.Ast.AExpr.safeAExprOperand', 'BExpr' has no+-- parenthesizing escape hatch of its own (see @renderOperand@ above), so an+-- unbounded draw is simply replaced by an always-bounded 'CExprBExpr'+-- instead of wrapped.+safeBExprOperand :: Qc.Gen BExpr -> Qc.Gen BExpr+safeBExprOperand gen = do+  a <- gen+  if isBoundedBExprOperand a+    then pure a+    else CExprBExpr <$> Qc.arbitrary++instance Qc.Arbitrary BExpr where+  shrink = Qc.genericShrink+  arbitrary =+    Qc.sized $ \n ->+      if n <= 1+        then CExprBExpr <$> Qc.arbitrary+        else+          Qc.oneof+            [ CExprBExpr <$> Qc.arbitrary,+              TypecastBExpr <$> safeBExprOperand (Gens.downscale Qc.arbitrary) <*> Qc.arbitrary,+              PlusBExpr <$> Gens.downscale Qc.arbitrary,+              MinusBExpr <$> Gens.downscale Qc.arbitrary,+              SymbolicBinOpBExpr <$> safeBExprOperand (Gens.downscale Qc.arbitrary) <*> Qc.arbitrary <*> Gens.downscale Qc.arbitrary,+              QualOpBExpr <$> Qc.arbitrary <*> Gens.downscale Qc.arbitrary,+              IsOpBExpr <$> safeBExprOperand (Gens.downscale Qc.arbitrary) <*> Qc.arbitrary <*> Gens.downscale Qc.arbitrary+            ]